From f675cb53f5b536d1cd7ae06dccc716e05a311344 Mon Sep 17 00:00:00 2001
From: Tomas Valent <tomas.valent@gmail.com>
Date: Tue, 30 Sep 2025 06:40:19 +0200
Subject: [PATCH 01/97] Add Rubymine to list of Editors Herb Dev Tools (#538)

Add Rubymine to the list

inspired by


https://github.com/igorkasyanchuk/editor_opener/blob/31b09cf4f62c1b84b10e111c91ce3ce3ff450a60/lib/editor_opener/action_dispatch/trace_to_file_extractor.rb#L13

& https://github.com/marcoroth/herb/pull/486/files

Signed-off-by: Tomas Valent <tomas.valent@gmail.com>
---
 javascript/packages/dev-tools/src/herb-overlay.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/javascript/packages/dev-tools/src/herb-overlay.ts b/javascript/packages/dev-tools/src/herb-overlay.ts
index 49cc8aff3..e2b12d4a1 100644
--- a/javascript/packages/dev-tools/src/herb-overlay.ts
+++ b/javascript/packages/dev-tools/src/herb-overlay.ts
@@ -934,6 +934,7 @@ export class HerbOverlay {
       `subl://open?url=file://${absolutePath}&line=${line}&column=${column}`,
       `atom://core/open/file?filename=${absolutePath}&line=${line}&column=${column}`,
       `txmt://open?url=file://${absolutePath}&line=${line}&column=${column}`,
+      `x-mine://open?file=//${absolutePath}&line=${line}&column=${column}`,
     ];
 
     try {

From 7249cd76c1ebaec6ae72a87b7693f91e84d39392 Mon Sep 17 00:00:00 2001
From: Domingo Edwards <domingo.edwards@uc.cl>
Date: Tue, 30 Sep 2025 02:14:29 -0300
Subject: [PATCH 02/97] Linter: Implement `erb-comment-syntax`  linter rule
 (#528)

Closes: #527
Advances: https://github.com/marcoroth/herb/issues/537

This PR adds the rule `erb-comment-syntax`. It is the same rule
implemented in
[CommentSyntax](https://github.com/Shopify/erb_lint?tab=readme-ov-file#commentsyntax)
of ERB Lint.

The rule itself avoid parsing errors in the action_view erb default
parsing implementation.

Also the porting of ERB Lint rules to herb rules facilitates the
adoption of Herb as a ERB Lint replacement.

---------

Co-authored-by: Marco Roth <marco.roth@intergga.ch>
---
 .../packages/linter/docs/rules/README.md      |  1 +
 .../linter/docs/rules/erb-comment-syntax.md   | 40 ++++++++++
 .../packages/linter/src/default-rules.ts      |  2 +
 .../linter/src/rules/erb-comment-syntax.ts    | 30 ++++++++
 javascript/packages/linter/src/rules/index.ts |  1 +
 .../test/__snapshots__/cli.test.ts.snap       |  6 +-
 .../test/rules/erb-comment-syntax.test.ts     | 75 +++++++++++++++++++
 javascript/packages/vscode/package.json       |  1 +
 8 files changed, 153 insertions(+), 3 deletions(-)
 create mode 100644 javascript/packages/linter/docs/rules/erb-comment-syntax.md
 create mode 100644 javascript/packages/linter/src/rules/erb-comment-syntax.ts
 create mode 100644 javascript/packages/linter/test/rules/erb-comment-syntax.test.ts

diff --git a/javascript/packages/linter/docs/rules/README.md b/javascript/packages/linter/docs/rules/README.md
index 689d05bc4..4a361e7ec 100644
--- a/javascript/packages/linter/docs/rules/README.md
+++ b/javascript/packages/linter/docs/rules/README.md
@@ -4,6 +4,7 @@ This page contains documentation for all Herb Linter rules.
 
 ## Available Rules
 
+- [`erb-comment-syntax`](./erb-comment-syntax.md) - Disallow Ruby comments immediately after ERB tags
 - [`erb-no-empty-tags`](./erb-no-empty-tags.md) - Disallow empty ERB tags
 - [`erb-no-output-control-flow`](./erb-no-output-control-flow.md) - Prevents outputting control flow blocks
 - [`erb-no-silent-tag-in-attribute-name`](./erb-no-silent-tag-in-attribute-name.md) - Disallow ERB silent tags in HTML attribute names
diff --git a/javascript/packages/linter/docs/rules/erb-comment-syntax.md b/javascript/packages/linter/docs/rules/erb-comment-syntax.md
new file mode 100644
index 000000000..a4891b51f
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/erb-comment-syntax.md
@@ -0,0 +1,40 @@
+# Linter Rule: Disallow Ruby comments immediately after ERB tags
+
+**Rule:** `erb-comment-syntax`
+
+## Description
+
+Disallow ERB tags that start with `<% #` (with a space before the `#`). Use the ERB comment syntax `<%#` instead.
+
+## Rationale
+
+Ruby comments starting immediately after an ERB tag opening (e.g., `<% # comment %>`) can cause parsing issues in some contexts. The proper ERB comment syntax `<%# comment %>` is more reliable and explicitly designed for comments in templates.
+
+For multi-line comments or actual Ruby code with comments, ensure the content starts on a new line after the opening tag.
+
+## Examples
+
+### ✅ Good
+
+```erb
+<%# This is a proper ERB comment %>
+
+<%
+  # This is a proper ERB comment
+%>
+
+<%
+  # Multi-line Ruby comment
+  # spanning multiple lines
+%>
+```
+
+### 🚫 Bad
+
+```erb
+<% # This should be an ERB comment %>
+
+<%= # This should also be an ERB comment %>
+
+<%== # This should also be an ERB comment %>
+```
diff --git a/javascript/packages/linter/src/default-rules.ts b/javascript/packages/linter/src/default-rules.ts
index 5e6a04926..8dcd84e9f 100644
--- a/javascript/packages/linter/src/default-rules.ts
+++ b/javascript/packages/linter/src/default-rules.ts
@@ -1,5 +1,6 @@
 import type { RuleClass } from "./types.js"
 
+import { ERBCommentSyntax } from "./rules/erb-comment-syntax.js";
 import { ERBNoEmptyTagsRule } from "./rules/erb-no-empty-tags.js"
 import { ERBNoOutputControlFlowRule } from "./rules/erb-no-output-control-flow.js"
 import { ERBNoSilentTagInAttributeNameRule } from "./rules/erb-no-silent-tag-in-attribute-name.js"
@@ -36,6 +37,7 @@ import { SVGTagNameCapitalizationRule } from "./rules/svg-tag-name-capitalizatio
 import { HTMLNoUnderscoresInAttributeNamesRule } from "./rules/html-no-underscores-in-attribute-names.js"
 
 export const defaultRules: RuleClass[] = [
+  ERBCommentSyntax,
   ERBNoEmptyTagsRule,
   ERBNoOutputControlFlowRule,
   ERBNoSilentTagInAttributeNameRule,
diff --git a/javascript/packages/linter/src/rules/erb-comment-syntax.ts b/javascript/packages/linter/src/rules/erb-comment-syntax.ts
new file mode 100644
index 000000000..aabed1d1f
--- /dev/null
+++ b/javascript/packages/linter/src/rules/erb-comment-syntax.ts
@@ -0,0 +1,30 @@
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { ParserRule } from "../types.js"
+
+import type { LintOffense, LintContext } from "../types.js"
+import type { ParseResult, ERBContentNode } from "@herb-tools/core"
+
+class ERBCommentSyntaxVisitor extends BaseRuleVisitor {
+  visitERBContentNode(node: ERBContentNode): void {
+    if (node.content?.value.startsWith(" #")) {
+      const openingTag = node.tag_opening?.value
+
+      this.addOffense(
+        `Use \`<%#\` instead of \`${openingTag} #\`. Ruby comments immediately after ERB tags can cause parsing issues.`,
+        node.location
+      )
+    }
+  }
+}
+
+export class ERBCommentSyntax extends ParserRule {
+  name = "erb-comment-syntax"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ERBCommentSyntaxVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}
diff --git a/javascript/packages/linter/src/rules/index.ts b/javascript/packages/linter/src/rules/index.ts
index 29a4ce56a..ce38e34f0 100644
--- a/javascript/packages/linter/src/rules/index.ts
+++ b/javascript/packages/linter/src/rules/index.ts
@@ -1,4 +1,5 @@
 export * from "./rule-utils.js"
+export * from "./erb-comment-syntax.js"
 export * from "./erb-no-empty-tags.js"
 export * from "./erb-no-output-control-flow.js"
 export * from "./erb-no-silent-tag-in-attribute-name.js"
diff --git a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
index 836e0922b..bf976497d 100644
--- a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
+++ b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
@@ -561,7 +561,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for bad file 1`]
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 31,
+    "ruleCount": 32,
     "totalErrors": 2,
     "totalOffenses": 2,
     "totalWarnings": 0,
@@ -579,7 +579,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for clean file 1`
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 0,
-    "ruleCount": 31,
+    "ruleCount": 32,
     "totalErrors": 0,
     "totalOffenses": 0,
     "totalWarnings": 0,
@@ -649,7 +649,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for file with err
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 31,
+    "ruleCount": 32,
     "totalErrors": 3,
     "totalOffenses": 3,
     "totalWarnings": 0,
diff --git a/javascript/packages/linter/test/rules/erb-comment-syntax.test.ts b/javascript/packages/linter/test/rules/erb-comment-syntax.test.ts
new file mode 100644
index 000000000..8bc529690
--- /dev/null
+++ b/javascript/packages/linter/test/rules/erb-comment-syntax.test.ts
@@ -0,0 +1,75 @@
+import dedent from "dedent"
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { ERBCommentSyntax } from "../../src/rules/erb-comment-syntax.js"
+
+describe("ERBCommentSyntax", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("when the ERB comment syntax is correct", () => {
+    const html = dedent`
+      <%# good comment %>
+    `
+
+    const linter = new Linter(Herb, [ERBCommentSyntax])
+    const lintResult = linter.lint(html)
+
+    expect(lintResult.offenses).toHaveLength(0)
+  })
+
+  test("when the ERB multi-line comment syntax is correct", () => {
+    const html = dedent`
+      <%
+        # good comment
+      %>
+    `
+
+    const linter = new Linter(Herb, [ERBCommentSyntax])
+    const lintResult = linter.lint(html)
+
+    expect(lintResult.offenses).toHaveLength(0)
+  })
+
+  test("when the ERB multi-line comment syntax is correct with multiple comment lines", () => {
+    const html = dedent`
+      <%
+        # good comment
+        # good comment
+      %>
+    `
+
+    const linter = new Linter(Herb, [ERBCommentSyntax])
+    const lintResult = linter.lint(html)
+
+    expect(lintResult.offenses).toHaveLength(0)
+  })
+
+  test("when the ERB comment syntax is incorrect", () => {
+    const html = dedent`
+      <% # bad comment %>
+    `
+
+    const linter = new Linter(Herb, [ERBCommentSyntax])
+    const lintResult = linter.lint(html)
+
+    expect(lintResult.offenses).toHaveLength(1)
+    expect(lintResult.offenses[0].message).toBe("Use `<%#` instead of `<% #`. Ruby comments immediately after ERB tags can cause parsing issues.")
+  })
+
+  test("when the ERB comment syntax is incorrect multiple times in one file", () => {
+    const html = dedent`
+      <% # first bad comment %>
+      <%= # second bad comment %>
+    `
+
+    const linter = new Linter(Herb, [ERBCommentSyntax])
+    const lintResult = linter.lint(html)
+
+    expect(lintResult.offenses).toHaveLength(2)
+    expect(lintResult.offenses[0].message).toBe("Use `<%#` instead of `<% #`. Ruby comments immediately after ERB tags can cause parsing issues.")
+    expect(lintResult.offenses[1].message).toBe("Use `<%#` instead of `<%= #`. Ruby comments immediately after ERB tags can cause parsing issues.")
+  })
+})
diff --git a/javascript/packages/vscode/package.json b/javascript/packages/vscode/package.json
index 8dd528949..571a05a17 100644
--- a/javascript/packages/vscode/package.json
+++ b/javascript/packages/vscode/package.json
@@ -61,6 +61,7 @@
           "items": {
             "type": "string",
             "enum": [
+              "erb-comment-syntax",
               "erb-no-empty-tags",
               "erb-no-output-control-flow",
               "erb-no-silent-tag-in-attribute-name",

From 5da59fc7c24ccb6986e5fe88a3be292d22e5ec7a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Tue, 30 Sep 2025 08:44:34 +0200
Subject: [PATCH 03/97] C: Implement more efficient buffer resizing (#539)

## Problem

If the buffer is nearly full even one extra character can trigger an
expansion of the buffer. Since the buffer only grows by twice the number
of required characters per resize, in this case 2 characters, the buffer
has to be constantly resized.

### Visualization


![buffer_problem](https://github.com/user-attachments/assets/11658cf7-1ab5-41fe-8a75-fc6eaddfb80a)

## How the problem is addressed

Rather than just checking the required length, we test whether doubling
the current capacity will be enough. If it is, we expand to the doubled
capacity. If not, we double the required length itself and resize the
buffer to that size.

## Performance impact

Lexing a  [real world html page](https://shop.herthabsc.com)

Before: ~88.255ms

After: ~79.208ms

Parsing showed no significant performance impact though
---
 src/buffer.c         | 11 ++++++++++-
 test/c/test_buffer.c | 15 +++++++++++++++
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/src/buffer.c b/src/buffer.c
index 750e2190d..f162c4116 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -114,7 +114,16 @@ bool buffer_expand_capacity(buffer_T* buffer) {
 bool buffer_expand_if_needed(buffer_T* buffer, const size_t required_length) {
   if (buffer_has_capacity(buffer, required_length)) { return true; }
 
-  return buffer_resize(buffer, buffer->capacity + (required_length * 2));
+  bool should_double_capacity = required_length < buffer->capacity;
+  size_t new_capacity = 0;
+
+  if (should_double_capacity) {
+    new_capacity = buffer->capacity * 2;
+  } else {
+    new_capacity = buffer->capacity + (required_length * 2);
+  }
+
+  return buffer_resize(buffer, new_capacity);
 }
 
 /**
diff --git a/test/c/test_buffer.c b/test/c/test_buffer.c
index 27d7b8609..054b2d698 100644
--- a/test/c/test_buffer.c
+++ b/test/c/test_buffer.c
@@ -113,6 +113,20 @@ TEST(test_buffer_expand_if_needed)
   buffer_free(&buffer);
 END
 
+TEST(test_buffer_expand_if_needed_with_nearly_full_buffer)
+  buffer_T buffer = buffer_new();
+
+  ck_assert_int_eq(buffer.capacity, 1024);
+
+  buffer_append_repeated(&buffer, ' ', 1023);
+  ck_assert_int_eq(buffer.capacity, 1024);
+
+  ck_assert(buffer_expand_if_needed(&buffer, 2));
+  ck_assert_int_eq(buffer.capacity, 2048);
+
+  buffer_free(&buffer);
+END
+
 // Test resizing buffer
 TEST(test_buffer_resize)
   buffer_T buffer = buffer_new();
@@ -229,6 +243,7 @@ TCase *buffer_tests(void) {
   tcase_add_test(buffer, test_buffer_increase_capacity);
   tcase_add_test(buffer, test_buffer_expand_capacity);
   tcase_add_test(buffer, test_buffer_expand_if_needed);
+  tcase_add_test(buffer, test_buffer_expand_if_needed_with_nearly_full_buffer);
   tcase_add_test(buffer, test_buffer_resize);
   tcase_add_test(buffer, test_buffer_clear);
   tcase_add_test(buffer, test_buffer_free);

From 35124fc2ac558a816279f046b6af36e9bef18e69 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Wed, 1 Oct 2025 18:19:52 +0900
Subject: [PATCH 04/97] Parser: Fix parsing boolean attributes with
 `track_whitespace` (#560)

---
 .../test/rules/html-no-empty-headings.test.ts | 59 +++++++++------
 .../test/rules/parser-no-errors.test.ts       | 13 ++++
 src/lexer_peek_helpers.c                      |  2 +
 test/parser/boolean_attributes_test.rb        | 16 ++++
 ...29e8b-b26dbda6d8a652930695c93bd07179f4.txt | 40 ++++++++++
 ...901a9-b26dbda6d8a652930695c93bd07179f4.txt | 37 +++++++++
 ...5b3ec-b26dbda6d8a652930695c93bd07179f4.txt | 75 +++++++++++++++++++
 7 files changed, 218 insertions(+), 24 deletions(-)
 create mode 100644 test/snapshots/parser/boolean_attributes_test/test_0007_boolean_attribute_on_void_element_followed_by_newline_and_ERB_tag_with_track_whitespace_865f46b916df0289c3b60c880f529e8b-b26dbda6d8a652930695c93bd07179f4.txt
 create mode 100644 test/snapshots/parser/boolean_attributes_test/test_0008_boolean_attribute_on_void_element_followed_by_ERB_tag_with_track_whitespace_7a98c943c925e6943aaa2bec978901a9-b26dbda6d8a652930695c93bd07179f4.txt
 create mode 100644 test/snapshots/parser/boolean_attributes_test/test_0009_boolean_attribute_on_void_element_followed_by_ERB_tag_with_track_whitespace_1d3295149578acc142f855bb3b75b3ec-b26dbda6d8a652930695c93bd07179f4.txt

diff --git a/javascript/packages/linter/test/rules/html-no-empty-headings.test.ts b/javascript/packages/linter/test/rules/html-no-empty-headings.test.ts
index a27e3e4ed..151398aec 100644
--- a/javascript/packages/linter/test/rules/html-no-empty-headings.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-empty-headings.test.ts
@@ -10,7 +10,7 @@ describe("html-no-empty-headings", () => {
 
   test("passes for heading with text content", () => {
     const html = '<h1>Heading Content</h1>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -21,7 +21,7 @@ describe("html-no-empty-headings", () => {
 
   test("passes for heading with nested elements", () => {
     const html = '<h2><span>Text</span></h2>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -32,7 +32,7 @@ describe("html-no-empty-headings", () => {
 
   test("passes for heading with ERB content", () => {
     const html = '<h3><%= title %></h3>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -43,7 +43,7 @@ describe("html-no-empty-headings", () => {
 
   test("fails for empty heading", () => {
     const html = '<h1></h1>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -58,7 +58,7 @@ describe("html-no-empty-headings", () => {
 
   test("fails for heading with only whitespace", () => {
     const html = '<h2>   \n\t  </h2>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -72,7 +72,7 @@ describe("html-no-empty-headings", () => {
 
   test("fails for self-closing heading", () => {
     const html = '<h3 />'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -86,7 +86,7 @@ describe("html-no-empty-headings", () => {
 
   test("handles all heading levels h1-h6", () => {
     const html = '<h1></h1><h2></h2><h3></h3><h4></h4><h5></h5><h6></h6>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -101,7 +101,7 @@ describe("html-no-empty-headings", () => {
 
   test("handles mixed case heading tags", () => {
     const html = '<H1></H1>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -111,7 +111,7 @@ describe("html-no-empty-headings", () => {
 
   test("ignores non-heading tags", () => {
     const html = '<div></div><p></p>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -121,7 +121,7 @@ describe("html-no-empty-headings", () => {
 
   test("passes for headings with mixed content", () => {
     const html = '<h1>Welcome <%= user.name %>!</h1>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -131,7 +131,7 @@ describe("html-no-empty-headings", () => {
 
   test("passes for heading with only ERB", () => {
     const html = '<h1><%= page.title %></h1>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -141,7 +141,7 @@ describe("html-no-empty-headings", () => {
 
   test("handles multiple empty headings", () => {
     const html = '<h1></h1><h2>Valid</h2><h3></h3>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -152,7 +152,7 @@ describe("html-no-empty-headings", () => {
 
   test("passes for div with role='heading' and content", () => {
     const html = '<div role="heading" aria-level="1">Heading Content</div>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -163,7 +163,7 @@ describe("html-no-empty-headings", () => {
 
   test("fails for empty div with role='heading'", () => {
     const html = '<div role="heading" aria-level="1"></div>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -178,7 +178,7 @@ describe("html-no-empty-headings", () => {
 
   test("fails for div with role='heading' containing only whitespace", () => {
     const html = '<div role="heading" aria-level="2">   </div>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -191,7 +191,7 @@ describe("html-no-empty-headings", () => {
 
   test("fails for self-closing div with role='heading'", () => {
     const html = '<div role="heading" aria-level="3" />'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -204,7 +204,7 @@ describe("html-no-empty-headings", () => {
 
   test("ignores div without role='heading'", () => {
     const html = '<div></div><div role="button">Button</div>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -215,7 +215,7 @@ describe("html-no-empty-headings", () => {
 
   test("handles mixed standard headings and ARIA headings", () => {
     const html = '<h1></h1><div role="heading">Valid</div><h2>Valid</h2><div role="heading"></div>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -229,7 +229,7 @@ describe("html-no-empty-headings", () => {
 
   test("fails for heading with only aria-hidden content", () => {
     const html = '<h1><span aria-hidden="true">Inaccessible text</span></h1>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -244,7 +244,7 @@ describe("html-no-empty-headings", () => {
 
   test("fails for heading with mixed accessible and inaccessible content", () => {
     const html = '<h2><span aria-hidden="true">Hidden</span><span aria-hidden="true">Also hidden</span></h2>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -255,7 +255,7 @@ describe("html-no-empty-headings", () => {
 
   test("passes for heading with mix of accessible and inaccessible content", () => {
     const html = '<h3>Visible text<span aria-hidden="true">Hidden text</span></h3>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -266,7 +266,7 @@ describe("html-no-empty-headings", () => {
 
   test("passes for heading itself with aria-hidden='true' but has content", () => {
     const html = '<h1 aria-hidden="true">Heading Content</h1>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -277,7 +277,7 @@ describe("html-no-empty-headings", () => {
 
   test("passes for heading itself with hidden attribute but has content", () => {
     const html = '<h2 hidden>Heading Content</h2>'
-    
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
@@ -288,7 +288,18 @@ describe("html-no-empty-headings", () => {
 
   test("passes for heading with nested span containing text", () => {
     const html = '<h3><span>Text</span></h3>'
-    
+
+    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
+    const lintResult = linter.lint(html)
+
+    expect(lintResult.errors).toBe(0)
+    expect(lintResult.warnings).toBe(0)
+    expect(lintResult.offenses).toHaveLength(0)
+  })
+
+  test("passes for heading with nested span containing text", () => {
+    const html = '<h2 class="class" data-turbo-temporary><%= content %></h2>'
+
     const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
     const lintResult = linter.lint(html)
 
diff --git a/javascript/packages/linter/test/rules/parser-no-errors.test.ts b/javascript/packages/linter/test/rules/parser-no-errors.test.ts
index ec1c4277b..2fde56509 100644
--- a/javascript/packages/linter/test/rules/parser-no-errors.test.ts
+++ b/javascript/packages/linter/test/rules/parser-no-errors.test.ts
@@ -205,4 +205,17 @@ describe("ParserNoErrorsRule", () => {
     expect(lintResult.offenses[2].message).toBe("Opening tag `<h2>` at (1:1) doesn't have a matching closing tag `</h2>`. (`MISSING_CLOSING_TAG_ERROR`)")
     expect(lintResult.offenses[3].message).toBe("Opening tag `<h2>` at (1:25) doesn't have a matching closing tag `</h2>`. (`MISSING_CLOSING_TAG_ERROR`)")
   })
+
+  test("html element ending with boolean attribute followed by ERB tag", () => {
+    const html = dedent`
+      <link crossorigin>
+      <%= hello %>
+    `
+
+    const linter = new Linter(Herb, [ParserNoErrorsRule ])
+    const lintResult = linter.lint(html)
+
+    expect(lintResult.errors).toBe(0)
+    expect(lintResult.offenses).toHaveLength(0)
+  })
 })
diff --git a/src/lexer_peek_helpers.c b/src/lexer_peek_helpers.c
index ca045ba31..20bccfc19 100644
--- a/src/lexer_peek_helpers.c
+++ b/src/lexer_peek_helpers.c
@@ -77,6 +77,7 @@ bool lexer_peek_for_token_type_after_whitespace(lexer_T* lexer, token_type_T tok
   size_t saved_line = lexer->current_line;
   size_t saved_column = lexer->current_column;
   char saved_character = lexer->current_character;
+  lexer_state_T saved_state = lexer->state;
 
   token_T* token = lexer_next_token(lexer);
 
@@ -93,6 +94,7 @@ bool lexer_peek_for_token_type_after_whitespace(lexer_T* lexer, token_type_T tok
   lexer->current_line = saved_line;
   lexer->current_column = saved_column;
   lexer->current_character = saved_character;
+  lexer->state = saved_state;
 
   return result;
 }
diff --git a/test/parser/boolean_attributes_test.rb b/test/parser/boolean_attributes_test.rb
index 076935b8f..24d96191c 100644
--- a/test/parser/boolean_attributes_test.rb
+++ b/test/parser/boolean_attributes_test.rb
@@ -29,5 +29,21 @@ class BooleanAttributesTest < Minitest::Spec
     test "boolean attribute surrounded by regular attributes" do
       assert_parsed_snapshot(%(<input class="classes" required id="ids"/>))
     end
+
+    test "boolean attribute on void element followed by newline and ERB tag with track_whitespace" do
+      assert_parsed_snapshot(%(<link crossorigin>\n<%= hello %>), track_whitespace: true)
+    end
+
+    test "boolean attribute on void element followed by ERB tag with track_whitespace" do
+      assert_parsed_snapshot(%(<link crossorigin><%= hello %>), track_whitespace: true)
+    end
+
+    test "boolean attribute on void element followed by ERB tag with track_whitespace" do
+      assert_parsed_snapshot(<<~HTML, track_whitespace: true)
+        <div id="test" hidden>
+          <%= "hi" %>
+        </div>
+      HTML
+    end
   end
 end
diff --git a/test/snapshots/parser/boolean_attributes_test/test_0007_boolean_attribute_on_void_element_followed_by_newline_and_ERB_tag_with_track_whitespace_865f46b916df0289c3b60c880f529e8b-b26dbda6d8a652930695c93bd07179f4.txt b/test/snapshots/parser/boolean_attributes_test/test_0007_boolean_attribute_on_void_element_followed_by_newline_and_ERB_tag_with_track_whitespace_865f46b916df0289c3b60c880f529e8b-b26dbda6d8a652930695c93bd07179f4.txt
new file mode 100644
index 000000000..6574e7dac
--- /dev/null
+++ b/test/snapshots/parser/boolean_attributes_test/test_0007_boolean_attribute_on_void_element_followed_by_newline_and_ERB_tag_with_track_whitespace_865f46b916df0289c3b60c880f529e8b-b26dbda6d8a652930695c93bd07179f4.txt
@@ -0,0 +1,40 @@
+@ DocumentNode (location: (1:0)-(2:12))
+└── children: (3 items)
+    ├── @ HTMLElementNode (location: (1:0)-(1:18))
+    │   ├── open_tag:
+    │   │   └── @ HTMLOpenTagNode (location: (1:0)-(1:18))
+    │   │       ├── tag_opening: "<" (location: (1:0)-(1:1))
+    │   │       ├── tag_name: "link" (location: (1:1)-(1:5))
+    │   │       ├── tag_closing: ">" (location: (1:17)-(1:18))
+    │   │       ├── children: (2 items)
+    │   │       │   ├── @ WhitespaceNode (location: (1:5)-(1:6))
+    │   │       │   │   └── value: " " (location: (1:5)-(1:6))
+    │   │       │   │
+    │   │       │   └── @ HTMLAttributeNode (location: (1:6)-(1:17))
+    │   │       │       ├── name:
+    │   │       │       │   └── @ HTMLAttributeNameNode (location: (1:6)-(1:17))
+    │   │       │       │       └── children: (1 item)
+    │   │       │       │           └── @ LiteralNode (location: (1:6)-(1:17))
+    │   │       │       │               └── content: "crossorigin"
+    │   │       │       │
+    │   │       │       │
+    │   │       │       ├── equals: ∅
+    │   │       │       └── value: ∅
+    │   │       │
+    │   │       └── is_void: false
+    │   │
+    │   ├── tag_name: "link" (location: (1:1)-(1:5))
+    │   ├── body: []
+    │   ├── close_tag: ∅
+    │   ├── is_void: true
+    │   └── source: "HTML"
+    │
+    ├── @ HTMLTextNode (location: (2:3)-(2:0))
+    │   └── content: "\n"
+    │
+    └── @ ERBContentNode (location: (2:0)-(2:12))
+        ├── tag_opening: "<%=" (location: (2:0)-(2:3))
+        ├── content: " hello " (location: (2:3)-(2:10))
+        ├── tag_closing: "%>" (location: (2:10)-(2:12))
+        ├── parsed: true
+        └── valid: true
\ No newline at end of file
diff --git a/test/snapshots/parser/boolean_attributes_test/test_0008_boolean_attribute_on_void_element_followed_by_ERB_tag_with_track_whitespace_7a98c943c925e6943aaa2bec978901a9-b26dbda6d8a652930695c93bd07179f4.txt b/test/snapshots/parser/boolean_attributes_test/test_0008_boolean_attribute_on_void_element_followed_by_ERB_tag_with_track_whitespace_7a98c943c925e6943aaa2bec978901a9-b26dbda6d8a652930695c93bd07179f4.txt
new file mode 100644
index 000000000..535ea29fc
--- /dev/null
+++ b/test/snapshots/parser/boolean_attributes_test/test_0008_boolean_attribute_on_void_element_followed_by_ERB_tag_with_track_whitespace_7a98c943c925e6943aaa2bec978901a9-b26dbda6d8a652930695c93bd07179f4.txt
@@ -0,0 +1,37 @@
+@ DocumentNode (location: (1:0)-(1:30))
+└── children: (2 items)
+    ├── @ HTMLElementNode (location: (1:0)-(1:18))
+    │   ├── open_tag:
+    │   │   └── @ HTMLOpenTagNode (location: (1:0)-(1:18))
+    │   │       ├── tag_opening: "<" (location: (1:0)-(1:1))
+    │   │       ├── tag_name: "link" (location: (1:1)-(1:5))
+    │   │       ├── tag_closing: ">" (location: (1:17)-(1:18))
+    │   │       ├── children: (2 items)
+    │   │       │   ├── @ WhitespaceNode (location: (1:5)-(1:6))
+    │   │       │   │   └── value: " " (location: (1:5)-(1:6))
+    │   │       │   │
+    │   │       │   └── @ HTMLAttributeNode (location: (1:6)-(1:17))
+    │   │       │       ├── name:
+    │   │       │       │   └── @ HTMLAttributeNameNode (location: (1:6)-(1:17))
+    │   │       │       │       └── children: (1 item)
+    │   │       │       │           └── @ LiteralNode (location: (1:6)-(1:17))
+    │   │       │       │               └── content: "crossorigin"
+    │   │       │       │
+    │   │       │       │
+    │   │       │       ├── equals: ∅
+    │   │       │       └── value: ∅
+    │   │       │
+    │   │       └── is_void: false
+    │   │
+    │   ├── tag_name: "link" (location: (1:1)-(1:5))
+    │   ├── body: []
+    │   ├── close_tag: ∅
+    │   ├── is_void: true
+    │   └── source: "HTML"
+    │
+    └── @ ERBContentNode (location: (1:21)-(1:30))
+        ├── tag_opening: "<%=" (location: (1:21)-(1:21))
+        ├── content: " hello " (location: (1:21)-(1:28))
+        ├── tag_closing: "%>" (location: (1:28)-(1:30))
+        ├── parsed: true
+        └── valid: true
\ No newline at end of file
diff --git a/test/snapshots/parser/boolean_attributes_test/test_0009_boolean_attribute_on_void_element_followed_by_ERB_tag_with_track_whitespace_1d3295149578acc142f855bb3b75b3ec-b26dbda6d8a652930695c93bd07179f4.txt b/test/snapshots/parser/boolean_attributes_test/test_0009_boolean_attribute_on_void_element_followed_by_ERB_tag_with_track_whitespace_1d3295149578acc142f855bb3b75b3ec-b26dbda6d8a652930695c93bd07179f4.txt
new file mode 100644
index 000000000..3dce31a53
--- /dev/null
+++ b/test/snapshots/parser/boolean_attributes_test/test_0009_boolean_attribute_on_void_element_followed_by_ERB_tag_with_track_whitespace_1d3295149578acc142f855bb3b75b3ec-b26dbda6d8a652930695c93bd07179f4.txt
@@ -0,0 +1,75 @@
+@ DocumentNode (location: (1:0)-(4:0))
+└── children: (2 items)
+    ├── @ HTMLElementNode (location: (1:0)-(3:6))
+    │   ├── open_tag:
+    │   │   └── @ HTMLOpenTagNode (location: (1:0)-(1:22))
+    │   │       ├── tag_opening: "<" (location: (1:0)-(1:1))
+    │   │       ├── tag_name: "div" (location: (1:1)-(1:4))
+    │   │       ├── tag_closing: ">" (location: (1:21)-(1:22))
+    │   │       ├── children: (4 items)
+    │   │       │   ├── @ WhitespaceNode (location: (1:4)-(1:5))
+    │   │       │   │   └── value: " " (location: (1:4)-(1:5))
+    │   │       │   │
+    │   │       │   ├── @ HTMLAttributeNode (location: (1:5)-(1:14))
+    │   │       │   │   ├── name:
+    │   │       │   │   │   └── @ HTMLAttributeNameNode (location: (1:5)-(1:7))
+    │   │       │   │   │       └── children: (1 item)
+    │   │       │   │   │           └── @ LiteralNode (location: (1:5)-(1:7))
+    │   │       │   │   │               └── content: "id"
+    │   │       │   │   │
+    │   │       │   │   │
+    │   │       │   │   ├── equals: "=" (location: (1:7)-(1:8))
+    │   │       │   │   └── value:
+    │   │       │   │       └── @ HTMLAttributeValueNode (location: (1:8)-(1:14))
+    │   │       │   │           ├── open_quote: """ (location: (1:8)-(1:9))
+    │   │       │   │           ├── children: (1 item)
+    │   │       │   │           │   └── @ LiteralNode (location: (1:9)-(1:13))
+    │   │       │   │           │       └── content: "test"
+    │   │       │   │           │
+    │   │       │   │           ├── close_quote: """ (location: (1:13)-(1:14))
+    │   │       │   │           └── quoted: true
+    │   │       │   │
+    │   │       │   │
+    │   │       │   ├── @ WhitespaceNode (location: (1:14)-(1:15))
+    │   │       │   │   └── value: " " (location: (1:14)-(1:15))
+    │   │       │   │
+    │   │       │   └── @ HTMLAttributeNode (location: (1:15)-(1:21))
+    │   │       │       ├── name:
+    │   │       │       │   └── @ HTMLAttributeNameNode (location: (1:15)-(1:21))
+    │   │       │       │       └── children: (1 item)
+    │   │       │       │           └── @ LiteralNode (location: (1:15)-(1:21))
+    │   │       │       │               └── content: "hidden"
+    │   │       │       │
+    │   │       │       │
+    │   │       │       ├── equals: ∅
+    │   │       │       └── value: ∅
+    │   │       │
+    │   │       └── is_void: false
+    │   │
+    │   ├── tag_name: "div" (location: (1:1)-(1:4))
+    │   ├── body: (3 items)
+    │   │   ├── @ HTMLTextNode (location: (2:5)-(2:2))
+    │   │   │   └── content: "\n  "
+    │   │   │
+    │   │   ├── @ ERBContentNode (location: (2:2)-(2:13))
+    │   │   │   ├── tag_opening: "<%=" (location: (2:2)-(2:5))
+    │   │   │   ├── content: " "hi" " (location: (2:5)-(2:11))
+    │   │   │   ├── tag_closing: "%>" (location: (2:11)-(2:13))
+    │   │   │   ├── parsed: true
+    │   │   │   └── valid: true
+    │   │   │
+    │   │   └── @ HTMLTextNode (location: (2:13)-(3:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── close_tag:
+    │   │   └── @ HTMLCloseTagNode (location: (3:0)-(3:6))
+    │   │       ├── tag_opening: "</" (location: (3:0)-(3:2))
+    │   │       ├── tag_name: "div" (location: (3:2)-(3:5))
+    │   │       ├── children: []
+    │   │       └── tag_closing: ">" (location: (3:5)-(3:6))
+    │   │
+    │   ├── is_void: false
+    │   └── source: "HTML"
+    │
+    └── @ HTMLTextNode (location: (3:6)-(4:0))
+        └── content: "\n"
\ No newline at end of file

From c5fb3ee431918037ab7a71fd232184ec4d3b41e0 Mon Sep 17 00:00:00 2001
From: Matt Duszynski <mattduszynski@gmail.com>
Date: Wed, 1 Oct 2025 16:12:30 +0200
Subject: [PATCH 05/97] Linter: Add test case for trailing boolean attribute in
 HTML element (#485)

Sharing my investigation so far - I was able to reproduce the issue
reported in #471. The core parser appears to be working correctly, but
the linter errors with an unexpected token error.
---
 .../packages/linter/test/__snapshots__/cli.test.ts.snap  | 9 +++++++++
 javascript/packages/linter/test/cli.test.ts              | 7 +++++++
 .../linter/test/fixtures/boolean-attribute.html.erb      | 3 +++
 3 files changed, 19 insertions(+)
 create mode 100644 javascript/packages/linter/test/fixtures/boolean-attribute.html.erb

diff --git a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
index bf976497d..285f873cc 100644
--- a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
+++ b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
@@ -743,6 +743,15 @@ exports[`CLI Output Formatting > formats success output correctly 1`] = `
   Offenses     0 offenses"
 `;
 
+exports[`CLI Output Formatting > handles boolean attributes 1`] = `
+"✓ test/fixtures/boolean-attribute.html.erb - No issues found
+
+
+ Summary:
+  Checked      1 file
+  Offenses     0 offenses"
+`;
+
 exports[`CLI Output Formatting > handles multiple errors correctly 1`] = `
 "[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
 
diff --git a/javascript/packages/linter/test/cli.test.ts b/javascript/packages/linter/test/cli.test.ts
index 4d1fa047f..ca39c0489 100644
--- a/javascript/packages/linter/test/cli.test.ts
+++ b/javascript/packages/linter/test/cli.test.ts
@@ -50,6 +50,13 @@ describe("CLI Output Formatting", () => {
     expect(exitCode).toBe(1)
   })
 
+  test("handles boolean attributes", () => {
+    const { output, exitCode } = runLinter("boolean-attribute.html.erb", "--no-wrap-lines")
+
+    expect(output).toMatchSnapshot()
+    expect(exitCode).toBe(0)
+  })
+
   test("formats success output correctly", () => {
     const { output, exitCode } = runLinter("clean-file.html.erb", "--no-wrap-lines")
 
diff --git a/javascript/packages/linter/test/fixtures/boolean-attribute.html.erb b/javascript/packages/linter/test/fixtures/boolean-attribute.html.erb
new file mode 100644
index 000000000..94811a213
--- /dev/null
+++ b/javascript/packages/linter/test/fixtures/boolean-attribute.html.erb
@@ -0,0 +1,3 @@
+<div id="test" hidden>
+  <%= "hi" %>
+</div>

From 8f9ee4a9d4d0370acf6440d76a0ce9fcd6d335d5 Mon Sep 17 00:00:00 2001
From: Domingo Edwards <dedwards@buk.cl>
Date: Wed, 1 Oct 2025 11:34:47 -0300
Subject: [PATCH 06/97] Linter: fix rule generator template (#563)

Fix the template for implementing new rules.
---
 .../linter-rule/generators/app/templates/rule.ts.ejs        | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/javascript/packages/linter/generators/linter-rule/generators/app/templates/rule.ts.ejs b/javascript/packages/linter/generators/linter-rule/generators/app/templates/rule.ts.ejs
index 2612d781b..c3a5b3df0 100644
--- a/javascript/packages/linter/generators/linter-rule/generators/app/templates/rule.ts.ejs
+++ b/javascript/packages/linter/generators/linter-rule/generators/app/templates/rule.ts.ejs
@@ -12,7 +12,7 @@
 import { BaseRuleVisitor } from "./rule-utils.js"
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { Node, HTMLElementNode, ERBContentNode } from "@herb-tools/core"
+import type { ParseResult, HTMLElementNode, ERBContentNode } from "@herb-tools/core"
 
 class <%= visitorClassName %> extends BaseRuleVisitor {
   visitHTMLElementNode(node: HTMLElementNode): void {
@@ -31,10 +31,10 @@ class <%= visitorClassName %> extends BaseRuleVisitor {
 export class <%= ruleClassName %> extends ParserRule {
   name = "<%= ruleName %>"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new <%= visitorClassName %>(this.name, context)
 
-    visitor.visit(node)
+    visitor.visit(result.value)
 
     return visitor.offenses
   }

From 6239048b44b905eaa438368b10e952657db3044b Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Fri, 3 Oct 2025 05:45:04 +0900
Subject: [PATCH 07/97] Lexer: Support lexing and parsing `=%>` ERB closing tag
 (#568)

This pull request adds support to be able to lex and parse the `=%>` ERB
closing tag. Since it's use is quite unknown and not well-defined we
should be able to parse is, so we can guide and advice people in the
linter to now use it, i.e using the Right Trim rule introduced in #556.

Co-Authored-By: Domingo Edwards <dedwards@buk.cl>
---
 src/include/lexer_peek_helpers.h              |   1 +
 src/lexer.c                                   |   1 +
 src/lexer_peek_helpers.c                      |   6 +-
 test/lexer/erb_test.rb                        |   8 ++
 test/parser/erb_test.rb                       |  24 ++++
 ...%_=%>_344eadf6b1e04a6f534a3c7e38bbadf1.txt |   4 +
 ...=_=%>_273e03432c2039cc05443a602e8c633a.txt |   4 +
 ...alue_91d881ce0dd66286e4866c07a91e025c.txt} |   0
 ...fore_e474134558bf8ffccb829ba880271d99.txt} |   0
 ...fter_4ce9cd67e9f49e97d785cb27fb5e287a.txt} |   0
 ...fter_e07f0e9a593189f256789bd0ab7b5a82.txt} |   0
 ...tent_3b1dbeebb7d6cc88ee758abcd174c7c4.txt} |   0
 ...ruby_71e2451824a84db91b7e1cf752872168.txt} |   0
 ..._tag_fae7aab59f46d7906cdeccfc1fa2cb3e.txt} |   0
 ...e_tag_e5e99c2c84b3c9a106b8cf08b02ce9d6.txt |   8 ++
 ...e_tag_040322f44f30d4766dc7bfe98114d53f.txt |  47 +++++++
 ...e_tag_276e28a241d24b1f8016400a1c84fef1.txt | 121 ++++++++++++++++++
 17 files changed, 223 insertions(+), 1 deletion(-)
 create mode 100644 test/snapshots/lexer/erb_test/test_0008_erb_<%_=%>_344eadf6b1e04a6f534a3c7e38bbadf1.txt
 create mode 100644 test/snapshots/lexer/erb_test/test_0009_erb_<%=_=%>_273e03432c2039cc05443a602e8c633a.txt
 rename test/snapshots/lexer/erb_test/{test_0008_erb_output_inside_HTML_attribute_value_91d881ce0dd66286e4866c07a91e025c.txt => test_0010_erb_output_inside_HTML_attribute_value_91d881ce0dd66286e4866c07a91e025c.txt} (100%)
 rename test/snapshots/lexer/erb_test/{test_0009_erb_output_inside_HTML_attribute_value_with_value_before_e474134558bf8ffccb829ba880271d99.txt => test_0011_erb_output_inside_HTML_attribute_value_with_value_before_e474134558bf8ffccb829ba880271d99.txt} (100%)
 rename test/snapshots/lexer/erb_test/{test_0010_erb_output_inside_HTML_attribute_value_with_value_before_and_after_4ce9cd67e9f49e97d785cb27fb5e287a.txt => test_0012_erb_output_inside_HTML_attribute_value_with_value_before_and_after_4ce9cd67e9f49e97d785cb27fb5e287a.txt} (100%)
 rename test/snapshots/lexer/erb_test/{test_0011_erb_output_inside_HTML_attribute_value_with_value_and_after_e07f0e9a593189f256789bd0ab7b5a82.txt => test_0013_erb_output_inside_HTML_attribute_value_with_value_and_after_e07f0e9a593189f256789bd0ab7b5a82.txt} (100%)
 rename test/snapshots/lexer/erb_test/{test_0012_multi-line_erb_content_3b1dbeebb7d6cc88ee758abcd174c7c4.txt => test_0014_multi-line_erb_content_3b1dbeebb7d6cc88ee758abcd174c7c4.txt} (100%)
 rename test/snapshots/lexer/erb_test/{test_0013_multi-line_erb_content_with_complex_ruby_71e2451824a84db91b7e1cf752872168.txt => test_0015_multi-line_erb_content_with_complex_ruby_71e2451824a84db91b7e1cf752872168.txt} (100%)
 rename test/snapshots/lexer/erb_test/{test_0014_multi-line_erb_silent_tag_fae7aab59f46d7906cdeccfc1fa2cb3e.txt => test_0016_multi-line_erb_silent_tag_fae7aab59f46d7906cdeccfc1fa2cb3e.txt} (100%)
 create mode 100644 test/snapshots/parser/erb_test/test_0033_erb_output_with_=%>_close_tag_e5e99c2c84b3c9a106b8cf08b02ce9d6.txt
 create mode 100644 test/snapshots/parser/erb_test/test_0034_erb_if_with_=%>_close_tag_040322f44f30d4766dc7bfe98114d53f.txt
 create mode 100644 test/snapshots/parser/erb_test/test_0035_erb_if-elsif-else_with_=%>_close_tag_276e28a241d24b1f8016400a1c84fef1.txt

diff --git a/src/include/lexer_peek_helpers.h b/src/include/lexer_peek_helpers.h
index ae78bee03..faa0ecec8 100644
--- a/src/include/lexer_peek_helpers.h
+++ b/src/include/lexer_peek_helpers.h
@@ -31,6 +31,7 @@ bool lexer_peek_for_html_comment_end(const lexer_T* lexer, int offset);
 bool lexer_peek_erb_close_tag(const lexer_T* lexer, int offset);
 bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, int offset);
 bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, int offset);
+bool lexer_peek_erb_equals_close_tag(const lexer_T* lexer, int offset);
 bool lexer_peek_erb_end(const lexer_T* lexer, int offset);
 
 char lexer_backtrack(const lexer_T* lexer, int offset);
diff --git a/src/lexer.c b/src/lexer.c
index 6e91e180c..513f67882 100644
--- a/src/lexer.c
+++ b/src/lexer.c
@@ -256,6 +256,7 @@ static token_T* lexer_parse_erb_close(lexer_T* lexer) {
   lexer->state = STATE_DATA;
 
   if (lexer_peek_erb_percent_close_tag(lexer, 0)) { return lexer_advance_with(lexer, "%%>", TOKEN_ERB_END); }
+  if (lexer_peek_erb_equals_close_tag(lexer, 0)) { return lexer_advance_with(lexer, "=%>", TOKEN_ERB_END); }
   if (lexer_peek_erb_dash_close_tag(lexer, 0)) { return lexer_advance_with(lexer, "-%>", TOKEN_ERB_END); }
 
   return lexer_advance_with(lexer, "%>", TOKEN_ERB_END);
diff --git a/src/lexer_peek_helpers.c b/src/lexer_peek_helpers.c
index 20bccfc19..a46bbeff6 100644
--- a/src/lexer_peek_helpers.c
+++ b/src/lexer_peek_helpers.c
@@ -65,10 +65,14 @@ bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, const int offset) {
   return lexer_peek_for(lexer, offset, "%%>", false);
 }
 
+bool lexer_peek_erb_equals_close_tag(const lexer_T* lexer, const int offset) {
+  return lexer_peek_for(lexer, offset, "=%>", false);
+}
+
 bool lexer_peek_erb_end(const lexer_T* lexer, const int offset) {
   return (
     lexer_peek_erb_close_tag(lexer, offset) || lexer_peek_erb_dash_close_tag(lexer, offset)
-    || lexer_peek_erb_percent_close_tag(lexer, offset)
+    || lexer_peek_erb_percent_close_tag(lexer, offset) || lexer_peek_erb_equals_close_tag(lexer, offset)
   );
 }
 
diff --git a/test/lexer/erb_test.rb b/test/lexer/erb_test.rb
index b3c5b1ded..e821c7e8e 100644
--- a/test/lexer/erb_test.rb
+++ b/test/lexer/erb_test.rb
@@ -34,6 +34,14 @@ class ERBTest < Minitest::Spec
       assert_lexed_snapshot(%(<%%= "Test" %%>))
     end
 
+    test "erb <% =%>" do
+      assert_lexed_snapshot(%(<% "Test" =%>))
+    end
+
+    test "erb <%= =%>" do
+      assert_lexed_snapshot(%(<%= "Test" =%>))
+    end
+
     test "erb output inside HTML attribute value" do
       assert_lexed_snapshot(%(<article id="<%= dom_id(article) %>"></article>))
     end
diff --git a/test/parser/erb_test.rb b/test/parser/erb_test.rb
index 1c95ef3f6..142a25eab 100644
--- a/test/parser/erb_test.rb
+++ b/test/parser/erb_test.rb
@@ -181,5 +181,29 @@ class ERBTest < Minitest::Spec
         %>
       HTML
     end
+
+    test "erb output with =%> close tag" do
+      assert_parsed_snapshot(%(<%= "hello" =%>))
+    end
+
+    test "erb if with =%> close tag" do
+      assert_parsed_snapshot(<<~HTML)
+        <% if true =%>
+          <p>Content</p>
+        <% end =%>
+      HTML
+    end
+
+    test "erb if-elsif-else with =%> close tag" do
+      assert_parsed_snapshot(<<~HTML)
+        <% if condition =%>
+          <p>True</p>
+        <% elsif other =%>
+          <p>Other</p>
+        <% else =%>
+          <p>False</p>
+        <% end =%>
+      HTML
+    end
   end
 end
diff --git a/test/snapshots/lexer/erb_test/test_0008_erb_<%_=%>_344eadf6b1e04a6f534a3c7e38bbadf1.txt b/test/snapshots/lexer/erb_test/test_0008_erb_<%_=%>_344eadf6b1e04a6f534a3c7e38bbadf1.txt
new file mode 100644
index 000000000..f84f7c4c9
--- /dev/null
+++ b/test/snapshots/lexer/erb_test/test_0008_erb_<%_=%>_344eadf6b1e04a6f534a3c7e38bbadf1.txt
@@ -0,0 +1,4 @@
+#<Herb::Token type="TOKEN_ERB_START" value="<%" range=[0, 2] start=(1:0) end=(1:2)>
+#<Herb::Token type="TOKEN_ERB_CONTENT" value=" \"Test\" " range=[2, 10] start=(1:2) end=(1:10)>
+#<Herb::Token type="TOKEN_ERB_END" value="=%>" range=[10, 13] start=(1:10) end=(1:13)>
+#<Herb::Token type="TOKEN_EOF" value="<EOF>" range=[13, 13] start=(1:13) end=(1:13)>
diff --git a/test/snapshots/lexer/erb_test/test_0009_erb_<%=_=%>_273e03432c2039cc05443a602e8c633a.txt b/test/snapshots/lexer/erb_test/test_0009_erb_<%=_=%>_273e03432c2039cc05443a602e8c633a.txt
new file mode 100644
index 000000000..62d751f5b
--- /dev/null
+++ b/test/snapshots/lexer/erb_test/test_0009_erb_<%=_=%>_273e03432c2039cc05443a602e8c633a.txt
@@ -0,0 +1,4 @@
+#<Herb::Token type="TOKEN_ERB_START" value="<%=" range=[0, 3] start=(1:0) end=(1:3)>
+#<Herb::Token type="TOKEN_ERB_CONTENT" value=" \"Test\" " range=[3, 11] start=(1:3) end=(1:11)>
+#<Herb::Token type="TOKEN_ERB_END" value="=%>" range=[11, 14] start=(1:11) end=(1:14)>
+#<Herb::Token type="TOKEN_EOF" value="<EOF>" range=[14, 14] start=(1:14) end=(1:14)>
diff --git a/test/snapshots/lexer/erb_test/test_0008_erb_output_inside_HTML_attribute_value_91d881ce0dd66286e4866c07a91e025c.txt b/test/snapshots/lexer/erb_test/test_0010_erb_output_inside_HTML_attribute_value_91d881ce0dd66286e4866c07a91e025c.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0008_erb_output_inside_HTML_attribute_value_91d881ce0dd66286e4866c07a91e025c.txt
rename to test/snapshots/lexer/erb_test/test_0010_erb_output_inside_HTML_attribute_value_91d881ce0dd66286e4866c07a91e025c.txt
diff --git a/test/snapshots/lexer/erb_test/test_0009_erb_output_inside_HTML_attribute_value_with_value_before_e474134558bf8ffccb829ba880271d99.txt b/test/snapshots/lexer/erb_test/test_0011_erb_output_inside_HTML_attribute_value_with_value_before_e474134558bf8ffccb829ba880271d99.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0009_erb_output_inside_HTML_attribute_value_with_value_before_e474134558bf8ffccb829ba880271d99.txt
rename to test/snapshots/lexer/erb_test/test_0011_erb_output_inside_HTML_attribute_value_with_value_before_e474134558bf8ffccb829ba880271d99.txt
diff --git a/test/snapshots/lexer/erb_test/test_0010_erb_output_inside_HTML_attribute_value_with_value_before_and_after_4ce9cd67e9f49e97d785cb27fb5e287a.txt b/test/snapshots/lexer/erb_test/test_0012_erb_output_inside_HTML_attribute_value_with_value_before_and_after_4ce9cd67e9f49e97d785cb27fb5e287a.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0010_erb_output_inside_HTML_attribute_value_with_value_before_and_after_4ce9cd67e9f49e97d785cb27fb5e287a.txt
rename to test/snapshots/lexer/erb_test/test_0012_erb_output_inside_HTML_attribute_value_with_value_before_and_after_4ce9cd67e9f49e97d785cb27fb5e287a.txt
diff --git a/test/snapshots/lexer/erb_test/test_0011_erb_output_inside_HTML_attribute_value_with_value_and_after_e07f0e9a593189f256789bd0ab7b5a82.txt b/test/snapshots/lexer/erb_test/test_0013_erb_output_inside_HTML_attribute_value_with_value_and_after_e07f0e9a593189f256789bd0ab7b5a82.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0011_erb_output_inside_HTML_attribute_value_with_value_and_after_e07f0e9a593189f256789bd0ab7b5a82.txt
rename to test/snapshots/lexer/erb_test/test_0013_erb_output_inside_HTML_attribute_value_with_value_and_after_e07f0e9a593189f256789bd0ab7b5a82.txt
diff --git a/test/snapshots/lexer/erb_test/test_0012_multi-line_erb_content_3b1dbeebb7d6cc88ee758abcd174c7c4.txt b/test/snapshots/lexer/erb_test/test_0014_multi-line_erb_content_3b1dbeebb7d6cc88ee758abcd174c7c4.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0012_multi-line_erb_content_3b1dbeebb7d6cc88ee758abcd174c7c4.txt
rename to test/snapshots/lexer/erb_test/test_0014_multi-line_erb_content_3b1dbeebb7d6cc88ee758abcd174c7c4.txt
diff --git a/test/snapshots/lexer/erb_test/test_0013_multi-line_erb_content_with_complex_ruby_71e2451824a84db91b7e1cf752872168.txt b/test/snapshots/lexer/erb_test/test_0015_multi-line_erb_content_with_complex_ruby_71e2451824a84db91b7e1cf752872168.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0013_multi-line_erb_content_with_complex_ruby_71e2451824a84db91b7e1cf752872168.txt
rename to test/snapshots/lexer/erb_test/test_0015_multi-line_erb_content_with_complex_ruby_71e2451824a84db91b7e1cf752872168.txt
diff --git a/test/snapshots/lexer/erb_test/test_0014_multi-line_erb_silent_tag_fae7aab59f46d7906cdeccfc1fa2cb3e.txt b/test/snapshots/lexer/erb_test/test_0016_multi-line_erb_silent_tag_fae7aab59f46d7906cdeccfc1fa2cb3e.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0014_multi-line_erb_silent_tag_fae7aab59f46d7906cdeccfc1fa2cb3e.txt
rename to test/snapshots/lexer/erb_test/test_0016_multi-line_erb_silent_tag_fae7aab59f46d7906cdeccfc1fa2cb3e.txt
diff --git a/test/snapshots/parser/erb_test/test_0033_erb_output_with_=%>_close_tag_e5e99c2c84b3c9a106b8cf08b02ce9d6.txt b/test/snapshots/parser/erb_test/test_0033_erb_output_with_=%>_close_tag_e5e99c2c84b3c9a106b8cf08b02ce9d6.txt
new file mode 100644
index 000000000..06e906b7b
--- /dev/null
+++ b/test/snapshots/parser/erb_test/test_0033_erb_output_with_=%>_close_tag_e5e99c2c84b3c9a106b8cf08b02ce9d6.txt
@@ -0,0 +1,8 @@
+@ DocumentNode (location: (1:0)-(1:15))
+└── children: (1 item)
+    └── @ ERBContentNode (location: (1:0)-(1:15))
+        ├── tag_opening: "<%=" (location: (1:0)-(1:3))
+        ├── content: " "hello" " (location: (1:3)-(1:12))
+        ├── tag_closing: "=%>" (location: (1:12)-(1:15))
+        ├── parsed: true
+        └── valid: true
\ No newline at end of file
diff --git a/test/snapshots/parser/erb_test/test_0034_erb_if_with_=%>_close_tag_040322f44f30d4766dc7bfe98114d53f.txt b/test/snapshots/parser/erb_test/test_0034_erb_if_with_=%>_close_tag_040322f44f30d4766dc7bfe98114d53f.txt
new file mode 100644
index 000000000..5ac9012b3
--- /dev/null
+++ b/test/snapshots/parser/erb_test/test_0034_erb_if_with_=%>_close_tag_040322f44f30d4766dc7bfe98114d53f.txt
@@ -0,0 +1,47 @@
+@ DocumentNode (location: (1:0)-(4:0))
+└── children: (2 items)
+    ├── @ ERBIfNode (location: (1:0)-(3:10))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " if true " (location: (1:2)-(1:11))
+    │   ├── tag_closing: "=%>" (location: (1:11)-(1:14))
+    │   ├── statements: (3 items)
+    │   │   ├── @ HTMLTextNode (location: (1:14)-(2:2))
+    │   │   │   └── content: "\n  "
+    │   │   │
+    │   │   ├── @ HTMLElementNode (location: (2:2)-(2:16))
+    │   │   │   ├── open_tag:
+    │   │   │   │   └── @ HTMLOpenTagNode (location: (2:2)-(2:5))
+    │   │   │   │       ├── tag_opening: "<" (location: (2:2)-(2:3))
+    │   │   │   │       ├── tag_name: "p" (location: (2:3)-(2:4))
+    │   │   │   │       ├── tag_closing: ">" (location: (2:4)-(2:5))
+    │   │   │   │       ├── children: []
+    │   │   │   │       └── is_void: false
+    │   │   │   │
+    │   │   │   ├── tag_name: "p" (location: (2:3)-(2:4))
+    │   │   │   ├── body: (1 item)
+    │   │   │   │   └── @ HTMLTextNode (location: (2:5)-(2:12))
+    │   │   │   │       └── content: "Content"
+    │   │   │   │
+    │   │   │   ├── close_tag:
+    │   │   │   │   └── @ HTMLCloseTagNode (location: (2:12)-(2:16))
+    │   │   │   │       ├── tag_opening: "</" (location: (2:12)-(2:14))
+    │   │   │   │       ├── tag_name: "p" (location: (2:14)-(2:15))
+    │   │   │   │       ├── children: []
+    │   │   │   │       └── tag_closing: ">" (location: (2:15)-(2:16))
+    │   │   │   │
+    │   │   │   ├── is_void: false
+    │   │   │   └── source: "HTML"
+    │   │   │
+    │   │   └── @ HTMLTextNode (location: (2:16)-(3:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── subsequent: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (3:0)-(3:10))
+    │           ├── tag_opening: "<%" (location: (3:0)-(3:2))
+    │           ├── content: " end " (location: (3:2)-(3:7))
+    │           └── tag_closing: "=%>" (location: (3:7)-(3:10))
+    │
+    │
+    └── @ HTMLTextNode (location: (3:10)-(4:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/parser/erb_test/test_0035_erb_if-elsif-else_with_=%>_close_tag_276e28a241d24b1f8016400a1c84fef1.txt b/test/snapshots/parser/erb_test/test_0035_erb_if-elsif-else_with_=%>_close_tag_276e28a241d24b1f8016400a1c84fef1.txt
new file mode 100644
index 000000000..8c281e427
--- /dev/null
+++ b/test/snapshots/parser/erb_test/test_0035_erb_if-elsif-else_with_=%>_close_tag_276e28a241d24b1f8016400a1c84fef1.txt
@@ -0,0 +1,121 @@
+@ DocumentNode (location: (1:0)-(8:0))
+└── children: (2 items)
+    ├── @ ERBIfNode (location: (1:0)-(7:10))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " if condition " (location: (1:2)-(1:16))
+    │   ├── tag_closing: "=%>" (location: (1:16)-(1:19))
+    │   ├── statements: (3 items)
+    │   │   ├── @ HTMLTextNode (location: (1:19)-(2:2))
+    │   │   │   └── content: "\n  "
+    │   │   │
+    │   │   ├── @ HTMLElementNode (location: (2:2)-(2:13))
+    │   │   │   ├── open_tag:
+    │   │   │   │   └── @ HTMLOpenTagNode (location: (2:2)-(2:5))
+    │   │   │   │       ├── tag_opening: "<" (location: (2:2)-(2:3))
+    │   │   │   │       ├── tag_name: "p" (location: (2:3)-(2:4))
+    │   │   │   │       ├── tag_closing: ">" (location: (2:4)-(2:5))
+    │   │   │   │       ├── children: []
+    │   │   │   │       └── is_void: false
+    │   │   │   │
+    │   │   │   ├── tag_name: "p" (location: (2:3)-(2:4))
+    │   │   │   ├── body: (1 item)
+    │   │   │   │   └── @ HTMLTextNode (location: (2:5)-(2:9))
+    │   │   │   │       └── content: "True"
+    │   │   │   │
+    │   │   │   ├── close_tag:
+    │   │   │   │   └── @ HTMLCloseTagNode (location: (2:9)-(2:13))
+    │   │   │   │       ├── tag_opening: "</" (location: (2:9)-(2:11))
+    │   │   │   │       ├── tag_name: "p" (location: (2:11)-(2:12))
+    │   │   │   │       ├── children: []
+    │   │   │   │       └── tag_closing: ">" (location: (2:12)-(2:13))
+    │   │   │   │
+    │   │   │   ├── is_void: false
+    │   │   │   └── source: "HTML"
+    │   │   │
+    │   │   └── @ HTMLTextNode (location: (2:13)-(3:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── subsequent:
+    │   │   └── @ ERBIfNode (location: (3:0)-(5:0))
+    │   │       ├── tag_opening: "<%" (location: (3:0)-(3:2))
+    │   │       ├── content: " elsif other " (location: (3:2)-(3:15))
+    │   │       ├── tag_closing: "=%>" (location: (3:15)-(3:18))
+    │   │       ├── statements: (3 items)
+    │   │       │   ├── @ HTMLTextNode (location: (3:18)-(4:2))
+    │   │       │   │   └── content: "\n  "
+    │   │       │   │
+    │   │       │   ├── @ HTMLElementNode (location: (4:2)-(4:14))
+    │   │       │   │   ├── open_tag:
+    │   │       │   │   │   └── @ HTMLOpenTagNode (location: (4:2)-(4:5))
+    │   │       │   │   │       ├── tag_opening: "<" (location: (4:2)-(4:3))
+    │   │       │   │   │       ├── tag_name: "p" (location: (4:3)-(4:4))
+    │   │       │   │   │       ├── tag_closing: ">" (location: (4:4)-(4:5))
+    │   │       │   │   │       ├── children: []
+    │   │       │   │   │       └── is_void: false
+    │   │       │   │   │
+    │   │       │   │   ├── tag_name: "p" (location: (4:3)-(4:4))
+    │   │       │   │   ├── body: (1 item)
+    │   │       │   │   │   └── @ HTMLTextNode (location: (4:5)-(4:10))
+    │   │       │   │   │       └── content: "Other"
+    │   │       │   │   │
+    │   │       │   │   ├── close_tag:
+    │   │       │   │   │   └── @ HTMLCloseTagNode (location: (4:10)-(4:14))
+    │   │       │   │   │       ├── tag_opening: "</" (location: (4:10)-(4:12))
+    │   │       │   │   │       ├── tag_name: "p" (location: (4:12)-(4:13))
+    │   │       │   │   │       ├── children: []
+    │   │       │   │   │       └── tag_closing: ">" (location: (4:13)-(4:14))
+    │   │       │   │   │
+    │   │       │   │   ├── is_void: false
+    │   │       │   │   └── source: "HTML"
+    │   │       │   │
+    │   │       │   └── @ HTMLTextNode (location: (4:14)-(5:0))
+    │   │       │       └── content: "\n"
+    │   │       │
+    │   │       ├── subsequent:
+    │   │       │   └── @ ERBElseNode (location: (5:0)-(7:0))
+    │   │       │       ├── tag_opening: "<%" (location: (5:0)-(5:2))
+    │   │       │       ├── content: " else " (location: (5:2)-(5:8))
+    │   │       │       ├── tag_closing: "=%>" (location: (5:8)-(5:11))
+    │   │       │       └── statements: (3 items)
+    │   │       │           ├── @ HTMLTextNode (location: (5:11)-(6:2))
+    │   │       │           │   └── content: "\n  "
+    │   │       │           │
+    │   │       │           ├── @ HTMLElementNode (location: (6:2)-(6:14))
+    │   │       │           │   ├── open_tag:
+    │   │       │           │   │   └── @ HTMLOpenTagNode (location: (6:2)-(6:5))
+    │   │       │           │   │       ├── tag_opening: "<" (location: (6:2)-(6:3))
+    │   │       │           │   │       ├── tag_name: "p" (location: (6:3)-(6:4))
+    │   │       │           │   │       ├── tag_closing: ">" (location: (6:4)-(6:5))
+    │   │       │           │   │       ├── children: []
+    │   │       │           │   │       └── is_void: false
+    │   │       │           │   │
+    │   │       │           │   ├── tag_name: "p" (location: (6:3)-(6:4))
+    │   │       │           │   ├── body: (1 item)
+    │   │       │           │   │   └── @ HTMLTextNode (location: (6:5)-(6:10))
+    │   │       │           │   │       └── content: "False"
+    │   │       │           │   │
+    │   │       │           │   ├── close_tag:
+    │   │       │           │   │   └── @ HTMLCloseTagNode (location: (6:10)-(6:14))
+    │   │       │           │   │       ├── tag_opening: "</" (location: (6:10)-(6:12))
+    │   │       │           │   │       ├── tag_name: "p" (location: (6:12)-(6:13))
+    │   │       │           │   │       ├── children: []
+    │   │       │           │   │       └── tag_closing: ">" (location: (6:13)-(6:14))
+    │   │       │           │   │
+    │   │       │           │   ├── is_void: false
+    │   │       │           │   └── source: "HTML"
+    │   │       │           │
+    │   │       │           └── @ HTMLTextNode (location: (6:14)-(7:0))
+    │   │       │               └── content: "\n"
+    │   │       │
+    │   │       │
+    │   │       └── end_node: ∅
+    │   │
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (7:0)-(7:10))
+    │           ├── tag_opening: "<%" (location: (7:0)-(7:2))
+    │           ├── content: " end " (location: (7:2)-(7:7))
+    │           └── tag_closing: "=%>" (location: (7:7)-(7:10))
+    │
+    │
+    └── @ HTMLTextNode (location: (7:10)-(8:0))
+        └── content: "\n"
\ No newline at end of file

From 8c1718839bc28f031aa2bb3d9953bd4cb7467dde Mon Sep 17 00:00:00 2001
From: Domingo Edwards <dedwards@buk.cl>
Date: Thu, 2 Oct 2025 18:43:22 -0300
Subject: [PATCH 08/97] Linter: Implement `erb-right-trim`  linter rule (#556)

Solves #551

Implements the [RightTrim rule from
erb-lint](https://github.com/Shopify/erb_lint?tab=readme-ov-file#righttrim).
---
 .../packages/linter/docs/rules/README.md      |  1 +
 .../linter/docs/rules/erb-right-trim.md       | 23 +++++++++
 .../packages/linter/src/default-rules.ts      |  2 +
 .../linter/src/rules/erb-right-trim.ts        | 38 ++++++++++++++
 javascript/packages/linter/src/rules/index.ts |  1 +
 .../test/__snapshots__/cli.test.ts.snap       |  6 +--
 .../linter/test/rules/erb-right-trim.test.ts  | 51 +++++++++++++++++++
 javascript/packages/vscode/package.json       |  1 +
 8 files changed, 120 insertions(+), 3 deletions(-)
 create mode 100644 javascript/packages/linter/docs/rules/erb-right-trim.md
 create mode 100644 javascript/packages/linter/src/rules/erb-right-trim.ts
 create mode 100644 javascript/packages/linter/test/rules/erb-right-trim.test.ts

diff --git a/javascript/packages/linter/docs/rules/README.md b/javascript/packages/linter/docs/rules/README.md
index 4a361e7ec..625d62d94 100644
--- a/javascript/packages/linter/docs/rules/README.md
+++ b/javascript/packages/linter/docs/rules/README.md
@@ -11,6 +11,7 @@ This page contains documentation for all Herb Linter rules.
 - [`erb-prefer-image-tag-helper`](./erb-prefer-image-tag-helper.md) - Prefer `image_tag` helper over `<img>` with ERB expressions
 - [`erb-require-whitespace-inside-tags`](./erb-require-whitespace-inside-tags.md) - Requires whitespace around ERB tags
 - [`erb-requires-trailing-newline`](./erb-requires-trailing-newline.md) - Enforces that all HTML+ERB template files end with exactly one trailing newline character.
+- [`erb-right-trim`](./erb-right-trim.md) - Enforces trimming with `-`
 - [`html-anchor-require-href`](./html-anchor-require-href.md) - Requires an href attribute on anchor tags
 - [`html-aria-attribute-must-be-valid`](./html-aria-attribute-must-be-valid.md) - Disallow invalid or unknown `aria-*` attributes.
 - [`html-aria-label-is-well-formatted`](./html-aria-label-is-well-formatted.md) - `aria-label` must be well-formatted
diff --git a/javascript/packages/linter/docs/rules/erb-right-trim.md b/javascript/packages/linter/docs/rules/erb-right-trim.md
new file mode 100644
index 000000000..b44861994
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/erb-right-trim.md
@@ -0,0 +1,23 @@
+# Linter Rule: Enforces trimming with -
+
+**Rule:**: `erb-right-trim`
+
+Trimming at the right of an ERB tag can be done with either =%&gt; or -%&gt;, this linter enforces "-" as the default trimming style.
+
+## Examples
+
+### ❌ Incorrect
+
+```erb
+<%= title =%>
+```
+
+### ✅ Correct
+
+```erb
+<%= title -%>
+```
+
+## Configuration
+
+This rule has no configuration options.
diff --git a/javascript/packages/linter/src/default-rules.ts b/javascript/packages/linter/src/default-rules.ts
index 8dcd84e9f..3126bc3b4 100644
--- a/javascript/packages/linter/src/default-rules.ts
+++ b/javascript/packages/linter/src/default-rules.ts
@@ -35,6 +35,7 @@ import { HTMLTagNameLowercaseRule } from "./rules/html-tag-name-lowercase.js"
 import { ParserNoErrorsRule } from "./rules/parser-no-errors.js"
 import { SVGTagNameCapitalizationRule } from "./rules/svg-tag-name-capitalization.js"
 import { HTMLNoUnderscoresInAttributeNamesRule } from "./rules/html-no-underscores-in-attribute-names.js"
+import { ERBRightTrimRule } from "./rules/erb-right-trim.js"
 
 export const defaultRules: RuleClass[] = [
   ERBCommentSyntax,
@@ -72,4 +73,5 @@ export const defaultRules: RuleClass[] = [
   ParserNoErrorsRule,
   SVGTagNameCapitalizationRule,
   HTMLNoUnderscoresInAttributeNamesRule,
+  ERBRightTrimRule,
 ]
diff --git a/javascript/packages/linter/src/rules/erb-right-trim.ts b/javascript/packages/linter/src/rules/erb-right-trim.ts
new file mode 100644
index 000000000..ccd3083e3
--- /dev/null
+++ b/javascript/packages/linter/src/rules/erb-right-trim.ts
@@ -0,0 +1,38 @@
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { ParserRule } from "../types.js"
+
+import type { LintOffense, LintContext } from "../types.js"
+import type { ERBContentNode, ParseResult } from "@herb-tools/core"
+
+class ERBRightTrimVisitor extends BaseRuleVisitor {
+  
+  visitERBContentNode(node: ERBContentNode): void {
+    if (!node.tag_closing) {
+      return
+    }
+
+    if (!node.content?.value) {
+      return
+    }
+
+    if (node.tag_closing.value === "=%>") {
+      this.addOffense(
+        "Prefer -%> instead of =%> for trimming on the right",
+        node.location
+      )
+    }
+  }
+
+}
+
+export class ERBRightTrimRule extends ParserRule {
+  name = "erb-right-trim"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ERBRightTrimVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}
diff --git a/javascript/packages/linter/src/rules/index.ts b/javascript/packages/linter/src/rules/index.ts
index ce38e34f0..92b7d97e1 100644
--- a/javascript/packages/linter/src/rules/index.ts
+++ b/javascript/packages/linter/src/rules/index.ts
@@ -31,3 +31,4 @@ export * from "./html-no-title-attribute.js"
 export * from "./html-tag-name-lowercase.js"
 export * from "./svg-tag-name-capitalization.js"
 export * from "./html-no-underscores-in-attribute-names.js"
+export * from "./erb-right-trim.js"
diff --git a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
index 285f873cc..d24c9fd66 100644
--- a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
+++ b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
@@ -561,7 +561,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for bad file 1`]
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 32,
+    "ruleCount": 33,
     "totalErrors": 2,
     "totalOffenses": 2,
     "totalWarnings": 0,
@@ -579,7 +579,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for clean file 1`
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 0,
-    "ruleCount": 32,
+    "ruleCount": 33,
     "totalErrors": 0,
     "totalOffenses": 0,
     "totalWarnings": 0,
@@ -649,7 +649,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for file with err
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 32,
+    "ruleCount": 33,
     "totalErrors": 3,
     "totalOffenses": 3,
     "totalWarnings": 0,
diff --git a/javascript/packages/linter/test/rules/erb-right-trim.test.ts b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
new file mode 100644
index 000000000..c38b5b76b
--- /dev/null
+++ b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
@@ -0,0 +1,51 @@
+import dedent from "dedent"
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+
+import { ERBRightTrimRule } from "../../src/rules/erb-right-trim.js"
+
+describe("ERBRightTrimRule", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("when the erb tag close with %>", () => {
+    const html = dedent`
+      <h1>
+        <%= title %>
+      </h1>
+    `
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const lintResult = linter.lint(html)
+
+    expect(lintResult.offenses).toHaveLength(0)
+  })
+
+  test("when the erb tag close with -%>", () => {
+    const html = dedent`
+      <h1>
+        <%= title -%>
+      </h1>
+    `
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const lintResult = linter.lint(html)
+
+    expect(lintResult.offenses).toHaveLength(0)
+  })
+
+  test("when the erb tag close with =%>", () => {
+    const html = dedent`
+      <h1>
+        <%= title =%>
+    `
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const lintResult = linter.lint(html)
+
+    expect(lintResult.errors).toBe(1)
+    expect(lintResult.warnings).toBe(0)
+    expect(lintResult.offenses).toHaveLength(1)
+    expect(lintResult.offenses[0].code).toBe("erb-right-trim")
+    expect(lintResult.offenses[0].message).toBe("Prefer -%> instead of =%> for trimming on the right")
+  })
+})
diff --git a/javascript/packages/vscode/package.json b/javascript/packages/vscode/package.json
index 571a05a17..63036b345 100644
--- a/javascript/packages/vscode/package.json
+++ b/javascript/packages/vscode/package.json
@@ -68,6 +68,7 @@
               "erb-prefer-image-tag-helper",
               "erb-require-whitespace-inside-tags",
               "erb-requires-trailing-newline",
+              "erb-right-trim",
               "html-anchor-require-href",
               "html-aria-attribute-must-be-valid",
               "html-aria-label-is-well-formatted",

From 69a4d9761b32f21e38d55356fcaf4e32a513ffcb Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Fri, 3 Oct 2025 07:19:42 +0900
Subject: [PATCH 09/97] Add `visitNode` and `visitERBNode` methods to improve
 `erb-right-trim` (#569)

This pull request introduces two new methods `visitNode(node: Node)` and
`visitERBNode(node: ERBNode)` in the JavaScript visitor that allows to
visit any node, or visit any ERB node. This is useful and allows us to
improve the `erb-right-trim` introduced in #556.

This now updates the `erb-right-trim` to also handle cases where the
right trimming is used when it has no effect (like on non-outputting ERB
Nodes like `<%`).

/cc @domingo2000
---
 .../packages/linter/docs/rules/README.md      |  2 +-
 .../linter/docs/rules/erb-right-trim.md       | 52 ++++++++--
 .../linter/src/rules/erb-right-trim.ts        | 28 +++---
 .../packages/linter/src/rules/rule-utils.ts   |  4 +-
 .../linter/test/rules/erb-right-trim.test.ts  | 98 ++++++++++++++++++-
 .../packages/core/src/visitor.ts.erb          | 30 +++++-
 6 files changed, 189 insertions(+), 25 deletions(-)

diff --git a/javascript/packages/linter/docs/rules/README.md b/javascript/packages/linter/docs/rules/README.md
index 625d62d94..883a73b6a 100644
--- a/javascript/packages/linter/docs/rules/README.md
+++ b/javascript/packages/linter/docs/rules/README.md
@@ -11,7 +11,7 @@ This page contains documentation for all Herb Linter rules.
 - [`erb-prefer-image-tag-helper`](./erb-prefer-image-tag-helper.md) - Prefer `image_tag` helper over `<img>` with ERB expressions
 - [`erb-require-whitespace-inside-tags`](./erb-require-whitespace-inside-tags.md) - Requires whitespace around ERB tags
 - [`erb-requires-trailing-newline`](./erb-requires-trailing-newline.md) - Enforces that all HTML+ERB template files end with exactly one trailing newline character.
-- [`erb-right-trim`](./erb-right-trim.md) - Enforces trimming with `-`
+- [`erb-right-trim`](./erb-right-trim.md) - Enforce consistent right-trimming syntax.
 - [`html-anchor-require-href`](./html-anchor-require-href.md) - Requires an href attribute on anchor tags
 - [`html-aria-attribute-must-be-valid`](./html-aria-attribute-must-be-valid.md) - Disallow invalid or unknown `aria-*` attributes.
 - [`html-aria-label-is-well-formatted`](./html-aria-label-is-well-formatted.md) - `aria-label` must be well-formatted
diff --git a/javascript/packages/linter/docs/rules/erb-right-trim.md b/javascript/packages/linter/docs/rules/erb-right-trim.md
index b44861994..74901eed9 100644
--- a/javascript/packages/linter/docs/rules/erb-right-trim.md
+++ b/javascript/packages/linter/docs/rules/erb-right-trim.md
@@ -1,23 +1,57 @@
-# Linter Rule: Enforces trimming with -
+# Linter Rule: Enforce consistent right-trimming syntax
 
-**Rule:**: `erb-right-trim`
+**Rule:** `erb-right-trim`
 
-Trimming at the right of an ERB tag can be done with either =%&gt; or -%&gt;, this linter enforces "-" as the default trimming style.
+## Description
+
+This rule enforces the use of `-%>` for right-trimming ERB output tags (like `<%= %>`) instead of `=%>`. It also warns when right-trimming syntax (`-%>` or `=%>`) is used on non-output ERB tags (like `<% %>`, `<% if %>`, etc.) where it has no effect.
+
+## Rationale
+
+While `=%>` can be used for right-trimming whitespace in some ERB engines (like Erubi), it is an obscure and not well-defined syntax that lacks consistent support across most ERB implementations. The `-%>` syntax is the standard, well-documented approach for right-trimming that is universally supported and consistent with left-trimming syntax (`<%-`).
+
+Additionally, right-trimming syntax only has an effect on ERB output tags (`<%=` and `<%==`). Using `-%>` or `=%>` on non-output ERB tags (control flow like `<% if %>`, `<% each %>`, etc.) has no effect and is misleading.
+
+Using `-%>` for output tags ensures compatibility across different ERB engines, improves code clarity, and aligns with established Rails and ERB conventions.
 
 ## Examples
 
-### ❌ Incorrect
+### ✅ Good
 
 ```erb
-<%= title =%>
+<%= title -%>
+
+<% if true %>
+  <h1>Content</h1>
+<% end %>
+
+<% items.each do |item| %>
+  <li><%= item -%></li>
+<% end %>
 ```
 
-### ✅ Correct
+### 🚫 Bad
 
 ```erb
-<%= title -%>
+<%= title =%>
+
+
+<% title =%>
+
+
+<% title -%>
+
+
+<% if true -%>
+  <h1>Content</h1>
+<% end %>
+
+
+<% items.each do |item| =%>
+  <li><%= item %></li>
+<% end %>
 ```
 
-## Configuration
+## References
 
-This rule has no configuration options.
+- [Inspiration: ERB Lint `RightTrim` rule](https://github.com/Shopify/erb_lint/blob/main/README.md#righttrim)
diff --git a/javascript/packages/linter/src/rules/erb-right-trim.ts b/javascript/packages/linter/src/rules/erb-right-trim.ts
index ccd3083e3..182db6857 100644
--- a/javascript/packages/linter/src/rules/erb-right-trim.ts
+++ b/javascript/packages/linter/src/rules/erb-right-trim.ts
@@ -1,28 +1,34 @@
 import { BaseRuleVisitor } from "./rule-utils.js"
 import { ParserRule } from "../types.js"
+import { isERBOutputNode } from "@herb-tools/core"
 
 import type { LintOffense, LintContext } from "../types.js"
-import type { ERBContentNode, ParseResult } from "@herb-tools/core"
+import type { ERBNode, ParseResult } from "@herb-tools/core"
 
 class ERBRightTrimVisitor extends BaseRuleVisitor {
-  
-  visitERBContentNode(node: ERBContentNode): void {
-    if (!node.tag_closing) {
-      return
-    }
+  visitERBNode(node: ERBNode): void {
+    if (!node.tag_closing) return
+
+    const trimClosing = node.tag_closing.value
+
+    if (trimClosing !== "=%>" && trimClosing !== "-%>") return
+
+    if (!isERBOutputNode(node)) {
+      this.addOffense(
+        `Right-trimming with \`${trimClosing}\` has no effect on non-output ERB tags. Use \`%>\` instead`,
+        node.tag_closing.location
+      )
 
-    if (!node.content?.value) {
       return
     }
 
-    if (node.tag_closing.value === "=%>") {
+    if (trimClosing === "=%>") {
       this.addOffense(
-        "Prefer -%> instead of =%> for trimming on the right",
-        node.location
+        "Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines",
+        node.tag_closing.location
       )
     }
   }
-
 }
 
 export class ERBRightTrimRule extends ParserRule {
diff --git a/javascript/packages/linter/src/rules/rule-utils.ts b/javascript/packages/linter/src/rules/rule-utils.ts
index 911b16783..ae29bc634 100644
--- a/javascript/packages/linter/src/rules/rule-utils.ts
+++ b/javascript/packages/linter/src/rules/rule-utils.ts
@@ -13,7 +13,7 @@ import {
 } from "@herb-tools/core"
 
 import type {
-  ERBNode,
+  ERBContentNode,
   HTMLAttributeNameNode,
   HTMLAttributeNode,
   HTMLAttributeValueNode,
@@ -300,7 +300,7 @@ export function getAttributeValue(attributeNode: HTMLAttributeNode): string | nu
   for (const child of valueNode.children) {
     switch (child.type) {
       case "AST_ERB_CONTENT_NODE": {
-        const erbNode = child as ERBNode
+        const erbNode = child as ERBContentNode
 
         if (erbNode.content) {
           result += `${erbNode.tag_opening?.value}${erbNode.content.value}${erbNode.tag_closing?.value}`
diff --git a/javascript/packages/linter/test/rules/erb-right-trim.test.ts b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
index c38b5b76b..3e97321a4 100644
--- a/javascript/packages/linter/test/rules/erb-right-trim.test.ts
+++ b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
@@ -46,6 +46,102 @@ describe("ERBRightTrimRule", () => {
     expect(lintResult.warnings).toBe(0)
     expect(lintResult.offenses).toHaveLength(1)
     expect(lintResult.offenses[0].code).toBe("erb-right-trim")
-    expect(lintResult.offenses[0].message).toBe("Prefer -%> instead of =%> for trimming on the right")
+    expect(lintResult.offenses[0].message).toBe("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines")
+  })
+
+  test("when an if block uses =%>", () => {
+    const html = dedent`
+      <% if condition =%>
+        <p>Content</p>
+      <% end %>
+    `
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const lintResult = linter.lint(html)
+
+    expect(lintResult.errors).toBe(1)
+    expect(lintResult.warnings).toBe(0)
+    expect(lintResult.offenses).toHaveLength(1)
+    expect(lintResult.offenses[0].code).toBe("erb-right-trim")
+    expect(lintResult.offenses[0].message).toBe("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
+  })
+
+  test("when an if-else block uses =%>", () => {
+    const html = dedent`
+      <% if condition =%>
+        <p>True branch</p>
+      <% else =%>
+        <p>False branch</p>
+      <% end %>
+    `
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const lintResult = linter.lint(html)
+
+    expect(lintResult.errors).toBe(2)
+    expect(lintResult.warnings).toBe(0)
+    expect(lintResult.offenses).toHaveLength(2)
+    expect(lintResult.offenses[0].code).toBe("erb-right-trim")
+
+    expect(lintResult.offenses[0].message).toBe("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
+    expect(lintResult.offenses[1].message).toBe("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
+  })
+
+  test("when each block uses =%>", () => {
+    const html = dedent`
+      <% items.each do |item| =%>
+        <li><%= item %></li>
+      <% end %>
+    `
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const lintResult = linter.lint(html)
+
+    expect(lintResult.errors).toBe(1)
+    expect(lintResult.warnings).toBe(0)
+    expect(lintResult.offenses).toHaveLength(1)
+    expect(lintResult.offenses[0].code).toBe("erb-right-trim")
+    expect(lintResult.offenses[0].message).toBe("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
+  })
+
+  test("when non-output tag uses -%>", () => {
+    const html = dedent`
+      <% if condition -%>
+        <p>Content</p>
+      <% elsif other_condition -%>
+        <p>Content</p>
+      <% elsif yet_another_condition -%>
+        <p>Content</p>
+      <% else -%>
+        <p>Content</p>
+      <% end -%>
+    `
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const lintResult = linter.lint(html)
+
+    expect(lintResult.errors).toBe(5)
+    expect(lintResult.warnings).toBe(0)
+    expect(lintResult.offenses).toHaveLength(5)
+
+    expect(lintResult.offenses[0].code).toBe("erb-right-trim")
+    expect(lintResult.offenses[0].message).toBe("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
+    expect(lintResult.offenses[1].message).toBe("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
+    expect(lintResult.offenses[2].message).toBe("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
+    expect(lintResult.offenses[3].message).toBe("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
+    expect(lintResult.offenses[4].message).toBe("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
+  })
+
+  test("when multiple non-output tags use trimming", () => {
+    const html = dedent`
+      <% items.each do |item| -%>
+        <li><%= item %></li>
+      <% end -%>
+    `
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const lintResult = linter.lint(html)
+
+    expect(lintResult.errors).toBe(2)
+    expect(lintResult.warnings).toBe(0)
+    expect(lintResult.offenses).toHaveLength(2)
+
+    expect(lintResult.offenses[0].message).toBe("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
+    expect(lintResult.offenses[1].message).toBe("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
   })
 })
diff --git a/templates/javascript/packages/core/src/visitor.ts.erb b/templates/javascript/packages/core/src/visitor.ts.erb
index 47a7cfade..f38a060fc 100644
--- a/templates/javascript/packages/core/src/visitor.ts.erb
+++ b/templates/javascript/packages/core/src/visitor.ts.erb
@@ -1,11 +1,27 @@
 import {
   Node,
+  ERBNode,
   <%- nodes.each do |node| -%>
   <%= node.name %>,
   <%- end -%>
 } from "./nodes.js"
 
-export class Visitor {
+/**
+ * Interface that enforces all node visit methods are implemented
+ * This ensures that any class implementing IVisitor must have a visit method for every node type
+ */
+export interface IVisitor {
+  visit(node: Node | null | undefined): void
+  visitAll(nodes: (Node | null | undefined)[]): void
+  visitChildNodes(node: Node): void
+  <%- nodes.each do |node| -%>
+  visit<%= node.name %>(node: <%= node.name %>): void
+  <%- end -%>
+  visitNode(node: Node): void
+  visitERBNode(node: ERBNode): void
+}
+
+export class Visitor implements IVisitor {
   visit(node: Node | null | undefined): void {
     if (!node) return
 
@@ -20,8 +36,20 @@ export class Visitor {
     node.compactChildNodes().forEach(node => node.accept(this))
   }
 
+  visitNode(_node: Node): void {
+    // Default implementation does nothing
+  }
+
+  visitERBNode(_node: ERBNode): void {
+    // Default implementation does nothing
+  }
+
   <%- nodes.each do |node| -%>
   visit<%= node.name %>(node: <%= node.name %>): void {
+    this.visitNode(node)
+    <%- if node.name.start_with?("ERB") -%>
+    this.visitERBNode(node)
+    <%- end -%>
     this.visitChildNodes(node)
   }
 

From 0e028d1b45b9ed8c5fe0bfd7fac40f7bbcdd3927 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Fri, 3 Oct 2025 07:29:18 +0900
Subject: [PATCH 10/97] Linter Rule: Refactor
 `erb-require-whitespace-inside-tags` to use `visitERBNode` (#570)

This pull request updates the `erb-require-whitespace-inside-tags`
linter rule to use the new `visitERBNode` method in the visitor
introduced in #569.
---
 .../rules/erb-require-whitespace-inside-tags.ts  | 16 ++++------------
 1 file changed, 4 insertions(+), 12 deletions(-)

diff --git a/javascript/packages/linter/src/rules/erb-require-whitespace-inside-tags.ts b/javascript/packages/linter/src/rules/erb-require-whitespace-inside-tags.ts
index 3c5b1c896..05021794f 100644
--- a/javascript/packages/linter/src/rules/erb-require-whitespace-inside-tags.ts
+++ b/javascript/packages/linter/src/rules/erb-require-whitespace-inside-tags.ts
@@ -1,20 +1,12 @@
-import type { ParseResult, Token, Node } from "@herb-tools/core"
-import { isERBNode } from "@herb-tools/core";
 import { ParserRule } from "../types.js"
-import type { LintOffense, LintContext } from "../types.js"
 import { BaseRuleVisitor } from "./rule-utils.js"
 
-class RequireWhitespaceInsideTags extends BaseRuleVisitor {
+import type { LintOffense, LintContext } from "../types.js"
+import type { ParseResult, Token, ERBNode } from "@herb-tools/core"
 
-  visitChildNodes(node: Node): void {
-    this.checkWhitespace(node)
-    super.visitChildNodes(node)
-  }
+class RequireWhitespaceInsideTags extends BaseRuleVisitor {
 
-  private checkWhitespace(node: Node): void {
-    if (!isERBNode(node)) {
-      return
-    }
+  visitERBNode(node: ERBNode): void {
     const openTag = node.tag_opening
     const closeTag = node.tag_closing
     const content = node.content

From edf93582f7a923b31ee28f48c791f466a4a1b8f8 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Sat, 4 Oct 2025 09:16:21 +0900
Subject: [PATCH 11/97] docs: Add References section to `erb-comment-syntax`
 linter rule

Signed-off-by: Marco Roth <marco.roth@intergga.ch>
---
 javascript/packages/linter/docs/rules/erb-comment-syntax.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/javascript/packages/linter/docs/rules/erb-comment-syntax.md b/javascript/packages/linter/docs/rules/erb-comment-syntax.md
index a4891b51f..b3c9ae781 100644
--- a/javascript/packages/linter/docs/rules/erb-comment-syntax.md
+++ b/javascript/packages/linter/docs/rules/erb-comment-syntax.md
@@ -38,3 +38,7 @@ For multi-line comments or actual Ruby code with comments, ensure the content st
 
 <%== # This should also be an ERB comment %>
 ```
+
+## References
+
+- [Inspiration: ERB Lint `CommentSyntax` rule](https://github.com/shopify/erb_lint?tab=readme-ov-file#commentsyntax)

From abaeeb77bbf9ae60af847d1f7884a5b6d9226e6f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Sun, 5 Oct 2025 06:44:35 +0200
Subject: [PATCH 12/97] C: Localize token struct members (#529)

## What it does

This PR removes the need for heap allocating the struct members of a
token (position, range, location)

## How it does it

- Change the `token_T` members `range` and `location` to be structs,
instead of pointers to structs
- Change `location_T` members `start` and `end` to be structs, instead
of pointers to structs
- Removes functions only used to access struct members, as they were not
consistently used anyway
- Removes init functions that do not add anything beyond providing a 1-1
mapping of argument to struct members
- Removes copy methods as we are passing the structs by value
- Use 32bit unsigned integers for range/position/location struct
members, effectively limiting the parseable filesize to 2^32-1 bytes
(4gb) which for all intents and purposes (templates after all) should
more than suffice. Saves a bit of memory without any real world
drawbacks.
---
 config.yml                                    |  28 +--
 ext/herb/extension_helpers.c                  |  24 +-
 ext/herb/extension_helpers.h                  |   6 +-
 javascript/packages/node/binding.gyp          |   1 -
 .../node/extension/extension_helpers.cpp      |  36 +--
 .../node/extension/extension_helpers.h        |   6 +-
 src/analyze.c                                 |  78 +++----
 src/ast_node.c                                |  23 +-
 src/include/ast_node.h                        |   6 +-
 src/include/lexer_peek_helpers.h              |  13 +-
 src/include/lexer_struct.h                    |  19 +-
 src/include/location.h                        |  23 +-
 src/include/parser_helpers.h                  |   2 +-
 src/include/position.h                        |  17 +-
 src/include/pretty_print.h                    |   2 +-
 src/include/prism_helpers.h                   |   2 +-
 src/include/range.h                           |  17 +-
 src/include/token.h                           |   3 -
 src/include/token_struct.h                    |   4 +-
 src/lexer.c                                   |   4 +-
 src/lexer_peek_helpers.c                      |   6 +-
 src/location.c                                |  46 +---
 src/parser.c                                  | 217 ++++++++----------
 src/parser_helpers.c                          |  30 +--
 src/position.c                                |  33 ---
 src/pretty_print.c                            |  19 +-
 src/prism_helpers.c                           |  14 +-
 src/range.c                                   |  37 +--
 src/token.c                                   |  54 ++---
 templates/src/ast_nodes.c.erb                 |   4 +-
 templates/src/errors.c.erb                    |  12 +-
 templates/src/include/ast_nodes.h.erb         |   4 +-
 templates/src/include/errors.h.erb            |   6 +-
 wasm/extension_helpers.cpp                    |  30 +--
 wasm/extension_helpers.h                      |   6 +-
 35 files changed, 320 insertions(+), 512 deletions(-)
 delete mode 100644 src/position.c

diff --git a/config.yml b/config.yml
index b67bfb480..df26a43fa 100644
--- a/config.yml
+++ b/config.yml
@@ -34,8 +34,8 @@ errors:
         arguments:
           - token_type_to_string(found->type)
           - token_type_to_string(expected_type)
-          - found->location->start->line
-          - found->location->start->column
+          - found->location.start.line
+          - found->location.start.column
 
       fields:
         - name: expected_type
@@ -49,8 +49,8 @@ errors:
         template: "Found closing tag `</%s>` at (%zu:%zu) without a matching opening tag."
         arguments:
           - closing_tag->value
-          - closing_tag->location->start->line
-          - closing_tag->location->start->column
+          - closing_tag->location.start.line
+          - closing_tag->location.start.column
 
       fields:
         - name: closing_tag
@@ -61,8 +61,8 @@ errors:
         template: "Opening tag `<%s>` at (%zu:%zu) doesn't have a matching closing tag `</%s>`."
         arguments:
           - opening_tag->value
-          - opening_tag->location->start->line
-          - opening_tag->location->start->column
+          - opening_tag->location.start.line
+          - opening_tag->location.start.column
           - opening_tag->value
 
       fields:
@@ -74,11 +74,11 @@ errors:
         template: "Opening tag `<%s>` at (%zu:%zu) closed with `</%s>` at (%zu:%zu)."
         arguments:
           - opening_tag->value
-          - opening_tag->location->start->line
-          - opening_tag->location->start->column
+          - opening_tag->location.start.line
+          - opening_tag->location.start.column
           - closing_tag->value
-          - closing_tag->location->start->line
-          - closing_tag->location->start->column
+          - closing_tag->location.start.line
+          - closing_tag->location.start.column
 
       fields:
         - name: opening_tag
@@ -93,8 +93,8 @@ errors:
         arguments:
           - opening_quote->value
           - closing_quote->value
-          - closing_quote->location->start->line
-          - closing_quote->location->start->column
+          - closing_quote->location.start.line
+          - closing_quote->location.start.column
 
       fields:
         - name: opening_quote
@@ -127,8 +127,8 @@ errors:
         template: "Tag `<%s>` opened at (%zu:%zu) was never closed before the end of document."
         arguments:
           - opening_tag->value
-          - opening_tag->location->start->line
-          - opening_tag->location->start->column
+          - opening_tag->location.start.line
+          - opening_tag->location.start.column
 
       fields:
         - name: opening_tag
diff --git a/ext/herb/extension_helpers.c b/ext/herb/extension_helpers.c
index 875f34d1f..e9ab162b5 100644
--- a/ext/herb/extension_helpers.c
+++ b/ext/herb/extension_helpers.c
@@ -20,32 +20,26 @@ const char* check_string(VALUE value) {
   return RSTRING_PTR(value);
 }
 
-VALUE rb_position_from_c_struct(position_T* position) {
-  if (!position) { return Qnil; }
-
+VALUE rb_position_from_c_struct(position_T position) {
   VALUE args[2];
-  args[0] = SIZET2NUM(position->line);
-  args[1] = SIZET2NUM(position->column);
+  args[0] = UINT2NUM(position.line);
+  args[1] = UINT2NUM(position.column);
 
   return rb_class_new_instance(2, args, cPosition);
 }
 
-VALUE rb_location_from_c_struct(location_T* location) {
-  if (!location) { return Qnil; }
-
+VALUE rb_location_from_c_struct(location_T location) {
   VALUE args[2];
-  args[0] = rb_position_from_c_struct(location->start);
-  args[1] = rb_position_from_c_struct(location->end);
+  args[0] = rb_position_from_c_struct(location.start);
+  args[1] = rb_position_from_c_struct(location.end);
 
   return rb_class_new_instance(2, args, cLocation);
 }
 
-VALUE rb_range_from_c_struct(range_T* range) {
-  if (!range) { return Qnil; }
-
+VALUE rb_range_from_c_struct(range_T range) {
   VALUE args[2];
-  args[0] = SIZET2NUM(range->from);
-  args[1] = SIZET2NUM(range->to);
+  args[0] = UINT2NUM(range.from);
+  args[1] = UINT2NUM(range.to);
 
   return rb_class_new_instance(2, args, cRange);
 }
diff --git a/ext/herb/extension_helpers.h b/ext/herb/extension_helpers.h
index 120cbf8ba..d672da2b3 100644
--- a/ext/herb/extension_helpers.h
+++ b/ext/herb/extension_helpers.h
@@ -12,11 +12,11 @@
 const char* check_string(VALUE value);
 VALUE read_file_to_ruby_string(const char* file_path);
 
-VALUE rb_position_from_c_struct(position_T* position);
-VALUE rb_location_from_c_struct(location_T* location);
+VALUE rb_position_from_c_struct(position_T position);
+VALUE rb_location_from_c_struct(location_T location);
 
 VALUE rb_token_from_c_struct(token_T* token);
-VALUE rb_range_from_c_struct(range_T* range);
+VALUE rb_range_from_c_struct(range_T range);
 
 VALUE create_lex_result(array_T* tokens, VALUE source);
 VALUE create_parse_result(AST_DOCUMENT_NODE_T* root, VALUE source);
diff --git a/javascript/packages/node/binding.gyp b/javascript/packages/node/binding.gyp
index 95096ee66..8afbd6559 100644
--- a/javascript/packages/node/binding.gyp
+++ b/javascript/packages/node/binding.gyp
@@ -31,7 +31,6 @@
         "./extension/libherb/memory.c",
         "./extension/libherb/parser_helpers.c",
         "./extension/libherb/parser.c",
-        "./extension/libherb/position.c",
         "./extension/libherb/pretty_print.c",
         "./extension/libherb/prism_helpers.c",
         "./extension/libherb/range.c",
diff --git a/javascript/packages/node/extension/extension_helpers.cpp b/javascript/packages/node/extension/extension_helpers.cpp
index e64c18dc1..d48b7556f 100644
--- a/javascript/packages/node/extension/extension_helpers.cpp
+++ b/javascript/packages/node/extension/extension_helpers.cpp
@@ -46,19 +46,13 @@ napi_value CreateString(napi_env env, const char* str) {
   return result;
 }
 
-napi_value CreatePosition(napi_env env, position_T* position) {
-  if (!position) {
-    napi_value null_value;
-    napi_get_null(env, &null_value);
-    return null_value;
-  }
-
+napi_value CreatePosition(napi_env env, position_T position) {
   napi_value result;
   napi_create_object(env, &result);
 
   napi_value line, column;
-  napi_create_uint32(env, (uint32_t)position->line, &line);
-  napi_create_uint32(env, (uint32_t)position->column, &column);
+  napi_create_uint32(env, (uint32_t)position.line, &line);
+  napi_create_uint32(env, (uint32_t)position.column, &column);
 
   napi_set_named_property(env, result, "line", line);
   napi_set_named_property(env, result, "column", column);
@@ -66,18 +60,12 @@ napi_value CreatePosition(napi_env env, position_T* position) {
   return result;
 }
 
-napi_value CreateLocation(napi_env env, location_T* location) {
-  if (!location) {
-    napi_value null_value;
-    napi_get_null(env, &null_value);
-    return null_value;
-  }
-
+napi_value CreateLocation(napi_env env, location_T location) {
   napi_value result;
   napi_create_object(env, &result);
 
-  napi_value start = CreatePosition(env, location->start);
-  napi_value end = CreatePosition(env, location->end);
+  napi_value start = CreatePosition(env, location.start);
+  napi_value end = CreatePosition(env, location.end);
 
   napi_set_named_property(env, result, "start", start);
   napi_set_named_property(env, result, "end", end);
@@ -85,19 +73,13 @@ napi_value CreateLocation(napi_env env, location_T* location) {
   return result;
 }
 
-napi_value CreateRange(napi_env env, range_T* range) {
-  if (!range) {
-    napi_value null_value;
-    napi_get_null(env, &null_value);
-    return null_value;
-  }
-
+napi_value CreateRange(napi_env env, range_T range) {
   napi_value result;
   napi_create_array(env, &result);
 
   napi_value from, to;
-  napi_create_uint32(env, (uint32_t)range->from, &from);
-  napi_create_uint32(env, (uint32_t)range->to, &to);
+  napi_create_uint32(env, (uint32_t)range.from, &from);
+  napi_create_uint32(env, (uint32_t)range.to, &to);
 
   napi_set_element(env, result, 0, from);
   napi_set_element(env, result, 1, to);
diff --git a/javascript/packages/node/extension/extension_helpers.h b/javascript/packages/node/extension/extension_helpers.h
index 7387ea9d8..6bfa4f1aa 100644
--- a/javascript/packages/node/extension/extension_helpers.h
+++ b/javascript/packages/node/extension/extension_helpers.h
@@ -14,9 +14,9 @@ napi_value ReadFileToString(napi_env env, const char* file_path);
 napi_value CreateLexResult(napi_env env, array_T* tokens, napi_value source);
 napi_value CreateParseResult(napi_env env, AST_DOCUMENT_NODE_T* root, napi_value source);
 
-napi_value CreateLocation(napi_env env, location_T* location);
+napi_value CreateLocation(napi_env env, location_T location);
 napi_value CreateToken(napi_env env, token_T* token);
-napi_value CreatePosition(napi_env env, position_T* position);
-napi_value CreateRange(napi_env env, range_T* range);
+napi_value CreatePosition(napi_env env, position_T position);
+napi_value CreateRange(napi_env env, range_T range);
 
 #endif
diff --git a/src/analyze.c b/src/analyze.c
index 8c0a7ea4a..5ed8215db 100644
--- a/src/analyze.c
+++ b/src/analyze.c
@@ -158,16 +158,16 @@ static AST_NODE_T* create_control_node(
   control_type_t control_type
 ) {
   array_T* errors = array_init(8);
-  position_T* start_position = erb_node->tag_opening->location->start;
-  position_T* end_position = erb_node->tag_closing->location->end;
+  position_T start_position = erb_node->tag_opening->location.start;
+  position_T end_position = erb_node->tag_closing->location.end;
 
   if (end_node) {
-    end_position = end_node->base.location->end;
+    end_position = end_node->base.location.end;
   } else if (children && array_size(children) > 0) {
     AST_NODE_T* last_child = array_get(children, array_size(children) - 1);
-    end_position = last_child->location->end;
+    end_position = last_child->location.end;
   } else if (subsequent) {
-    end_position = subsequent->location->end;
+    end_position = subsequent->location.end;
   }
 
   token_T* tag_opening = erb_node->tag_opening;
@@ -459,8 +459,8 @@ static size_t process_control_structure(
           erb_content->content,
           erb_content->tag_closing,
           when_statements,
-          erb_content->tag_opening->location->start,
-          erb_content->tag_closing->location->end,
+          erb_content->tag_opening->location.start,
+          erb_content->tag_closing->location.end,
           array_init(8)
         );
 
@@ -495,8 +495,8 @@ static size_t process_control_structure(
           erb_content->content,
           erb_content->tag_closing,
           in_statements,
-          erb_content->tag_opening->location->start,
-          erb_content->tag_closing->location->end,
+          erb_content->tag_opening->location.start,
+          erb_content->tag_closing->location.end,
           array_init(8)
         );
 
@@ -546,8 +546,8 @@ static size_t process_control_structure(
             next_erb->content,
             next_erb->tag_closing,
             else_children,
-            next_erb->tag_opening->location->start,
-            next_erb->tag_closing->location->end,
+            next_erb->tag_opening->location.start,
+            next_erb->tag_closing->location.end,
             array_init(8)
           );
         }
@@ -567,8 +567,8 @@ static size_t process_control_structure(
             end_erb->tag_opening,
             end_erb->content,
             end_erb->tag_closing,
-            end_erb->tag_opening->location->start,
-            end_erb->tag_closing->location->end,
+            end_erb->tag_opening->location.start,
+            end_erb->tag_closing->location.end,
             end_erb->base.errors
           );
 
@@ -577,19 +577,19 @@ static size_t process_control_structure(
       }
     }
 
-    position_T* start_position = erb_node->tag_opening->location->start;
-    position_T* end_position = erb_node->tag_closing->location->end;
+    position_T start_position = erb_node->tag_opening->location.start;
+    position_T end_position = erb_node->tag_closing->location.end;
 
     if (end_node) {
-      end_position = end_node->base.location->end;
+      end_position = end_node->base.location.end;
     } else if (else_clause) {
-      end_position = else_clause->base.location->end;
+      end_position = else_clause->base.location.end;
     } else if (array_size(when_conditions) > 0) {
       AST_NODE_T* last_when = array_get(when_conditions, array_size(when_conditions) - 1);
-      end_position = last_when->location->end;
+      end_position = last_when->location.end;
     } else if (array_size(in_conditions) > 0) {
       AST_NODE_T* last_in = array_get(in_conditions, array_size(in_conditions) - 1);
-      end_position = last_in->location->end;
+      end_position = last_in->location.end;
     }
 
     if (array_size(in_conditions) > 0) {
@@ -682,8 +682,8 @@ static size_t process_control_structure(
             next_erb->content,
             next_erb->tag_closing,
             else_children,
-            next_erb->tag_opening->location->start,
-            next_erb->tag_closing->location->end,
+            next_erb->tag_opening->location.start,
+            next_erb->tag_closing->location.end,
             array_init(8)
           );
         }
@@ -723,8 +723,8 @@ static size_t process_control_structure(
             next_erb->content,
             next_erb->tag_closing,
             ensure_children,
-            next_erb->tag_opening->location->start,
-            next_erb->tag_closing->location->end,
+            next_erb->tag_opening->location.start,
+            next_erb->tag_closing->location.end,
             array_init(8)
           );
         }
@@ -744,8 +744,8 @@ static size_t process_control_structure(
             end_erb->tag_opening,
             end_erb->content,
             end_erb->tag_closing,
-            end_erb->tag_opening->location->start,
-            end_erb->tag_closing->location->end,
+            end_erb->tag_opening->location.start,
+            end_erb->tag_closing->location.end,
             end_erb->base.errors
           );
 
@@ -754,17 +754,17 @@ static size_t process_control_structure(
       }
     }
 
-    position_T* start_position = erb_node->tag_opening->location->start;
-    position_T* end_position = erb_node->tag_closing->location->end;
+    position_T start_position = erb_node->tag_opening->location.start;
+    position_T end_position = erb_node->tag_closing->location.end;
 
     if (end_node) {
-      end_position = end_node->base.location->end;
+      end_position = end_node->base.location.end;
     } else if (ensure_clause) {
-      end_position = ensure_clause->base.location->end;
+      end_position = ensure_clause->base.location.end;
     } else if (else_clause) {
-      end_position = else_clause->base.location->end;
+      end_position = else_clause->base.location.end;
     } else if (rescue_clause) {
-      end_position = rescue_clause->base.location->end;
+      end_position = rescue_clause->base.location.end;
     }
 
     AST_ERB_BEGIN_NODE_T* begin_node = ast_erb_begin_node_init(
@@ -802,8 +802,8 @@ static size_t process_control_structure(
             close_erb->tag_opening,
             close_erb->content,
             close_erb->tag_closing,
-            close_erb->tag_opening->location->start,
-            close_erb->tag_closing->location->end,
+            close_erb->tag_opening->location.start,
+            close_erb->tag_closing->location.end,
             close_erb->base.errors
           );
 
@@ -812,14 +812,14 @@ static size_t process_control_structure(
       }
     }
 
-    position_T* start_position = erb_node->tag_opening->location->start;
-    position_T* end_position = erb_node->tag_closing->location->end;
+    position_T start_position = erb_node->tag_opening->location.start;
+    position_T end_position = erb_node->tag_closing->location.end;
 
     if (end_node) {
-      end_position = end_node->base.location->end;
+      end_position = end_node->base.location.end;
     } else if (children && array_size(children) > 0) {
       AST_NODE_T* last_child = array_get(children, array_size(children) - 1);
-      end_position = last_child->location->end;
+      end_position = last_child->location.end;
     }
 
     AST_ERB_BLOCK_NODE_T* block_node = ast_erb_block_node_init(
@@ -866,8 +866,8 @@ static size_t process_control_structure(
           end_erb->tag_opening,
           end_erb->content,
           end_erb->tag_closing,
-          end_erb->tag_opening->location->start,
-          end_erb->tag_closing->location->end,
+          end_erb->tag_opening->location.start,
+          end_erb->tag_closing->location.end,
           end_erb->base.errors
         );
 
diff --git a/src/ast_node.c b/src/ast_node.c
index 350599c13..c70acb936 100644
--- a/src/ast_node.c
+++ b/src/ast_node.c
@@ -12,11 +12,12 @@ size_t ast_node_sizeof(void) {
   return sizeof(struct AST_NODE_STRUCT);
 }
 
-void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T* start, position_T* end, array_T* errors) {
+void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T start, position_T end, array_T* errors) {
   if (!node) { return; }
 
   node->type = type;
-  node->location = location_init(position_copy(start), position_copy(end));
+  node->location.start = start;
+  node->location.end = end;
 
   if (errors == NULL) {
     node->errors = array_init(8);
@@ -28,7 +29,7 @@ void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T* sta
 AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token) {
   AST_LITERAL_NODE_T* literal = malloc(sizeof(AST_LITERAL_NODE_T));
 
-  ast_node_init(&literal->base, AST_LITERAL_NODE, token->location->start, token->location->end, NULL);
+  ast_node_init(&literal->base, AST_LITERAL_NODE, token->location.start, token->location.end, NULL);
 
   literal->content = herb_strdup(token->value);
 
@@ -51,24 +52,20 @@ void ast_node_append_error(const AST_NODE_T* node, ERROR_T* error) {
   array_append(node->errors, error);
 }
 
-void ast_node_set_start(AST_NODE_T* node, position_T* position) {
-  if (node->location->start != NULL) { position_free(node->location->start); }
-
-  node->location->start = position_copy(position);
+void ast_node_set_start(AST_NODE_T* node, position_T position) {
+  node->location.start = position;
 }
 
-void ast_node_set_end(AST_NODE_T* node, position_T* position) {
-  if (node->location->end != NULL) { position_free(node->location->end); }
-
-  node->location->end = position_copy(position);
+void ast_node_set_end(AST_NODE_T* node, position_T position) {
+  node->location.end = position;
 }
 
 void ast_node_set_start_from_token(AST_NODE_T* node, const token_T* token) {
-  ast_node_set_start(node, token->location->start);
+  ast_node_set_start(node, token->location.start);
 }
 
 void ast_node_set_end_from_token(AST_NODE_T* node, const token_T* token) {
-  ast_node_set_end(node, token->location->end);
+  ast_node_set_end(node, token->location.end);
 }
 
 void ast_node_set_positions_from_token(AST_NODE_T* node, const token_T* token) {
diff --git a/src/include/ast_node.h b/src/include/ast_node.h
index e41ece34a..23af16d0c 100644
--- a/src/include/ast_node.h
+++ b/src/include/ast_node.h
@@ -6,7 +6,7 @@
 #include "position.h"
 #include "token_struct.h"
 
-void ast_node_init(AST_NODE_T* node, ast_node_type_T type, position_T* start, position_T* end, array_T* errors);
+void ast_node_init(AST_NODE_T* node, ast_node_type_T type, position_T start, position_T end, array_T* errors);
 void ast_node_free(AST_NODE_T* node);
 
 AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token);
@@ -18,8 +18,8 @@ ast_node_type_T ast_node_type(const AST_NODE_T* node);
 
 char* ast_node_name(AST_NODE_T* node);
 
-void ast_node_set_start(AST_NODE_T* node, position_T* position);
-void ast_node_set_end(AST_NODE_T* node, position_T* position);
+void ast_node_set_start(AST_NODE_T* node, position_T position);
+void ast_node_set_end(AST_NODE_T* node, position_T position);
 
 size_t ast_node_errors_count(const AST_NODE_T* node);
 array_T* ast_node_errors(const AST_NODE_T* node);
diff --git a/src/include/lexer_peek_helpers.h b/src/include/lexer_peek_helpers.h
index faa0ecec8..c89ca2e08 100644
--- a/src/include/lexer_peek_helpers.h
+++ b/src/include/lexer_peek_helpers.h
@@ -5,16 +5,17 @@
 #include "token_struct.h"
 
 #include <stdbool.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 typedef struct {
-  size_t position;
-  size_t line;
-  size_t column;
-  size_t previous_position;
-  size_t previous_line;
-  size_t previous_column;
+  uint32_t position;
+  uint32_t line;
+  uint32_t column;
+  uint32_t previous_position;
+  uint32_t previous_line;
+  uint32_t previous_column;
   char current_character;
   lexer_state_T state;
 } lexer_state_snapshot_T;
diff --git a/src/include/lexer_struct.h b/src/include/lexer_struct.h
index 709233884..0b305acf5 100644
--- a/src/include/lexer_struct.h
+++ b/src/include/lexer_struct.h
@@ -2,6 +2,7 @@
 #define HERB_LEXER_STRUCT_H
 
 #include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 
 typedef enum {
@@ -12,20 +13,20 @@ typedef enum {
 
 typedef struct LEXER_STRUCT {
   const char* source;
-  size_t source_length;
+  uint32_t source_length;
 
-  size_t current_line;
-  size_t current_column;
-  size_t current_position;
+  uint32_t current_line;
+  uint32_t current_column;
+  uint32_t current_position;
 
-  size_t previous_line;
-  size_t previous_column;
-  size_t previous_position;
+  uint32_t previous_line;
+  uint32_t previous_column;
+  uint32_t previous_position;
 
   char current_character;
   lexer_state_T state;
-  size_t stall_counter;
-  size_t last_position;
+  uint32_t stall_counter;
+  uint32_t last_position;
   bool stalled;
 } lexer_T;
 
diff --git a/src/include/location.h b/src/include/location.h
index ef07ba688..d01c94aa9 100644
--- a/src/include/location.h
+++ b/src/include/location.h
@@ -1,25 +1,22 @@
 #ifndef HERB_LOCATION_H
 #define HERB_LOCATION_H
 
+#include <stdint.h>
 #include <stdlib.h>
 
 #include "position.h"
 
 typedef struct LOCATION_STRUCT {
-  position_T* start;
-  position_T* end;
+  position_T start;
+  position_T end;
 } location_T;
 
-location_T* location_init(position_T* start, position_T* end);
-location_T* location_from(size_t start_line, size_t start_column, size_t end_line, size_t end_column);
-
-position_T* location_start(location_T* location);
-position_T* location_end_(location_T* location);
-
-size_t location_sizeof(void);
-
-location_T* location_copy(location_T* location);
-
-void location_free(location_T* location);
+void location_from(
+  location_T* location,
+  uint32_t start_line,
+  uint32_t start_column,
+  uint32_t end_line,
+  uint32_t end_column
+);
 
 #endif
diff --git a/src/include/parser_helpers.h b/src/include/parser_helpers.h
index aff4ac8ae..eba20f447 100644
--- a/src/include/parser_helpers.h
+++ b/src/include/parser_helpers.h
@@ -19,7 +19,7 @@ void parser_append_literal_node_from_buffer(
   const parser_T* parser,
   buffer_T* buffer,
   array_T* children,
-  position_T* start
+  position_T start
 );
 
 bool parser_in_svg_context(const parser_T* parser);
diff --git a/src/include/position.h b/src/include/position.h
index 95e64044b..8fad03d5f 100644
--- a/src/include/position.h
+++ b/src/include/position.h
@@ -1,22 +1,11 @@
 #ifndef HERB_POSITION_H
 #define HERB_POSITION_H
 
-#include <stdlib.h>
+#include <stdint.h>
 
 typedef struct POSITION_STRUCT {
-  size_t line;
-  size_t column;
+  uint32_t line;
+  uint32_t column;
 } position_T;
 
-position_T* position_init(size_t line, size_t column);
-
-size_t position_line(const position_T* position);
-size_t position_column(const position_T* position);
-
-size_t position_sizeof(void);
-
-position_T* position_copy(position_T* position);
-
-void position_free(position_T* position);
-
 #endif
diff --git a/src/include/pretty_print.h b/src/include/pretty_print.h
index 610bc3f73..7cabef7af 100644
--- a/src/include/pretty_print.h
+++ b/src/include/pretty_print.h
@@ -21,7 +21,7 @@ void pretty_print_position_property(
   buffer_T* buffer
 );
 
-void pretty_print_location(location_T* location, buffer_T* buffer);
+void pretty_print_location(location_T location, buffer_T* buffer);
 
 void pretty_print_property(
   const char* name,
diff --git a/src/include/prism_helpers.h b/src/include/prism_helpers.h
index 66438c342..ebfb53b4f 100644
--- a/src/include/prism_helpers.h
+++ b/src/include/prism_helpers.h
@@ -16,6 +16,6 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
   pm_parser_t* parser
 );
 
-position_T* position_from_source_with_offset(const char* source, size_t offset);
+position_T position_from_source_with_offset(const char* source, size_t offset);
 
 #endif
diff --git a/src/include/range.h b/src/include/range.h
index c5c28f8bb..019b1962b 100644
--- a/src/include/range.h
+++ b/src/include/range.h
@@ -1,23 +1,14 @@
 #ifndef HERB_RANGE_H
 #define HERB_RANGE_H
 
+#include <stdint.h>
 #include <stdlib.h>
 
 typedef struct RANGE_STRUCT {
-  size_t from;
-  size_t to;
+  uint32_t from;
+  uint32_t to;
 } range_T;
 
-range_T* range_init(size_t from, size_t to);
-
-size_t range_from(const range_T* range);
-size_t range_to(const range_T* range);
-size_t range_length(range_T* range);
-
-range_T* range_copy(range_T* range);
-
-size_t range_sizeof(void);
-
-void range_free(range_T* range);
+uint32_t range_length(range_T range);
 
 #endif
diff --git a/src/include/token.h b/src/include/token.h
index 6930439e9..523dd1f04 100644
--- a/src/include/token.h
+++ b/src/include/token.h
@@ -13,9 +13,6 @@ const char* token_type_to_string(token_type_T type);
 char* token_value(const token_T* token);
 int token_type(const token_T* token);
 
-position_T* token_start_position(token_T* token);
-position_T* token_end_position(token_T* token);
-
 size_t token_sizeof(void);
 
 token_T* token_copy(token_T* token);
diff --git a/src/include/token_struct.h b/src/include/token_struct.h
index e5192165b..2727d2a4c 100644
--- a/src/include/token_struct.h
+++ b/src/include/token_struct.h
@@ -50,8 +50,8 @@ typedef enum {
 
 typedef struct TOKEN_STRUCT {
   char* value;
-  range_T* range;
-  location_T* location;
+  range_T range;
+  location_T location;
   token_type_T type;
 } token_T;
 
diff --git a/src/lexer.c b/src/lexer.c
index 513f67882..f62bbd696 100644
--- a/src/lexer.c
+++ b/src/lexer.c
@@ -42,7 +42,7 @@ lexer_T* lexer_init(const char* source) {
   lexer->state = STATE_DATA;
 
   lexer->source = source;
-  lexer->source_length = strlen(source);
+  lexer->source_length = (uint32_t) strlen(source);
   lexer->current_character = source[0];
 
   lexer->current_line = 1;
@@ -66,7 +66,7 @@ token_T* lexer_error(lexer_T* lexer, const char* message) {
   snprintf(
     error_message,
     sizeof(error_message),
-    "[Lexer] Error: %s (character '%c', line %zu, col %zu)\n",
+    "[Lexer] Error: %s (character '%c', line %u, col %u)\n",
     message,
     lexer->current_character,
     lexer->current_line,
diff --git a/src/lexer_peek_helpers.c b/src/lexer_peek_helpers.c
index a46bbeff6..a1f96fa5e 100644
--- a/src/lexer_peek_helpers.c
+++ b/src/lexer_peek_helpers.c
@@ -77,9 +77,9 @@ bool lexer_peek_erb_end(const lexer_T* lexer, const int offset) {
 }
 
 bool lexer_peek_for_token_type_after_whitespace(lexer_T* lexer, token_type_T token_type) {
-  size_t saved_position = lexer->current_position;
-  size_t saved_line = lexer->current_line;
-  size_t saved_column = lexer->current_column;
+  uint32_t saved_position = lexer->current_position;
+  uint32_t saved_line = lexer->current_line;
+  uint32_t saved_column = lexer->current_column;
   char saved_character = lexer->current_character;
   lexer_state_T saved_state = lexer->state;
 
diff --git a/src/location.c b/src/location.c
index 1c83c5e49..aec168d3c 100644
--- a/src/location.c
+++ b/src/location.c
@@ -1,41 +1,13 @@
 #include "include/location.h"
-#include "include/memory.h"
 #include "include/position.h"
 
-size_t location_sizeof(void) {
-  return sizeof(location_T);
-}
-
-location_T* location_init(position_T* start, position_T* end) {
-  location_T* location = safe_malloc(location_sizeof());
-
-  location->start = start;
-  location->end = end;
-
-  return location;
-}
-
-location_T* location_from(size_t start_line, size_t start_column, size_t end_line, size_t end_column) {
-  return location_init(position_init(start_line, start_column), position_init(end_line, end_column));
-}
-
-position_T* location_start(location_T* location) {
-  return location->start;
-}
-
-position_T* location_end(location_T* location) {
-  return location->end;
-}
-
-location_T* location_copy(location_T* location) {
-  if (location == NULL) { return NULL; }
-
-  return location_init(position_copy(location->start), position_copy(location->end));
-}
-
-void location_free(location_T* location) {
-  if (location->start != NULL) { position_free(location->start); }
-  if (location->end != NULL) { position_free(location->end); }
-
-  free(location);
+void location_from(
+  location_T* location,
+  uint32_t start_line,
+  uint32_t start_column,
+  uint32_t end_line,
+  uint32_t end_column
+) {
+  location->start = (position_T) { .line = start_line, .column = start_column };
+  location->end = (position_T) { .line = end_line, .column = end_column };
 }
diff --git a/src/parser.c b/src/parser.c
index 3e4e4ffde..47847d9b5 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -56,15 +56,14 @@ static AST_CDATA_NODE_T* parser_parse_cdata(parser_T* parser) {
   buffer_T content = buffer_new();
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_CDATA_START, errors);
-  position_T* start = position_copy(parser->current_token->location->start);
+  position_T start = parser->current_token->location.start;
 
   while (token_is_none_of(parser, TOKEN_CDATA_END, TOKEN_EOF)) {
     if (token_is(parser, TOKEN_ERB_START)) {
       parser_append_literal_node_from_buffer(parser, &content, children, start);
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
       array_append(children, erb_node);
-      position_free(start);
-      start = position_copy(parser->current_token->location->start);
+      start = parser->current_token->location.start;
       continue;
     }
 
@@ -80,12 +79,11 @@ static AST_CDATA_NODE_T* parser_parse_cdata(parser_T* parser) {
     tag_opening,
     children,
     tag_closing,
-    tag_opening->location->start,
-    tag_closing->location->end,
+    tag_opening->location.start,
+    tag_closing->location.end,
     errors
   );
 
-  position_free(start);
   buffer_free(&content);
   token_free(tag_opening);
   token_free(tag_closing);
@@ -97,7 +95,7 @@ static AST_HTML_COMMENT_NODE_T* parser_parse_html_comment(parser_T* parser) {
   array_T* errors = array_init(8);
   array_T* children = array_init(8);
   token_T* comment_start = parser_consume_expected(parser, TOKEN_HTML_COMMENT_START, errors);
-  position_T* start = position_copy(parser->current_token->location->start);
+  position_T start = parser->current_token->location.start;
 
   buffer_T comment = buffer_new();
 
@@ -108,8 +106,7 @@ static AST_HTML_COMMENT_NODE_T* parser_parse_html_comment(parser_T* parser) {
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
       array_append(children, erb_node);
 
-      position_free(start);
-      start = position_copy(parser->current_token->location->start);
+      start = parser->current_token->location.start;
 
       continue;
     }
@@ -127,13 +124,12 @@ static AST_HTML_COMMENT_NODE_T* parser_parse_html_comment(parser_T* parser) {
     comment_start,
     children,
     comment_end,
-    comment_start->location->start,
-    comment_end->location->end,
+    comment_start->location.start,
+    comment_end->location.end,
     errors
   );
 
   buffer_free(&comment);
-  position_free(start);
   token_free(comment_start);
   token_free(comment_end);
 
@@ -147,7 +143,7 @@ static AST_HTML_DOCTYPE_NODE_T* parser_parse_html_doctype(parser_T* parser) {
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_HTML_DOCTYPE, errors);
 
-  position_T* start = position_copy(parser->current_token->location->start);
+  position_T start = parser->current_token->location.start;
 
   while (token_is_none_of(parser, TOKEN_HTML_TAG_END, TOKEN_EOF)) {
     if (token_is(parser, TOKEN_ERB_START)) {
@@ -172,12 +168,11 @@ static AST_HTML_DOCTYPE_NODE_T* parser_parse_html_doctype(parser_T* parser) {
     tag_opening,
     children,
     tag_closing,
-    tag_opening->location->start,
-    tag_closing->location->end,
+    tag_opening->location.start,
+    tag_closing->location.end,
     errors
   );
 
-  position_free(start);
   token_free(tag_opening);
   token_free(tag_closing);
   buffer_free(&content);
@@ -192,7 +187,7 @@ static AST_XML_DECLARATION_NODE_T* parser_parse_xml_declaration(parser_T* parser
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_XML_DECLARATION, errors);
 
-  position_T* start = position_copy(parser->current_token->location->start);
+  position_T start = parser->current_token->location.start;
 
   while (token_is_none_of(parser, TOKEN_XML_DECLARATION_END, TOKEN_EOF)) {
     if (token_is(parser, TOKEN_ERB_START)) {
@@ -201,8 +196,7 @@ static AST_XML_DECLARATION_NODE_T* parser_parse_xml_declaration(parser_T* parser
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
       array_append(children, erb_node);
 
-      position_free(start);
-      start = position_copy(parser->current_token->location->start);
+      start = parser->current_token->location.start;
 
       continue;
     }
@@ -220,12 +214,11 @@ static AST_XML_DECLARATION_NODE_T* parser_parse_xml_declaration(parser_T* parser
     tag_opening,
     children,
     tag_closing,
-    tag_opening->location->start,
-    tag_closing->location->end,
+    tag_opening->location.start,
+    tag_closing->location.end,
     errors
   );
 
-  position_free(start);
   token_free(tag_opening);
   token_free(tag_closing);
   buffer_free(&content);
@@ -234,7 +227,7 @@ static AST_XML_DECLARATION_NODE_T* parser_parse_xml_declaration(parser_T* parser
 }
 
 static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, array_T* document_errors) {
-  position_T* start = position_copy(parser->current_token->location->start);
+  position_T start = parser->current_token->location.start;
 
   buffer_T content = buffer_new();
 
@@ -255,13 +248,12 @@ static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, array_T
         "Token Error",
         "not TOKEN_ERROR",
         token->value,
-        token->location->start,
-        token->location->end,
+        token->location.start,
+        token->location.end,
         document_errors
       );
 
       token_free(token);
-      position_free(start);
 
       return NULL;
     }
@@ -275,17 +267,15 @@ static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, array_T
 
   if (buffer_length(&content) > 0) {
     AST_HTML_TEXT_NODE_T* text_node =
-      ast_html_text_node_init(buffer_value(&content), start, parser->current_token->location->start, errors);
+      ast_html_text_node_init(buffer_value(&content), start, parser->current_token->location.start, errors);
 
-    position_free(start);
     buffer_free(&content);
 
     return text_node;
   }
 
-  AST_HTML_TEXT_NODE_T* text_node = ast_html_text_node_init("", start, parser->current_token->location->start, errors);
+  AST_HTML_TEXT_NODE_T* text_node = ast_html_text_node_init("", start, parser->current_token->location.start, errors);
 
-  position_free(start);
   buffer_free(&content);
 
   return text_node;
@@ -295,7 +285,7 @@ static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T
   array_T* errors = array_init(8);
   array_T* children = array_init(8);
   buffer_T buffer = buffer_new();
-  position_T* start = position_copy(parser->current_token->location->start);
+  position_T start = parser->current_token->location.start;
 
   while (token_is_none_of(
     parser,
@@ -312,8 +302,7 @@ static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
       array_append(children, erb_node);
 
-      position_free(start);
-      start = position_copy(parser->current_token->location->start);
+      start = parser->current_token->location.start;
       continue;
     }
 
@@ -324,26 +313,23 @@ static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T
 
   parser_append_literal_node_from_buffer(parser, &buffer, children, start);
 
-  position_T* node_start = NULL;
-  position_T* node_end = NULL;
+  position_T node_start = { 0 };
+  position_T node_end = { 0 };
 
   if (children->size > 0) {
     AST_NODE_T* first_child = array_get(children, 0);
     AST_NODE_T* last_child = array_get(children, children->size - 1);
 
-    node_start = position_copy(first_child->location->start);
-    node_end = position_copy(last_child->location->end);
+    node_start = first_child->location.start;
+    node_end = last_child->location.end;
   } else {
-    node_start = position_copy(parser->current_token->location->start);
-    node_end = position_copy(parser->current_token->location->start);
+    node_start = parser->current_token->location.start;
+    node_end = parser->current_token->location.start;
   }
 
   AST_HTML_ATTRIBUTE_NAME_NODE_T* attribute_name =
     ast_html_attribute_name_node_init(children, node_start, node_end, errors);
 
-  position_free(start);
-  position_free(node_start);
-  position_free(node_end);
   buffer_free(&buffer);
 
   return attribute_name;
@@ -356,7 +342,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
 ) {
   buffer_T buffer = buffer_new();
   token_T* opening_quote = parser_consume_expected(parser, TOKEN_QUOTE, errors);
-  position_T* start = position_copy(parser->current_token->location->start);
+  position_T start = parser->current_token->location.start;
 
   while (!token_is(parser, TOKEN_EOF)
          && !(
@@ -368,8 +354,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
 
       array_append(children, parser_parse_erb_tag(parser));
 
-      position_free(start);
-      start = position_copy(parser->current_token->location->start);
+      start = parser->current_token->location.start;
 
       continue;
     }
@@ -414,8 +399,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
         "Unescaped quote character in attribute value",
         "escaped quote (\\') or different quote style (\")",
         opening_quote->value,
-        potential_closing->location->start,
-        potential_closing->location->end,
+        potential_closing->location.start,
+        potential_closing->location.end,
         errors
       );
 
@@ -438,8 +423,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
 
           array_append(children, parser_parse_erb_tag(parser));
 
-          position_free(start);
-          start = position_copy(parser->current_token->location->start);
+          start = parser->current_token->location.start;
 
           continue;
         }
@@ -458,7 +442,6 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
   }
 
   parser_append_literal_node_from_buffer(parser, &buffer, children, start);
-  position_free(start);
   buffer_free(&buffer);
 
   token_T* closing_quote = parser_consume_expected(parser, TOKEN_QUOTE, errors);
@@ -467,8 +450,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
     append_quotes_mismatch_error(
       opening_quote,
       closing_quote,
-      closing_quote->location->start,
-      closing_quote->location->end,
+      closing_quote->location.start,
+      closing_quote->location.end,
       errors
     );
   }
@@ -478,8 +461,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
     children,
     closing_quote,
     true,
-    opening_quote->location->start,
-    closing_quote->location->end,
+    opening_quote->location.start,
+    closing_quote->location.end,
     errors
   );
 
@@ -503,8 +486,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
       children,
       NULL,
       false,
-      erb_node->base.location->start,
-      erb_node->base.location->end,
+      erb_node->base.location.start,
+      erb_node->base.location.end,
       errors
     );
   }
@@ -522,8 +505,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
       children,
       NULL,
       false,
-      literal->base.location->start,
-      literal->base.location->end,
+      literal->base.location.start,
+      literal->base.location.end,
       errors
     );
   }
@@ -533,8 +516,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
 
   if (token_is(parser, TOKEN_BACKTICK)) {
     token_T* token = parser_advance(parser);
-    position_T* start = position_copy(token->location->start);
-    position_T* end = position_copy(token->location->end);
+    position_T start = token->location.start;
+    position_T end = token->location.end;
 
     append_unexpected_error(
       "Invalid quote character for HTML attribute",
@@ -548,8 +531,6 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
     AST_HTML_ATTRIBUTE_VALUE_NODE_T* value =
       ast_html_attribute_value_node_init(NULL, children, NULL, false, start, end, errors);
 
-    position_free(start);
-    position_free(end);
     token_free(token);
 
     return value;
@@ -559,8 +540,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
     "Unexpected Token",
     "TOKEN_IDENTIFIER, TOKEN_QUOTE, TOKEN_ERB_START",
     token_type_to_string(parser->current_token->type),
-    parser->current_token->location->start,
-    parser->current_token->location->end,
+    parser->current_token->location.start,
+    parser->current_token->location.end,
     errors
   );
 
@@ -569,8 +550,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
     children,
     NULL,
     false,
-    parser->current_token->location->start,
-    parser->current_token->location->end,
+    parser->current_token->location.start,
+    parser->current_token->location.end,
     errors
   );
 
@@ -586,17 +567,19 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
 
     if (has_equals) {
       buffer_T equals_buffer = buffer_new();
-      position_T* equals_start = NULL;
-      position_T* equals_end = NULL;
-      size_t range_start = 0;
-      size_t range_end = 0;
+      position_T equals_start = { 0 };
+      position_T equals_end = { 0 };
+      uint32_t range_start = 0;
+      uint32_t range_end = 0;
 
+      bool equals_start_present = false;
       while (token_is_any_of(parser, TOKEN_WHITESPACE, TOKEN_NEWLINE)) {
         token_T* whitespace = parser_advance(parser);
 
-        if (equals_start == NULL) {
-          equals_start = position_copy(whitespace->location->start);
-          range_start = whitespace->range->from;
+        if (equals_start_present == false) {
+          equals_start_present = true;
+          equals_start = whitespace->location.start;
+          range_start = whitespace->range.from;
         }
 
         buffer_append(&equals_buffer, whitespace->value);
@@ -605,29 +588,30 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
 
       token_T* equals = parser_advance(parser);
 
-      if (equals_start == NULL) {
-        equals_start = position_copy(equals->location->start);
-        range_start = equals->range->from;
+      if (equals_start_present == false) {
+        equals_start_present = true;
+        equals_start = equals->location.start;
+        range_start = equals->range.from;
       }
 
       buffer_append(&equals_buffer, equals->value);
-      equals_end = position_copy(equals->location->end);
-      range_end = equals->range->to;
+      equals_end = equals->location.end;
+      range_end = equals->range.to;
       token_free(equals);
 
       while (token_is_any_of(parser, TOKEN_WHITESPACE, TOKEN_NEWLINE)) {
         token_T* whitespace = parser_advance(parser);
         buffer_append(&equals_buffer, whitespace->value);
-        equals_end = position_copy(whitespace->location->end);
-        range_end = whitespace->range->to;
+        equals_end = whitespace->location.end;
+        range_end = whitespace->range.to;
         token_free(whitespace);
       }
 
       token_T* equals_with_whitespace = calloc(1, sizeof(token_T));
       equals_with_whitespace->type = TOKEN_EQUALS;
       equals_with_whitespace->value = herb_strdup(equals_buffer.value);
-      equals_with_whitespace->location = location_init(equals_start, equals_end);
-      equals_with_whitespace->range = range_init(range_start, range_end);
+      equals_with_whitespace->location = (location_T) { .start = equals_start, .end = equals_end };
+      equals_with_whitespace->range = (range_T) { .from = range_start, .to = range_end };
 
       buffer_free(&equals_buffer);
 
@@ -637,8 +621,8 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
         attribute_name,
         equals_with_whitespace,
         attribute_value,
-        attribute_name->base.location->start,
-        attribute_value->base.location->end,
+        attribute_name->base.location.start,
+        attribute_value->base.location.end,
         NULL
       );
     } else {
@@ -646,8 +630,8 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
         attribute_name,
         NULL,
         NULL,
-        attribute_name->base.location->start,
-        attribute_name->base.location->end,
+        attribute_name->base.location.start,
+        attribute_name->base.location.end,
         NULL
       );
     }
@@ -666,8 +650,8 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
       attribute_name,
       equals,
       attribute_value,
-      attribute_name->base.location->start,
-      attribute_value->base.location->end,
+      attribute_name->base.location.start,
+      attribute_value->base.location.end,
       NULL
     );
 
@@ -680,8 +664,8 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
     attribute_name,
     NULL,
     NULL,
-    attribute_name->base.location->start,
-    attribute_name->base.location->end,
+    attribute_name->base.location.start,
+    attribute_name->base.location.end,
     NULL
   );
 }
@@ -849,8 +833,8 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
     tag_end,
     children,
     is_self_closing,
-    tag_start->location->start,
-    tag_end->location->end,
+    tag_start->location.start,
+    tag_end->location.end,
     errors
   );
 
@@ -883,8 +867,8 @@ static AST_HTML_CLOSE_TAG_NODE_T* parser_parse_html_close_tag(parser_T* parser)
       tag_name,
       expected,
       got,
-      tag_opening->location->start,
-      tag_closing->location->end,
+      tag_opening->location.start,
+      tag_closing->location.end,
       errors
     );
 
@@ -897,8 +881,8 @@ static AST_HTML_CLOSE_TAG_NODE_T* parser_parse_html_close_tag(parser_T* parser)
     tag_name,
     children,
     tag_closing,
-    tag_opening->location->start,
-    tag_closing->location->end,
+    tag_opening->location.start,
+    tag_closing->location.end,
     errors
   );
 
@@ -921,8 +905,8 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_self_closing_element(
     NULL,
     true,
     ELEMENT_SOURCE_HTML,
-    open_tag->base.location->start,
-    open_tag->base.location->end,
+    open_tag->base.location.start,
+    open_tag->base.location.end,
     NULL
   );
 }
@@ -970,8 +954,8 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_regular_element(
     close_tag,
     false,
     ELEMENT_SOURCE_HTML,
-    open_tag->base.location->start,
-    close_tag->base.location->end,
+    open_tag->base.location.start,
+    close_tag->base.location.end,
     errors
   );
 }
@@ -1001,8 +985,8 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_element(parser_T* parser) {
     NULL,
     false,
     ELEMENT_SOURCE_HTML,
-    open_tag->base.location->start,
-    open_tag->base.location->end,
+    open_tag->base.location.start,
+    open_tag->base.location.end,
     errors
   );
 }
@@ -1021,8 +1005,8 @@ static AST_ERB_CONTENT_NODE_T* parser_parse_erb_tag(parser_T* parser) {
     NULL,
     false,
     false,
-    opening_tag->location->start,
-    closing_tag->location->end,
+    opening_tag->location.start,
+    closing_tag->location.end,
     errors
   );
 
@@ -1035,12 +1019,11 @@ static AST_ERB_CONTENT_NODE_T* parser_parse_erb_tag(parser_T* parser) {
 
 static void parser_parse_foreign_content(parser_T* parser, array_T* children, array_T* errors) {
   buffer_T content = buffer_new();
-  position_T* start = position_copy(parser->current_token->location->start);
+  position_T start = parser->current_token->location.start;
   const char* expected_closing_tag = parser_get_foreign_content_closing_tag(parser->foreign_content_type);
 
   if (expected_closing_tag == NULL) {
     parser_exit_foreign_content(parser);
-    position_free(start);
     buffer_free(&content);
 
     return;
@@ -1053,8 +1036,7 @@ static void parser_parse_foreign_content(parser_T* parser, array_T* children, ar
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
       array_append(children, erb_node);
 
-      position_free(start);
-      start = position_copy(parser->current_token->location->start);
+      start = parser->current_token->location.start;
 
       continue;
     }
@@ -1077,7 +1059,6 @@ static void parser_parse_foreign_content(parser_T* parser, array_T* children, ar
         parser_append_literal_node_from_buffer(parser, &content, children, start);
         parser_exit_foreign_content(parser);
 
-        position_free(start);
         buffer_free(&content);
 
         return;
@@ -1091,7 +1072,6 @@ static void parser_parse_foreign_content(parser_T* parser, array_T* children, ar
 
   parser_append_literal_node_from_buffer(parser, &content, children, start);
   parser_exit_foreign_content(parser);
-  position_free(start);
   buffer_free(&content);
 }
 
@@ -1167,8 +1147,8 @@ static void parser_parse_unclosed_html_tags(const parser_T* parser, array_T* err
 
     append_unclosed_element_error(
       unclosed_tag,
-      parser->current_token->location->start,
-      parser->current_token->location->end,
+      parser->current_token->location.start,
+      parser->current_token->location.end,
       errors
     );
 
@@ -1192,8 +1172,8 @@ static void parser_parse_stray_closing_tags(parser_T* parser, array_T* children,
     if (!is_void_element(close_tag->tag_name->value)) {
       append_missing_opening_tag_error(
         close_tag->tag_name,
-        close_tag->base.location->start,
-        close_tag->base.location->end,
+        close_tag->base.location.start,
+        close_tag->base.location.end,
         close_tag->base.errors
       );
     }
@@ -1207,7 +1187,7 @@ static void parser_parse_stray_closing_tags(parser_T* parser, array_T* children,
 static AST_DOCUMENT_NODE_T* parser_parse_document(parser_T* parser) {
   array_T* children = array_init(8);
   array_T* errors = array_init(8);
-  position_T* start = position_copy(parser->current_token->location->start);
+  position_T start = parser->current_token->location.start;
 
   parser_parse_in_data_state(parser, children, errors);
   parser_parse_unclosed_html_tags(parser, errors);
@@ -1215,9 +1195,8 @@ static AST_DOCUMENT_NODE_T* parser_parse_document(parser_T* parser) {
 
   token_T* eof = parser_consume_expected(parser, TOKEN_EOF, errors);
 
-  AST_DOCUMENT_NODE_T* document_node = ast_document_node_init(children, start, eof->location->end, errors);
+  AST_DOCUMENT_NODE_T* document_node = ast_document_node_init(children, start, eof->location.end, errors);
 
-  position_free(start);
   token_free(eof);
 
   return document_node;
@@ -1232,8 +1211,8 @@ static void parser_handle_whitespace(parser_T* parser, token_T* whitespace_token
     array_T* errors = array_init(8);
     AST_WHITESPACE_NODE_T* whitespace_node = ast_whitespace_node_init(
       whitespace_token,
-      whitespace_token->location->start,
-      whitespace_token->location->end,
+      whitespace_token->location.start,
+      whitespace_token->location.end,
       errors
     );
     array_append(children, whitespace_node);
diff --git a/src/parser_helpers.c b/src/parser_helpers.c
index bf92a5523..0c848f9ec 100644
--- a/src/parser_helpers.c
+++ b/src/parser_helpers.c
@@ -99,8 +99,8 @@ void parser_append_unexpected_error(parser_T* parser, const char* description, c
     description,
     expected,
     token_type_to_string(token->type),
-    token->location->start,
-    token->location->end,
+    token->location.start,
+    token->location.end,
     errors
   );
 
@@ -111,8 +111,8 @@ void parser_append_unexpected_token_error(parser_T* parser, token_type_T expecte
   append_unexpected_token_error(
     expected_type,
     parser->current_token,
-    parser->current_token->location->start,
-    parser->current_token->location->end,
+    parser->current_token->location.start,
+    parser->current_token->location.end,
     errors
   );
 }
@@ -121,12 +121,12 @@ void parser_append_literal_node_from_buffer(
   const parser_T* parser,
   buffer_T* buffer,
   array_T* children,
-  position_T* start
+  position_T start
 ) {
   if (buffer_length(buffer) == 0) { return; }
 
   AST_LITERAL_NODE_T* literal =
-    ast_literal_node_init(buffer_value(buffer), start, parser->current_token->location->start, NULL);
+    ast_literal_node_init(buffer_value(buffer), start, parser->current_token->location.start, NULL);
 
   if (children != NULL) { array_append(children, literal); }
   buffer_clear(buffer);
@@ -149,7 +149,7 @@ token_T* parser_consume_expected(parser_T* parser, const token_type_T expected_t
   if (token == NULL) {
     token = parser_advance(parser);
 
-    append_unexpected_token_error(expected_type, token, token->location->start, token->location->end, array);
+    append_unexpected_token_error(expected_type, token, token->location.start, token->location.end, array);
   }
 
   return token;
@@ -162,8 +162,8 @@ AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
 ) {
   append_missing_closing_tag_error(
     open_tag->tag_name,
-    open_tag->tag_name->location->start,
-    open_tag->tag_name->location->end,
+    open_tag->tag_name->location.start,
+    open_tag->tag_name->location.end,
     errors
   );
 
@@ -174,8 +174,8 @@ AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
     NULL,
     false,
     ELEMENT_SOURCE_HTML,
-    open_tag->base.location->start,
-    open_tag->base.location->end,
+    open_tag->base.location.start,
+    open_tag->base.location.end,
     errors
   );
 }
@@ -192,15 +192,15 @@ void parser_handle_mismatched_tags(
     append_tag_names_mismatch_error(
       expected_tag,
       actual_tag,
-      actual_tag->location->start,
-      actual_tag->location->end,
+      actual_tag->location.start,
+      actual_tag->location.end,
       errors
     );
   } else {
     append_missing_opening_tag_error(
       close_tag->tag_name,
-      close_tag->tag_name->location->start,
-      close_tag->tag_name->location->end,
+      close_tag->tag_name->location.start,
+      close_tag->tag_name->location.end,
       errors
     );
   }
diff --git a/src/position.c b/src/position.c
deleted file mode 100644
index 7b946b764..000000000
--- a/src/position.c
+++ /dev/null
@@ -1,33 +0,0 @@
-#include "include/position.h"
-#include "include/memory.h"
-
-size_t position_sizeof(void) {
-  return sizeof(position_T);
-}
-
-position_T* position_init(const size_t line, const size_t column) {
-  position_T* position = safe_malloc(position_sizeof());
-
-  position->line = line;
-  position->column = column;
-
-  return position;
-}
-
-size_t position_line(const position_T* position) {
-  return position->line;
-}
-
-size_t position_column(const position_T* position) {
-  return position->column;
-}
-
-position_T* position_copy(position_T* position) {
-  if (position == NULL) { return NULL; }
-
-  return position_init(position_line(position), position_column(position));
-}
-
-void position_free(position_T* position) {
-  free(position);
-}
diff --git a/src/pretty_print.c b/src/pretty_print.c
index ee79d4e34..85b2f5894 100644
--- a/src/pretty_print.c
+++ b/src/pretty_print.c
@@ -158,16 +158,16 @@ void pretty_print_errors(
   }
 }
 
-void pretty_print_location(location_T* location, buffer_T* buffer) {
+void pretty_print_location(location_T location, buffer_T* buffer) {
   buffer_append(buffer, "(location: (");
   char location_string[128];
   sprintf(
     location_string,
-    "%zu,%zu)-(%zu,%zu",
-    (location->start && location->start->line) ? location->start->line : 0,
-    (location->start && location->start->column) ? location->start->column : 0,
-    (location->end && location->end->line) ? location->end->line : 0,
-    (location->end && location->end->column) ? location->end->column : 0
+    "%u,%u)-(%u,%u",
+    location.start.line,
+    location.start.column,
+    location.end.line,
+    location.end.column
   );
   buffer_append(buffer, location_string);
   buffer_append(buffer, "))");
@@ -188,12 +188,7 @@ void pretty_print_position_property(
 
     char position_string[128];
 
-    sprintf(
-      position_string,
-      "%zu:%zu",
-      (position->line) ? position->line : 0,
-      (position->column) ? position->column : 0
-    );
+    sprintf(position_string, "%u:%u", (position->line) ? position->line : 0, (position->column) ? position->column : 0);
 
     buffer_append(buffer, position_string);
     buffer_append(buffer, ")");
diff --git a/src/prism_helpers.c b/src/prism_helpers.c
index 93c4857f2..06ac155b5 100644
--- a/src/prism_helpers.c
+++ b/src/prism_helpers.c
@@ -16,15 +16,15 @@ const char* pm_error_level_to_string(pm_error_level_t level) {
   }
 }
 
-position_T* position_from_source_with_offset(const char* source, size_t offset) {
-  position_T* position = position_init(1, 0);
+position_T position_from_source_with_offset(const char* source, size_t offset) {
+  position_T position = { .line = 1, .column = 0 };
 
   for (size_t i = 0; i < offset; i++) {
     if (is_newline(source[i])) {
-      position->line++;
-      position->column = 0;
+      position.line++;
+      position.column = 0;
     } else {
-      position->column++;
+      position.column++;
     }
   }
 
@@ -40,8 +40,8 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
   size_t start_offset = (size_t) (error->location.start - parser->start);
   size_t end_offset = (size_t) (error->location.end - parser->start);
 
-  position_T* start = position_from_source_with_offset(source, start_offset);
-  position_T* end = position_from_source_with_offset(source, end_offset);
+  position_T start = position_from_source_with_offset(source, start_offset);
+  position_T end = position_from_source_with_offset(source, end_offset);
 
   return ruby_parse_error_init(
     error->message,
diff --git a/src/range.c b/src/range.c
index 030b87b71..6e6abea50 100644
--- a/src/range.c
+++ b/src/range.c
@@ -1,38 +1,5 @@
 #include "include/range.h"
 
-size_t range_sizeof(void) {
-  return sizeof(range_T);
-}
-
-range_T* range_init(const size_t from, const size_t to) {
-  range_T* range = calloc(1, range_sizeof());
-
-  range->from = from;
-  range->to = to;
-
-  return range;
-}
-
-size_t range_from(const range_T* range) {
-  return range->from;
-}
-
-size_t range_to(const range_T* range) {
-  return range->to;
-}
-
-size_t range_length(range_T* range) {
-  return range_to(range) - range_from(range);
-}
-
-range_T* range_copy(range_T* range) {
-  if (!range) { return NULL; }
-
-  return range_init(range_from(range), range_to(range));
-}
-
-void range_free(range_T* range) {
-  if (range == NULL) { return; }
-
-  free(range);
+uint32_t range_length(range_T range) {
+  return range.to - range.from;
 }
diff --git a/src/token.c b/src/token.c
index a8cb5fb3f..37c7d4d89 100644
--- a/src/token.c
+++ b/src/token.c
@@ -2,6 +2,7 @@
 #include "include/json.h"
 #include "include/lexer.h"
 #include "include/position.h"
+#include "include/range.h"
 #include "include/token_struct.h"
 #include "include/util.h"
 
@@ -28,10 +29,15 @@ token_T* token_init(const char* value, const token_type_T type, lexer_T* lexer)
   }
 
   token->type = type;
-  token->range = range_init(lexer->previous_position, lexer->current_position);
-
-  token->location =
-    location_from(lexer->previous_line, lexer->previous_column, lexer->current_line, lexer->current_column);
+  token->range = (range_T) { .from = lexer->previous_position, .to = lexer->current_position };
+
+  location_from(
+    &token->location,
+    lexer->previous_line,
+    lexer->previous_column,
+    lexer->current_line,
+    lexer->current_column
+  );
 
   lexer->previous_line = lexer->current_line;
   lexer->previous_column = lexer->current_column;
@@ -84,7 +90,7 @@ const char* token_type_to_string(const token_type_T type) {
 
 char* token_to_string(const token_T* token) {
   const char* type_string = token_type_to_string(token->type);
-  const char* template = "#<Herb::Token type=\"%s\" value=\"%s\" range=[%d, %d] start=(%d:%d) end=(%d:%d)>";
+  const char* template = "#<Herb::Token type=\"%s\" value=\"%s\" range=[%u, %u] start=(%u:%u) end=(%u:%u)>";
 
   char* string = calloc(strlen(type_string) + strlen(template) + strlen(token->value) + 16, sizeof(char));
   char* escaped;
@@ -100,12 +106,12 @@ char* token_to_string(const token_T* token) {
     template,
     type_string,
     escaped,
-    token->range->from,
-    token->range->to,
-    token->location->start->line,
-    token->location->start->column,
-    token->location->end->line,
-    token->location->end->column
+    token->range.from,
+    token->range.to,
+    token->location.start.line,
+    token->location.start.column,
+    token->location.end.line,
+    token->location.end.column
   );
 
   free(escaped);
@@ -122,24 +128,24 @@ char* token_to_json(const token_T* token) {
 
   buffer_T range = buffer_new();
   json_start_array(&json, "range");
-  json_add_size_t(&range, NULL, token->range->from);
-  json_add_size_t(&range, NULL, token->range->to);
+  json_add_size_t(&range, NULL, token->range.from);
+  json_add_size_t(&range, NULL, token->range.to);
   buffer_concat(&json, &range);
   buffer_free(&range);
   json_end_array(&json);
 
   buffer_T start = buffer_new();
   json_start_object(&json, "start");
-  json_add_size_t(&start, "line", token->location->start->line);
-  json_add_size_t(&start, "column", token->location->start->column);
+  json_add_size_t(&start, "line", token->location.start.line);
+  json_add_size_t(&start, "column", token->location.start.column);
   buffer_concat(&json, &start);
   buffer_free(&start);
   json_end_object(&json);
 
   buffer_T end = buffer_new();
   json_start_object(&json, "end");
-  json_add_size_t(&end, "line", token->location->end->line);
-  json_add_size_t(&end, "column", token->location->end->column);
+  json_add_size_t(&end, "line", token->location.end.line);
+  json_add_size_t(&end, "column", token->location.end.column);
   buffer_concat(&json, &end);
   buffer_free(&end);
   json_end_object(&json);
@@ -157,14 +163,6 @@ int token_type(const token_T* token) {
   return token->type;
 }
 
-position_T* token_start_position(token_T* token) {
-  return token->location->start;
-}
-
-position_T* token_end_position(token_T* token) {
-  return token->location->end;
-}
-
 token_T* token_copy(token_T* token) {
   if (!token) { return NULL; }
 
@@ -184,8 +182,8 @@ token_T* token_copy(token_T* token) {
   }
 
   new_token->type = token->type;
-  new_token->range = range_copy(token->range);
-  new_token->location = location_copy(token->location);
+  new_token->range = token->range;
+  new_token->location = token->location;
 
   return new_token;
 }
@@ -194,8 +192,6 @@ void token_free(token_T* token) {
   if (!token) { return; }
 
   if (token->value != NULL) { free(token->value); }
-  if (token->range != NULL) { range_free(token->range); }
-  if (token->location != NULL) { location_free(token->location); }
 
   free(token);
 }
diff --git a/templates/src/ast_nodes.c.erb b/templates/src/ast_nodes.c.erb
index c89debea1..3c6bcebcc 100644
--- a/templates/src/ast_nodes.c.erb
+++ b/templates/src/ast_nodes.c.erb
@@ -13,7 +13,7 @@
 
 <%- nodes.each do |node| -%>
 <%- node_arguments = node.fields.any? ? node.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
-<%- arguments = node_arguments + ["position_T* start_position", "position_T* end_position", "array_T* errors"] -%>
+<%- arguments = node_arguments + ["position_T start_position", "position_T end_position", "array_T* errors"] -%>
 
 <%= node.struct_type %>* ast_<%= node.human %>_init(<%= arguments.join(", ") %>) {
   <%= node.struct_type %>* <%= node.human %> = malloc(sizeof(<%= node.struct_type %>));
@@ -81,8 +81,6 @@ void ast_free_base_node(AST_NODE_T* node) {
     array_free(&node->errors);
   }
 
-  if (node->location) { location_free(node->location); }
-
   free(node);
 }
 
diff --git a/templates/src/errors.c.erb b/templates/src/errors.c.erb
index a3336a711..edf63a9e2 100644
--- a/templates/src/errors.c.erb
+++ b/templates/src/errors.c.erb
@@ -17,15 +17,16 @@ size_t error_sizeof(void) {
   return sizeof(struct ERROR_STRUCT);
 }
 
-void error_init(ERROR_T* error, const error_type_T type, position_T* start, position_T* end) {
+void error_init(ERROR_T* error, const error_type_T type, position_T start, position_T end) {
   if (!error) { return; }
 
   error->type = type;
-  error->location = location_init(position_copy(start), position_copy(end));
+  error->location.start = start;
+  error->location.end = end;
 }
 <%- errors.each do |error| -%>
 <%- error_arguments = error.fields.any? ? error.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
-<%- arguments = error_arguments + ["position_T* start", "position_T* end"] -%>
+<%- arguments = error_arguments + ["position_T start", "position_T end"] -%>
 
 <%= error.struct_type %>* <%= error.human %>_init(<%= arguments.join(", ") %>) {
   <%= error.struct_type %>* <%= error.human %> = malloc(sizeof(<%= error.struct_type %>));
@@ -72,7 +73,7 @@ void error_init(ERROR_T* error, const error_type_T type, position_T* start, posi
   <%- error.fields.each do |field| -%>
   <%- case field -%>
   <%- when Herb::Template::PositionField -%>
-  <%= error.human %>-><%= field.name %> = position_copy(<%= field.name %>);
+  <%= error.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::TokenField -%>
   <%= error.human %>-><%= field.name %> = token_copy(<%= field.name %>);
   <%- when Herb::Template::TokenTypeField -%>
@@ -116,7 +117,6 @@ const char* error_human_type(ERROR_T* error) {
 void error_free_base_error(ERROR_T* error) {
   if (error == NULL) { return; }
 
-  if (error->location != NULL) { location_free(error->location); }
   if (error->message != NULL) { free(error->message); }
 
   free(error);
@@ -130,8 +130,6 @@ static void error_free_<%= error.human %>(<%= error.struct_type %>* <%= error.hu
   <%- end -%>
   <%- error.fields.each do |field| -%>
   <%- case field -%>
-  <%- when Herb::Template::PositionField -%>
-  if (<%= error.human %>-><%= field.name %> != NULL) { position_free(<%= error.human %>-><%= field.name %>); }
   <%- when Herb::Template::TokenField -%>
   if (<%= error.human %>-><%= field.name %> != NULL) { token_free(<%= error.human %>-><%= field.name %>); }
   <%- when Herb::Template::TokenTypeField -%>
diff --git a/templates/src/include/ast_nodes.h.erb b/templates/src/include/ast_nodes.h.erb
index 9b6dca00f..89a7a4736 100644
--- a/templates/src/include/ast_nodes.h.erb
+++ b/templates/src/include/ast_nodes.h.erb
@@ -20,7 +20,7 @@ typedef enum {
 
 typedef struct AST_NODE_STRUCT {
   ast_node_type_T type;
-  location_T* location;
+  location_T location;
   // maybe a range too?
   array_T* errors;
 } AST_NODE_T;
@@ -36,7 +36,7 @@ typedef struct <%= node.struct_name %> {
 
 <%- nodes.each do |node| -%>
 <%- node_arguments = node.fields.any? ? node.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
-<%- arguments = node_arguments + ["position_T* start_position", "position_T* end_position", "array_T* errors"] -%>
+<%- arguments = node_arguments + ["position_T start_position", "position_T end_position", "array_T* errors"] -%>
 <%= node.struct_type %>* ast_<%= node.human %>_init(<%= arguments.join(", ") %>);
 <%- end -%>
 
diff --git a/templates/src/include/errors.h.erb b/templates/src/include/errors.h.erb
index 1baca9430..41a5ea068 100644
--- a/templates/src/include/errors.h.erb
+++ b/templates/src/include/errors.h.erb
@@ -16,7 +16,7 @@ typedef enum {
 
 typedef struct ERROR_STRUCT {
   error_type_T type;
-  location_T* location;
+  location_T location;
   char* message;
 } ERROR_T;
 
@@ -31,12 +31,12 @@ typedef struct {
 
 <%- errors.each do |error| -%>
 <%- error_arguments = error.fields.any? ? error.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
-<%- arguments = error_arguments + ["position_T* start", "position_T* end"] -%>
+<%- arguments = error_arguments + ["position_T start", "position_T end"] -%>
 <%= error.struct_type %>* <%= error.human %>_init(<%= arguments.join(", ") %>);
 void append_<%= error.human %>(<%= (arguments << "array_T* errors").join(", ") %>);
 <%- end -%>
 
-void error_init(ERROR_T* error, error_type_T type, position_T* start, position_T* end);
+void error_init(ERROR_T* error, error_type_T type, position_T start, position_T end);
 
 size_t error_sizeof(void);
 error_type_T error_type(ERROR_T* error);
diff --git a/wasm/extension_helpers.cpp b/wasm/extension_helpers.cpp
index 490a81412..ecc59f2e0 100644
--- a/wasm/extension_helpers.cpp
+++ b/wasm/extension_helpers.cpp
@@ -27,44 +27,32 @@ val CreateString(const char* string) {
   return string ? val(string) : val::null();
 }
 
-val CreatePosition(position_T* position) {
-  if (!position) {
-    return val::null();
-  }
-
+val CreatePosition(position_T position) {
   val Object = val::global("Object");
   val result = Object.new_();
 
-  result.set("line", position->line);
-  result.set("column", position->column);
+  result.set("line", position.line);
+  result.set("column", position.column);
 
   return result;
 }
 
-val CreateLocation(location_T* location) {
-  if (!location) {
-    return val::null();
-  }
-
+val CreateLocation(location_T location) {
   val Object = val::global("Object");
   val result = Object.new_();
 
-  result.set("start", CreatePosition(location->start));
-  result.set("end", CreatePosition(location->end));
+  result.set("start", CreatePosition(location.start));
+  result.set("end", CreatePosition(location.end));
 
   return result;
 }
 
-val CreateRange(range_T* range) {
-  if (!range) {
-    return val::null();
-  }
-
+val CreateRange(range_T range) {
   val Array = val::global("Array");
   val result = Array.new_();
 
-  result.call<void>("push", range->from);
-  result.call<void>("push", range->to);
+  result.call<void>("push", range.from);
+  result.call<void>("push", range.to);
 
   return result;
 }
diff --git a/wasm/extension_helpers.h b/wasm/extension_helpers.h
index 923df6f3b..86bf67100 100644
--- a/wasm/extension_helpers.h
+++ b/wasm/extension_helpers.h
@@ -14,9 +14,9 @@ extern "C" {
 }
 
 emscripten::val CreateString(const char* string);
-emscripten::val CreatePosition(position_T* position);
-emscripten::val CreateLocation(location_T* location);
-emscripten::val CreateRange(range_T* range);
+emscripten::val CreatePosition(position_T position);
+emscripten::val CreateLocation(location_T location);
+emscripten::val CreateRange(range_T range);
 emscripten::val CreateToken(token_T* token);
 emscripten::val CreateLexResult(array_T* tokens, const std::string& source);
 emscripten::val CreateParseResult(AST_DOCUMENT_NODE_T *root, const std::string& source);

From 9517614fc1d2c69235913642f4f83e8e4c36876e Mon Sep 17 00:00:00 2001
From: Drew Hoffer <55151884+drewhoffer@users.noreply.github.com>
Date: Sun, 5 Oct 2025 01:11:07 -0400
Subject: [PATCH 13/97] Linter: Fix `--version` flag for CLI (#488)

Closes #437

---------

Co-authored-by: Marco Roth <marco.roth@intergga.ch>
---
 javascript/packages/linter/src/cli.ts                 | 4 +++-
 javascript/packages/linter/src/cli/argument-parser.ts | 6 ++++--
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/javascript/packages/linter/src/cli.ts b/javascript/packages/linter/src/cli.ts
index a9b32f1de..eb3fbfc00 100644
--- a/javascript/packages/linter/src/cli.ts
+++ b/javascript/packages/linter/src/cli.ts
@@ -124,7 +124,7 @@ export class CLI {
   }
 
   protected async beforeProcess(): Promise<void> {
-    await Herb.load()
+    // Hook for subclasses to add custom output before processing
   }
 
   protected async afterProcess(_results: any, _outputOptions: any): Promise<void> {
@@ -132,6 +132,8 @@ export class CLI {
   }
 
   async run() {
+    await Herb.load()
+
     const startTime = Date.now()
     const startDate = new Date()
 
diff --git a/javascript/packages/linter/src/cli/argument-parser.ts b/javascript/packages/linter/src/cli/argument-parser.ts
index c25337b08..8389119c1 100644
--- a/javascript/packages/linter/src/cli/argument-parser.ts
+++ b/javascript/packages/linter/src/cli/argument-parser.ts
@@ -9,7 +9,7 @@ import { Herb } from "@herb-tools/node-wasm"
 import { THEME_NAMES, DEFAULT_THEME } from "@herb-tools/highlighter"
 import type { ThemeInput } from "@herb-tools/highlighter"
 
-import { name, version } from "../../package.json"
+import { name, version, dependencies } from "../../package.json"
 
 export type FormatOption = "simple" | "detailed" | "json"
 
@@ -74,7 +74,9 @@ export class ArgumentParser {
 
     if (values.version) {
       console.log("Versions:")
-      console.log(`  ${name}@${version}, ${Herb.version}`.split(", ").join("\n  "))
+      console.log(`  ${name}@${version}`)
+      console.log(`  @herb-tools/printer@${dependencies["@herb-tools/printer"]}`)
+      console.log(`  ${Herb.version}`.split(", ").join("\n  "))
       process.exit(0)
     }
 

From ea545add32ee8f5fd8aaa08e469885d165677bb0 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Sun, 5 Oct 2025 14:37:40 +0900
Subject: [PATCH 14/97] Formatter: Print `Experimental Preview` warning on
 `stderr` (#575)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This pull request updates the formatter CLI to print the `⚠️
Experimental Preview ...` warning on `stderr` instead of `stdout` to
other tools can programmatically use the formatter output.

Resolves https://github.com/marcoroth/herb/issues/574
---
 javascript/packages/formatter/src/cli.ts      |  4 +-
 .../packages/formatter/test/cli.test.ts       | 58 +++++++++++--------
 2 files changed, 36 insertions(+), 26 deletions(-)

diff --git a/javascript/packages/formatter/src/cli.ts b/javascript/packages/formatter/src/cli.ts
index 5d88c1d28..a6502833d 100644
--- a/javascript/packages/formatter/src/cli.ts
+++ b/javascript/packages/formatter/src/cli.ts
@@ -112,8 +112,8 @@ export class CLI {
         process.exit(0)
       }
 
-      console.log("⚠️  Experimental Preview: The formatter is in early development. Please report any unexpected behavior or bugs to https://github.com/marcoroth/herb/issues/new?template=formatting-issue.md")
-      console.log()
+      console.error("⚠️  Experimental Preview: The formatter is in early development. Please report any unexpected behavior or bugs to https://github.com/marcoroth/herb/issues/new?template=formatting-issue.md")
+      console.error()
 
       const formatOptions = resolveFormatOptions({
         indentWidth,
diff --git a/javascript/packages/formatter/test/cli.test.ts b/javascript/packages/formatter/test/cli.test.ts
index 5d4d3ed46..b45f7d49c 100644
--- a/javascript/packages/formatter/test/cli.test.ts
+++ b/javascript/packages/formatter/test/cli.test.ts
@@ -155,20 +155,41 @@ describe("CLI Binary", () => {
     }
   })
 
-  it("should show experimental preview message", async () => {
+  it("should show experimental preview message on stderr", async () => {
     const result = await execBinary([])
 
-    expect(result.stdout).toContain("⚠️  Experimental Preview")
-    expect(result.stdout).toContain("early development")
-    expect(result.stdout).toContain("github.com/marcoroth/herb/issues")
+    expect(result.stderr).toContain("⚠️  Experimental Preview")
+    expect(result.stderr).toContain("early development")
+    expect(result.stderr).toContain("github.com/marcoroth/herb/issues")
+  })
+
+  it("should not include experimental preview message in stdout", async () => {
+    const input = '<div>test</div>'
+    const result = await execBinary([], input)
+
+    expectExitCode(result, 0)
+    expect(result.stdout).not.toContain("⚠️  Experimental Preview")
+    expect(result.stdout).toContain('<div>test</div>')
+  })
+
+  it("stdout should contain only formatted output without warnings", async () => {
+    const input = '<div class="test"><p>Hello</p></div>'
+    const result = await execBinary([], input)
+
+    expectExitCode(result, 0)
+
+    expect(result.stderr).toContain("⚠️  Experimental Preview")
+    expect(result.stdout).not.toContain("⚠️")
+    expect(result.stdout).not.toContain("Experimental")
+    expect(result.stdout).toBe('<div class="test">\n  <p>Hello</p>\n</div>\n')
   })
 
   it("should format empty input from stdin when no args provided", async () => {
     const result = await execBinary([], "")
 
     expectExitCode(result, 0)
-    expect(result.stdout).toContain("⚠️  Experimental Preview")
-    expect(result.stdout).toContain("\n\n")
+    expect(result.stderr).toContain("⚠️  Experimental Preview")
+    expect(result.stdout).toBe("\n")
   })
 
   it("should handle no files found in empty directory", async () => {
@@ -178,7 +199,7 @@ describe("CLI Binary", () => {
       const result = await execBinary(["test-empty-dir"])
 
       expectExitCode(result, 0)
-      expect(result.stdout).toContain("⚠️  Experimental Preview")
+      expect(result.stderr).toContain("⚠️  Experimental Preview")
       expect(result.stdout).toContain("No files found matching pattern:")
       expect(result.stdout).toContain("test-empty-dir/**/*.html.erb")
     } finally {
@@ -365,12 +386,8 @@ describe("CLI Binary", () => {
 
     expectExitCode(result, 0)
     expect(result.stdout.endsWith('\n')).toBe(true)
-    expect(result.stdout).toContain("⚠️  Experimental Preview")
-    expect(result.stdout).toContain('<div>Hello</div>')
-
-    const lines = result.stdout.split('\n')
-    const formattedLines = lines.slice(2) // Skip experimental preview lines
-    expect(formattedLines.join('\n')).toBe('<div>Hello</div>\n')
+    expect(result.stderr).toContain("⚠️  Experimental Preview")
+    expect(result.stdout).toBe('<div>Hello</div>\n')
   })
 
   it("CLI should preserve existing trailing newline", async () => {
@@ -379,12 +396,8 @@ describe("CLI Binary", () => {
 
     expectExitCode(result, 0)
     expect(result.stdout.endsWith('\n')).toBe(true)
-    expect(result.stdout).toContain("⚠️  Experimental Preview")
-    expect(result.stdout).toContain('<div>Hello</div>')
-
-    const lines = result.stdout.split('\n')
-    const formattedLines = lines.slice(2) // Skip experimental preview lines
-    expect(formattedLines.join('\n')).toBe('<div>Hello</div>\n')
+    expect(result.stderr).toContain("⚠️  Experimental Preview")
+    expect(result.stdout).toBe('<div>Hello</div>\n')
   })
 
   it("CLI should add trailing newline to empty input", async () => {
@@ -392,11 +405,8 @@ describe("CLI Binary", () => {
     const result = await execBinary([], input)
 
     expectExitCode(result, 0)
-    expect(result.stdout).toContain("⚠️  Experimental Preview")
-
-    const lines = result.stdout.split('\n')
-    const formattedLines = lines.slice(2) // Skip experimental preview lines
-    expect(formattedLines.join('\n')).toBe('\n')
+    expect(result.stderr).toContain("⚠️  Experimental Preview")
+    expect(result.stdout).toBe('\n')
   })
 
   it("should show --indent-width option in help", async () => {

From 2ca92ab0144c1377e20fcff4084a34584970e590 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Sun, 5 Oct 2025 15:07:07 +0900
Subject: [PATCH 15/97] Engine: Support Ruby Block Comments when compiling
 templates (#576)

This pull request updates the Engine to detect and support the
compilation of [Ruby Block
Comments](https://docs.ruby-lang.org/en/master/syntax/comments_rdoc.html)
in HTML+ERB templates.

The following templates can now be compiled and evaluated:

```html+erb
<%
=begin %>
  This, while unusual, is a legal form of commenting.
<%
=end %>
<div>Hey there</div>
```

Resolves https://github.com/marcoroth/herb/issues/562
---
 examples/block_comment.html.erb               |  7 ++
 lib/herb/engine.rb                            | 16 ++--
 test/engine/block_comments_test.rb            | 95 +++++++++++++++++++
 ...iline_ff404c4e708f59f532b4042441e458ad.txt | 11 +++
 ..._tags_95bcfa3f3e28634bf923f18df0cd38a1.txt |  9 ++
 ...after_0ee0ba8a9a25359175b884cf66f37b2c.txt | 12 +++
 ...iline_6bf3affa07b559b73f6428e0dbd270d2.txt |  2 +
 ..._tags_8a842d797202d0b31c9832cd43a22686.txt |  2 +
 ...after_c5e6a4e1e9e691af8dcc74ae6c9564c9.txt |  4 +
 ...ation_d5c98b9f230e001f8aabf838d3774698.txt | 12 +++
 ...tion_3ee70e5b90c1ff368a7783c49c6dc611.txt} |  0
 ...tion_da96aac1987dbb33d41eb4a121419b47.txt} |  0
 ...tion_2b3c4e3c244db77468813a7472298e82.txt} |  0
 ...tion_8c18fb8399a2fd1e65b0333bc01e041c.txt} |  0
 ...tion_0109f6af5a474973b8b1b52636135c4f.txt} |  0
 ...tion_eeecb969def01ab8005c7b9f23686fed.txt} |  0
 ...tion_1437d0425640509570342c24b30de571.txt} |  0
 ...tion_ba78b92bec7a4692a2043f2ba2ebe057.txt} |  0
 ...tion_4ddb2a17755d3e775e3225970bc60a96.txt} |  0
 ...tion_aa8aed9ef61b138a28efed42f4b72251.txt} |  0
 ...tion_1729fad3a77618acdc687c9fb671b75b.txt} |  0
 ...tion_d81de4ca83482c4836215ef7177d9eec.txt} |  0
 ...tion_9c22f391d1d03fa66b3d18095354a236.txt} |  0
 ...tion_0b1269c00fd15a74df125278ed6a9fc4.txt} |  0
 ...tion_45fa7aa654c0dc06d1a1b9504002dfba.txt} |  0
 ...tion_a705eb5ed83b4db368d7204baa136b36.txt} |  0
 26 files changed, 164 insertions(+), 6 deletions(-)
 create mode 100644 examples/block_comment.html.erb
 create mode 100644 test/engine/block_comments_test.rb
 create mode 100644 test/snapshots/engine/block_comments_test/test_0001_ruby_block_comments_with_=begin_and_=end_multiline_ff404c4e708f59f532b4042441e458ad.txt
 create mode 100644 test/snapshots/engine/block_comments_test/test_0002_ruby_block_comments_inside_erb_tags_95bcfa3f3e28634bf923f18df0cd38a1.txt
 create mode 100644 test/snapshots/engine/block_comments_test/test_0003_ruby_block_comments_with_code_before_and_after_0ee0ba8a9a25359175b884cf66f37b2c.txt
 create mode 100644 test/snapshots/engine/block_comments_test/test_0004_evaluation:_ruby_block_comments_with_=begin_and_=end_mutliline_6bf3affa07b559b73f6428e0dbd270d2.txt
 create mode 100644 test/snapshots/engine/block_comments_test/test_0005_evaluation:_ruby_block_comments_inside_erb_tags_8a842d797202d0b31c9832cd43a22686.txt
 create mode 100644 test/snapshots/engine/block_comments_test/test_0006_evaluation:_ruby_block_comments_with_code_before_and_after_c5e6a4e1e9e691af8dcc74ae6c9564c9.txt
 create mode 100644 test/snapshots/engine/examples_compilation_test/test_0004_block_comment_compilation_d5c98b9f230e001f8aabf838d3774698.txt
 rename test/snapshots/engine/examples_compilation_test/{test_0004_case_when_compilation_3ee70e5b90c1ff368a7783c49c6dc611.txt => test_0005_case_when_compilation_3ee70e5b90c1ff368a7783c49c6dc611.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0005_comment_compilation_da96aac1987dbb33d41eb4a121419b47.txt => test_0006_comment_compilation_da96aac1987dbb33d41eb4a121419b47.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0006_comment_before_content_compilation_2b3c4e3c244db77468813a7472298e82.txt => test_0007_comment_before_content_compilation_2b3c4e3c244db77468813a7472298e82.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0007_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt => test_0008_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0008_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt => test_0009_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0009_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt => test_0010_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0010_if_else_compilation_1437d0425640509570342c24b30de571.txt => test_0011_if_else_compilation_1437d0425640509570342c24b30de571.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0011_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt => test_0012_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0012_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt => test_0013_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0013_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt => test_0014_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0014_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt => test_0015_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0015_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt => test_0016_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0016_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt => test_0017_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0017_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt => test_0018_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0018_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt => test_0019_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0019_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt => test_0020_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt} (100%)

diff --git a/examples/block_comment.html.erb b/examples/block_comment.html.erb
new file mode 100644
index 000000000..c424fd687
--- /dev/null
+++ b/examples/block_comment.html.erb
@@ -0,0 +1,7 @@
+<%
+=begin %>
+  This, while unusual, is a legal form of commenting.
+<%
+=end %>
+
+<div>Content</div>
diff --git a/lib/herb/engine.rb b/lib/herb/engine.rb
index 133db20d7..c4fe7752b 100644
--- a/lib/herb/engine.rb
+++ b/lib/herb/engine.rb
@@ -193,13 +193,17 @@ def add_text(text)
     def add_code(code)
       terminate_expression
 
-      @src << " " << code
-
-      # TODO: rework and check for Prism::InlineComment as soon as we expose the Prism Nodes in the Herb AST
-      if code.include?("#")
-        @src << "\n"
+      if code.include?("=begin") || code.include?("=end")
+        @src << "\n" << code << "\n"
       else
-        @src << ";" unless code[-1] == "\n"
+        @src << " " << code
+
+        # TODO: rework and check for Prism::InlineComment as soon as we expose the Prism Nodes in the Herb AST
+        if code.include?("#")
+          @src << "\n"
+        else
+          @src << ";" unless code[-1] == "\n"
+        end
       end
 
       @buffer_on_stack = false
diff --git a/test/engine/block_comments_test.rb b/test/engine/block_comments_test.rb
new file mode 100644
index 000000000..b179f7854
--- /dev/null
+++ b/test/engine/block_comments_test.rb
@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+require_relative "../snapshot_utils"
+require_relative "../../lib/herb/engine"
+
+module Engine
+  class BlockCommentsTest < Minitest::Spec
+    include SnapshotUtils
+
+    test "ruby block comments with =begin and =end multiline" do
+      template = <<~ERB
+        <%
+        =begin %>
+          This, while unusual, is a legal form of commenting.
+        <%
+        =end %>
+        <div>Hey there</div>
+      ERB
+
+      assert_compiled_snapshot(template)
+    end
+
+    test "ruby block comments inside erb tags" do
+      template = <<~ERB
+        <%
+        =begin
+        This is a comment
+        =end
+        %>
+        <p>Content</p>
+      ERB
+
+      assert_compiled_snapshot(template)
+    end
+
+    test "ruby block comments with code before and after" do
+      template = <<~ERB
+        <% x = 1 %>
+        <%
+        =begin
+        Multi-line comment
+        spanning multiple lines
+        =end
+        %>
+        <% y = 2 %>
+        <div><%= x + y %></div>
+      ERB
+
+      assert_compiled_snapshot(template)
+    end
+
+    test "evaluation: ruby block comments with =begin and =end mutliline" do
+      template = <<~ERB
+        <%
+        =begin %>
+          This, while unusual, is a legal form of commenting.
+        <%
+        =end %>
+        <div>Hey there</div>
+      ERB
+
+      assert_evaluated_snapshot(template)
+    end
+
+    test "evaluation: ruby block comments inside erb tags" do
+      template = <<~ERB
+        <%
+        =begin
+        This is a comment
+        =end
+        %>
+        <p>Content</p>
+      ERB
+
+      assert_evaluated_snapshot(template)
+    end
+
+    test "evaluation: ruby block comments with code before and after" do
+      template = <<~ERB
+        <% x = 1 %>
+        <%
+        =begin
+        Multi-line comment
+        spanning multiple lines
+        =end
+        %>
+        <% y = 2 %>
+        <div><%= x + y %></div>
+      ERB
+
+      assert_evaluated_snapshot(template, { x: 1, y: 2 })
+    end
+  end
+end
diff --git a/test/snapshots/engine/block_comments_test/test_0001_ruby_block_comments_with_=begin_and_=end_multiline_ff404c4e708f59f532b4042441e458ad.txt b/test/snapshots/engine/block_comments_test/test_0001_ruby_block_comments_with_=begin_and_=end_multiline_ff404c4e708f59f532b4042441e458ad.txt
new file mode 100644
index 000000000..b86d395f2
--- /dev/null
+++ b/test/snapshots/engine/block_comments_test/test_0001_ruby_block_comments_with_=begin_and_=end_multiline_ff404c4e708f59f532b4042441e458ad.txt
@@ -0,0 +1,11 @@
+_buf = ::String.new;
+
+=begin
+ _buf << '
+  This, while unusual, is a legal form of commenting.
+'.freeze;
+=end
+ _buf << '
+<div>Hey there</div>
+'.freeze;
+_buf.to_s
diff --git a/test/snapshots/engine/block_comments_test/test_0002_ruby_block_comments_inside_erb_tags_95bcfa3f3e28634bf923f18df0cd38a1.txt b/test/snapshots/engine/block_comments_test/test_0002_ruby_block_comments_inside_erb_tags_95bcfa3f3e28634bf923f18df0cd38a1.txt
new file mode 100644
index 000000000..467a7f23a
--- /dev/null
+++ b/test/snapshots/engine/block_comments_test/test_0002_ruby_block_comments_inside_erb_tags_95bcfa3f3e28634bf923f18df0cd38a1.txt
@@ -0,0 +1,9 @@
+_buf = ::String.new;
+
+=begin
+This is a comment
+=end
+ _buf << '
+<p>Content</p>
+'.freeze;
+_buf.to_s
diff --git a/test/snapshots/engine/block_comments_test/test_0003_ruby_block_comments_with_code_before_and_after_0ee0ba8a9a25359175b884cf66f37b2c.txt b/test/snapshots/engine/block_comments_test/test_0003_ruby_block_comments_with_code_before_and_after_0ee0ba8a9a25359175b884cf66f37b2c.txt
new file mode 100644
index 000000000..545dc4e42
--- /dev/null
+++ b/test/snapshots/engine/block_comments_test/test_0003_ruby_block_comments_with_code_before_and_after_0ee0ba8a9a25359175b884cf66f37b2c.txt
@@ -0,0 +1,12 @@
+_buf = ::String.new;
+ x = 1; _buf << '
+'.freeze;
+=begin
+Multi-line comment
+spanning multiple lines
+=end
+ _buf << '
+'.freeze; y = 2; _buf << '
+<div>'.freeze; _buf << (x + y).to_s; _buf << '</div>
+'.freeze;
+_buf.to_s
diff --git a/test/snapshots/engine/block_comments_test/test_0004_evaluation:_ruby_block_comments_with_=begin_and_=end_mutliline_6bf3affa07b559b73f6428e0dbd270d2.txt b/test/snapshots/engine/block_comments_test/test_0004_evaluation:_ruby_block_comments_with_=begin_and_=end_mutliline_6bf3affa07b559b73f6428e0dbd270d2.txt
new file mode 100644
index 000000000..a6a4497b5
--- /dev/null
+++ b/test/snapshots/engine/block_comments_test/test_0004_evaluation:_ruby_block_comments_with_=begin_and_=end_mutliline_6bf3affa07b559b73f6428e0dbd270d2.txt
@@ -0,0 +1,2 @@
+
+<div>Hey there</div>
diff --git a/test/snapshots/engine/block_comments_test/test_0005_evaluation:_ruby_block_comments_inside_erb_tags_8a842d797202d0b31c9832cd43a22686.txt b/test/snapshots/engine/block_comments_test/test_0005_evaluation:_ruby_block_comments_inside_erb_tags_8a842d797202d0b31c9832cd43a22686.txt
new file mode 100644
index 000000000..1efa30582
--- /dev/null
+++ b/test/snapshots/engine/block_comments_test/test_0005_evaluation:_ruby_block_comments_inside_erb_tags_8a842d797202d0b31c9832cd43a22686.txt
@@ -0,0 +1,2 @@
+
+<p>Content</p>
diff --git a/test/snapshots/engine/block_comments_test/test_0006_evaluation:_ruby_block_comments_with_code_before_and_after_c5e6a4e1e9e691af8dcc74ae6c9564c9.txt b/test/snapshots/engine/block_comments_test/test_0006_evaluation:_ruby_block_comments_with_code_before_and_after_c5e6a4e1e9e691af8dcc74ae6c9564c9.txt
new file mode 100644
index 000000000..d630b5b60
--- /dev/null
+++ b/test/snapshots/engine/block_comments_test/test_0006_evaluation:_ruby_block_comments_with_code_before_and_after_c5e6a4e1e9e691af8dcc74ae6c9564c9.txt
@@ -0,0 +1,4 @@
+
+
+
+<div>3</div>
diff --git a/test/snapshots/engine/examples_compilation_test/test_0004_block_comment_compilation_d5c98b9f230e001f8aabf838d3774698.txt b/test/snapshots/engine/examples_compilation_test/test_0004_block_comment_compilation_d5c98b9f230e001f8aabf838d3774698.txt
new file mode 100644
index 000000000..dd6f62d48
--- /dev/null
+++ b/test/snapshots/engine/examples_compilation_test/test_0004_block_comment_compilation_d5c98b9f230e001f8aabf838d3774698.txt
@@ -0,0 +1,12 @@
+_buf = ::String.new;
+
+=begin
+ _buf << '
+  This, while unusual, is a legal form of commenting.
+'.freeze;
+=end
+ _buf << '
+
+<div>Content</div>
+'.freeze;
+_buf.to_s
diff --git a/test/snapshots/engine/examples_compilation_test/test_0004_case_when_compilation_3ee70e5b90c1ff368a7783c49c6dc611.txt b/test/snapshots/engine/examples_compilation_test/test_0005_case_when_compilation_3ee70e5b90c1ff368a7783c49c6dc611.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0004_case_when_compilation_3ee70e5b90c1ff368a7783c49c6dc611.txt
rename to test/snapshots/engine/examples_compilation_test/test_0005_case_when_compilation_3ee70e5b90c1ff368a7783c49c6dc611.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0005_comment_compilation_da96aac1987dbb33d41eb4a121419b47.txt b/test/snapshots/engine/examples_compilation_test/test_0006_comment_compilation_da96aac1987dbb33d41eb4a121419b47.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0005_comment_compilation_da96aac1987dbb33d41eb4a121419b47.txt
rename to test/snapshots/engine/examples_compilation_test/test_0006_comment_compilation_da96aac1987dbb33d41eb4a121419b47.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0006_comment_before_content_compilation_2b3c4e3c244db77468813a7472298e82.txt b/test/snapshots/engine/examples_compilation_test/test_0007_comment_before_content_compilation_2b3c4e3c244db77468813a7472298e82.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0006_comment_before_content_compilation_2b3c4e3c244db77468813a7472298e82.txt
rename to test/snapshots/engine/examples_compilation_test/test_0007_comment_before_content_compilation_2b3c4e3c244db77468813a7472298e82.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0007_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt b/test/snapshots/engine/examples_compilation_test/test_0008_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0007_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt
rename to test/snapshots/engine/examples_compilation_test/test_0008_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0008_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt b/test/snapshots/engine/examples_compilation_test/test_0009_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0008_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt
rename to test/snapshots/engine/examples_compilation_test/test_0009_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0009_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt b/test/snapshots/engine/examples_compilation_test/test_0010_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0009_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt
rename to test/snapshots/engine/examples_compilation_test/test_0010_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0010_if_else_compilation_1437d0425640509570342c24b30de571.txt b/test/snapshots/engine/examples_compilation_test/test_0011_if_else_compilation_1437d0425640509570342c24b30de571.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0010_if_else_compilation_1437d0425640509570342c24b30de571.txt
rename to test/snapshots/engine/examples_compilation_test/test_0011_if_else_compilation_1437d0425640509570342c24b30de571.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0011_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt b/test/snapshots/engine/examples_compilation_test/test_0012_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0011_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt
rename to test/snapshots/engine/examples_compilation_test/test_0012_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0012_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt b/test/snapshots/engine/examples_compilation_test/test_0013_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0012_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt
rename to test/snapshots/engine/examples_compilation_test/test_0013_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0013_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt b/test/snapshots/engine/examples_compilation_test/test_0014_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0013_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt
rename to test/snapshots/engine/examples_compilation_test/test_0014_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0014_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt b/test/snapshots/engine/examples_compilation_test/test_0015_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0014_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt
rename to test/snapshots/engine/examples_compilation_test/test_0015_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0015_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt b/test/snapshots/engine/examples_compilation_test/test_0016_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0015_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt
rename to test/snapshots/engine/examples_compilation_test/test_0016_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0016_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt b/test/snapshots/engine/examples_compilation_test/test_0017_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0016_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt
rename to test/snapshots/engine/examples_compilation_test/test_0017_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0017_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt b/test/snapshots/engine/examples_compilation_test/test_0018_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0017_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt
rename to test/snapshots/engine/examples_compilation_test/test_0018_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0018_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt b/test/snapshots/engine/examples_compilation_test/test_0019_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0018_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt
rename to test/snapshots/engine/examples_compilation_test/test_0019_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0019_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt b/test/snapshots/engine/examples_compilation_test/test_0020_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0019_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt
rename to test/snapshots/engine/examples_compilation_test/test_0020_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt

From 161fc1800703bd8ae78d1a0e5e78e08d7af3d0e9 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Sun, 5 Oct 2025 15:53:54 +0900
Subject: [PATCH 16/97] Parser: Fix analysis of nested `case/when` and
 `case/in` parsing (#578)

This pull request updates the parser to fix the analysis of nested
control flow structures within `case/when` and `case/in` statements.

The following kind templates now have the properly nested structure:

```html+erb
<% case 1 %>
<% when 1 %>
  <%= content_tag(:p) do %>
    Yep
  <% end %>
<% end %>
```

Resolves https://github.com/marcoroth/herb/issues/540
---
 src/analyze.c                                 | 38 +---------
 test/analyze/case_in_test.rb                  | 36 +++++++++
 test/analyze/case_test.rb                     | 64 ++++++++++++++++
 ...lause_a5d7393ef0ab780cd777fd4d09413ac8.txt | 48 ++++++++++++
 ...lause_8cdfe954fcb68cf29f71d5c05893547c.txt | 66 ++++++++++++++++
 ...lause_51fcf7566215a5284ae1ee34c920837e.txt | 49 ++++++++++++
 ..._when_adb20c2773fe1206d2b47123f8001e22.txt | 48 ++++++++++++
 ..._when_05f7d387314a95620a58ddc7f7d31b7b.txt | 66 ++++++++++++++++
 ..._when_6e70c1bf60788969969296d35c409a47.txt | 66 ++++++++++++++++
 ...auses_3f35d3ebf6ea6eaf8e7b9bc7f8393a0f.txt | 75 +++++++++++++++++++
 ..._when_ccc0bd511203c41d9274ccc360e736c2.txt | 49 ++++++++++++
 11 files changed, 569 insertions(+), 36 deletions(-)
 create mode 100644 test/snapshots/analyze/case_in_test/test_0008_case_in_with_block_inside_in_clause_a5d7393ef0ab780cd777fd4d09413ac8.txt
 create mode 100644 test/snapshots/analyze/case_in_test/test_0009_case_in_with_multiple_blocks_in_in_clause_8cdfe954fcb68cf29f71d5c05893547c.txt
 create mode 100644 test/snapshots/analyze/case_in_test/test_0010_case_in_with_if_statement_inside_in_clause_51fcf7566215a5284ae1ee34c920837e.txt
 create mode 100644 test/snapshots/analyze/case_test/test_0008_case_with_block_inside_when_adb20c2773fe1206d2b47123f8001e22.txt
 create mode 100644 test/snapshots/analyze/case_test/test_0009_case_with_multiple_blocks_in_when_05f7d387314a95620a58ddc7f7d31b7b.txt
 create mode 100644 test/snapshots/analyze/case_test/test_0010_case_with_nested_blocks_in_when_6e70c1bf60788969969296d35c409a47.txt
 create mode 100644 test/snapshots/analyze/case_test/test_0011_case_with_block_in_multiple_when_clauses_3f35d3ebf6ea6eaf8e7b9bc7f8393a0f.txt
 create mode 100644 test/snapshots/analyze/case_test/test_0012_case_with_if_statement_inside_when_ccc0bd511203c41d9274ccc360e736c2.txt

diff --git a/src/analyze.c b/src/analyze.c
index 5ed8215db..bd0778520 100644
--- a/src/analyze.c
+++ b/src/analyze.c
@@ -435,24 +435,7 @@ static size_t process_control_structure(
         array_T* when_statements = array_init(8);
         index++;
 
-        while (index < array_size(array)) {
-          AST_NODE_T* child = array_get(array, index);
-
-          if (!child) { break; }
-
-          if (child->type == AST_ERB_CONTENT_NODE) {
-            AST_ERB_CONTENT_NODE_T* child_erb = (AST_ERB_CONTENT_NODE_T*) child;
-            control_type_t child_type = detect_control_type(child_erb);
-
-            if (child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_IN || child_type == CONTROL_TYPE_ELSE
-                || child_type == CONTROL_TYPE_END) {
-              break;
-            }
-          }
-
-          array_append(when_statements, child);
-          index++;
-        }
+        index = process_block_children(node, array, index, when_statements, context, CONTROL_TYPE_WHEN);
 
         AST_ERB_WHEN_NODE_T* when_node = ast_erb_when_node_init(
           erb_content->tag_opening,
@@ -471,24 +454,7 @@ static size_t process_control_structure(
         array_T* in_statements = array_init(8);
         index++;
 
-        while (index < array_size(array)) {
-          AST_NODE_T* child = array_get(array, index);
-
-          if (!child) { break; }
-
-          if (child->type == AST_ERB_CONTENT_NODE) {
-            AST_ERB_CONTENT_NODE_T* child_erb = (AST_ERB_CONTENT_NODE_T*) child;
-            control_type_t child_type = detect_control_type(child_erb);
-
-            if (child_type == CONTROL_TYPE_IN || child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_ELSE
-                || child_type == CONTROL_TYPE_END) {
-              break;
-            }
-          }
-
-          array_append(in_statements, child);
-          index++;
-        }
+        index = process_block_children(node, array, index, in_statements, context, CONTROL_TYPE_IN);
 
         AST_ERB_IN_NODE_T* in_node = ast_erb_in_node_init(
           erb_content->tag_opening,
diff --git a/test/analyze/case_in_test.rb b/test/analyze/case_in_test.rb
index a648ada19..8fb1a25ac 100644
--- a/test/analyze/case_in_test.rb
+++ b/test/analyze/case_in_test.rb
@@ -92,5 +92,41 @@ class CaseInTest < Minitest::Spec
         <% end %>
       HTML
     end
+
+    test "case in with block inside in clause" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case result %>
+        <% in { status: :success } %>
+          <%= content_tag(:div) do %>
+            Success!
+          <% end %>
+        <% end %>
+      HTML
+    end
+
+    test "case in with multiple blocks in in clause" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case data %>
+        <% in { type: :alert } %>
+          <%= content_tag(:div) do %>
+            Alert
+          <% end %>
+          <%= content_tag(:span) do %>
+            Icon
+          <% end %>
+        <% end %>
+      HTML
+    end
+
+    test "case in with if statement inside in clause" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case value %>
+        <% in [Integer] %>
+          <% if positive? %>
+            Positive
+          <% end %>
+        <% end %>
+      HTML
+    end
   end
 end
diff --git a/test/analyze/case_test.rb b/test/analyze/case_test.rb
index 8a7d2b538..0e181c0b4 100644
--- a/test/analyze/case_test.rb
+++ b/test/analyze/case_test.rb
@@ -90,5 +90,69 @@ class CaseTest < Minitest::Spec
         <% end %>
       HTML
     end
+
+    test "case with block inside when" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case 1 %>
+        <% when 1 %>
+          <%= content_tag(:p) do %>
+            Yep
+          <% end %>
+        <% end %>
+      HTML
+    end
+
+    test "case with multiple blocks in when" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case status %>
+        <% when :active %>
+          <%= content_tag(:div) do %>
+            Active
+          <% end %>
+          <%= content_tag(:span) do %>
+            Badge
+          <% end %>
+        <% end %>
+      HTML
+    end
+
+    test "case with nested blocks in when" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case level %>
+        <% when 1 %>
+          <%= content_tag(:div) do %>
+            <%= content_tag(:p) do %>
+              Nested
+            <% end %>
+          <% end %>
+        <% end %>
+      HTML
+    end
+
+    test "case with block in multiple when clauses" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case type %>
+        <% when :a %>
+          <%= form_for(obj) do |f| %>
+            Form A
+          <% end %>
+        <% when :b %>
+          <%= form_for(obj) do |f| %>
+            Form B
+          <% end %>
+        <% end %>
+      HTML
+    end
+
+    test "case with if statement inside when" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case status %>
+        <% when :active %>
+          <% if admin? %>
+            Admin view
+          <% end %>
+        <% end %>
+      HTML
+    end
   end
 end
diff --git a/test/snapshots/analyze/case_in_test/test_0008_case_in_with_block_inside_in_clause_a5d7393ef0ab780cd777fd4d09413ac8.txt b/test/snapshots/analyze/case_in_test/test_0008_case_in_with_block_inside_in_clause_a5d7393ef0ab780cd777fd4d09413ac8.txt
new file mode 100644
index 000000000..c29867eb1
--- /dev/null
+++ b/test/snapshots/analyze/case_in_test/test_0008_case_in_with_block_inside_in_clause_a5d7393ef0ab780cd777fd4d09413ac8.txt
@@ -0,0 +1,48 @@
+@ DocumentNode (location: (1:0)-(7:0))
+└── children: (2 items)
+    ├── @ ERBCaseMatchNode (location: (1:0)-(6:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case result " (location: (1:2)-(1:15))
+    │   ├── tag_closing: "%>" (location: (1:15)-(1:17))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:17)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (1 item)
+    │   │   └── @ ERBInNode (location: (2:0)-(2:29))
+    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │       ├── content: " in { status: :success } " (location: (2:2)-(2:27))
+    │   │       ├── tag_closing: "%>" (location: (2:27)-(2:29))
+    │   │       └── statements: (3 items)
+    │   │           ├── @ HTMLTextNode (location: (2:29)-(3:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBBlockNode (location: (3:2)-(5:11))
+    │   │           │   ├── tag_opening: "<%=" (location: (3:2)-(3:5))
+    │   │           │   ├── content: " content_tag(:div) do " (location: (3:5)-(3:27))
+    │   │           │   ├── tag_closing: "%>" (location: (3:27)-(3:29))
+    │   │           │   ├── body: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (3:29)-(5:2))
+    │   │           │   │       └── content: "\n    Success!\n  "
+    │   │           │   │
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (5:2)-(5:11))
+    │   │           │           ├── tag_opening: "<%" (location: (5:2)-(5:4))
+    │   │           │           ├── content: " end " (location: (5:4)-(5:9))
+    │   │           │           └── tag_closing: "%>" (location: (5:9)-(5:11))
+    │   │           │
+    │   │           │
+    │   │           └── @ HTMLTextNode (location: (5:11)-(6:0))
+    │   │               └── content: "\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (6:0)-(6:9))
+    │           ├── tag_opening: "<%" (location: (6:0)-(6:2))
+    │           ├── content: " end " (location: (6:2)-(6:7))
+    │           └── tag_closing: "%>" (location: (6:7)-(6:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (6:9)-(7:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/analyze/case_in_test/test_0009_case_in_with_multiple_blocks_in_in_clause_8cdfe954fcb68cf29f71d5c05893547c.txt b/test/snapshots/analyze/case_in_test/test_0009_case_in_with_multiple_blocks_in_in_clause_8cdfe954fcb68cf29f71d5c05893547c.txt
new file mode 100644
index 000000000..15df4180f
--- /dev/null
+++ b/test/snapshots/analyze/case_in_test/test_0009_case_in_with_multiple_blocks_in_in_clause_8cdfe954fcb68cf29f71d5c05893547c.txt
@@ -0,0 +1,66 @@
+@ DocumentNode (location: (1:0)-(10:0))
+└── children: (2 items)
+    ├── @ ERBCaseMatchNode (location: (1:0)-(9:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case data " (location: (1:2)-(1:13))
+    │   ├── tag_closing: "%>" (location: (1:13)-(1:15))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:15)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (1 item)
+    │   │   └── @ ERBInNode (location: (2:0)-(2:25))
+    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │       ├── content: " in { type: :alert } " (location: (2:2)-(2:23))
+    │   │       ├── tag_closing: "%>" (location: (2:23)-(2:25))
+    │   │       └── statements: (5 items)
+    │   │           ├── @ HTMLTextNode (location: (2:25)-(3:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBBlockNode (location: (3:2)-(5:11))
+    │   │           │   ├── tag_opening: "<%=" (location: (3:2)-(3:5))
+    │   │           │   ├── content: " content_tag(:div) do " (location: (3:5)-(3:27))
+    │   │           │   ├── tag_closing: "%>" (location: (3:27)-(3:29))
+    │   │           │   ├── body: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (3:29)-(5:2))
+    │   │           │   │       └── content: "\n    Alert\n  "
+    │   │           │   │
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (5:2)-(5:11))
+    │   │           │           ├── tag_opening: "<%" (location: (5:2)-(5:4))
+    │   │           │           ├── content: " end " (location: (5:4)-(5:9))
+    │   │           │           └── tag_closing: "%>" (location: (5:9)-(5:11))
+    │   │           │
+    │   │           │
+    │   │           ├── @ HTMLTextNode (location: (5:11)-(6:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBBlockNode (location: (6:2)-(8:11))
+    │   │           │   ├── tag_opening: "<%=" (location: (6:2)-(6:5))
+    │   │           │   ├── content: " content_tag(:span) do " (location: (6:5)-(6:28))
+    │   │           │   ├── tag_closing: "%>" (location: (6:28)-(6:30))
+    │   │           │   ├── body: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (6:30)-(8:2))
+    │   │           │   │       └── content: "\n    Icon\n  "
+    │   │           │   │
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (8:2)-(8:11))
+    │   │           │           ├── tag_opening: "<%" (location: (8:2)-(8:4))
+    │   │           │           ├── content: " end " (location: (8:4)-(8:9))
+    │   │           │           └── tag_closing: "%>" (location: (8:9)-(8:11))
+    │   │           │
+    │   │           │
+    │   │           └── @ HTMLTextNode (location: (8:11)-(9:0))
+    │   │               └── content: "\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (9:0)-(9:9))
+    │           ├── tag_opening: "<%" (location: (9:0)-(9:2))
+    │           ├── content: " end " (location: (9:2)-(9:7))
+    │           └── tag_closing: "%>" (location: (9:7)-(9:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (9:9)-(10:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/analyze/case_in_test/test_0010_case_in_with_if_statement_inside_in_clause_51fcf7566215a5284ae1ee34c920837e.txt b/test/snapshots/analyze/case_in_test/test_0010_case_in_with_if_statement_inside_in_clause_51fcf7566215a5284ae1ee34c920837e.txt
new file mode 100644
index 000000000..5acba3aa5
--- /dev/null
+++ b/test/snapshots/analyze/case_in_test/test_0010_case_in_with_if_statement_inside_in_clause_51fcf7566215a5284ae1ee34c920837e.txt
@@ -0,0 +1,49 @@
+@ DocumentNode (location: (1:0)-(7:0))
+└── children: (2 items)
+    ├── @ ERBCaseMatchNode (location: (1:0)-(6:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case value " (location: (1:2)-(1:14))
+    │   ├── tag_closing: "%>" (location: (1:14)-(1:16))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:16)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (1 item)
+    │   │   └── @ ERBInNode (location: (2:0)-(2:18))
+    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │       ├── content: " in [Integer] " (location: (2:2)-(2:16))
+    │   │       ├── tag_closing: "%>" (location: (2:16)-(2:18))
+    │   │       └── statements: (3 items)
+    │   │           ├── @ HTMLTextNode (location: (2:18)-(3:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBIfNode (location: (3:2)-(5:11))
+    │   │           │   ├── tag_opening: "<%" (location: (3:2)-(3:4))
+    │   │           │   ├── content: " if positive? " (location: (3:4)-(3:18))
+    │   │           │   ├── tag_closing: "%>" (location: (3:18)-(3:20))
+    │   │           │   ├── statements: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (3:20)-(5:2))
+    │   │           │   │       └── content: "\n    Positive\n  "
+    │   │           │   │
+    │   │           │   ├── subsequent: ∅
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (5:2)-(5:11))
+    │   │           │           ├── tag_opening: "<%" (location: (5:2)-(5:4))
+    │   │           │           ├── content: " end " (location: (5:4)-(5:9))
+    │   │           │           └── tag_closing: "%>" (location: (5:9)-(5:11))
+    │   │           │
+    │   │           │
+    │   │           └── @ HTMLTextNode (location: (5:11)-(6:0))
+    │   │               └── content: "\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (6:0)-(6:9))
+    │           ├── tag_opening: "<%" (location: (6:0)-(6:2))
+    │           ├── content: " end " (location: (6:2)-(6:7))
+    │           └── tag_closing: "%>" (location: (6:7)-(6:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (6:9)-(7:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/analyze/case_test/test_0008_case_with_block_inside_when_adb20c2773fe1206d2b47123f8001e22.txt b/test/snapshots/analyze/case_test/test_0008_case_with_block_inside_when_adb20c2773fe1206d2b47123f8001e22.txt
new file mode 100644
index 000000000..e2e329787
--- /dev/null
+++ b/test/snapshots/analyze/case_test/test_0008_case_with_block_inside_when_adb20c2773fe1206d2b47123f8001e22.txt
@@ -0,0 +1,48 @@
+@ DocumentNode (location: (1:0)-(7:0))
+└── children: (2 items)
+    ├── @ ERBCaseNode (location: (1:0)-(6:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case 1 " (location: (1:2)-(1:10))
+    │   ├── tag_closing: "%>" (location: (1:10)-(1:12))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:12)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (1 item)
+    │   │   └── @ ERBWhenNode (location: (2:0)-(2:12))
+    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │       ├── content: " when 1 " (location: (2:2)-(2:10))
+    │   │       ├── tag_closing: "%>" (location: (2:10)-(2:12))
+    │   │       └── statements: (3 items)
+    │   │           ├── @ HTMLTextNode (location: (2:12)-(3:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBBlockNode (location: (3:2)-(5:11))
+    │   │           │   ├── tag_opening: "<%=" (location: (3:2)-(3:5))
+    │   │           │   ├── content: " content_tag(:p) do " (location: (3:5)-(3:25))
+    │   │           │   ├── tag_closing: "%>" (location: (3:25)-(3:27))
+    │   │           │   ├── body: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (3:27)-(5:2))
+    │   │           │   │       └── content: "\n    Yep\n  "
+    │   │           │   │
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (5:2)-(5:11))
+    │   │           │           ├── tag_opening: "<%" (location: (5:2)-(5:4))
+    │   │           │           ├── content: " end " (location: (5:4)-(5:9))
+    │   │           │           └── tag_closing: "%>" (location: (5:9)-(5:11))
+    │   │           │
+    │   │           │
+    │   │           └── @ HTMLTextNode (location: (5:11)-(6:0))
+    │   │               └── content: "\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (6:0)-(6:9))
+    │           ├── tag_opening: "<%" (location: (6:0)-(6:2))
+    │           ├── content: " end " (location: (6:2)-(6:7))
+    │           └── tag_closing: "%>" (location: (6:7)-(6:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (6:9)-(7:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/analyze/case_test/test_0009_case_with_multiple_blocks_in_when_05f7d387314a95620a58ddc7f7d31b7b.txt b/test/snapshots/analyze/case_test/test_0009_case_with_multiple_blocks_in_when_05f7d387314a95620a58ddc7f7d31b7b.txt
new file mode 100644
index 000000000..ff5e466ab
--- /dev/null
+++ b/test/snapshots/analyze/case_test/test_0009_case_with_multiple_blocks_in_when_05f7d387314a95620a58ddc7f7d31b7b.txt
@@ -0,0 +1,66 @@
+@ DocumentNode (location: (1:0)-(10:0))
+└── children: (2 items)
+    ├── @ ERBCaseNode (location: (1:0)-(9:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case status " (location: (1:2)-(1:15))
+    │   ├── tag_closing: "%>" (location: (1:15)-(1:17))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:17)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (1 item)
+    │   │   └── @ ERBWhenNode (location: (2:0)-(2:18))
+    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │       ├── content: " when :active " (location: (2:2)-(2:16))
+    │   │       ├── tag_closing: "%>" (location: (2:16)-(2:18))
+    │   │       └── statements: (5 items)
+    │   │           ├── @ HTMLTextNode (location: (2:18)-(3:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBBlockNode (location: (3:2)-(5:11))
+    │   │           │   ├── tag_opening: "<%=" (location: (3:2)-(3:5))
+    │   │           │   ├── content: " content_tag(:div) do " (location: (3:5)-(3:27))
+    │   │           │   ├── tag_closing: "%>" (location: (3:27)-(3:29))
+    │   │           │   ├── body: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (3:29)-(5:2))
+    │   │           │   │       └── content: "\n    Active\n  "
+    │   │           │   │
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (5:2)-(5:11))
+    │   │           │           ├── tag_opening: "<%" (location: (5:2)-(5:4))
+    │   │           │           ├── content: " end " (location: (5:4)-(5:9))
+    │   │           │           └── tag_closing: "%>" (location: (5:9)-(5:11))
+    │   │           │
+    │   │           │
+    │   │           ├── @ HTMLTextNode (location: (5:11)-(6:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBBlockNode (location: (6:2)-(8:11))
+    │   │           │   ├── tag_opening: "<%=" (location: (6:2)-(6:5))
+    │   │           │   ├── content: " content_tag(:span) do " (location: (6:5)-(6:28))
+    │   │           │   ├── tag_closing: "%>" (location: (6:28)-(6:30))
+    │   │           │   ├── body: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (6:30)-(8:2))
+    │   │           │   │       └── content: "\n    Badge\n  "
+    │   │           │   │
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (8:2)-(8:11))
+    │   │           │           ├── tag_opening: "<%" (location: (8:2)-(8:4))
+    │   │           │           ├── content: " end " (location: (8:4)-(8:9))
+    │   │           │           └── tag_closing: "%>" (location: (8:9)-(8:11))
+    │   │           │
+    │   │           │
+    │   │           └── @ HTMLTextNode (location: (8:11)-(9:0))
+    │   │               └── content: "\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (9:0)-(9:9))
+    │           ├── tag_opening: "<%" (location: (9:0)-(9:2))
+    │           ├── content: " end " (location: (9:2)-(9:7))
+    │           └── tag_closing: "%>" (location: (9:7)-(9:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (9:9)-(10:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/analyze/case_test/test_0010_case_with_nested_blocks_in_when_6e70c1bf60788969969296d35c409a47.txt b/test/snapshots/analyze/case_test/test_0010_case_with_nested_blocks_in_when_6e70c1bf60788969969296d35c409a47.txt
new file mode 100644
index 000000000..857244cb8
--- /dev/null
+++ b/test/snapshots/analyze/case_test/test_0010_case_with_nested_blocks_in_when_6e70c1bf60788969969296d35c409a47.txt
@@ -0,0 +1,66 @@
+@ DocumentNode (location: (1:0)-(9:0))
+└── children: (2 items)
+    ├── @ ERBCaseNode (location: (1:0)-(8:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case level " (location: (1:2)-(1:14))
+    │   ├── tag_closing: "%>" (location: (1:14)-(1:16))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:16)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (1 item)
+    │   │   └── @ ERBWhenNode (location: (2:0)-(2:12))
+    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │       ├── content: " when 1 " (location: (2:2)-(2:10))
+    │   │       ├── tag_closing: "%>" (location: (2:10)-(2:12))
+    │   │       └── statements: (3 items)
+    │   │           ├── @ HTMLTextNode (location: (2:12)-(3:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBBlockNode (location: (3:2)-(7:11))
+    │   │           │   ├── tag_opening: "<%=" (location: (3:2)-(3:5))
+    │   │           │   ├── content: " content_tag(:div) do " (location: (3:5)-(3:27))
+    │   │           │   ├── tag_closing: "%>" (location: (3:27)-(3:29))
+    │   │           │   ├── body: (3 items)
+    │   │           │   │   ├── @ HTMLTextNode (location: (3:29)-(4:4))
+    │   │           │   │   │   └── content: "\n    "
+    │   │           │   │   │
+    │   │           │   │   ├── @ ERBBlockNode (location: (4:4)-(6:13))
+    │   │           │   │   │   ├── tag_opening: "<%=" (location: (4:4)-(4:7))
+    │   │           │   │   │   ├── content: " content_tag(:p) do " (location: (4:7)-(4:27))
+    │   │           │   │   │   ├── tag_closing: "%>" (location: (4:27)-(4:29))
+    │   │           │   │   │   ├── body: (1 item)
+    │   │           │   │   │   │   └── @ HTMLTextNode (location: (4:29)-(6:4))
+    │   │           │   │   │   │       └── content: "\n      Nested\n    "
+    │   │           │   │   │   │
+    │   │           │   │   │   └── end_node:
+    │   │           │   │   │       └── @ ERBEndNode (location: (6:4)-(6:13))
+    │   │           │   │   │           ├── tag_opening: "<%" (location: (6:4)-(6:6))
+    │   │           │   │   │           ├── content: " end " (location: (6:6)-(6:11))
+    │   │           │   │   │           └── tag_closing: "%>" (location: (6:11)-(6:13))
+    │   │           │   │   │
+    │   │           │   │   │
+    │   │           │   │   └── @ HTMLTextNode (location: (6:13)-(7:2))
+    │   │           │   │       └── content: "\n  "
+    │   │           │   │
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (7:2)-(7:11))
+    │   │           │           ├── tag_opening: "<%" (location: (7:2)-(7:4))
+    │   │           │           ├── content: " end " (location: (7:4)-(7:9))
+    │   │           │           └── tag_closing: "%>" (location: (7:9)-(7:11))
+    │   │           │
+    │   │           │
+    │   │           └── @ HTMLTextNode (location: (7:11)-(8:0))
+    │   │               └── content: "\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (8:0)-(8:9))
+    │           ├── tag_opening: "<%" (location: (8:0)-(8:2))
+    │           ├── content: " end " (location: (8:2)-(8:7))
+    │           └── tag_closing: "%>" (location: (8:7)-(8:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (8:9)-(9:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/analyze/case_test/test_0011_case_with_block_in_multiple_when_clauses_3f35d3ebf6ea6eaf8e7b9bc7f8393a0f.txt b/test/snapshots/analyze/case_test/test_0011_case_with_block_in_multiple_when_clauses_3f35d3ebf6ea6eaf8e7b9bc7f8393a0f.txt
new file mode 100644
index 000000000..818e209a5
--- /dev/null
+++ b/test/snapshots/analyze/case_test/test_0011_case_with_block_in_multiple_when_clauses_3f35d3ebf6ea6eaf8e7b9bc7f8393a0f.txt
@@ -0,0 +1,75 @@
+@ DocumentNode (location: (1:0)-(11:0))
+└── children: (2 items)
+    ├── @ ERBCaseNode (location: (1:0)-(10:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case type " (location: (1:2)-(1:13))
+    │   ├── tag_closing: "%>" (location: (1:13)-(1:15))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:15)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (2 items)
+    │   │   ├── @ ERBWhenNode (location: (2:0)-(2:13))
+    │   │   │   ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │   │   ├── content: " when :a " (location: (2:2)-(2:11))
+    │   │   │   ├── tag_closing: "%>" (location: (2:11)-(2:13))
+    │   │   │   └── statements: (3 items)
+    │   │   │       ├── @ HTMLTextNode (location: (2:13)-(3:2))
+    │   │   │       │   └── content: "\n  "
+    │   │   │       │
+    │   │   │       ├── @ ERBBlockNode (location: (3:2)-(5:11))
+    │   │   │       │   ├── tag_opening: "<%=" (location: (3:2)-(3:5))
+    │   │   │       │   ├── content: " form_for(obj) do |f| " (location: (3:5)-(3:27))
+    │   │   │       │   ├── tag_closing: "%>" (location: (3:27)-(3:29))
+    │   │   │       │   ├── body: (1 item)
+    │   │   │       │   │   └── @ HTMLTextNode (location: (3:29)-(5:2))
+    │   │   │       │   │       └── content: "\n    Form A\n  "
+    │   │   │       │   │
+    │   │   │       │   └── end_node:
+    │   │   │       │       └── @ ERBEndNode (location: (5:2)-(5:11))
+    │   │   │       │           ├── tag_opening: "<%" (location: (5:2)-(5:4))
+    │   │   │       │           ├── content: " end " (location: (5:4)-(5:9))
+    │   │   │       │           └── tag_closing: "%>" (location: (5:9)-(5:11))
+    │   │   │       │
+    │   │   │       │
+    │   │   │       └── @ HTMLTextNode (location: (5:11)-(6:0))
+    │   │   │           └── content: "\n"
+    │   │   │
+    │   │   │
+    │   │   └── @ ERBWhenNode (location: (6:0)-(6:13))
+    │   │       ├── tag_opening: "<%" (location: (6:0)-(6:2))
+    │   │       ├── content: " when :b " (location: (6:2)-(6:11))
+    │   │       ├── tag_closing: "%>" (location: (6:11)-(6:13))
+    │   │       └── statements: (3 items)
+    │   │           ├── @ HTMLTextNode (location: (6:13)-(7:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBBlockNode (location: (7:2)-(9:11))
+    │   │           │   ├── tag_opening: "<%=" (location: (7:2)-(7:5))
+    │   │           │   ├── content: " form_for(obj) do |f| " (location: (7:5)-(7:27))
+    │   │           │   ├── tag_closing: "%>" (location: (7:27)-(7:29))
+    │   │           │   ├── body: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (7:29)-(9:2))
+    │   │           │   │       └── content: "\n    Form B\n  "
+    │   │           │   │
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (9:2)-(9:11))
+    │   │           │           ├── tag_opening: "<%" (location: (9:2)-(9:4))
+    │   │           │           ├── content: " end " (location: (9:4)-(9:9))
+    │   │           │           └── tag_closing: "%>" (location: (9:9)-(9:11))
+    │   │           │
+    │   │           │
+    │   │           └── @ HTMLTextNode (location: (9:11)-(10:0))
+    │   │               └── content: "\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (10:0)-(10:9))
+    │           ├── tag_opening: "<%" (location: (10:0)-(10:2))
+    │           ├── content: " end " (location: (10:2)-(10:7))
+    │           └── tag_closing: "%>" (location: (10:7)-(10:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (10:9)-(11:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/analyze/case_test/test_0012_case_with_if_statement_inside_when_ccc0bd511203c41d9274ccc360e736c2.txt b/test/snapshots/analyze/case_test/test_0012_case_with_if_statement_inside_when_ccc0bd511203c41d9274ccc360e736c2.txt
new file mode 100644
index 000000000..5cef31f1d
--- /dev/null
+++ b/test/snapshots/analyze/case_test/test_0012_case_with_if_statement_inside_when_ccc0bd511203c41d9274ccc360e736c2.txt
@@ -0,0 +1,49 @@
+@ DocumentNode (location: (1:0)-(7:0))
+└── children: (2 items)
+    ├── @ ERBCaseNode (location: (1:0)-(6:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case status " (location: (1:2)-(1:15))
+    │   ├── tag_closing: "%>" (location: (1:15)-(1:17))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:17)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (1 item)
+    │   │   └── @ ERBWhenNode (location: (2:0)-(2:18))
+    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │       ├── content: " when :active " (location: (2:2)-(2:16))
+    │   │       ├── tag_closing: "%>" (location: (2:16)-(2:18))
+    │   │       └── statements: (3 items)
+    │   │           ├── @ HTMLTextNode (location: (2:18)-(3:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBIfNode (location: (3:2)-(5:11))
+    │   │           │   ├── tag_opening: "<%" (location: (3:2)-(3:4))
+    │   │           │   ├── content: " if admin? " (location: (3:4)-(3:15))
+    │   │           │   ├── tag_closing: "%>" (location: (3:15)-(3:17))
+    │   │           │   ├── statements: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (3:17)-(5:2))
+    │   │           │   │       └── content: "\n    Admin view\n  "
+    │   │           │   │
+    │   │           │   ├── subsequent: ∅
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (5:2)-(5:11))
+    │   │           │           ├── tag_opening: "<%" (location: (5:2)-(5:4))
+    │   │           │           ├── content: " end " (location: (5:4)-(5:9))
+    │   │           │           └── tag_closing: "%>" (location: (5:9)-(5:11))
+    │   │           │
+    │   │           │
+    │   │           └── @ HTMLTextNode (location: (5:11)-(6:0))
+    │   │               └── content: "\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (6:0)-(6:9))
+    │           ├── tag_opening: "<%" (location: (6:0)-(6:2))
+    │           ├── content: " end " (location: (6:2)-(6:7))
+    │           └── tag_closing: "%>" (location: (6:7)-(6:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (6:9)-(7:0))
+        └── content: "\n"
\ No newline at end of file

From 5067d4e595a0829d2c48a7e2fe71817a0d9bf0e3 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Sun, 5 Oct 2025 16:58:06 +0900
Subject: [PATCH 17/97] Parser: Analyze `case` statements with `yield` as
 `ERBCaseNode` (#577)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This pull request updates the parser to analyze `yield` inside `case`
nodes as `ERBCaseNode` instead of `ERBYieldNode`.

The following templates:
```html+erb
<% case yield(:a) %>
<% when 'a' %>
  aaa
<% end %>
```

Gets now parsed as:
```js
@ DocumentNode (location: (1:0)-(5:0))
└── children: (2 items)
    ├── @ ERBCaseNode (location: (1:0)-(4:9))
    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
    │   ├── content: " case yield(:a) " (location: (1:2)-(1:18))
    │   ├── tag_closing: "%>" (location: (1:18)-(1:20))
    │   ├── children: (1 item)
    │   │   └── @ HTMLTextNode (location: (1:20)-(2:0))
    │   │       └── content: "\n"
    │   │
    │   ├── conditions: (1 item)
    │   │   └── @ ERBWhenNode (location: (2:0)-(2:14))
    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
    │   │       ├── content: " when 'a' " (location: (2:2)-(2:12))
    │   │       ├── tag_closing: "%>" (location: (2:12)-(2:14))
    │   │       └── statements: (1 item)
    │   │           └── @ HTMLTextNode (location: (2:14)-(4:0))
    │   │               └── content: "\n  aaa\n"
    │   │
    │   │
    │   ├── else_clause: ∅
    │   └── end_node:
    │       └── @ ERBEndNode (location: (4:0)-(4:9))
    │           ├── tag_opening: "<%" (location: (4:0)-(4:2))
    │           ├── content: " end " (location: (4:2)-(4:7))
    │           └── tag_closing: "%>" (location: (4:7)-(4:9))
    │
    │
    └── @ HTMLTextNode (location: (4:9)-(5:0))
        └── content: "\n"
```

Previously it was parsed as:

```js
@ DocumentNode (location: (1:0)-(5:0))
└── children: (6 items)
    ├── @ ERBYieldNode (location: (1:0)-(1:20))
    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
    │   ├── content: " case yield(:a) " (location: (1:2)-(1:18))
    │   └── tag_closing: "%>" (location: (1:18)-(1:20))
    │
    ├── @ HTMLTextNode (location: (1:20)-(2:0))
    │   └── content: "\n"
    │
    ├── @ ERBContentNode (location: (2:0)-(2:14))
    │   ├── tag_opening: "<%" (location: (2:0)-(2:2))
    │   ├── content: " when 'a' " (location: (2:2)-(2:12))
    │   ├── tag_closing: "%>" (location: (2:12)-(2:14))
    │   ├── parsed: true
    │   └── valid: false
    │
    ├── @ HTMLTextNode (location: (2:14)-(4:0))
    │   └── content: "\n  aaa\n"
    │
    ├── @ ERBContentNode (location: (4:0)-(4:9))
    │   ├── tag_opening: "<%" (location: (4:0)-(4:2))
    │   ├── content: " end " (location: (4:2)-(4:7))
    │   ├── tag_closing: "%>" (location: (4:7)-(4:9))
    │   ├── parsed: true
    │   └── valid: false
    │
    └── @ HTMLTextNode (location: (4:9)-(5:0))
        └── content: "\n"
```

Resolves https://github.com/marcoroth/herb/issues/561
---
 src/analyze.c                                 |  7 ++---
 test/analyze/case_test.rb                     |  9 ++++++
 ...yield_dc59b65969b8ef95076abc05c3907392.txt | 30 +++++++++++++++++++
 3 files changed, 41 insertions(+), 5 deletions(-)
 create mode 100644 test/snapshots/analyze/case_test/test_0013_case_with_yield_dc59b65969b8ef95076abc05c3907392.txt

diff --git a/src/analyze.c b/src/analyze.c
index bd0778520..dcf5e5485 100644
--- a/src/analyze.c
+++ b/src/analyze.c
@@ -96,12 +96,8 @@ static control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
 
   if (!ruby) { return CONTROL_TYPE_UNKNOWN; }
 
-  if (ruby->valid) {
-    if (has_yield_node(ruby)) { return CONTROL_TYPE_YIELD; }
-    return CONTROL_TYPE_UNKNOWN;
-  }
+  if (ruby->valid) { return CONTROL_TYPE_UNKNOWN; }
 
-  if (has_yield_node(ruby)) { return CONTROL_TYPE_YIELD; }
   if (has_block_node(ruby)) { return CONTROL_TYPE_BLOCK; }
   if (has_if_node(ruby)) { return CONTROL_TYPE_IF; }
   if (has_elsif_node(ruby)) { return CONTROL_TYPE_ELSIF; }
@@ -119,6 +115,7 @@ static control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
   if (has_until_node(ruby)) { return CONTROL_TYPE_UNTIL; }
   if (has_for_node(ruby)) { return CONTROL_TYPE_FOR; }
   if (has_block_closing(ruby)) { return CONTROL_TYPE_BLOCK_CLOSE; }
+  if (has_yield_node(ruby)) { return CONTROL_TYPE_YIELD; }
 
   return CONTROL_TYPE_UNKNOWN;
 }
diff --git a/test/analyze/case_test.rb b/test/analyze/case_test.rb
index 0e181c0b4..a4b7bf5d4 100644
--- a/test/analyze/case_test.rb
+++ b/test/analyze/case_test.rb
@@ -154,5 +154,14 @@ class CaseTest < Minitest::Spec
         <% end %>
       HTML
     end
+
+    test "case with yield" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case yield(:a) %>
+        <% when 'a' %>
+          aaa
+        <% end %>
+      HTML
+    end
   end
 end
diff --git a/test/snapshots/analyze/case_test/test_0013_case_with_yield_dc59b65969b8ef95076abc05c3907392.txt b/test/snapshots/analyze/case_test/test_0013_case_with_yield_dc59b65969b8ef95076abc05c3907392.txt
new file mode 100644
index 000000000..1a4e6654e
--- /dev/null
+++ b/test/snapshots/analyze/case_test/test_0013_case_with_yield_dc59b65969b8ef95076abc05c3907392.txt
@@ -0,0 +1,30 @@
+@ DocumentNode (location: (1:0)-(5:0))
+└── children: (2 items)
+    ├── @ ERBCaseNode (location: (1:0)-(4:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case yield(:a) " (location: (1:2)-(1:18))
+    │   ├── tag_closing: "%>" (location: (1:18)-(1:20))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:20)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (1 item)
+    │   │   └── @ ERBWhenNode (location: (2:0)-(2:14))
+    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │       ├── content: " when 'a' " (location: (2:2)-(2:12))
+    │   │       ├── tag_closing: "%>" (location: (2:12)-(2:14))
+    │   │       └── statements: (1 item)
+    │   │           └── @ HTMLTextNode (location: (2:14)-(4:0))
+    │   │               └── content: "\n  aaa\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (4:0)-(4:9))
+    │           ├── tag_opening: "<%" (location: (4:0)-(4:2))
+    │           ├── content: " end " (location: (4:2)-(4:7))
+    │           └── tag_closing: "%>" (location: (4:7)-(4:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (4:9)-(5:0))
+        └── content: "\n"
\ No newline at end of file

From 2276a01f37f33c37bdd3d6fb9b9cb0573f7a4e02 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Mon, 6 Oct 2025 13:05:38 +0900
Subject: [PATCH 18/97] `v0.7.5`

---
 Gemfile.lock                                  |  2 +-
 docs/package.json                             |  6 ++---
 javascript/packages/browser/package.json      |  4 ++--
 .../packages/browser/test/browser.test.ts     |  2 +-
 javascript/packages/core/package.json         |  2 +-
 javascript/packages/dev-tools/package.json    |  4 ++--
 javascript/packages/formatter/package.json    |  6 ++---
 .../herb-language-server/package.json         |  4 ++--
 javascript/packages/highlighter/package.json  |  6 ++---
 .../packages/language-server/package.json     |  8 +++----
 javascript/packages/linter/README.md          |  4 ++--
 javascript/packages/linter/package.json       | 10 ++++----
 .../test/__snapshots__/cli.test.ts.snap       | 24 +++++++++----------
 javascript/packages/node-wasm/package.json    |  4 ++--
 .../packages/node-wasm/test/node-wasm.test.ts |  2 +-
 javascript/packages/node/package.json         |  4 ++--
 javascript/packages/node/test/node.test.ts    |  2 +-
 javascript/packages/printer/package.json      |  4 ++--
 .../packages/stimulus-lint/package.json       | 10 ++++----
 .../tailwind-class-sorter/package.json        |  2 +-
 javascript/packages/vscode/package.json       |  8 +++----
 lib/herb/version.rb                           |  2 +-
 playground/package.json                       |  6 ++---
 src/include/version.h                         |  2 +-
 test/c/test_herb.c                            |  2 +-
 test/herb_test.rb                             |  2 +-
 26 files changed, 66 insertions(+), 66 deletions(-)

diff --git a/Gemfile.lock b/Gemfile.lock
index 4e87cabfe..2199da0f3 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -17,7 +17,7 @@ GIT
 PATH
   remote: .
   specs:
-    herb (0.7.4)
+    herb (0.7.5)
 
 GEM
   remote: https://rubygems.org/
diff --git a/docs/package.json b/docs/package.json
index f6685b400..cbda66736 100644
--- a/docs/package.json
+++ b/docs/package.json
@@ -19,9 +19,9 @@
     "fetch:contributors": "mkdir -p .vitepress/data/ && gh api -X get https://api.github.com/repos/marcoroth/herb/contributors > .vitepress/data/contributors.json"
   },
   "dependencies": {
-    "@herb-tools/browser": "0.7.4",
-    "@herb-tools/core": "0.7.4",
-    "@herb-tools/node": "0.7.4"
+    "@herb-tools/browser": "0.7.5",
+    "@herb-tools/core": "0.7.5",
+    "@herb-tools/node": "0.7.5"
   },
   "devDependencies": {
     "@shikijs/vitepress-twoslash": "^3.4.2",
diff --git a/javascript/packages/browser/package.json b/javascript/packages/browser/package.json
index c65ea539a..55622a4ad 100644
--- a/javascript/packages/browser/package.json
+++ b/javascript/packages/browser/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/browser",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "WebAssembly-based HTML-aware ERB parser for browsers.",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
     }
   },
   "dependencies": {
-    "@herb-tools/core": "0.7.4"
+    "@herb-tools/core": "0.7.5"
   },
   "files": [
     "package.json",
diff --git a/javascript/packages/browser/test/browser.test.ts b/javascript/packages/browser/test/browser.test.ts
index ff99b6553..464db9da9 100644
--- a/javascript/packages/browser/test/browser.test.ts
+++ b/javascript/packages/browser/test/browser.test.ts
@@ -17,7 +17,7 @@ describe("@herb-tools/browser", () => {
   test("version() returns a string", async () => {
     const version = Herb.version
     expect(typeof version).toBe("string")
-    expect(version).toBe("@herb-tools/browser@0.7.4, @herb-tools/core@0.7.4, libprism@1.5.1, libherb@0.7.4 (WebAssembly)")
+    expect(version).toBe("@herb-tools/browser@0.7.5, @herb-tools/core@0.7.5, libprism@1.5.1, libherb@0.7.5 (WebAssembly)")
   })
 
   test("parse() can process a simple template", async () => {
diff --git a/javascript/packages/core/package.json b/javascript/packages/core/package.json
index 109a4d029..6ae07a8a2 100644
--- a/javascript/packages/core/package.json
+++ b/javascript/packages/core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/core",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "Core module exporting shared interfaces, AST node definitions, and common utilities for Herb",
   "type": "module",
   "license": "MIT",
diff --git a/javascript/packages/dev-tools/package.json b/javascript/packages/dev-tools/package.json
index c66f0ff4e..4dbe1b66f 100644
--- a/javascript/packages/dev-tools/package.json
+++ b/javascript/packages/dev-tools/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/dev-tools",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "Development tools for visual debugging in HTML+ERB templates",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
     }
   },
   "dependencies": {
-    "@herb-tools/core": "0.7.4"
+    "@herb-tools/core": "0.7.5"
   },
   "files": [
     "package.json",
diff --git a/javascript/packages/formatter/package.json b/javascript/packages/formatter/package.json
index 467e1ac21..4de78cad0 100644
--- a/javascript/packages/formatter/package.json
+++ b/javascript/packages/formatter/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/formatter",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "Auto-formatter for HTML+ERB templates with intelligent indentation, line wrapping, and ERB-aware pretty-printing.",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
@@ -35,8 +35,8 @@
     }
   },
   "dependencies": {
-    "@herb-tools/core": "0.7.4",
-    "@herb-tools/printer": "0.7.4"
+    "@herb-tools/core": "0.7.5",
+    "@herb-tools/printer": "0.7.5"
   },
   "devDependencies": {
     "glob": "^11.0.3"
diff --git a/javascript/packages/herb-language-server/package.json b/javascript/packages/herb-language-server/package.json
index f21a0796f..e7f0e79fb 100644
--- a/javascript/packages/herb-language-server/package.json
+++ b/javascript/packages/herb-language-server/package.json
@@ -1,7 +1,7 @@
 {
   "name": "herb-language-server",
   "description": "Placeholder package to reserve the herb-language-server name on NPM; use @herb-tools/language-server instead.",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "author": "Marco Roth",
   "license": "MIT",
   "engines": {
@@ -45,6 +45,6 @@
     "dist/"
   ],
   "dependencies": {
-    "@herb-tools/language-server": "0.7.4"
+    "@herb-tools/language-server": "0.7.5"
   }
 }
diff --git a/javascript/packages/highlighter/package.json b/javascript/packages/highlighter/package.json
index fa81157f0..4a6a07d1c 100644
--- a/javascript/packages/highlighter/package.json
+++ b/javascript/packages/highlighter/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/highlighter",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "Syntax highlighter and diagnostic renderer for HTML+ERB templates.",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
@@ -35,8 +35,8 @@
     "prepublishOnly": "yarn clean && yarn build && yarn test"
   },
   "dependencies": {
-    "@herb-tools/core": "0.7.4",
-    "@herb-tools/node-wasm": "0.7.4",
+    "@herb-tools/core": "0.7.5",
+    "@herb-tools/node-wasm": "0.7.5",
     "glob": "^11.0.3"
   },
   "files": [
diff --git a/javascript/packages/language-server/package.json b/javascript/packages/language-server/package.json
index 224cbe31a..a5580abbb 100644
--- a/javascript/packages/language-server/package.json
+++ b/javascript/packages/language-server/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@herb-tools/language-server",
   "description": "Herb HTML+ERB Language Tools and Language Server Protocol integration.",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "author": "Marco Roth",
   "license": "MIT",
   "engines": {
@@ -45,9 +45,9 @@
     "dist/"
   ],
   "dependencies": {
-    "@herb-tools/formatter": "0.7.4",
-    "@herb-tools/linter": "0.7.4",
-    "@herb-tools/node-wasm": "0.7.4",
+    "@herb-tools/formatter": "0.7.5",
+    "@herb-tools/linter": "0.7.5",
+    "@herb-tools/node-wasm": "0.7.5",
     "dedent": "^1.6.0",
     "vscode-languageserver": "^9.0.1",
     "vscode-languageserver-textdocument": "^1.0.12"
diff --git a/javascript/packages/linter/README.md b/javascript/packages/linter/README.md
index f27c4c26d..54002f00f 100644
--- a/javascript/packages/linter/README.md
+++ b/javascript/packages/linter/README.md
@@ -184,7 +184,7 @@ npx @herb-tools/linter --format=simple --github
 
 **Example: `--github` (GitHub annotations + detailed format)**
 ```
-::error file=template.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.4::Missing required `alt` attribute on `<img>` tag [html-img-require-alt]%0A%0A%0Atemplate.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <span>Test content</span>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A
+::error file=template.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.5::Missing required `alt` attribute on `<img>` tag [html-img-require-alt]%0A%0A%0Atemplate.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <span>Test content</span>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A
 
 [error] Missing required `alt` attribute on `<img>` tag [html-img-require-alt]
 
@@ -199,7 +199,7 @@ template.html.erb:3:3
 
 **Example: `--format=simple --github` (GitHub annotations + simple format)**
 ```
-::error file=template.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.4::Missing required `alt` attribute on `<img>` tag [html-img-require-alt]%0A%0A%0Atemplate.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <span>Test content</span>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A
+::error file=template.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.5::Missing required `alt` attribute on `<img>` tag [html-img-require-alt]%0A%0A%0Atemplate.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <span>Test content</span>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A
 
 template.html.erb:
   3:3 ✗ Missing required `alt` attribute on `<img>` tag [html-img-require-alt]
diff --git a/javascript/packages/linter/package.json b/javascript/packages/linter/package.json
index aa3766a66..e0f6c34e3 100644
--- a/javascript/packages/linter/package.json
+++ b/javascript/packages/linter/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/linter",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "HTML+ERB linter for validating HTML structure and enforcing best practices",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
@@ -39,10 +39,10 @@
     }
   },
   "dependencies": {
-    "@herb-tools/core": "0.7.4",
-    "@herb-tools/highlighter": "0.7.4",
-    "@herb-tools/node-wasm": "0.7.4",
-    "@herb-tools/printer": "0.7.4",
+    "@herb-tools/core": "0.7.5",
+    "@herb-tools/highlighter": "0.7.5",
+    "@herb-tools/node-wasm": "0.7.5",
+    "@herb-tools/printer": "0.7.5",
     "glob": "^11.0.3"
   },
   "files": [
diff --git a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
index d24c9fd66..8ba66e99b 100644
--- a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
+++ b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
@@ -1,11 +1,11 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
 exports[`CLI Output Formatting > GitHub Actions format escapes special characters in messages 1`] = `
-"::error file=test/fixtures/test-file-with-errors.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.4::Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. [html-img-require-alt]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <SPAN>Test content</SPAN>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A      5 │%0A
+"::error file=test/fixtures/test-file-with-errors.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.5::Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. [html-img-require-alt]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <SPAN>Test content</SPAN>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A      5 │%0A
 
-::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=3,title=html-tag-name-lowercase • @herb-tools/linter@0.7.4::Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:3%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │    ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
+::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=3,title=html-tag-name-lowercase • @herb-tools/linter@0.7.5::Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:3%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │    ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
 
-::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=22,title=html-tag-name-lowercase • @herb-tools/linter@0.7.4::Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:22%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │                       ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
+::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=22,title=html-tag-name-lowercase • @herb-tools/linter@0.7.5::Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:22%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │                       ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
 
 [error] Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. (html-img-require-alt)
 
@@ -55,7 +55,7 @@ test/fixtures/test-file-with-errors.html.erb:2:22
 `;
 
 exports[`CLI Output Formatting > GitHub Actions format includes rule codes 1`] = `
-"::error file=test/fixtures/no-trailing-newline.html.erb,line=1,col=29,title=erb-requires-trailing-newline • @herb-tools/linter@0.7.4::File must end with trailing newline [erb-requires-trailing-newline]%0A%0A%0Atest/fixtures/no-trailing-newline.html.erb:1:29%0A%0A  →   1 │ <div>No trailing newline</div>%0A        │                              ~%0A
+"::error file=test/fixtures/no-trailing-newline.html.erb,line=1,col=29,title=erb-requires-trailing-newline • @herb-tools/linter@0.7.5::File must end with trailing newline [erb-requires-trailing-newline]%0A%0A%0Atest/fixtures/no-trailing-newline.html.erb:1:29%0A%0A  →   1 │ <div>No trailing newline</div>%0A        │                              ~%0A
 
 [error] File must end with trailing newline (erb-requires-trailing-newline)
 
@@ -389,9 +389,9 @@ test/fixtures/few-rule-offenses.html.erb:3:16
 `;
 
 exports[`CLI Output Formatting > formats GitHub Actions output correctly for bad file 1`] = `
-"::error file=test/fixtures/bad-file.html.erb,line=1,col=1,title=html-tag-name-lowercase • @herb-tools/linter@0.7.4::Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/bad-file.html.erb:1:1%0A%0A  →   1 │ <SPAN>Bad file</SPAN>%0A        │  ~~~~%0A      2 │%0A
+"::error file=test/fixtures/bad-file.html.erb,line=1,col=1,title=html-tag-name-lowercase • @herb-tools/linter@0.7.5::Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/bad-file.html.erb:1:1%0A%0A  →   1 │ <SPAN>Bad file</SPAN>%0A        │  ~~~~%0A      2 │%0A
 
-::error file=test/fixtures/bad-file.html.erb,line=1,col=16,title=html-tag-name-lowercase • @herb-tools/linter@0.7.4::Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/bad-file.html.erb:1:16%0A%0A  →   1 │ <SPAN>Bad file</SPAN>%0A        │                 ~~~~%0A      2 │%0A
+::error file=test/fixtures/bad-file.html.erb,line=1,col=16,title=html-tag-name-lowercase • @herb-tools/linter@0.7.5::Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/bad-file.html.erb:1:16%0A%0A  →   1 │ <SPAN>Bad file</SPAN>%0A        │                 ~~~~%0A      2 │%0A
 
 [error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
 
@@ -431,11 +431,11 @@ exports[`CLI Output Formatting > formats GitHub Actions output correctly for cle
 `;
 
 exports[`CLI Output Formatting > formats GitHub Actions output correctly for file with errors 1`] = `
-"::error file=test/fixtures/test-file-with-errors.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.4::Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. [html-img-require-alt]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <SPAN>Test content</SPAN>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A      5 │%0A
+"::error file=test/fixtures/test-file-with-errors.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.5::Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. [html-img-require-alt]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <SPAN>Test content</SPAN>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A      5 │%0A
 
-::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=3,title=html-tag-name-lowercase • @herb-tools/linter@0.7.4::Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:3%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │    ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
+::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=3,title=html-tag-name-lowercase • @herb-tools/linter@0.7.5::Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:3%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │    ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
 
-::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=22,title=html-tag-name-lowercase • @herb-tools/linter@0.7.4::Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:22%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │                       ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
+::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=22,title=html-tag-name-lowercase • @herb-tools/linter@0.7.5::Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:22%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │                       ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
 
 [error] Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. (html-img-require-alt)
 
@@ -782,11 +782,11 @@ test/fixtures/bad-file.html.erb:1:16
 `;
 
 exports[`CLI Output Formatting > uses GitHub Actions format by default when GITHUB_ACTIONS is true 1`] = `
-"::error file=test/fixtures/test-file-with-errors.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.4::Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. [html-img-require-alt]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <SPAN>Test content</SPAN>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A      5 │%0A
+"::error file=test/fixtures/test-file-with-errors.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.5::Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. [html-img-require-alt]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <SPAN>Test content</SPAN>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A      5 │%0A
 
-::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=3,title=html-tag-name-lowercase • @herb-tools/linter@0.7.4::Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:3%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │    ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
+::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=3,title=html-tag-name-lowercase • @herb-tools/linter@0.7.5::Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:3%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │    ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
 
-::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=22,title=html-tag-name-lowercase • @herb-tools/linter@0.7.4::Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:22%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │                       ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
+::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=22,title=html-tag-name-lowercase • @herb-tools/linter@0.7.5::Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:22%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │                       ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
 
 [error] Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. (html-img-require-alt)
 
diff --git a/javascript/packages/node-wasm/package.json b/javascript/packages/node-wasm/package.json
index ae23a1a7e..da589ec3c 100644
--- a/javascript/packages/node-wasm/package.json
+++ b/javascript/packages/node-wasm/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/node-wasm",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "WebAssembly-based HTML-aware ERB parser for Node.js.",
   "type": "module",
   "license": "MIT",
@@ -36,7 +36,7 @@
     }
   },
   "dependencies": {
-    "@herb-tools/core": "0.7.4"
+    "@herb-tools/core": "0.7.5"
   },
   "files": [
     "package.json",
diff --git a/javascript/packages/node-wasm/test/node-wasm.test.ts b/javascript/packages/node-wasm/test/node-wasm.test.ts
index 7533c7b1a..562da6ea2 100644
--- a/javascript/packages/node-wasm/test/node-wasm.test.ts
+++ b/javascript/packages/node-wasm/test/node-wasm.test.ts
@@ -17,7 +17,7 @@ describe("@herb-tools/node-wasm", () => {
   test("version() returns a string", async () => {
     const version = Herb.version
     expect(typeof version).toBe("string")
-    expect(version).toBe("@herb-tools/node-wasm@0.7.4, @herb-tools/core@0.7.4, libprism@1.5.1, libherb@0.7.4 (WebAssembly)")
+    expect(version).toBe("@herb-tools/node-wasm@0.7.5, @herb-tools/core@0.7.5, libprism@1.5.1, libherb@0.7.5 (WebAssembly)")
   })
 
   test("parse() can process a simple template", async () => {
diff --git a/javascript/packages/node/package.json b/javascript/packages/node/package.json
index f5f9e9b95..b31eae271 100644
--- a/javascript/packages/node/package.json
+++ b/javascript/packages/node/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/node",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "Native Node.js addon for HTML-aware ERB parsing using Herb.",
   "type": "module",
   "license": "MIT",
@@ -48,7 +48,7 @@
     "host": "https://github.com/marcoroth/herb/releases/download/"
   },
   "dependencies": {
-    "@herb-tools/core": "0.7.4",
+    "@herb-tools/core": "0.7.5",
     "@mapbox/node-pre-gyp": "^2.0.0",
     "node-addon-api": "^5.1.0"
   },
diff --git a/javascript/packages/node/test/node.test.ts b/javascript/packages/node/test/node.test.ts
index 032656916..8ac737608 100644
--- a/javascript/packages/node/test/node.test.ts
+++ b/javascript/packages/node/test/node.test.ts
@@ -17,7 +17,7 @@ describe("@herb-tools/node", () => {
   test("version() returns a string", async () => {
     const version = Herb.version
     expect(typeof version).toBe("string")
-    expect(version).toBe("@herb-tools/node@0.7.4, @herb-tools/core@0.7.4, libprism@1.5.1, libherb@0.7.4 (Node.js C++ native extension)")
+    expect(version).toBe("@herb-tools/node@0.7.5, @herb-tools/core@0.7.5, libprism@1.5.1, libherb@0.7.5 (Node.js C++ native extension)")
   })
 
   test("parse() can process a simple template", async () => {
diff --git a/javascript/packages/printer/package.json b/javascript/packages/printer/package.json
index 16928c514..08de93261 100644
--- a/javascript/packages/printer/package.json
+++ b/javascript/packages/printer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/printer",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "AST printer infrastructure and lossless reconstruction tool for HTML+ERB templates",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
@@ -37,7 +37,7 @@
     "prepublishOnly": "yarn clean && yarn build && yarn test"
   },
   "dependencies": {
-    "@herb-tools/core": "0.7.4",
+    "@herb-tools/core": "0.7.5",
     "glob": "^10.3.10"
   },
   "files": [
diff --git a/javascript/packages/stimulus-lint/package.json b/javascript/packages/stimulus-lint/package.json
index f6f62f9b5..3297934fc 100644
--- a/javascript/packages/stimulus-lint/package.json
+++ b/javascript/packages/stimulus-lint/package.json
@@ -1,6 +1,6 @@
 {
   "name": "stimulus-lint",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Linting rules for Stimulus controllers and HTML+ERB view templates.",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
@@ -34,10 +34,10 @@
     "prepublishOnly": "yarn clean && yarn build && yarn test"
   },
   "dependencies": {
-    "@herb-tools/linter": "0.7.4",
-    "@herb-tools/core": "0.7.4",
-    "@herb-tools/node-wasm": "0.7.4",
-    "@herb-tools/highlighter": "0.7.4",
+    "@herb-tools/linter": "0.7.5",
+    "@herb-tools/core": "0.7.5",
+    "@herb-tools/node-wasm": "0.7.5",
+    "@herb-tools/highlighter": "0.7.5",
     "stimulus-parser": "^0.3.0"
   },
   "files": [
diff --git a/javascript/packages/tailwind-class-sorter/package.json b/javascript/packages/tailwind-class-sorter/package.json
index 6b6d6eb0d..901efe796 100644
--- a/javascript/packages/tailwind-class-sorter/package.json
+++ b/javascript/packages/tailwind-class-sorter/package.json
@@ -2,7 +2,7 @@
   "type": "module",
   "name": "@herb-tools/tailwind-class-sorter",
   "description": "Standalone Tailwind CSS class sorter with Prettier plugin compatibility, extracted from tailwindlabs/prettier-plugin-tailwindcss",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "license": "MIT",
   "main": "./dist/tailwind-class-sorter.cjs",
   "module": "./dist/tailwind-class-sorter.esm.js",
diff --git a/javascript/packages/vscode/package.json b/javascript/packages/vscode/package.json
index 63036b345..5b2395279 100644
--- a/javascript/packages/vscode/package.json
+++ b/javascript/packages/vscode/package.json
@@ -2,7 +2,7 @@
   "name": "herb-lsp",
   "displayName": "Herb LSP - HTML+ERB Language Tools",
   "description": "VS Code extension for connecting with the Herb Language Server and Language Tools for HTML+ERB files",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "private": true,
   "license": "MIT",
   "pricing": "Free",
@@ -241,9 +241,9 @@
     "prepublishOnly": "yarn clean && yarn build && yarn test"
   },
   "devDependencies": {
-    "@herb-tools/formatter": "0.7.4",
-    "@herb-tools/linter": "0.7.4",
-    "@herb-tools/node-wasm": "0.7.4",
+    "@herb-tools/formatter": "0.7.5",
+    "@herb-tools/linter": "0.7.5",
+    "@herb-tools/node-wasm": "0.7.5",
     "@types/node": "20.x",
     "@types/vscode": "^1.43.0",
     "@typescript-eslint/eslint-plugin": "^8.40.0",
diff --git a/lib/herb/version.rb b/lib/herb/version.rb
index 47f0c2796..b3a0aa4e9 100644
--- a/lib/herb/version.rb
+++ b/lib/herb/version.rb
@@ -2,5 +2,5 @@
 # typed: true
 
 module Herb
-  VERSION = "0.7.4"
+  VERSION = "0.7.5"
 end
diff --git a/playground/package.json b/playground/package.json
index 31c6c5407..37c24a366 100644
--- a/playground/package.json
+++ b/playground/package.json
@@ -19,9 +19,9 @@
   },
   "dependencies": {
     "@alenaksu/json-viewer": "^2.0.1",
-    "@herb-tools/browser": "0.7.4",
-    "@herb-tools/formatter": "0.7.4",
-    "@herb-tools/linter": "0.7.4",
+    "@herb-tools/browser": "0.7.5",
+    "@herb-tools/formatter": "0.7.5",
+    "@herb-tools/linter": "0.7.5",
     "@hotwired/stimulus": "^3.2.2",
     "dedent": "^1.6.0",
     "express": "^5.1.0",
diff --git a/src/include/version.h b/src/include/version.h
index 4185a598a..a75f8cba0 100644
--- a/src/include/version.h
+++ b/src/include/version.h
@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.7.4"
+#define HERB_VERSION "0.7.5"
 
 #endif
diff --git a/test/c/test_herb.c b/test/c/test_herb.c
index 7eab745f0..bc0c1272c 100644
--- a/test/c/test_herb.c
+++ b/test/c/test_herb.c
@@ -2,7 +2,7 @@
 #include "../../src/include/herb.h"
 
 TEST(test_herb_version)
-  ck_assert_str_eq(herb_version(), "0.7.4");
+  ck_assert_str_eq(herb_version(), "0.7.5");
 END
 
 TCase *herb_tests(void) {
diff --git a/test/herb_test.rb b/test/herb_test.rb
index 866423e31..c32f572d0 100644
--- a/test/herb_test.rb
+++ b/test/herb_test.rb
@@ -4,6 +4,6 @@
 
 class HerbTest < Minitest::Spec
   test "version" do
-    assert_equal "herb gem v0.7.4, libprism v1.5.1, libherb v0.7.4 (Ruby C native extension)", Herb.version
+    assert_equal "herb gem v0.7.5, libprism v1.5.1, libherb v0.7.5 (Ruby C native extension)", Herb.version
   end
 end

From b4a8e359db4779e5b1da95b203bd1766fa213b99 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Mon, 6 Oct 2025 14:42:29 +0900
Subject: [PATCH 19/97] Update `bin/setup` script

---
 bin/setup | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/bin/setup b/bin/setup
index 361c7f2e6..bb27d1eb8 100755
--- a/bin/setup
+++ b/bin/setup
@@ -2,5 +2,7 @@
 
 set -e  # Exit on error
 
-make prism
-make all
+bundle install
+bundle exec rake templates
+yarn install
+yarn build

From caab4f14f6307e087e8f5fe58876dca4d2664e21 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Mon, 6 Oct 2025 14:42:41 +0900
Subject: [PATCH 20/97] Add `bin/publish_packages` script

---
 bin/publish_packages | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100755 bin/publish_packages

diff --git a/bin/publish_packages b/bin/publish_packages
new file mode 100755
index 000000000..10766ab81
--- /dev/null
+++ b/bin/publish_packages
@@ -0,0 +1,25 @@
+#!/bin/bash
+
+set -euo pipefail
+
+echo "Building all packages..."
+yarn nx run-many -t build --all
+
+echo "Running tests in all packages..."
+yarn nx run-many -t test --all
+
+for package_dir in javascript/packages/*; do
+  if [ -d "$package_dir" ] && [ -f "$package_dir/package.json" ]; then
+    package=$(basename "$package_dir")
+
+    if [ "$package" = "vscode" ]; then
+      echo "Skipping vscode package..."
+      continue
+    fi
+
+    echo "Publishing $package..."
+    (cd "$package_dir" && yarn publish)
+  fi
+done
+
+echo "All packages published successfully!"

From 1af6962dc1039d173e753c962f2ce949a9896928 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Wed, 8 Oct 2025 10:02:48 +0200
Subject: [PATCH 21/97] C: Also call `analyze` in C-CLI `parse` command (#584)

This pull request updates the C-CLI to also call
`herb_analyze_parse_tree` in the `parse` command, so that the
`ERBContentNodes` also get analyzed in a HTML+ERB document.

AS discussed in
https://github.com/marcoroth/herb/issues/406#issuecomment-3350166452
---
 src/main.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/main.c b/src/main.c
index d89af37b0..9ce19649a 100644
--- a/src/main.c
+++ b/src/main.c
@@ -106,6 +106,9 @@ int main(const int argc, char* argv[]) {
 
   if (strcmp(argv[1], "parse") == 0) {
     AST_DOCUMENT_NODE_T* root = herb_parse(source, NULL);
+
+    herb_analyze_parse_tree(root, source);
+
     clock_gettime(CLOCK_MONOTONIC, &end);
 
     ast_pretty_print_node((AST_NODE_T*) root, 0, 0, &output);

From 1f3ac1d5416120a52bc12f9f2b0ed36d5296d23a Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Wed, 8 Oct 2025 12:10:35 +0200
Subject: [PATCH 22/97] C: Favor explicit buffer capacity over default capacity
 (#585)

This pull request is an alternative to #579 and reworks the buffer to
not have a default capacity anymore, but instead, let the caller decide
how big the initial buffer capacity should be.

This also allows callers to request enough capacity upfront if they know
the approximate or exact buffer buffer length, which then doesn't need
any buffer capacity expansions at a later point, thus removing the need
to reallocate.

Closes #579
---
 bin/leaks_parse                             | 13 ++-
 ext/herb/extension.c                        | 12 +--
 javascript/packages/node/extension/herb.cpp | 12 +--
 src/analyze.c                               |  2 +
 src/buffer.c                                | 25 +++---
 src/extract.c                               |  9 +-
 src/herb.c                                  |  7 +-
 src/include/buffer.h                        |  6 +-
 src/io.c                                    |  5 +-
 src/lexer.c                                 | 15 ++--
 src/main.c                                  | 25 +++---
 src/parser.c                                | 64 +++++++-------
 src/token.c                                 | 18 ++--
 test/c/test_buffer.c                        | 82 +++++++++++-------
 test/c/test_json.c                          | 93 +++++++++++++--------
 test/c/test_lex.c                           | 10 ++-
 test/c/test_token.c                         | 10 ++-
 wasm/herb-wasm.cpp                          | 10 ++-
 18 files changed, 257 insertions(+), 161 deletions(-)

diff --git a/bin/leaks_parse b/bin/leaks_parse
index 603132e80..0212a2948 100755
--- a/bin/leaks_parse
+++ b/bin/leaks_parse
@@ -1,7 +1,7 @@
 #!/bin/bash
 
 if [ -z "$1" ]; then
-  echo "Usage: $0 <file>"
+  echo "Usage: $0 <file_or_directory>"
   exit 1
 fi
 
@@ -10,4 +10,13 @@ if [[ "$(uname)" != "Darwin" ]]; then
   exit 0
 fi
 
-leaks --atExit -- ./herb parse "$1"
+TARGET="$1"
+
+if [ -d "$TARGET" ]; then
+  while IFS= read -r -d '' file; do
+    echo "Checking $file for leaks..."
+    leaks --atExit -- ./herb parse "$file" --silent || exit 1
+  done < <(find "$TARGET" -name "*.html.erb" -type f -print0)
+else
+  leaks --atExit -- ./herb parse "$TARGET" --silent
+fi
diff --git a/ext/herb/extension.c b/ext/herb/extension.c
index 7f83a0090..9b2884aee 100644
--- a/ext/herb/extension.c
+++ b/ext/herb/extension.c
@@ -89,13 +89,13 @@ static VALUE Herb_lex_to_json(VALUE self, VALUE source) {
   char* string = (char*) check_string(source);
   buffer_T output;
 
-  if (!buffer_init(&output)) { return Qnil; }
+  if (!buffer_init(&output, 4096)) { return Qnil; }
 
   herb_lex_json_to_buffer(string, &output);
 
   VALUE result = rb_str_new(output.value, output.length);
 
-  buffer_free(&output);
+  free(output.value);
 
   return result;
 }
@@ -104,12 +104,12 @@ static VALUE Herb_extract_ruby(VALUE self, VALUE source) {
   char* string = (char*) check_string(source);
   buffer_T output;
 
-  if (!buffer_init(&output)) { return Qnil; }
+  if (!buffer_init(&output, strlen(string))) { return Qnil; }
 
   herb_extract_ruby_to_buffer(string, &output);
 
   VALUE result = rb_utf8_str_new_cstr(output.value);
-  buffer_free(&output);
+  free(output.value);
 
   return result;
 }
@@ -118,12 +118,12 @@ static VALUE Herb_extract_html(VALUE self, VALUE source) {
   char* string = (char*) check_string(source);
   buffer_T output;
 
-  if (!buffer_init(&output)) { return Qnil; }
+  if (!buffer_init(&output, strlen(string))) { return Qnil; }
 
   herb_extract_html_to_buffer(string, &output);
 
   VALUE result = rb_utf8_str_new_cstr(output.value);
-  buffer_free(&output);
+  free(output.value);
 
   return result;
 }
diff --git a/javascript/packages/node/extension/herb.cpp b/javascript/packages/node/extension/herb.cpp
index 3b8ba8ebb..a3e080902 100644
--- a/javascript/packages/node/extension/herb.cpp
+++ b/javascript/packages/node/extension/herb.cpp
@@ -156,7 +156,7 @@ napi_value Herb_lex_to_json(napi_env env, napi_callback_info info) {
   if (!string) { return nullptr; }
 
   buffer_T output;
-  if (!buffer_init(&output)) {
+  if (!buffer_init(&output, 4096)) {
     free(string);
     napi_throw_error(env, nullptr, "Failed to initialize buffer");
     return nullptr;
@@ -167,7 +167,7 @@ napi_value Herb_lex_to_json(napi_env env, napi_callback_info info) {
   napi_value result;
   napi_create_string_utf8(env, output.value, output.length, &result);
 
-  buffer_free(&output);
+  free(output.value);
   free(string);
 
   return result;
@@ -187,7 +187,7 @@ napi_value Herb_extract_ruby(napi_env env, napi_callback_info info) {
   if (!string) { return nullptr; }
 
   buffer_T output;
-  if (!buffer_init(&output)) {
+  if (!buffer_init(&output, strlen(string))) {
     free(string);
     napi_throw_error(env, nullptr, "Failed to initialize buffer");
     return nullptr;
@@ -198,7 +198,7 @@ napi_value Herb_extract_ruby(napi_env env, napi_callback_info info) {
   napi_value result;
   napi_create_string_utf8(env, output.value, NAPI_AUTO_LENGTH, &result);
 
-  buffer_free(&output);
+  free(output.value);
   free(string);
   return result;
 }
@@ -217,7 +217,7 @@ napi_value Herb_extract_html(napi_env env, napi_callback_info info) {
   if (!string) { return nullptr; }
 
   buffer_T output;
-  if (!buffer_init(&output)) {
+  if (!buffer_init(&output, strlen(string))) {
     free(string);
     napi_throw_error(env, nullptr, "Failed to initialize buffer");
     return nullptr;
@@ -228,7 +228,7 @@ napi_value Herb_extract_html(napi_env env, napi_callback_info info) {
   napi_value result;
   napi_create_string_utf8(env, output.value, NAPI_AUTO_LENGTH, &result);
 
-  buffer_free(&output);
+  free(output.value);
   free(string);
   return result;
 }
diff --git a/src/analyze.c b/src/analyze.c
index dcf5e5485..ca8ada004 100644
--- a/src/analyze.c
+++ b/src/analyze.c
@@ -1069,6 +1069,8 @@ void herb_analyze_parse_tree(AST_DOCUMENT_NODE_T* document, const char* source)
 void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source) {
   char* extracted_ruby = herb_extract_ruby_with_semicolons(source);
 
+  if (!extracted_ruby) { return; }
+
   pm_parser_t parser;
   pm_options_t options = { 0, .partial_script = true };
   pm_parser_init(&parser, (const uint8_t*) extracted_ruby, strlen(extracted_ruby), &options);
diff --git a/src/buffer.c b/src/buffer.c
index f162c4116..adc08292e 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -7,8 +7,8 @@
 #include "include/memory.h"
 #include "include/util.h"
 
-bool buffer_init(buffer_T* buffer) {
-  buffer->capacity = 1024;
+bool buffer_init(buffer_T* buffer, const size_t capacity) {
+  buffer->capacity = capacity;
   buffer->length = 0;
   buffer->value = nullable_safe_malloc((buffer->capacity + 1) * sizeof(char));
 
@@ -22,9 +22,14 @@ bool buffer_init(buffer_T* buffer) {
   return true;
 }
 
-buffer_T buffer_new(void) {
-  buffer_T buffer;
-  buffer_init(&buffer);
+buffer_T* buffer_new(const size_t capacity) {
+  buffer_T* buffer = safe_malloc(sizeof(buffer_T));
+
+  if (!buffer_init(buffer, capacity)) {
+    free(buffer);
+    return NULL;
+  }
+
   return buffer;
 }
 
@@ -231,11 +236,11 @@ void buffer_clear(buffer_T* buffer) {
   buffer->value[0] = '\0';
 }
 
-void buffer_free(buffer_T* buffer) {
-  if (!buffer) { return; }
+void buffer_free(buffer_T** buffer) {
+  if (!buffer || !*buffer) { return; }
 
-  if (buffer->value != NULL) { free(buffer->value); }
+  if ((*buffer)->value != NULL) { free((*buffer)->value); }
 
-  buffer->value = NULL;
-  buffer->length = buffer->capacity = 0;
+  free(*buffer);
+  *buffer = NULL;
 }
diff --git a/src/extract.c b/src/extract.c
index cc7bedb49..ea3fdb93d 100644
--- a/src/extract.c
+++ b/src/extract.c
@@ -5,6 +5,7 @@
 #include "include/lexer.h"
 
 #include <stdlib.h>
+#include <string.h>
 
 void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* output) {
   array_T* tokens = herb_lex(source);
@@ -121,8 +122,10 @@ void herb_extract_html_to_buffer(const char* source, buffer_T* output) {
 }
 
 char* herb_extract_ruby_with_semicolons(const char* source) {
+  if (!source) { return NULL; }
+
   buffer_T output;
-  buffer_init(&output);
+  buffer_init(&output, strlen(source));
 
   herb_extract_ruby_to_buffer_with_semicolons(source, &output);
 
@@ -130,8 +133,10 @@ char* herb_extract_ruby_with_semicolons(const char* source) {
 }
 
 char* herb_extract(const char* source, const herb_extract_language_T language) {
+  if (!source) { return NULL; }
+
   buffer_T output;
-  buffer_init(&output);
+  buffer_init(&output, strlen(source));
 
   switch (language) {
     case HERB_EXTRACT_LANGUAGE_RUBY: herb_extract_ruby_to_buffer(source, &output); break;
diff --git a/src/herb.c b/src/herb.c
index d057b28a8..1348c9495 100644
--- a/src/herb.c
+++ b/src/herb.c
@@ -28,6 +28,8 @@ array_T* herb_lex(const char* source) {
 }
 
 AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options) {
+  if (!source) { source = ""; }
+
   lexer_T* lexer = lexer_init(source);
   parser_T* parser = herb_parser_init(lexer, options);
 
@@ -66,7 +68,8 @@ void herb_lex_to_buffer(const char* source, buffer_T* output) {
 void herb_lex_json_to_buffer(const char* source, buffer_T* output) {
   array_T* tokens = herb_lex(source);
 
-  buffer_T json = buffer_new();
+  buffer_T json;
+  buffer_init(&json, 4096);
   json_start_root_array(&json);
 
   for (size_t i = 0; i < array_size(tokens); i++) {
@@ -79,7 +82,7 @@ void herb_lex_json_to_buffer(const char* source, buffer_T* output) {
   json_end_array(&json);
   buffer_concat(output, &json);
 
-  buffer_free(&json);
+  free(json.value);
   herb_free_tokens(&tokens);
 }
 
diff --git a/src/include/buffer.h b/src/include/buffer.h
index a684e9ded..04c7fcb2b 100644
--- a/src/include/buffer.h
+++ b/src/include/buffer.h
@@ -10,8 +10,8 @@ typedef struct BUFFER_STRUCT {
   size_t capacity;
 } buffer_T;
 
-bool buffer_init(buffer_T* buffer);
-buffer_T buffer_new(void);
+bool buffer_init(buffer_T* buffer, size_t capacity);
+buffer_T* buffer_new(size_t capacity);
 
 bool buffer_increase_capacity(buffer_T* buffer, size_t additional_capacity);
 bool buffer_has_capacity(buffer_T* buffer, size_t required_length);
@@ -34,6 +34,6 @@ size_t buffer_capacity(const buffer_T* buffer);
 size_t buffer_sizeof(void);
 
 void buffer_clear(buffer_T* buffer);
-void buffer_free(buffer_T* buffer);
+void buffer_free(buffer_T** buffer);
 
 #endif
diff --git a/src/io.c b/src/io.c
index a1ef45632..9ee5b9fe0 100644
--- a/src/io.c
+++ b/src/io.c
@@ -8,6 +8,8 @@
 #define FILE_READ_CHUNK 4096
 
 char* herb_read_file(const char* filename) {
+  if (!filename) { return NULL; }
+
   FILE* fp = fopen(filename, "rb");
 
   if (fp == NULL) {
@@ -15,7 +17,8 @@ char* herb_read_file(const char* filename) {
     exit(1);
   }
 
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 4096);
 
   char chunk[FILE_READ_CHUNK];
   size_t bytes_read;
diff --git a/src/lexer.c b/src/lexer.c
index f62bbd696..1eaac649a 100644
--- a/src/lexer.c
+++ b/src/lexer.c
@@ -174,7 +174,8 @@ static token_T* lexer_match_and_advance(lexer_T* lexer, const char* value, const
 // ===== Specialized Parsers
 
 static token_T* lexer_parse_whitespace(lexer_T* lexer) {
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 128);
 
   while (isspace(lexer->current_character) && lexer->current_character != '\n' && lexer->current_character != '\r'
          && !lexer_eof(lexer)) {
@@ -184,13 +185,14 @@ static token_T* lexer_parse_whitespace(lexer_T* lexer) {
 
   token_T* token = token_init(buffer.value, TOKEN_WHITESPACE, lexer);
 
-  buffer_free(&buffer);
+  free(buffer.value);
 
   return token;
 }
 
 static token_T* lexer_parse_identifier(lexer_T* lexer) {
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 128);
 
   while ((isalnum(lexer->current_character) || lexer->current_character == '-' || lexer->current_character == '_'
           || lexer->current_character == ':')
@@ -202,7 +204,7 @@ static token_T* lexer_parse_identifier(lexer_T* lexer) {
 
   token_T* token = token_init(buffer.value, TOKEN_IDENTIFIER, lexer);
 
-  buffer_free(&buffer);
+  free(buffer.value);
 
   return token;
 }
@@ -223,7 +225,8 @@ static token_T* lexer_parse_erb_open(lexer_T* lexer) {
 }
 
 static token_T* lexer_parse_erb_content(lexer_T* lexer) {
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 1024);
 
   while (!lexer_peek_erb_end(lexer, 0)) {
     if (lexer_eof(lexer)) {
@@ -247,7 +250,7 @@ static token_T* lexer_parse_erb_content(lexer_T* lexer) {
 
   token_T* token = token_init(buffer.value, TOKEN_ERB_CONTENT, lexer);
 
-  buffer_free(&buffer);
+  free(buffer.value);
 
   return token;
 }
diff --git a/src/main.c b/src/main.c
index 9ce19649a..2e1efbfa2 100644
--- a/src/main.c
+++ b/src/main.c
@@ -55,7 +55,7 @@ int main(const int argc, char* argv[]) {
 
   buffer_T output;
 
-  if (!buffer_init(&output)) { return 1; }
+  if (!buffer_init(&output, 4096)) { return 1; }
 
   char* source = herb_read_file(argv[2]);
 
@@ -74,7 +74,7 @@ int main(const int argc, char* argv[]) {
     print_time_diff(start, end, "visiting");
 
     ast_node_free((AST_NODE_T*) root);
-    buffer_free(&output);
+    free(output.value);
     free(source);
 
     return 0;
@@ -87,7 +87,7 @@ int main(const int argc, char* argv[]) {
     printf("%s\n", output.value);
     print_time_diff(start, end, "lexing");
 
-    buffer_free(&output);
+    free(output.value);
     free(source);
 
     return 0;
@@ -98,7 +98,7 @@ int main(const int argc, char* argv[]) {
 
     printf("%s\n", output.value);
 
-    buffer_free(&output);
+    free(output.value);
     free(source);
 
     return 0;
@@ -111,13 +111,18 @@ int main(const int argc, char* argv[]) {
 
     clock_gettime(CLOCK_MONOTONIC, &end);
 
-    ast_pretty_print_node((AST_NODE_T*) root, 0, 0, &output);
-    printf("%s\n", output.value);
+    int silent = 0;
+    if (argc > 3 && strcmp(argv[3], "--silent") == 0) { silent = 1; }
+
+    if (!silent) {
+      ast_pretty_print_node((AST_NODE_T*) root, 0, 0, &output);
+      printf("%s\n", output.value);
 
-    print_time_diff(start, end, "parsing");
+      print_time_diff(start, end, "parsing");
+    }
 
     ast_node_free((AST_NODE_T*) root);
-    buffer_free(&output);
+    free(output.value);
     free(source);
 
     return 0;
@@ -130,7 +135,7 @@ int main(const int argc, char* argv[]) {
     printf("%s\n", output.value);
     print_time_diff(start, end, "extracting Ruby");
 
-    buffer_free(&output);
+    free(output.value);
     free(source);
 
     return 0;
@@ -143,7 +148,7 @@ int main(const int argc, char* argv[]) {
     printf("%s\n", output.value);
     print_time_diff(start, end, "extracting HTML");
 
-    buffer_free(&output);
+    free(output.value);
     free(source);
 
     return 0;
diff --git a/src/parser.c b/src/parser.c
index 47847d9b5..9877f2538 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -53,7 +53,8 @@ parser_T* herb_parser_init(lexer_T* lexer, parser_options_T* options) {
 static AST_CDATA_NODE_T* parser_parse_cdata(parser_T* parser) {
   array_T* errors = array_init(8);
   array_T* children = array_init(8);
-  buffer_T content = buffer_new();
+  buffer_T content;
+  buffer_init(&content, 128);
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_CDATA_START, errors);
   position_T start = parser->current_token->location.start;
@@ -84,7 +85,7 @@ static AST_CDATA_NODE_T* parser_parse_cdata(parser_T* parser) {
     errors
   );
 
-  buffer_free(&content);
+  free(content.value);
   token_free(tag_opening);
   token_free(tag_closing);
 
@@ -97,7 +98,8 @@ static AST_HTML_COMMENT_NODE_T* parser_parse_html_comment(parser_T* parser) {
   token_T* comment_start = parser_consume_expected(parser, TOKEN_HTML_COMMENT_START, errors);
   position_T start = parser->current_token->location.start;
 
-  buffer_T comment = buffer_new();
+  buffer_T comment;
+  buffer_init(&comment, 512);
 
   while (token_is_none_of(parser, TOKEN_HTML_COMMENT_END, TOKEN_EOF)) {
     if (token_is(parser, TOKEN_ERB_START)) {
@@ -129,7 +131,7 @@ static AST_HTML_COMMENT_NODE_T* parser_parse_html_comment(parser_T* parser) {
     errors
   );
 
-  buffer_free(&comment);
+  free(comment.value);
   token_free(comment_start);
   token_free(comment_end);
 
@@ -139,7 +141,8 @@ static AST_HTML_COMMENT_NODE_T* parser_parse_html_comment(parser_T* parser) {
 static AST_HTML_DOCTYPE_NODE_T* parser_parse_html_doctype(parser_T* parser) {
   array_T* errors = array_init(8);
   array_T* children = array_init(8);
-  buffer_T content = buffer_new();
+  buffer_T content;
+  buffer_init(&content, 64);
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_HTML_DOCTYPE, errors);
 
@@ -175,7 +178,7 @@ static AST_HTML_DOCTYPE_NODE_T* parser_parse_html_doctype(parser_T* parser) {
 
   token_free(tag_opening);
   token_free(tag_closing);
-  buffer_free(&content);
+  free(content.value);
 
   return doctype;
 }
@@ -183,7 +186,8 @@ static AST_HTML_DOCTYPE_NODE_T* parser_parse_html_doctype(parser_T* parser) {
 static AST_XML_DECLARATION_NODE_T* parser_parse_xml_declaration(parser_T* parser) {
   array_T* errors = array_init(8);
   array_T* children = array_init(8);
-  buffer_T content = buffer_new();
+  buffer_T content;
+  buffer_init(&content, 64);
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_XML_DECLARATION, errors);
 
@@ -221,7 +225,7 @@ static AST_XML_DECLARATION_NODE_T* parser_parse_xml_declaration(parser_T* parser
 
   token_free(tag_opening);
   token_free(tag_closing);
-  buffer_free(&content);
+  free(content.value);
 
   return xml_declaration;
 }
@@ -229,7 +233,8 @@ static AST_XML_DECLARATION_NODE_T* parser_parse_xml_declaration(parser_T* parser
 static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, array_T* document_errors) {
   position_T start = parser->current_token->location.start;
 
-  buffer_T content = buffer_new();
+  buffer_T content;
+  buffer_init(&content, 2048);
 
   while (token_is_none_of(
     parser,
@@ -241,7 +246,7 @@ static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, array_T
     TOKEN_EOF
   )) {
     if (token_is(parser, TOKEN_ERROR)) {
-      buffer_free(&content);
+      free(content.value);
 
       token_T* token = parser_consume_expected(parser, TOKEN_ERROR, document_errors);
       append_unexpected_error(
@@ -265,18 +270,15 @@ static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, array_T
 
   array_T* errors = array_init(8);
 
-  if (buffer_length(&content) > 0) {
-    AST_HTML_TEXT_NODE_T* text_node =
-      ast_html_text_node_init(buffer_value(&content), start, parser->current_token->location.start, errors);
-
-    buffer_free(&content);
+  AST_HTML_TEXT_NODE_T* text_node = NULL;
 
-    return text_node;
+  if (buffer_length(&content) > 0) {
+    text_node = ast_html_text_node_init(buffer_value(&content), start, parser->current_token->location.start, errors);
+  } else {
+    text_node = ast_html_text_node_init("", start, parser->current_token->location.start, errors);
   }
 
-  AST_HTML_TEXT_NODE_T* text_node = ast_html_text_node_init("", start, parser->current_token->location.start, errors);
-
-  buffer_free(&content);
+  free(content.value);
 
   return text_node;
 }
@@ -284,7 +286,8 @@ static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, array_T
 static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T* parser) {
   array_T* errors = array_init(8);
   array_T* children = array_init(8);
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 128);
   position_T start = parser->current_token->location.start;
 
   while (token_is_none_of(
@@ -330,7 +333,7 @@ static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T
   AST_HTML_ATTRIBUTE_NAME_NODE_T* attribute_name =
     ast_html_attribute_name_node_init(children, node_start, node_end, errors);
 
-  buffer_free(&buffer);
+  free(buffer.value);
 
   return attribute_name;
 }
@@ -340,7 +343,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
   array_T* children,
   array_T* errors
 ) {
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 512);
   token_T* opening_quote = parser_consume_expected(parser, TOKEN_QUOTE, errors);
   position_T start = parser->current_token->location.start;
 
@@ -442,7 +446,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
   }
 
   parser_append_literal_node_from_buffer(parser, &buffer, children, start);
-  buffer_free(&buffer);
+  free(buffer.value);
 
   token_T* closing_quote = parser_consume_expected(parser, TOKEN_QUOTE, errors);
 
@@ -566,7 +570,8 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
                    || lexer_peek_for_token_type_after_whitespace(parser->lexer, TOKEN_EQUALS);
 
     if (has_equals) {
-      buffer_T equals_buffer = buffer_new();
+      buffer_T equals_buffer;
+      buffer_init(&equals_buffer, 256);
       position_T equals_start = { 0 };
       position_T equals_end = { 0 };
       uint32_t range_start = 0;
@@ -613,7 +618,7 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
       equals_with_whitespace->location = (location_T) { .start = equals_start, .end = equals_end };
       equals_with_whitespace->range = (range_T) { .from = range_start, .to = range_end };
 
-      buffer_free(&equals_buffer);
+      free(equals_buffer.value);
 
       AST_HTML_ATTRIBUTE_VALUE_NODE_T* attribute_value = parser_parse_html_attribute_value(parser);
 
@@ -1018,13 +1023,14 @@ static AST_ERB_CONTENT_NODE_T* parser_parse_erb_tag(parser_T* parser) {
 }
 
 static void parser_parse_foreign_content(parser_T* parser, array_T* children, array_T* errors) {
-  buffer_T content = buffer_new();
+  buffer_T content;
+  buffer_init(&content, 1024);
   position_T start = parser->current_token->location.start;
   const char* expected_closing_tag = parser_get_foreign_content_closing_tag(parser->foreign_content_type);
 
   if (expected_closing_tag == NULL) {
     parser_exit_foreign_content(parser);
-    buffer_free(&content);
+    free(content.value);
 
     return;
   }
@@ -1059,7 +1065,7 @@ static void parser_parse_foreign_content(parser_T* parser, array_T* children, ar
         parser_append_literal_node_from_buffer(parser, &content, children, start);
         parser_exit_foreign_content(parser);
 
-        buffer_free(&content);
+        free(content.value);
 
         return;
       }
@@ -1072,7 +1078,7 @@ static void parser_parse_foreign_content(parser_T* parser, array_T* children, ar
 
   parser_append_literal_node_from_buffer(parser, &content, children, start);
   parser_exit_foreign_content(parser);
-  buffer_free(&content);
+  free(content.value);
 }
 
 static void parser_parse_in_data_state(parser_T* parser, array_T* children, array_T* errors) {
diff --git a/src/token.c b/src/token.c
index 37c7d4d89..60a5010ac 100644
--- a/src/token.c
+++ b/src/token.c
@@ -120,34 +120,38 @@ char* token_to_string(const token_T* token) {
 }
 
 char* token_to_json(const token_T* token) {
-  buffer_T json = buffer_new();
+  buffer_T json;
+  buffer_init(&json, 512);
 
   json_start_root_object(&json);
   json_add_string(&json, "type", token_type_to_string(token->type));
   json_add_string(&json, "value", token->value);
 
-  buffer_T range = buffer_new();
+  buffer_T range;
+  buffer_init(&range, 128);
   json_start_array(&json, "range");
   json_add_size_t(&range, NULL, token->range.from);
   json_add_size_t(&range, NULL, token->range.to);
   buffer_concat(&json, &range);
-  buffer_free(&range);
+  free(range.value);
   json_end_array(&json);
 
-  buffer_T start = buffer_new();
+  buffer_T start;
+  buffer_init(&start, 128);
   json_start_object(&json, "start");
   json_add_size_t(&start, "line", token->location.start.line);
   json_add_size_t(&start, "column", token->location.start.column);
   buffer_concat(&json, &start);
-  buffer_free(&start);
+  free(start.value);
   json_end_object(&json);
 
-  buffer_T end = buffer_new();
+  buffer_T end;
+  buffer_init(&end, 128);
   json_start_object(&json, "end");
   json_add_size_t(&end, "line", token->location.end.line);
   json_add_size_t(&end, "column", token->location.end.column);
   buffer_concat(&json, &end);
-  buffer_free(&end);
+  free(end.value);
   json_end_object(&json);
 
   json_end_object(&json);
diff --git a/test/c/test_buffer.c b/test/c/test_buffer.c
index 054b2d698..58bce8358 100644
--- a/test/c/test_buffer.c
+++ b/test/c/test_buffer.c
@@ -5,18 +5,19 @@
 TEST(test_buffer_init)
   buffer_T buffer;
 
-  ck_assert(buffer_init(&buffer));
+  ck_assert(buffer_init(&buffer, 1024));
   ck_assert_int_eq(buffer.capacity, 1024);
   ck_assert_int_eq(buffer.length, 0);
   ck_assert_ptr_nonnull(buffer.value);
   ck_assert_str_eq(buffer.value, "");
 
-  buffer_free(&buffer);
+  free(buffer.value);
 END
 
 // Test appending text to buffer
 TEST(test_buffer_append)
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 1024);
 
   ck_assert_str_eq(buffer.value, "");
 
@@ -28,25 +29,28 @@ TEST(test_buffer_append)
   ck_assert_str_eq(buffer.value, "Hello World");
   ck_assert_int_eq(buffer.length, 11);
 
-  buffer_free(&buffer);
+  free(buffer.value);
 END
 
 // Test prepending text to buffer
 TEST(test_buffer_prepend)
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 1024);
 
   buffer_append(&buffer, "World");
   buffer_prepend(&buffer, "Hello ");
   ck_assert_str_eq(buffer.value, "Hello World");
   ck_assert_int_eq(buffer.length, 11);
 
-  buffer_free(&buffer);
+  free(buffer.value);
 END
 
 // Test concatenating two buffers
 TEST(test_buffer_concat)
-  buffer_T buffer1 = buffer_new();
-  buffer_T buffer2 = buffer_new();
+  buffer_T buffer1;
+  buffer_init(&buffer1, 1024);
+  buffer_T buffer2;
+  buffer_init(&buffer2, 1024);
 
   buffer_append(&buffer1, "Hello");
   buffer_append(&buffer2, " World");
@@ -55,13 +59,14 @@ TEST(test_buffer_concat)
   ck_assert_str_eq(buffer1.value, "Hello World");
   ck_assert_int_eq(buffer1.length, 11);
 
-  buffer_free(&buffer1);
-  buffer_free(&buffer2);
+  free(buffer1.value);
+  free(buffer2.value);
 END
 
 // Test increating
 TEST(test_buffer_increase_capacity)
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 1024);
 
   ck_assert_int_eq(buffer.capacity, 1024);
 
@@ -71,12 +76,13 @@ TEST(test_buffer_increase_capacity)
   ck_assert(buffer_increase_capacity(&buffer, 1024 + 1));
   ck_assert_int_eq(buffer.capacity, 2050);
 
-  buffer_free(&buffer);
+  free(buffer.value);
 END
 
 // Test expanding capacity
 TEST(test_buffer_expand_capacity)
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 1024);
 
   ck_assert_int_eq(buffer.capacity, 1024);
 
@@ -89,12 +95,13 @@ TEST(test_buffer_expand_capacity)
   ck_assert(buffer_expand_capacity(&buffer));
   ck_assert_int_eq(buffer.capacity, 8192);
 
-  buffer_free(&buffer);
+  free(buffer.value);
 END
 
 // Test expanding if needed
 TEST(test_buffer_expand_if_needed)
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 1024);
 
   ck_assert_int_eq(buffer.capacity, 1024);
 
@@ -110,11 +117,12 @@ TEST(test_buffer_expand_if_needed)
   ck_assert(buffer_expand_if_needed(&buffer, 1025));
   ck_assert_int_eq(buffer.capacity, 3074); // initial capacity (1024) + (required (1025) * 2) = 3074
 
-  buffer_free(&buffer);
+  free(buffer.value);
 END
 
 TEST(test_buffer_expand_if_needed_with_nearly_full_buffer)
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 1024);
 
   ck_assert_int_eq(buffer.capacity, 1024);
 
@@ -124,12 +132,13 @@ TEST(test_buffer_expand_if_needed_with_nearly_full_buffer)
   ck_assert(buffer_expand_if_needed(&buffer, 2));
   ck_assert_int_eq(buffer.capacity, 2048);
 
-  buffer_free(&buffer);
+  free(buffer.value);
 END
 
 // Test resizing buffer
 TEST(test_buffer_resize)
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 1024);
 
   ck_assert_int_eq(buffer.capacity, 1024);
 
@@ -142,12 +151,13 @@ TEST(test_buffer_resize)
   ck_assert(buffer_resize(&buffer, 8192));
   ck_assert_int_eq(buffer.capacity, 8192);
 
-  buffer_free(&buffer);
+  free(buffer.value);
 END
 
 // Test clearing buffer without freeing memory
 TEST(test_buffer_clear)
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 1024);
 
   ck_assert_int_eq(buffer.capacity, 1024);
 
@@ -162,17 +172,21 @@ TEST(test_buffer_clear)
   ck_assert_int_eq(buffer.length, 0);
   ck_assert_int_eq(buffer.capacity, 1024); // Capacity should remain unchanged
 
-  buffer_free(&buffer);
+  free(buffer.value);
 END
 
 // Test freeing buffer
 TEST(test_buffer_free)
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 1024);
 
   buffer_append(&buffer, "Test");
   ck_assert_int_eq(buffer.length, 4);
   ck_assert_int_eq(buffer.capacity, 1024);
-  buffer_free(&buffer);
+  free(buffer.value);
+  buffer.value = NULL;
+  buffer.length = 0;
+  buffer.capacity = 0;
 
   ck_assert_ptr_null(buffer.value);
   ck_assert_int_eq(buffer.length, 0);
@@ -181,7 +195,8 @@ END
 
 // Test buffer UTF-8 integrity
 TEST(test_buffer_utf8_integrity)
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 1024);
 
   // UTF-8 String
   const char *utf8_text = "こんにちは";
@@ -192,12 +207,13 @@ TEST(test_buffer_utf8_integrity)
   ck_assert_int_eq(buffer.length, 15);
   ck_assert_str_eq(buffer.value, utf8_text);
 
-  buffer_free(&buffer);
+  free(buffer.value);
 END
 
 // Test: Buffer Appending UTF-8 Characters
 TEST(test_buffer_append_utf8)
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 1024);
 
   // Append UTF-8 string
   buffer_append(&buffer, "こんにちは"); // "Hello" in Japanese
@@ -205,12 +221,13 @@ TEST(test_buffer_append_utf8)
   ck_assert_int_eq(buffer_length(&buffer), 15);
   ck_assert_str_eq(buffer_value(&buffer), "こんにちは");
 
-  buffer_free(&buffer);
+  free(buffer.value);
 END
 
 // Test buffer length correctness
 TEST(test_buffer_length_correctness)
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 1024);
 
   buffer_append(&buffer, "Short");
   size_t length = buffer_length(&buffer);
@@ -220,17 +237,18 @@ TEST(test_buffer_length_correctness)
   length = buffer_length(&buffer);
   ck_assert_int_eq(length, 12);
 
-  buffer_free(&buffer);
+  free(buffer.value);
 END
 
 // Test: Buffer Null-Termination
 TEST(test_buffer_null_termination)
-  buffer_T buffer = buffer_new();
+  buffer_T buffer;
+  buffer_init(&buffer, 1024);
 
   buffer_append(&buffer, "Test");
   ck_assert(buffer_value(&buffer)[buffer_length(&buffer)] == '\0'); // Ensure null termination
 
-  buffer_free(&buffer);
+  free(buffer.value);
 END
 
 TCase *buffer_tests(void) {
diff --git a/test/c/test_json.c b/test/c/test_json.c
index 8dec4b990..d734b84f8 100644
--- a/test/c/test_json.c
+++ b/test/c/test_json.c
@@ -5,7 +5,8 @@
 #include "../../src/include/json.h"
 
 TEST(test_json_escape_basic)
-  buffer_T json = buffer_new();
+  buffer_T json;
+  buffer_init(&json, 1024);
 
   json_start_root_object(&json);
   json_add_string(&json, "key", "value");
@@ -13,11 +14,12 @@ TEST(test_json_escape_basic)
 
   ck_assert_str_eq(buffer_value(&json), "{\"key\": \"value\"}");
 
-  buffer_free(&json);
+  free(json.value);
 END
 
 TEST(test_json_escape_quotes)
-  buffer_T json = buffer_new();
+  buffer_T json;
+  buffer_init(&json, 1024);
 
   json_start_root_object(&json);
   json_add_string(&json, "quote", "This is a \"quoted\" string");
@@ -25,11 +27,12 @@ TEST(test_json_escape_quotes)
 
   ck_assert_str_eq(buffer_value(&json), "{\"quote\": \"This is a \\\"quoted\\\" string\"}");
 
-  buffer_free(&json);
+  free(json.value);
 END
 
 TEST(test_json_escape_backslash)
-  buffer_T json = buffer_new();
+  buffer_T json;
+  buffer_init(&json, 1024);
 
   json_start_root_object(&json);
   json_add_string(&json, "path", "C:\\Users\\Test");
@@ -37,11 +40,12 @@ TEST(test_json_escape_backslash)
 
   ck_assert_str_eq(buffer_value(&json), "{\"path\": \"C:\\\\Users\\\\Test\"}");
 
-  buffer_free(&json);
+  free(json.value);
 END
 
 TEST(test_json_escape_newline)
-  buffer_T json = buffer_new();
+  buffer_T json;
+  buffer_init(&json, 1024);
 
   json_start_root_object(&json);
   json_add_string(&json, "text", "Line1\nLine2");
@@ -49,11 +53,12 @@ TEST(test_json_escape_newline)
 
   ck_assert_str_eq(buffer_value(&json), "{\"text\": \"Line1\\nLine2\"}");
 
-  buffer_free(&json);
+  free(json.value);
 END
 
 TEST(test_json_escape_tab)
-  buffer_T json = buffer_new();
+  buffer_T json;
+  buffer_init(&json, 1024);
 
   json_start_root_object(&json);
   json_add_string(&json, "text", "Column1\tColumn2");
@@ -61,11 +66,12 @@ TEST(test_json_escape_tab)
 
   ck_assert_str_eq(buffer_value(&json), "{\"text\": \"Column1\\tColumn2\"}");
 
-  buffer_free(&json);
+  free(json.value);
 END
 
 TEST(test_json_escape_mixed)
-  buffer_T json = buffer_new();
+  buffer_T json;
+  buffer_init(&json, 1024);
 
   json_start_root_object(&json);
   json_add_string(&json, "complex", "A \"quoted\" \\ path\nwith\ttabs.");
@@ -73,11 +79,12 @@ TEST(test_json_escape_mixed)
 
   ck_assert_str_eq(buffer_value(&json), "{\"complex\": \"A \\\"quoted\\\" \\\\ path\\nwith\\ttabs.\"}");
 
-  buffer_free(&json);
+  free(json.value);
 END
 
 TEST(test_json_root_object)
-  buffer_T json = buffer_new();
+  buffer_T json;
+  buffer_init(&json, 1024);
 
   json_start_root_object(&json);
 
@@ -86,14 +93,16 @@ TEST(test_json_root_object)
   json_add_double(&json, "score", 99.5);
   json_add_bool(&json, "active", 1);
 
-  buffer_T address = buffer_new();
+  buffer_T address;
+  buffer_init(&address, 1024);
   json_start_object(&json, "address");
   json_add_string(&address, "city", "Basel");
   json_add_string(&address, "country", "Switzerland");
   buffer_concat(&json, &address);
   json_end_object(&json);
 
-  buffer_T languages = buffer_new();
+  buffer_T languages;
+  buffer_init(&languages, 1024);
   json_start_array(&json, "languages");
   json_add_string(&languages, NULL, "Ruby");
   json_add_string(&languages, NULL, "C");
@@ -101,7 +110,8 @@ TEST(test_json_root_object)
   buffer_concat(&json, &languages);
   json_end_array(&json);
 
-  buffer_T ratings = buffer_new();
+  buffer_T ratings;
+  buffer_init(&ratings, 1024);
   json_start_array(&json, "ratings");
   json_add_double(&ratings, NULL, 4.5);
   json_add_int(&ratings, NULL, 3);
@@ -115,11 +125,15 @@ TEST(test_json_root_object)
 
   ck_assert_str_eq(buffer_value(&json), "{\"name\": \"John\", \"age\": 20, \"score\": 99.50, \"active\": true, \"address\": {\"city\": \"Basel\", \"country\": \"Switzerland\"}, \"languages\": [\"Ruby\", \"C\", \"JavaScript\"], \"ratings\": [4.50, 3, 5.0, 3.79, 5]}");
 
-  buffer_free(&json);
+  free(address.value);
+  free(languages.value);
+  free(ratings.value);
+  free(json.value);
 END
 
 TEST(test_json_root_array)
-  buffer_T json = buffer_new();
+  buffer_T json;
+  buffer_init(&json, 1024);
 
   json_start_root_array(&json);
 
@@ -135,19 +149,22 @@ TEST(test_json_root_array)
 
   ck_assert_str_eq(buffer_value(&json), "[\"Ruby\", \"C\", \"JavaScript\", 42, 3.14, true, false]");
 
-  buffer_free(&json);
+  free(json.value);
 END
 
 TEST(test_json_append_array_to_object)
-  buffer_T json = buffer_new();
+  buffer_T json;
+  buffer_init(&json, 1024);
 
   json_start_root_object(&json);
 
-  buffer_T object = buffer_new();
+  buffer_T object;
+  buffer_init(&object, 1024);
   json_start_object(&json, "object");
   json_add_string(&object, "key", "value");
 
-  buffer_T array = buffer_new();
+  buffer_T array;
+  buffer_init(&array, 1024);
   json_start_array(&object, "array");
   json_add_string(&array, NULL, "One");
   json_add_string(&array, NULL, "Two");
@@ -162,20 +179,25 @@ TEST(test_json_append_array_to_object)
 
   ck_assert_str_eq(buffer_value(&json), "{\"object\": {\"key\": \"value\", \"array\": [\"One\", \"Two\"]}}");
 
-  buffer_free(&json);
+  free(array.value);
+  free(object.value);
+  free(json.value);
 END
 
 TEST(test_json_append_object_array)
-  buffer_T json = buffer_new();
+  buffer_T json;
+  buffer_init(&json, 1024);
 
   json_start_root_object(&json);
 
-  buffer_T array = buffer_new();
+  buffer_T array;
+  buffer_init(&array, 1024);
   json_start_array(&json, "array");
   json_add_string(&array, NULL, "One");
   json_add_string(&array, NULL, "Two");
 
-  buffer_T object = buffer_new();
+  buffer_T object;
+  buffer_init(&object, 1024);
   json_start_object(&array, NULL);
   json_add_string(&object, "key", "value");
 
@@ -189,7 +211,9 @@ TEST(test_json_append_object_array)
 
   ck_assert_str_eq(buffer_value(&json), "{\"array\": [\"One\", \"Two\", {\"key\": \"value\"}]}");
 
-  buffer_free(&json);
+  free(object.value);
+  free(array.value);
+  free(json.value);
 END
 
 TEST(test_json_double_to_string_precision)
@@ -248,16 +272,18 @@ TEST(test_json_int_to_string_min_max)
 END
 
 TEST(test_json_add_size_t_basic)
-  buffer_T json = buffer_new();
+  buffer_T json;
+  buffer_init(&json, 1024);
 
   json_add_size_t(&json, "size", 42);
   ck_assert_str_eq(buffer_value(&json), "\"size\": 42");
 
-  buffer_free(&json);
+  free(json.value);
 END
 
 TEST(test_json_add_size_t_large_number)
-  buffer_T json = buffer_new();
+  buffer_T json;
+  buffer_init(&json, 1024);
 
   json_add_size_t(&json, "size", 9876543210UL);
   ck_assert_str_eq(buffer_value(&json), "\"size\": 9876543210");
@@ -266,11 +292,12 @@ TEST(test_json_add_size_t_large_number)
   json_add_size_t(&json, "size", SIZE_MAX);
   ck_assert_str_eq(buffer_value(&json), "\"size\": 18446744073709551615");
 
-  buffer_free(&json);
+  free(json.value);
 END
 
 TEST(test_json_add_size_t_in_array)
-  buffer_T json = buffer_new();
+  buffer_T json;
+  buffer_init(&json, 1024);
 
   json_add_size_t(&json, NULL, 1024);
   json_add_size_t(&json, NULL, 2048);
@@ -278,7 +305,7 @@ TEST(test_json_add_size_t_in_array)
 
   ck_assert_str_eq(buffer_value(&json), "1024, 2048, 4096");
 
-  buffer_free(&json);
+  free(json.value);
 END
 
 
diff --git a/test/c/test_lex.c b/test/c/test_lex.c
index d0ed240a0..ee2418c9f 100644
--- a/test/c/test_lex.c
+++ b/test/c/test_lex.c
@@ -3,18 +3,20 @@
 
 TEST(herb_lex_to_buffer_empty_file)
   char* html = "";
-  buffer_T output = buffer_new();
+  buffer_T output;
+  buffer_init(&output, 1024);
 
   herb_lex_to_buffer(html, &output);
 
   ck_assert_str_eq(output.value, "#<Herb::Token type=\"TOKEN_EOF\" value=\"<EOF>\" range=[0, 0] start=(1:0) end=(1:0)>\n");
 
-  buffer_free(&output);
+  free(output.value);
 END
 
 TEST(herb_lex_to_buffer_basic_tag)
   char* html = "<html></html>";
-  buffer_T output = buffer_new();
+  buffer_T output;
+  buffer_init(&output, 1024);
 
   herb_lex_to_buffer(html, &output);
 
@@ -29,7 +31,7 @@ TEST(herb_lex_to_buffer_basic_tag)
     "#<Herb::Token type=\"TOKEN_EOF\" value=\"<EOF>\" range=[13, 13] start=(1:13) end=(1:13)>\n"
   );
 
-  buffer_free(&output);
+  free(output.value);
 END
 
 TCase *lex_tests(void) {
diff --git a/test/c/test_token.c b/test/c/test_token.c
index a0d06daa2..d8ea10fd5 100644
--- a/test/c/test_token.c
+++ b/test/c/test_token.c
@@ -8,7 +8,8 @@ TEST(test_token)
 END
 
 TEST(test_token_to_string)
-  buffer_T output = buffer_new();
+  buffer_T output;
+  buffer_init(&output, 1024);
   herb_lex_to_buffer("hello", &output);
 
   ck_assert_str_eq(
@@ -17,11 +18,12 @@ TEST(test_token_to_string)
     "#<Herb::Token type=\"TOKEN_EOF\" value=\"<EOF>\" range=[5, 5] start=(1:5) end=(1:5)>\n"
   );
 
-  buffer_free(&output);
+  free(output.value);
 END
 
 TEST(test_token_to_json)
-  buffer_T output = buffer_new();
+  buffer_T output;
+  buffer_init(&output, 1024);
   herb_lex_json_to_buffer("hello", &output);
 
   const char* expected = "["
@@ -31,7 +33,7 @@ TEST(test_token_to_json)
 
   ck_assert_str_eq(output.value, expected);
 
-  buffer_free(&output);
+  free(output.value);
 END
 
 TCase *token_tests(void) {
diff --git a/wasm/herb-wasm.cpp b/wasm/herb-wasm.cpp
index 91d270fdb..9d8624468 100644
--- a/wasm/herb-wasm.cpp
+++ b/wasm/herb-wasm.cpp
@@ -61,19 +61,21 @@ val Herb_parse(const std::string& source, val options) {
 
 std::string Herb_extract_ruby(const std::string& source) {
   buffer_T output;
-  buffer_init(&output);
+  buffer_init(&output, source.length());
+
   herb_extract_ruby_to_buffer(source.c_str(), &output);
   std::string result(buffer_value(&output));
-  buffer_free(&output);
+  free(output.value);
   return result;
 }
 
 std::string Herb_extract_html(const std::string& source) {
   buffer_T output;
-  buffer_init(&output);
+  buffer_init(&output, source.length());
+
   herb_extract_html_to_buffer(source.c_str(), &output);
   std::string result(buffer_value(&output));
-  buffer_free(&output);
+  free(output.value);
   return result;
 }
 

From b26978aedc928cda900e7d44dbf261e88e414c02 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Wed, 8 Oct 2025 12:36:45 +0200
Subject: [PATCH 23/97] C: Remove JSON Serialize Implementation (#586)

This pull request removes the JSON Serialize Implementation that we
haven't really made use of, so we are going to remove it for now.

If we end up needing it again, we can reference back to this pull
request and add the implementation back as it should be somewhat
straightforward to bring back.
---
 CONTRIBUTING.md                             |   1 -
 ext/herb/extension.c                        |  16 -
 javascript/packages/node/binding.gyp        |   1 -
 javascript/packages/node/extension/herb.cpp |  32 --
 lib/herb/libherb.rb                         |   1 -
 lib/herb/libherb/libherb.rb                 |   8 -
 src/herb.c                                  |  22 --
 src/include/herb.h                          |   1 -
 src/include/json.h                          |  28 --
 src/include/token.h                         |   1 -
 src/json.c                                  | 205 ------------
 src/main.c                                  |  12 -
 src/token.c                                 |  41 ---
 test/c/main.c                               |   2 -
 test/c/test_json.c                          | 333 --------------------
 test/c/test_token.c                         |  16 -
 16 files changed, 720 deletions(-)
 delete mode 100644 src/include/json.h
 delete mode 100644 src/json.c
 delete mode 100644 test/c/test_json.c

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index e0bdc6276..17cecb7a4 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -73,7 +73,6 @@ The `herb` executable exposes a few commands for interacting with `.html.erb` fi
 Herb 🌿 Powerful and seamless HTML-aware ERB parsing and tooling.
 
 ./herb lex [file]      -  Lex a file
-./herb lex_json [file] -  Lex a file and return the result as json.
 ./herb parse [file]    -  Parse a file
 ./herb ruby [file]     -  Extract Ruby from a file
 ./herb html [file]     -  Extract HTML from a file
diff --git a/ext/herb/extension.c b/ext/herb/extension.c
index 9b2884aee..d50931f9e 100644
--- a/ext/herb/extension.c
+++ b/ext/herb/extension.c
@@ -85,21 +85,6 @@ static VALUE Herb_parse_file(VALUE self, VALUE path) {
   return result;
 }
 
-static VALUE Herb_lex_to_json(VALUE self, VALUE source) {
-  char* string = (char*) check_string(source);
-  buffer_T output;
-
-  if (!buffer_init(&output, 4096)) { return Qnil; }
-
-  herb_lex_json_to_buffer(string, &output);
-
-  VALUE result = rb_str_new(output.value, output.length);
-
-  free(output.value);
-
-  return result;
-}
-
 static VALUE Herb_extract_ruby(VALUE self, VALUE source) {
   char* string = (char*) check_string(source);
   buffer_T output;
@@ -151,7 +136,6 @@ void Init_herb(void) {
   rb_define_singleton_method(mHerb, "lex", Herb_lex, 1);
   rb_define_singleton_method(mHerb, "parse_file", Herb_parse_file, 1);
   rb_define_singleton_method(mHerb, "lex_file", Herb_lex_file, 1);
-  rb_define_singleton_method(mHerb, "lex_to_json", Herb_lex_to_json, 1);
   rb_define_singleton_method(mHerb, "extract_ruby", Herb_extract_ruby, 1);
   rb_define_singleton_method(mHerb, "extract_html", Herb_extract_html, 1);
   rb_define_singleton_method(mHerb, "version", Herb_version, 0);
diff --git a/javascript/packages/node/binding.gyp b/javascript/packages/node/binding.gyp
index 8afbd6559..9bba520c9 100644
--- a/javascript/packages/node/binding.gyp
+++ b/javascript/packages/node/binding.gyp
@@ -24,7 +24,6 @@
         "./extension/libherb/herb.c",
         "./extension/libherb/html_util.c",
         "./extension/libherb/io.c",
-        "./extension/libherb/json.c",
         "./extension/libherb/lexer_peek_helpers.c",
         "./extension/libherb/lexer.c",
         "./extension/libherb/location.c",
diff --git a/javascript/packages/node/extension/herb.cpp b/javascript/packages/node/extension/herb.cpp
index a3e080902..e470ab027 100644
--- a/javascript/packages/node/extension/herb.cpp
+++ b/javascript/packages/node/extension/herb.cpp
@@ -142,37 +142,6 @@ napi_value Herb_parse_file(napi_env env, napi_callback_info info) {
   return result;
 }
 
-napi_value Herb_lex_to_json(napi_env env, napi_callback_info info) {
-  size_t argc = 1;
-  napi_value args[1];
-  napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
-
-  if (argc < 1) {
-    napi_throw_error(env, nullptr, "Wrong number of arguments");
-    return nullptr;
-  }
-
-  char* string = CheckString(env, args[0]);
-  if (!string) { return nullptr; }
-
-  buffer_T output;
-  if (!buffer_init(&output, 4096)) {
-    free(string);
-    napi_throw_error(env, nullptr, "Failed to initialize buffer");
-    return nullptr;
-  }
-
-  herb_lex_json_to_buffer(string, &output);
-
-  napi_value result;
-  napi_create_string_utf8(env, output.value, output.length, &result);
-
-  free(output.value);
-  free(string);
-
-  return result;
-}
-
 napi_value Herb_extract_ruby(napi_env env, napi_callback_info info) {
   size_t argc = 1;
   napi_value args[1];
@@ -252,7 +221,6 @@ napi_value Init(napi_env env, napi_value exports) {
     { "lex", nullptr, Herb_lex, nullptr, nullptr, nullptr, napi_default, nullptr },
     { "parseFile", nullptr, Herb_parse_file, nullptr, nullptr, nullptr, napi_default, nullptr },
     { "lexFile", nullptr, Herb_lex_file, nullptr, nullptr, nullptr, napi_default, nullptr },
-    { "lexToJson", nullptr, Herb_lex_to_json, nullptr, nullptr, nullptr, napi_default, nullptr },
     { "extractRuby", nullptr, Herb_extract_ruby, nullptr, nullptr, nullptr, napi_default, nullptr },
     { "extractHTML", nullptr, Herb_extract_html, nullptr, nullptr, nullptr, napi_default, nullptr },
     { "version", nullptr, Herb_version, nullptr, nullptr, nullptr, napi_default, nullptr },
diff --git a/lib/herb/libherb.rb b/lib/herb/libherb.rb
index 401004303..ea670bc00 100644
--- a/lib/herb/libherb.rb
+++ b/lib/herb/libherb.rb
@@ -25,7 +25,6 @@ def self.library_path
     ffi_lib(library_path)
 
     attach_function :herb_lex_to_buffer, [:pointer, :pointer], :void
-    attach_function :herb_lex_json_to_buffer, [:pointer, :pointer], :void
     attach_function :herb_lex, [:pointer], :pointer
     attach_function :herb_parse, [:pointer], :pointer
     attach_function :herb_extract_ruby_to_buffer, [:pointer, :pointer], :void
diff --git a/lib/herb/libherb/libherb.rb b/lib/herb/libherb/libherb.rb
index 38354e405..03c3b77d7 100644
--- a/lib/herb/libherb/libherb.rb
+++ b/lib/herb/libherb/libherb.rb
@@ -26,14 +26,6 @@ def self.lex(source)
     )
   end
 
-  def self.lex_to_json(source)
-    LibHerb::Buffer.with do |output|
-      LibHerb.herb_lex_json_to_buffer(source, output.pointer)
-
-      JSON.parse(output.read.force_encoding("utf-8"))
-    end
-  end
-
   def self.extract_ruby(source)
     LibHerb::Buffer.with do |output|
       LibHerb.herb_extract_ruby_to_buffer(source, output.pointer)
diff --git a/src/herb.c b/src/herb.c
index 1348c9495..dab7971be 100644
--- a/src/herb.c
+++ b/src/herb.c
@@ -2,7 +2,6 @@
 #include "include/array.h"
 #include "include/buffer.h"
 #include "include/io.h"
-#include "include/json.h"
 #include "include/lexer.h"
 #include "include/parser.h"
 #include "include/token.h"
@@ -65,27 +64,6 @@ void herb_lex_to_buffer(const char* source, buffer_T* output) {
   herb_free_tokens(&tokens);
 }
 
-void herb_lex_json_to_buffer(const char* source, buffer_T* output) {
-  array_T* tokens = herb_lex(source);
-
-  buffer_T json;
-  buffer_init(&json, 4096);
-  json_start_root_array(&json);
-
-  for (size_t i = 0; i < array_size(tokens); i++) {
-    token_T* token = array_get(tokens, i);
-    char* token_json = token_to_json(token);
-    json_add_raw_string(&json, token_json);
-    free(token_json);
-  }
-
-  json_end_array(&json);
-  buffer_concat(output, &json);
-
-  free(json.value);
-  herb_free_tokens(&tokens);
-}
-
 void herb_free_tokens(array_T** tokens) {
   if (!tokens || !*tokens) { return; }
 
diff --git a/src/include/herb.h b/src/include/herb.h
index d4ec2c7c6..ef886a087 100644
--- a/src/include/herb.h
+++ b/src/include/herb.h
@@ -14,7 +14,6 @@ extern "C" {
 #endif
 
 void herb_lex_to_buffer(const char* source, buffer_T* output);
-void herb_lex_json_to_buffer(const char* source, buffer_T* output);
 
 array_T* herb_lex(const char* source);
 array_T* herb_lex_file(const char* path);
diff --git a/src/include/json.h b/src/include/json.h
deleted file mode 100644
index b48428c3a..000000000
--- a/src/include/json.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef HERB_JSON_H
-#define HERB_JSON_H
-
-#include "buffer.h"
-
-void json_start_root_object(buffer_T* json);
-void json_start_root_array(buffer_T* json);
-
-void json_escape_string(buffer_T* json, const char* string);
-
-void json_add_string(buffer_T* json, const char* key, const char* value);
-void json_add_int(buffer_T* json, const char* key, int value);
-void json_add_size_t(buffer_T* json, const char* key, size_t value);
-void json_add_double(buffer_T* json, const char* key, double value);
-void json_add_bool(buffer_T* json, const char* key, int value);
-
-void json_add_raw_string(buffer_T* json, const char* string);
-
-void json_start_object(buffer_T* json, const char* key);
-void json_end_object(buffer_T* json);
-
-void json_start_array(buffer_T* json, const char* key);
-void json_end_array(buffer_T* json);
-
-void json_double_to_string(double value, char* buffer);
-void json_int_to_string(int value, char* buffer);
-
-#endif
diff --git a/src/include/token.h b/src/include/token.h
index 523dd1f04..5628e2f0d 100644
--- a/src/include/token.h
+++ b/src/include/token.h
@@ -7,7 +7,6 @@
 
 token_T* token_init(const char* value, token_type_T type, lexer_T* lexer);
 char* token_to_string(const token_T* token);
-char* token_to_json(const token_T* token);
 const char* token_type_to_string(token_type_T type);
 
 char* token_value(const token_T* token);
diff --git a/src/json.c b/src/json.c
deleted file mode 100644
index a1bc80662..000000000
--- a/src/json.c
+++ /dev/null
@@ -1,205 +0,0 @@
-#include "include/json.h"
-#include "include/buffer.h"
-
-void json_escape_string(buffer_T* json, const char* string) {
-  if (!string) {
-    buffer_append(json, "null");
-    return;
-  }
-
-  buffer_append(json, "\"");
-
-  while (*string) {
-    switch (*string) {
-      case '\"': buffer_append(json, "\\\""); break;
-      case '\\': buffer_append(json, "\\\\"); break;
-      case '\n': buffer_append(json, "\\n"); break;
-      case '\t': buffer_append(json, "\\t"); break;
-      default: buffer_append_char(json, *string); break;
-    }
-    string++;
-  }
-
-  buffer_append(json, "\"");
-}
-
-void json_int_to_string(const int value, char* buffer) {
-  char string[20]; // Enough to hold all possible int values
-  int i = 0;
-
-  // Handle negative numbers
-  unsigned int abs_value = (unsigned int) abs(value);
-
-  do {
-    string[i++] = (char) ((abs_value % 10) + '0');
-    abs_value /= 10;
-  } while (abs_value > 0);
-
-  if (value < 0) { string[i++] = '-'; }
-
-  int j = 0;
-
-  while (i > 0) {
-    buffer[j++] = string[--i];
-  }
-
-  buffer[j] = '\0';
-}
-
-void json_double_to_string(const double value, char* buffer) {
-  const int int_part = (int) value;
-  const double frac_part = value - (double) int_part;
-  const int frac_as_int = (int) (frac_part * 100); // Keep 2 decimal places
-
-  char int_buffer[20];
-  char frac_buffer[5];
-
-  json_int_to_string(int_part, int_buffer);
-  json_int_to_string(frac_as_int < 0 ? -frac_as_int : frac_as_int, frac_buffer);
-
-  char* pointer = buffer;
-  for (const char* source = int_buffer; *source != '\0'; ++source) {
-    *pointer++ = *source;
-  }
-
-  *pointer++ = '.';
-
-  for (const char* source = frac_buffer; *source != '\0'; ++source) {
-    *pointer++ = *source;
-  }
-
-  *pointer = '\0';
-}
-
-void json_add_string(buffer_T* json, const char* key, const char* value) {
-  if (!json) { return; }
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  json_escape_string(json, value);
-}
-
-void json_add_double(buffer_T* json, const char* key, const double value) {
-  if (!json) { return; }
-
-  char number[32];
-  json_double_to_string(value, number);
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  buffer_append(json, number);
-}
-
-void json_add_int(buffer_T* json, const char* key, const int value) {
-  if (!json) { return; }
-
-  char number[20];
-  json_int_to_string(value, number);
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  buffer_append(json, number);
-  if (json->length == 1) { buffer_append(json, " "); }
-}
-
-void json_add_size_t(buffer_T* json, const char* key, size_t value) {
-  if (!json) { return; }
-
-  char number[32];
-  char temp[32];
-  int i = 0;
-
-  do {
-    temp[i++] = (char) ((value % 10) + '0');
-    value /= 10;
-  } while (value > 0);
-
-  int j = 0;
-  while (i > 0) {
-    number[j++] = temp[--i];
-  }
-  number[j] = '\0';
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  buffer_append(json, number);
-  if (json->length == 1) { buffer_append(json, " "); }
-}
-
-void json_add_bool(buffer_T* json, const char* key, const int value) {
-  if (!json) { return; }
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  buffer_append(json, value ? "true" : "false");
-}
-
-void json_add_raw_string(buffer_T* json, const char* string) {
-  if (!json) { return; }
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  buffer_append(json, string);
-}
-
-void json_start_root_object(buffer_T* json) {
-  if (json) { buffer_append(json, "{"); }
-}
-
-void json_start_object(buffer_T* json, const char* key) {
-  if (!json) { return; }
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  buffer_append(json, "{");
-}
-
-void json_end_object(buffer_T* json) {
-  if (json) { buffer_append(json, "}"); }
-}
-
-void json_start_root_array(buffer_T* json) {
-  if (json) { buffer_append(json, "["); }
-}
-
-void json_start_array(buffer_T* json, const char* key) {
-  if (!json) { return; }
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-  json_escape_string(json, key);
-  buffer_append(json, ": [");
-}
-
-void json_end_array(buffer_T* json) {
-  if (json) { buffer_append(json, "]"); }
-}
diff --git a/src/main.c b/src/main.c
index 2e1efbfa2..e30b9e5f6 100644
--- a/src/main.c
+++ b/src/main.c
@@ -39,7 +39,6 @@ int main(const int argc, char* argv[]) {
     printf("Herb 🌿 Powerful and seamless HTML-aware ERB parsing and tooling.\n\n");
 
     printf("./herb lex [file]      -  Lex a file\n");
-    printf("./herb lex_json [file] -  Lex a file and return the result as json.\n");
     printf("./herb parse [file]    -  Parse a file\n");
     printf("./herb ruby [file]     -  Extract Ruby from a file\n");
     printf("./herb html [file]     -  Extract HTML from a file\n");
@@ -93,17 +92,6 @@ int main(const int argc, char* argv[]) {
     return 0;
   }
 
-  if (strcmp(argv[1], "lex_json") == 0) {
-    herb_lex_json_to_buffer(source, &output);
-
-    printf("%s\n", output.value);
-
-    free(output.value);
-    free(source);
-
-    return 0;
-  }
-
   if (strcmp(argv[1], "parse") == 0) {
     AST_DOCUMENT_NODE_T* root = herb_parse(source, NULL);
 
diff --git a/src/token.c b/src/token.c
index 60a5010ac..b84362754 100644
--- a/src/token.c
+++ b/src/token.c
@@ -1,5 +1,4 @@
 #include "include/token.h"
-#include "include/json.h"
 #include "include/lexer.h"
 #include "include/position.h"
 #include "include/range.h"
@@ -119,46 +118,6 @@ char* token_to_string(const token_T* token) {
   return string;
 }
 
-char* token_to_json(const token_T* token) {
-  buffer_T json;
-  buffer_init(&json, 512);
-
-  json_start_root_object(&json);
-  json_add_string(&json, "type", token_type_to_string(token->type));
-  json_add_string(&json, "value", token->value);
-
-  buffer_T range;
-  buffer_init(&range, 128);
-  json_start_array(&json, "range");
-  json_add_size_t(&range, NULL, token->range.from);
-  json_add_size_t(&range, NULL, token->range.to);
-  buffer_concat(&json, &range);
-  free(range.value);
-  json_end_array(&json);
-
-  buffer_T start;
-  buffer_init(&start, 128);
-  json_start_object(&json, "start");
-  json_add_size_t(&start, "line", token->location.start.line);
-  json_add_size_t(&start, "column", token->location.start.column);
-  buffer_concat(&json, &start);
-  free(start.value);
-  json_end_object(&json);
-
-  buffer_T end;
-  buffer_init(&end, 128);
-  json_start_object(&json, "end");
-  json_add_size_t(&end, "line", token->location.end.line);
-  json_add_size_t(&end, "column", token->location.end.column);
-  buffer_concat(&json, &end);
-  free(end.value);
-  json_end_object(&json);
-
-  json_end_object(&json);
-
-  return buffer_value(&json);
-}
-
 char* token_value(const token_T* token) {
   return token->value;
 }
diff --git a/test/c/main.c b/test/c/main.c
index c61106da6..200d92a6b 100644
--- a/test/c/main.c
+++ b/test/c/main.c
@@ -6,7 +6,6 @@ TCase *buffer_tests(void);
 TCase *herb_tests(void);
 TCase *html_util_tests(void);
 TCase *io_tests(void);
-TCase *json_tests(void);
 TCase *lex_tests(void);
 TCase *token_tests(void);
 TCase *util_tests(void);
@@ -19,7 +18,6 @@ Suite *herb_suite(void) {
   suite_add_tcase(suite, herb_tests());
   suite_add_tcase(suite, html_util_tests());
   suite_add_tcase(suite, io_tests());
-  suite_add_tcase(suite, json_tests());
   suite_add_tcase(suite, lex_tests());
   suite_add_tcase(suite, token_tests());
   suite_add_tcase(suite, util_tests());
diff --git a/test/c/test_json.c b/test/c/test_json.c
deleted file mode 100644
index d734b84f8..000000000
--- a/test/c/test_json.c
+++ /dev/null
@@ -1,333 +0,0 @@
-#include <limits.h>
-
-#include "include/test.h"
-#include "../../src/include/buffer.h"
-#include "../../src/include/json.h"
-
-TEST(test_json_escape_basic)
-  buffer_T json;
-  buffer_init(&json, 1024);
-
-  json_start_root_object(&json);
-  json_add_string(&json, "key", "value");
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"key\": \"value\"}");
-
-  free(json.value);
-END
-
-TEST(test_json_escape_quotes)
-  buffer_T json;
-  buffer_init(&json, 1024);
-
-  json_start_root_object(&json);
-  json_add_string(&json, "quote", "This is a \"quoted\" string");
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"quote\": \"This is a \\\"quoted\\\" string\"}");
-
-  free(json.value);
-END
-
-TEST(test_json_escape_backslash)
-  buffer_T json;
-  buffer_init(&json, 1024);
-
-  json_start_root_object(&json);
-  json_add_string(&json, "path", "C:\\Users\\Test");
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"path\": \"C:\\\\Users\\\\Test\"}");
-
-  free(json.value);
-END
-
-TEST(test_json_escape_newline)
-  buffer_T json;
-  buffer_init(&json, 1024);
-
-  json_start_root_object(&json);
-  json_add_string(&json, "text", "Line1\nLine2");
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"text\": \"Line1\\nLine2\"}");
-
-  free(json.value);
-END
-
-TEST(test_json_escape_tab)
-  buffer_T json;
-  buffer_init(&json, 1024);
-
-  json_start_root_object(&json);
-  json_add_string(&json, "text", "Column1\tColumn2");
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"text\": \"Column1\\tColumn2\"}");
-
-  free(json.value);
-END
-
-TEST(test_json_escape_mixed)
-  buffer_T json;
-  buffer_init(&json, 1024);
-
-  json_start_root_object(&json);
-  json_add_string(&json, "complex", "A \"quoted\" \\ path\nwith\ttabs.");
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"complex\": \"A \\\"quoted\\\" \\\\ path\\nwith\\ttabs.\"}");
-
-  free(json.value);
-END
-
-TEST(test_json_root_object)
-  buffer_T json;
-  buffer_init(&json, 1024);
-
-  json_start_root_object(&json);
-
-  json_add_string(&json, "name", "John");
-  json_add_int(&json, "age", 20);
-  json_add_double(&json, "score", 99.5);
-  json_add_bool(&json, "active", 1);
-
-  buffer_T address;
-  buffer_init(&address, 1024);
-  json_start_object(&json, "address");
-  json_add_string(&address, "city", "Basel");
-  json_add_string(&address, "country", "Switzerland");
-  buffer_concat(&json, &address);
-  json_end_object(&json);
-
-  buffer_T languages;
-  buffer_init(&languages, 1024);
-  json_start_array(&json, "languages");
-  json_add_string(&languages, NULL, "Ruby");
-  json_add_string(&languages, NULL, "C");
-  json_add_string(&languages, NULL, "JavaScript");
-  buffer_concat(&json, &languages);
-  json_end_array(&json);
-
-  buffer_T ratings;
-  buffer_init(&ratings, 1024);
-  json_start_array(&json, "ratings");
-  json_add_double(&ratings, NULL, 4.5);
-  json_add_int(&ratings, NULL, 3);
-  json_add_double(&ratings, NULL, 5.0);
-  json_add_double(&ratings, NULL, 3.8);
-  json_add_int(&ratings, NULL, 5);
-  buffer_concat(&json, &ratings);
-  json_end_array(&json);
-
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"name\": \"John\", \"age\": 20, \"score\": 99.50, \"active\": true, \"address\": {\"city\": \"Basel\", \"country\": \"Switzerland\"}, \"languages\": [\"Ruby\", \"C\", \"JavaScript\"], \"ratings\": [4.50, 3, 5.0, 3.79, 5]}");
-
-  free(address.value);
-  free(languages.value);
-  free(ratings.value);
-  free(json.value);
-END
-
-TEST(test_json_root_array)
-  buffer_T json;
-  buffer_init(&json, 1024);
-
-  json_start_root_array(&json);
-
-  json_add_string(&json, NULL, "Ruby");
-  json_add_string(&json, NULL, "C");
-  json_add_string(&json, NULL, "JavaScript");
-  json_add_int(&json, NULL, 42);
-  json_add_double(&json, NULL, 3.14159);
-  json_add_bool(&json, NULL, 1);
-  json_add_bool(&json, NULL, 0);
-
-  json_end_array(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "[\"Ruby\", \"C\", \"JavaScript\", 42, 3.14, true, false]");
-
-  free(json.value);
-END
-
-TEST(test_json_append_array_to_object)
-  buffer_T json;
-  buffer_init(&json, 1024);
-
-  json_start_root_object(&json);
-
-  buffer_T object;
-  buffer_init(&object, 1024);
-  json_start_object(&json, "object");
-  json_add_string(&object, "key", "value");
-
-  buffer_T array;
-  buffer_init(&array, 1024);
-  json_start_array(&object, "array");
-  json_add_string(&array, NULL, "One");
-  json_add_string(&array, NULL, "Two");
-
-  buffer_concat(&object, &array);
-  json_end_array(&object);
-
-  buffer_concat(&json, &object);
-  json_end_object(&json);
-
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"object\": {\"key\": \"value\", \"array\": [\"One\", \"Two\"]}}");
-
-  free(array.value);
-  free(object.value);
-  free(json.value);
-END
-
-TEST(test_json_append_object_array)
-  buffer_T json;
-  buffer_init(&json, 1024);
-
-  json_start_root_object(&json);
-
-  buffer_T array;
-  buffer_init(&array, 1024);
-  json_start_array(&json, "array");
-  json_add_string(&array, NULL, "One");
-  json_add_string(&array, NULL, "Two");
-
-  buffer_T object;
-  buffer_init(&object, 1024);
-  json_start_object(&array, NULL);
-  json_add_string(&object, "key", "value");
-
-  buffer_concat(&array, &object);
-  json_end_object(&array);
-
-  buffer_concat(&json, &array);
-  json_end_array(&json);
-
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"array\": [\"One\", \"Two\", {\"key\": \"value\"}]}");
-
-  free(object.value);
-  free(array.value);
-  free(json.value);
-END
-
-TEST(test_json_double_to_string_precision)
-  char buffer[64];
-
-  json_double_to_string(1.234567890123456, buffer);
-  ck_assert_str_eq(buffer, "1.23");
-
-  json_double_to_string(123456.7890123456789, buffer);
-  ck_assert_str_eq(buffer, "123456.78");
-
-  json_double_to_string(0.000000000000001, buffer);
-  ck_assert_str_eq(buffer, "0.0");
-
-  json_double_to_string(-42.987654321098765, buffer);
-  ck_assert_str_eq(buffer, "-42.98");
-
-  json_double_to_string(3.141592653589793, buffer);
-  ck_assert_str_eq(buffer, "3.14");
-END
-
-TEST(test_json_int_to_string_positive)
-  char buffer[20];
-
-  json_int_to_string(12345, buffer);
-  ck_assert_str_eq(buffer, "12345");
-
-  json_int_to_string(987654321, buffer);
-  ck_assert_str_eq(buffer, "987654321");
-
-  json_int_to_string(0, buffer);
-  ck_assert_str_eq(buffer, "0");
-END
-
-TEST(test_json_int_to_string_negative)
-  char buffer[20];
-
-  json_int_to_string(-1, buffer);
-  ck_assert_str_eq(buffer, "-1");
-
-  json_int_to_string(-42, buffer);
-  ck_assert_str_eq(buffer, "-42");
-
-  json_int_to_string(-987654321, buffer);
-  ck_assert_str_eq(buffer, "-987654321");
-END
-
-TEST(test_json_int_to_string_min_max)
-  char buffer[20];
-
-  json_int_to_string(2147483647, buffer);
-  ck_assert_str_eq(buffer, "2147483647");
-
-  json_int_to_string(-2147483648, buffer);
-  ck_assert_str_eq(buffer, "-2147483648");
-END
-
-TEST(test_json_add_size_t_basic)
-  buffer_T json;
-  buffer_init(&json, 1024);
-
-  json_add_size_t(&json, "size", 42);
-  ck_assert_str_eq(buffer_value(&json), "\"size\": 42");
-
-  free(json.value);
-END
-
-TEST(test_json_add_size_t_large_number)
-  buffer_T json;
-  buffer_init(&json, 1024);
-
-  json_add_size_t(&json, "size", 9876543210UL);
-  ck_assert_str_eq(buffer_value(&json), "\"size\": 9876543210");
-
-  buffer_clear(&json);
-  json_add_size_t(&json, "size", SIZE_MAX);
-  ck_assert_str_eq(buffer_value(&json), "\"size\": 18446744073709551615");
-
-  free(json.value);
-END
-
-TEST(test_json_add_size_t_in_array)
-  buffer_T json;
-  buffer_init(&json, 1024);
-
-  json_add_size_t(&json, NULL, 1024);
-  json_add_size_t(&json, NULL, 2048);
-  json_add_size_t(&json, NULL, 4096);
-
-  ck_assert_str_eq(buffer_value(&json), "1024, 2048, 4096");
-
-  free(json.value);
-END
-
-
-TCase* json_tests(void) {
-  TCase* json = tcase_create("JSON");
-
-  tcase_add_test(json, test_json_escape_basic);
-  tcase_add_test(json, test_json_escape_quotes);
-  tcase_add_test(json, test_json_escape_backslash);
-  tcase_add_test(json, test_json_escape_tab);
-  tcase_add_test(json, test_json_escape_mixed);
-  tcase_add_test(json, test_json_root_object);
-  tcase_add_test(json, test_json_root_array);
-  tcase_add_test(json, test_json_append_array_to_object);
-  tcase_add_test(json, test_json_append_object_array);
-  tcase_add_test(json, test_json_double_to_string_precision);
-  tcase_add_test(json, test_json_int_to_string_positive);
-  tcase_add_test(json, test_json_int_to_string_negative);
-  tcase_add_test(json, test_json_int_to_string_min_max);
-  tcase_add_test(json, test_json_add_size_t_basic);
-  tcase_add_test(json, test_json_add_size_t_large_number);
-  tcase_add_test(json, test_json_add_size_t_in_array);
-
-  return json;
-}
diff --git a/test/c/test_token.c b/test/c/test_token.c
index d8ea10fd5..946e0649f 100644
--- a/test/c/test_token.c
+++ b/test/c/test_token.c
@@ -21,27 +21,11 @@ TEST(test_token_to_string)
   free(output.value);
 END
 
-TEST(test_token_to_json)
-  buffer_T output;
-  buffer_init(&output, 1024);
-  herb_lex_json_to_buffer("hello", &output);
-
-  const char* expected = "["
-  "{\"type\": \"TOKEN_IDENTIFIER\", \"value\": \"hello\", \"range\": [0 , 5], \"start\": {\"line\": 1, \"column\": 0}, \"end\": {\"line\": 1, \"column\": 5}}, "
-  "{\"type\": \"TOKEN_EOF\", \"value\": \"\", \"range\": [5 , 5], \"start\": {\"line\": 1, \"column\": 5}, \"end\": {\"line\": 1, \"column\": 5}}"
-  "]";
-
-  ck_assert_str_eq(output.value, expected);
-
-  free(output.value);
-END
-
 TCase *token_tests(void) {
   TCase *token = tcase_create("Token");
 
   tcase_add_test(token, test_token);
   tcase_add_test(token, test_token_to_string);
-  tcase_add_test(token, test_token_to_json);
 
   return token;
 }

From 8d6adb1d25fc99634c01eb32c651cda685498cb4 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Wed, 8 Oct 2025 14:08:43 +0200
Subject: [PATCH 24/97] Linter: Add test helpers to simplify linter rule tests
 (#587)

This pull request implements linter test helpers to reduce the verbosity
in the linter rule tests. The new `createLinterTest()` helper provides a
cleaner API with `expectError()`, `expectWarning()`,
`expectNoOffenses()`, and `assertOffenses()` functions.

Example:

```ts
import { SomeRule } from "../../src/rules/some-rule.js"
import { createLinterTest } from "../helpers/linter-test-helper.js"

const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(SomeRule)

describe("SomeRule", () => {
  test("no offenses", () => {
    expectNoOffenses(`<div></div>`)
  })

  test("with offenses", () => {
    expectError("Error message.")
    expectWarning("Warning message.")

    assertOffenses(`<div></div>`)
  })
})
```

Resolves #461
---
 .../generators/app/templates/test.ts.ejs      |  39 +-
 .../linter/test/helpers/linter-test-helper.ts | 222 ++++++++++
 .../test/rules/erb-comment-syntax.test.ts     |  64 +--
 .../test/rules/erb-no-empty-tags.test.ts      | 125 ++----
 .../rules/erb-no-output-control-flow.test.ts  |  90 +---
 ...rb-no-silent-tag-in-attribute-name.test.ts |  97 ++---
 .../rules/erb-prefer-image-tag-helper.test.ts | 276 ++----------
 ...erb-require-whitespace-inside-tags.test.ts | 123 ++----
 .../erb-requires-trailing-newline.test.ts     | 132 ++----
 .../linter/test/rules/erb-right-trim.test.ts  | 190 ++++----
 .../html-anchor-require-href-rule.test.ts     |  71 +--
 .../html-aria-attribute-must-be-valid.test.ts |  80 +---
 .../html-aria-label-is-well-formatted.test.ts | 143 ++----
 .../html-aria-level-must-be-valid.test.ts     | 238 +++-------
 ...l-aria-role-heading-requires-level.test.ts |  33 +-
 .../html-aria-role-must-be-valid.test.ts      |  48 +-
 .../html-attribute-double-quotes.test.ts      | 141 ++----
 .../html-attribute-equals-spacing.test.ts     | 168 ++-----
 ...ml-attribute-values-require-quotes.test.ts | 106 +----
 ...id-both-disabled-and-aria-disabled.test.ts | 147 ++-----
 .../html-boolean-attributes-no-value.test.ts  | 126 ++----
 .../test/rules/html-iframe-has-title.test.ts  | 144 ++----
 .../test/rules/html-img-require-alt.test.ts   |  96 +---
 .../rules/html-navigation-has-label.test.ts   | 139 +-----
 .../html-no-aria-hidden-on-focusable.test.ts  | 179 ++------
 .../rules/html-no-block-inside-inline.test.ts | 240 +++-------
 .../html-no-duplicate-attributes.test.ts      |  87 +---
 .../test/rules/html-no-duplicate-ids.test.ts  | 411 ++++--------------
 .../rules/html-no-empty-attributes.test.ts    | 334 +++-----------
 .../test/rules/html-no-empty-headings.test.ts | 268 ++----------
 .../test/rules/html-no-nested-links.test.ts   |  96 +---
 .../rules/html-no-positive-tab-index.test.ts  | 127 ++----
 .../test/rules/html-no-self-closing.test.ts   | 182 +++-----
 .../rules/html-no-title-attribute.test.ts     | 152 ++-----
 ...-no-underscores-in-attribute-names.test.ts |  71 +--
 .../rules/html-tag-name-lowercase.test.ts     | 248 +++--------
 .../test/rules/parser-no-errors.test.ts       | 208 +++------
 .../rules/svg-tag-name-capitalization.test.ts |  88 ++--
 38 files changed, 1477 insertions(+), 4252 deletions(-)
 create mode 100644 javascript/packages/linter/test/helpers/linter-test-helper.ts

diff --git a/javascript/packages/linter/generators/linter-rule/generators/app/templates/test.ts.ejs b/javascript/packages/linter/generators/linter-rule/generators/app/templates/test.ts.ejs
index 79bb036f0..ffe5f017f 100644
--- a/javascript/packages/linter/generators/linter-rule/generators/app/templates/test.ts.ejs
+++ b/javascript/packages/linter/generators/linter-rule/generators/app/templates/test.ts.ejs
@@ -1,44 +1,25 @@
 import dedent from "dedent"
-
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
-
+import { describe, test } from "vitest"
 import { <%= ruleClassName %> } from "../../src/rules/<%= ruleName %>.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("<%= ruleClassName %>", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, expectWarning, assertOffenses } = createLinterTest(<%= ruleClassName %>)
 
+describe("<%= ruleClassName %>", () => {
   test("valid case TODO", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <h1>
         <%%= title %>
       </h1>
-    `
-    const linter = new Linter(Herb, [<%= ruleClassName %>])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("invalid case TODO", () => {
-    const html = dedent`
+    expectError("TODO: update rule message")
+
+    assertOffenses(dedent`
       <h1>
         <%%= title %>
-    `
-    const linter = new Linter(Herb, [<%= ruleClassName %>])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("<%= ruleName %>")
-    expect(lintResult.offenses[0].message).toBe("TODO: update rule message")
-
-    // TODO: add assertions for invalid case
+    `)
   })
 })
diff --git a/javascript/packages/linter/test/helpers/linter-test-helper.ts b/javascript/packages/linter/test/helpers/linter-test-helper.ts
new file mode 100644
index 000000000..b4bf26ce9
--- /dev/null
+++ b/javascript/packages/linter/test/helpers/linter-test-helper.ts
@@ -0,0 +1,222 @@
+import { beforeAll, afterEach, expect } from "vitest"
+
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+
+import type { RuleClass } from "../../src/types.js"
+
+interface ExpectedLocation {
+  line?: number
+  column?: number
+}
+
+type LocationInput = ExpectedLocation | [number, number] | [number]
+
+interface ExpectedOffense {
+  message: string
+  location?: ExpectedLocation
+}
+
+interface LinterTestHelpers {
+  expectNoOffenses: (html: string, context?: any) => void
+  expectWarning: (message: string, location?: LocationInput) => void
+  expectError: (message: string, location?: LocationInput) => void
+  assertOffenses: (html: string, context?: any) => void
+}
+
+/**
+ * Creates a test helper for linter rules that reduces boilerplate in tests.
+ *
+ * @param ruleClass - The rule class to test
+ * @returns Object with helper functions for testing
+ *
+ * @example
+ * ```ts
+ * const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(MyRule)
+ *
+ * test("valid case", () => {
+ *   expectNoOffenses(`<%= title %>`)
+ * })
+ *
+ * test("invalid case", () => {
+ *   expectError("Error message", { line: 1, column: 1 })
+ *   // or use array syntax
+ *   expectError("Error message", [1, 1])
+ *
+ *   assertOffenses(`<% %>`)
+ * })
+ * ```
+ */
+export function createLinterTest(ruleClass: RuleClass): LinterTestHelpers {
+  const expectedWarnings: ExpectedOffense[] = []
+  const expectedErrors: ExpectedOffense[] = []
+  let hasAsserted = false
+
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  afterEach(() => {
+    if (!hasAsserted && (expectedWarnings.length > 0 || expectedErrors.length > 0)) {
+      const pendingCount = expectedWarnings.length + expectedErrors.length
+      throw new Error(
+        `Test has ${pendingCount} pending expectation(s) that were never asserted. ` +
+        `Did you forget to call assertOffenses() or expectNoOffenses()?`
+      )
+    }
+
+    expectedWarnings.length = 0
+    expectedErrors.length = 0
+    hasAsserted = false
+  })
+
+  const expectNoOffenses = (html: string, context?: any) => {
+    if (expectedWarnings.length > 0 || expectedErrors.length > 0) {
+      throw new Error(
+        "Cannot call expectNoOffenses() after registering expectations with expectWarning() or expectError()"
+      )
+    }
+
+    hasAsserted = true
+    const linter = new Linter(Herb, [ruleClass])
+    const lintResult = linter.lint(html, context)
+
+    expect(lintResult.errors).toBe(0)
+    expect(lintResult.warnings).toBe(0)
+    expect(lintResult.offenses).toHaveLength(0)
+  }
+
+  const normalizeLocation = (location?: LocationInput): ExpectedLocation | undefined => {
+    if (!location) return undefined
+    if (Array.isArray(location)) {
+      return location.length === 2
+        ? { line: location[0], column: location[1] }
+        : { line: location[0] }
+    }
+    return location
+  }
+
+  const expectWarning = (message: string, location?: LocationInput) => {
+    expectedWarnings.push({ message, location: normalizeLocation(location) })
+  }
+
+  const expectError = (message: string, location?: LocationInput) => {
+    expectedErrors.push({ message, location: normalizeLocation(location) })
+  }
+
+  const assertOffenses = (html: string, context?: any) => {
+    if (expectedWarnings.length === 0 && expectedErrors.length === 0) {
+      throw new Error(
+        "Cannot call assertOffenses() with no expectations. Use expectNoOffenses() instead."
+      )
+    }
+
+    hasAsserted = true
+    const linter = new Linter(Herb, [ruleClass])
+    const lintResult = linter.lint(html, context)
+
+    const ruleInstance = new ruleClass()
+    const ruleName = ruleInstance.name
+
+    if (lintResult.errors !== expectedErrors.length) {
+      throw new Error(
+        `Expected ${expectedErrors.length} error(s) but found ${lintResult.errors}.\n` +
+        `Expected:\n${expectedErrors.map(e => `  - "${e.message}"`).join('\n')}\n` +
+        `Actual:\n${lintResult.offenses.filter(o => o.severity === 'error').map(o => `  - "${o.message}" at ${o.location.start.line}:${o.location.start.column}`).join('\n')}`
+      )
+    }
+
+    if (lintResult.warnings !== expectedWarnings.length) {
+      throw new Error(
+        `Expected ${expectedWarnings.length} warning(s) but found ${lintResult.warnings}.\n` +
+        `Expected:\n${expectedWarnings.map(w => `  - "${w.message}"`).join('\n')}\n` +
+        `Actual:\n${lintResult.offenses.filter(o => o.severity === 'warning').map(o => `  - "${o.message}" at ${o.location.start.line}:${o.location.start.column}`).join('\n')}`
+      )
+    }
+
+    lintResult.offenses.forEach(offense => {
+      expect(offense.rule).toBe(ruleName)
+    })
+
+    const actualErrors = lintResult.offenses.filter(o => o.severity === "error")
+    const actualWarnings = lintResult.offenses.filter(o => o.severity === "warning")
+
+    matchOffenses(expectedErrors, actualErrors, "error")
+    matchOffenses(expectedWarnings, actualWarnings, "warning")
+
+    expectedWarnings.length = 0
+    expectedErrors.length = 0
+  }
+
+  return {
+    expectNoOffenses,
+    expectWarning,
+    expectError,
+    assertOffenses
+  }
+}
+
+/**
+ * Matches expected offenses to actual offenses in an order-independent way
+ */
+function matchOffenses(
+  expected: ExpectedOffense[],
+  actual: any[],
+  severity: "error" | "warning"
+) {
+  const unmatched = [...expected]
+  const unmatchedActual = [...actual]
+
+  for (const actualOffense of actual) {
+    const matchIndex = unmatched.findIndex(exp => {
+      if (exp.message !== actualOffense.message) {
+        return false
+      }
+
+      if (exp.location?.line !== undefined && exp.location.line !== actualOffense.location.start.line) {
+        return false
+      }
+
+      if (exp.location?.column !== undefined && exp.location.column !== actualOffense.location.start.column) {
+        return false
+      }
+
+      return true
+    })
+
+    if (matchIndex !== -1) {
+      unmatched.splice(matchIndex, 1)
+      const actualIndex = unmatchedActual.findIndex(o => o === actualOffense)
+      if (actualIndex !== -1) {
+        unmatchedActual.splice(actualIndex, 1)
+      }
+    }
+  }
+
+  if (unmatched.length > 0 || unmatchedActual.length > 0) {
+    const errors: string[] = []
+
+    if (unmatched.length > 0) {
+      errors.push(`Expected ${severity}(s) not found:`)
+      unmatched.forEach(exp => {
+        const location = exp.location?.line !== undefined
+          ? exp.location?.column !== undefined
+            ? ` at ${exp.location.line}:${exp.location.column}`
+            : ` at line ${exp.location.line}`
+          : ""
+        errors.push(`  - "${exp.message}"${location}`)
+      })
+    }
+
+    if (unmatchedActual.length > 0) {
+      errors.push(`Unexpected ${severity}(s) found:`)
+      unmatchedActual.forEach(offense => {
+        errors.push(
+          `  - "${offense.message}" at ${offense.location.start.line}:${offense.location.start.column}`
+        )
+      })
+    }
+
+    throw new Error(errors.join("\n"))
+  }
+}
diff --git a/javascript/packages/linter/test/rules/erb-comment-syntax.test.ts b/javascript/packages/linter/test/rules/erb-comment-syntax.test.ts
index 8bc529690..6b2824316 100644
--- a/javascript/packages/linter/test/rules/erb-comment-syntax.test.ts
+++ b/javascript/packages/linter/test/rules/erb-comment-syntax.test.ts
@@ -1,75 +1,49 @@
 import dedent from "dedent"
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { ERBCommentSyntax } from "../../src/rules/erb-comment-syntax.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("ERBCommentSyntax", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBCommentSyntax)
 
+describe("ERBCommentSyntax", () => {
   test("when the ERB comment syntax is correct", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <%# good comment %>
-    `
-
-    const linter = new Linter(Herb, [ERBCommentSyntax])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("when the ERB multi-line comment syntax is correct", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <%
         # good comment
       %>
-    `
-
-    const linter = new Linter(Herb, [ERBCommentSyntax])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("when the ERB multi-line comment syntax is correct with multiple comment lines", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <%
         # good comment
         # good comment
       %>
-    `
-
-    const linter = new Linter(Herb, [ERBCommentSyntax])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("when the ERB comment syntax is incorrect", () => {
-    const html = dedent`
-      <% # bad comment %>
-    `
+    expectError("Use `<%#` instead of `<% #`. Ruby comments immediately after ERB tags can cause parsing issues.")
 
-    const linter = new Linter(Herb, [ERBCommentSyntax])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe("Use `<%#` instead of `<% #`. Ruby comments immediately after ERB tags can cause parsing issues.")
+    assertOffenses(dedent`
+      <% # bad comment %>
+    `)
   })
 
   test("when the ERB comment syntax is incorrect multiple times in one file", () => {
-    const html = dedent`
+    expectError("Use `<%#` instead of `<% #`. Ruby comments immediately after ERB tags can cause parsing issues.")
+    expectError("Use `<%#` instead of `<%= #`. Ruby comments immediately after ERB tags can cause parsing issues.")
+
+    assertOffenses(dedent`
       <% # first bad comment %>
       <%= # second bad comment %>
-    `
-
-    const linter = new Linter(Herb, [ERBCommentSyntax])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.offenses).toHaveLength(2)
-    expect(lintResult.offenses[0].message).toBe("Use `<%#` instead of `<% #`. Ruby comments immediately after ERB tags can cause parsing issues.")
-    expect(lintResult.offenses[1].message).toBe("Use `<%#` instead of `<%= #`. Ruby comments immediately after ERB tags can cause parsing issues.")
+    `)
   })
 })
diff --git a/javascript/packages/linter/test/rules/erb-no-empty-tags.test.ts b/javascript/packages/linter/test/rules/erb-no-empty-tags.test.ts
index 0034528db..9f901aaa0 100644
--- a/javascript/packages/linter/test/rules/erb-no-empty-tags.test.ts
+++ b/javascript/packages/linter/test/rules/erb-no-empty-tags.test.ts
@@ -1,19 +1,13 @@
 import dedent from "dedent"
-
-import { describe, test, expect, beforeAll } from "vitest"
-
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
-
+import { describe, test } from "vitest"
 import { ERBNoEmptyTagsRule } from "../../src/rules/erb-no-empty-tags.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("ERBNoEmptyTagsRule", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBNoEmptyTagsRule)
 
+describe("ERBNoEmptyTagsRule", () => {
   test("should not report errors for valid ERB tags with content", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <h1>
         <%= title %>
       </h1>
@@ -27,78 +21,50 @@ describe("ERBNoEmptyTagsRule", () => {
       <% end %>
 
       <%= "" %>
-    `
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("should not report errors for incomplete erb tags", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <%
-    `
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("should not report errors for incomplete erb output tags", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <%=
-    `
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("should report errors for completely empty ERB tags", () => {
-    const html = dedent`
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 2, column: 2 })
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 3, column: 2 })
+
+    assertOffenses(dedent`
       <h1>
         <% %>
         <%= %>
       </h1>
-    `
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
-    expect(lintResult.offenses[0].message).toBe("ERB tag should not be empty. Remove empty ERB tags or add content.")
-    expect(lintResult.offenses[1].message).toBe("ERB tag should not be empty. Remove empty ERB tags or add content.")
+    `)
   })
 
   test("should report errors for whitespace-only ERB tags", () => {
-    const html = dedent`
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 2, column: 2 })
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 3, column: 2 })
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 4, column: 2 })
+
+    assertOffenses(dedent`
       <h1>
         <%   %>
         <%=    %>
         <%
         %>
       </h1>
-    `
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(3)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(3)
-    lintResult.offenses.forEach(message => {
-      expect(message.message).toBe("ERB tag should not be empty. Remove empty ERB tags or add content.")
-    })
+    `)
   })
 
   test("should not report errors for ERB tags with meaningful content", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div>
         <%= user.name %>
         <% if condition %>
@@ -106,17 +72,14 @@ describe("ERBNoEmptyTagsRule", () => {
         <% # this is a comment %>
         <%= @variable %>
       </div>
-    `
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("should handle mixed valid and invalid ERB tags", () => {
-    const html = dedent`
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 3, column: 2 })
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 5, column: 2 })
+
+    assertOffenses(dedent`
       <div>
         <%= user.name %>
         <% %>
@@ -124,38 +87,18 @@ describe("ERBNoEmptyTagsRule", () => {
         <%= %>
         <% end %>
       </div>
-    `
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
-
-    lintResult.offenses.forEach(message => {
-      expect(message.message).toBe("ERB tag should not be empty. Remove empty ERB tags or add content.")
-    })
+    `)
   })
 
   test("should handle empty ERB tag in attribute value", () => {
-    const html = `<div class="<%= %>"></div>`
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe("ERB tag should not be empty. Remove empty ERB tags or add content.")
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 1, column: 12 })
+
+    assertOffenses(`<div class="<%= %>"></div>`)
   })
 
   test("should handle empty ERB tag in open tag", () => {
-    const html = `<div <%= %>></div>`
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe("ERB tag should not be empty. Remove empty ERB tags or add content.")
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 1, column: 5 })
+
+    assertOffenses(`<div <%= %>></div>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/erb-no-output-control-flow.test.ts b/javascript/packages/linter/test/rules/erb-no-output-control-flow.test.ts
index 2a6777e7c..0091b7ca5 100644
--- a/javascript/packages/linter/test/rules/erb-no-output-control-flow.test.ts
+++ b/javascript/packages/linter/test/rules/erb-no-output-control-flow.test.ts
@@ -1,15 +1,12 @@
-import { describe, it, beforeAll, expect } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
+import { describe, it } from "vitest"
 import dedent from "dedent";
 
-import { Linter } from "../../src/linter";
 import { ERBNoOutputControlFlowRule } from "../../src/rules/erb-no-output-control-flow";
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("erb-no-output-control-flow", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBNoOutputControlFlowRule)
 
+describe("erb-no-output-control-flow", () => {
   it("should allow if statements without output tags", () => {
     const html = dedent`
       <% if true %>
@@ -20,12 +17,8 @@ describe("erb-no-output-control-flow", () => {
         <div>Text3</div>
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+
+    expectNoOffenses(html)
   })
 
   it("should not allow if statments with output tags", () => {
@@ -34,13 +27,9 @@ describe("erb-no-output-control-flow", () => {
         <div>Text1</div>
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectError("Control flow statements like `if` should not be used with output tags. Use `<% if ... %>` instead.")
+    assertOffenses(html)
   })
 
   it("should not allow unless statements with output tags", () => {
@@ -49,13 +38,9 @@ describe("erb-no-output-control-flow", () => {
         <div>Text1</div>
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectError("Control flow statements like `unless` should not be used with output tags. Use `<% unless ... %>` instead.")
+    assertOffenses(html)
   })
 
   it("should not allow end statements with output tags", () => {
@@ -64,13 +49,9 @@ describe("erb-no-output-control-flow", () => {
         <div>Text1</div>
       <%= end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectError("Control flow statements like `end` should not be used with output tags. Use `<% end ... %>` instead.")
+    assertOffenses(html)
   })
 
   it("should not allow nested control flow blocks with output tags", () => {
@@ -82,13 +63,9 @@ describe("erb-no-output-control-flow", () => {
         <% end %>
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectError("Control flow statements like `if` should not be used with output tags. Use `<% if ... %>` instead.")
+    assertOffenses(html)
   })
 
   it('should show multiple errors for multiple output tags', () => {
@@ -101,13 +78,11 @@ describe("erb-no-output-control-flow", () => {
         <div>Text3</div>
       <%= end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(3)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(3)
+    expectError("Control flow statements like `if` should not be used with output tags. Use `<% if ... %>` instead.")
+    expectError("Control flow statements like `else` should not be used with output tags. Use `<% else ... %>` instead.")
+    expectError("Control flow statements like `end` should not be used with output tags. Use `<% end ... %>` instead.")
+    assertOffenses(html)
   })
 
   it("should show an error for outputting control flow blocks with nested control flow blocks", () => {
@@ -118,13 +93,9 @@ describe("erb-no-output-control-flow", () => {
         <% end %>
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectError("Control flow statements like `if` should not be used with output tags. Use `<% if ... %>` instead.")
+    assertOffenses(html)
   })
 
   it("should not report for link to with an if condition", () => {
@@ -133,13 +104,8 @@ describe("erb-no-output-control-flow", () => {
         Click
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("should not report on form_builder.fieldset with block", () => {
@@ -158,25 +124,15 @@ describe("erb-no-output-control-flow", () => {
          <%# ... %>
      <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("should not report on yield with if in the same ERB tag", () => {
    const html = dedent`
       <%= yield(:header) if content_for?(:header) %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 })
diff --git a/javascript/packages/linter/test/rules/erb-no-silent-tag-in-attribute-name.test.ts b/javascript/packages/linter/test/rules/erb-no-silent-tag-in-attribute-name.test.ts
index c79738655..dbe71de41 100644
--- a/javascript/packages/linter/test/rules/erb-no-silent-tag-in-attribute-name.test.ts
+++ b/javascript/packages/linter/test/rules/erb-no-silent-tag-in-attribute-name.test.ts
@@ -1,16 +1,13 @@
 import dedent from "dedent"
 
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 
 import { ERBNoSilentTagInAttributeNameRule } from "../../src/rules/erb-no-silent-tag-in-attribute-name.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("ERBNoSilentTagInAttributeNameRule", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBNoSilentTagInAttributeNameRule)
 
+describe("ERBNoSilentTagInAttributeNameRule", () => {
   test("valid attributes with output ERB tags", () => {
     const html = dedent`
       <div data-<%= key %>-target="value"></div>
@@ -18,12 +15,7 @@ describe("ERBNoSilentTagInAttributeNameRule", () => {
       <input data-<%= user.id %>-field="text">
     `
 
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   test("valid static attribute names", () => {
@@ -32,12 +24,8 @@ describe("ERBNoSilentTagInAttributeNameRule", () => {
       <img src="/logo.png" alt="Logo">
       <input type="text" data-target="value">
     `
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   test("valid conditional attributes with ERB control flow", () => {
@@ -46,68 +34,45 @@ describe("ERBNoSilentTagInAttributeNameRule", () => {
       <span <% if user.admin? %>class="admin"<% end %>></span>
       <input <% unless disabled %>enabled="true"<% end %>>
     `
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   test("invalid attribute with silent ERB tag", () => {
     const html = dedent`
       <div data-<% key %>-target="value"></div>
     `
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("erb-no-silent-tag-in-attribute-name")
-    expect(lintResult.offenses[0].message).toBe("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
+
+    expectError("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
+    assertOffenses(html)
   })
 
   test("invalid attribute with trimming silent ERB tag", () => {
     const html = dedent`
       <div data-<%- key -%>-id="thing"></div>
     `
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("erb-no-silent-tag-in-attribute-name")
-    expect(lintResult.offenses[0].message).toBe("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%-`) do not output content and should not be used in attribute names.")
+
+    expectError("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%-`) do not output content and should not be used in attribute names.")
+    assertOffenses(html)
   })
 
   test("invalid attribute with comment ERB tag", () => {
     const html = dedent`
       <div data-<%# comment %>-target="value"></div>
     `
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("erb-no-silent-tag-in-attribute-name")
-    expect(lintResult.offenses[0].message).toBe("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%#`) do not output content and should not be used in attribute names.")
+
+    expectError("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%#`) do not output content and should not be used in attribute names.")
+    assertOffenses(html)
   })
 
   test("multiple invalid attributes in same element", () => {
     const html = dedent`
       <div data-<% key %>-target="value" id-<% another %>-suffix="test"></div>
     `
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
-    expect(lintResult.offenses[0].message).toBe("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
-    expect(lintResult.offenses[1].message).toBe("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
+
+    expectError("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
+    expectError("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
+    assertOffenses(html)
   })
 
   test("mixed valid and invalid ERB tags in different attributes", () => {
@@ -118,14 +83,9 @@ describe("ERBNoSilentTagInAttributeNameRule", () => {
         class="<%= valid_class %>"
       ></div>
     `
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("erb-no-silent-tag-in-attribute-name")
-    expect(lintResult.offenses[0].message).toBe("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
+
+    expectError("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
+    assertOffenses(html)
   })
 
   test("nested HTML elements with various ERB patterns", () => {
@@ -136,14 +96,9 @@ describe("ERBNoSilentTagInAttributeNameRule", () => {
         <select prefix-<%# comment %>-suffix="value"></select>
       </form>
     `
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
 
-    expect(lintResult.offenses[0].message).toBe("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
-    expect(lintResult.offenses[1].message).toBe("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%#`) do not output content and should not be used in attribute names.")
+    expectError("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
+    expectError("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%#`) do not output content and should not be used in attribute names.")
+    assertOffenses(html)
   })
 })
diff --git a/javascript/packages/linter/test/rules/erb-prefer-image-tag-helper.test.ts b/javascript/packages/linter/test/rules/erb-prefer-image-tag-helper.test.ts
index acdb5d7e2..abe7e70e1 100644
--- a/javascript/packages/linter/test/rules/erb-prefer-image-tag-helper.test.ts
+++ b/javascript/packages/linter/test/rules/erb-prefer-image-tag-helper.test.ts
@@ -1,328 +1,134 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
 import dedent from "dedent"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { ERBPreferImageTagHelperRule } from "../../src/rules/erb-prefer-image-tag-helper.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("erb-prefer-image-tag-helper", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectWarning, assertOffenses } = createLinterTest(ERBPreferImageTagHelperRule)
 
+describe("erb-prefer-image-tag-helper", () => {
   test("passes for regular img tags without ERB", () => {
-    const html = '<img src="/logo.png" alt="Company logo">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="/logo.png" alt="Company logo">')
   })
 
   test("passes for image_tag helper usage", () => {
-    const html = '<%= image_tag "logo.png", alt: "Company logo", class: "logo" %>'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<%= image_tag "logo.png", alt: "Company logo", class: "logo" %>')
   })
 
   test("fails for img with image_path helper", () => {
-    const html = '<img src="<%= image_path("logo.png") %>" alt="Logo">'
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag image_path("logo.png"), alt: "..." %>` instead.')
 
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag image_path("logo.png"), alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= image_path("logo.png") %>" alt="Logo">')
   })
 
   test("fails for img with asset_path helper", () => {
-    const html = '<img src="<%= asset_path("banner.jpg") %>" alt="Banner">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag asset_path("banner.jpg"), alt: "..." %>` instead.')
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag asset_path("banner.jpg"), alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= asset_path("banner.jpg") %>" alt="Banner">')
   })
 
   test("handles self-closing img tags with image_path", () => {
-    const html = '<img src="<%= image_path("logo.png") %>" alt="Logo" />'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag image_path("logo.png"), alt: "..." %>` instead.')
 
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag image_path("logo.png"), alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= image_path("logo.png") %>" alt="Logo" />')
   })
 
   test("ignores non-img tags with image_path", () => {
-    const html = '<div data-background="<%= image_path("bg.jpg") %>">Content</div>'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<div data-background="<%= image_path("bg.jpg") %>">Content</div>')
   })
 
   test("fails for img with Rails URL helpers", () => {
-    const html = '<img src="<%= Rails.application.routes.url_helpers.root_url %>/icon.png" alt="Logo">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{Rails.application.routes.url_helpers.root_url}/icon.png", alt: "..." %>` instead.')
 
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{Rails.application.routes.url_helpers.root_url}/icon.png", alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= Rails.application.routes.url_helpers.root_url %>/icon.png" alt="Logo">')
   })
 
   test("fails for img with root_url helper", () => {
-    const html = '<img src="<%= root_url %>/banner.jpg" alt="Banner">'
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{root_url}/banner.jpg", alt: "..." %>` instead.')
 
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{root_url}/banner.jpg", alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= root_url %>/banner.jpg" alt="Banner">')
   })
 
   test("fails for img with custom path helpers", () => {
-    const html = '<img src="<%= admin_path %>/icon.png" alt="Admin icon">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{admin_path}/icon.png", alt: "..." %>` instead.')
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{admin_path}/icon.png", alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= admin_path %>/icon.png" alt="Admin icon">')
   })
 
   test("fails for img with dynamic user avatar URL", () => {
-    const html = '<img src="<%= user.avatar.url %>" alt="User avatar">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag user.avatar.url, alt: "..." %>` instead.')
 
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag user.avatar.url, alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= user.avatar.url %>" alt="User avatar">')
   })
 
   test("fails for img with dynamic product image", () => {
-    const html = '<img src="<%= product.image %>" alt="Product image">'
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag product.image, alt: "..." %>` instead.')
 
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag product.image, alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= product.image %>" alt="Product image">')
   })
 
   test("fails for img with any ERB expression", () => {
-    const html = '<img src="<%= @company.logo_path %>" alt="Company logo">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag @company.logo_path, alt: "..." %>` instead.')
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag @company.logo_path, alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= @company.logo_path %>" alt="Company logo">')
   })
 
   test("fails for img with multiple ERB expressions", () => {
-    const html = '<img src="<%= base_url %><%= image_path("logo.png") %>" alt="Logo">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{base_url}#{image_path("logo.png")}", alt: "..." %>` instead.')
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{base_url}#{image_path("logo.png")}", alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= base_url %><%= image_path("logo.png") %>" alt="Logo">')
   })
 
   test("fails for img with ERB expression containing string literal", () => {
-    const html = '<img src="<%= root_path %><%= "icon.png" %>" alt="Icon">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{root_path}#{"icon.png"}", alt: "..." %>` instead.')
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{root_path}#{"icon.png"}", alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= root_path %><%= "icon.png" %>" alt="Icon">')
   })
 
   test("fails for img with ERB expression containing string literal followed by another ERB tag", () => {
-    const html = '<img src="<%= root_path %>/assets/<%= "icon.png" %>" alt="Icon">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{root_path}/assets/#{"icon.png"}", alt: "..." %>` instead.')
 
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{root_path}/assets/#{"icon.png"}", alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= root_path %>/assets/<%= "icon.png" %>" alt="Icon">')
   })
 
   test("shouldn't flag empty src attribute", () => {
-    const html = '<img src="" alt="Empty"><img src="    " alt="Empty">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="" alt="Empty"><img src="    " alt="Empty">')
   })
 
   test("passes for img tags with static paths only", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div>
         <img src="/images/logo.png" alt="Logo">
         <img src="https://example.com/image.jpg" alt="External image">
         <img src="logo.png" alt="Relative path">
       </div>
-    `
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("passes for data URIs with embedded ERB content", () => {
-    const html = '<img src="data:image/png;base64,<%= base64_encoded_logo_image %>" alt="Logo">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="data:image/png;base64,<%= base64_encoded_logo_image %>" alt="Logo">')
   })
 
   test("passes for mixed static and ERB content in src", () => {
-    const html = '<img src="https://example.com/<%= user.id %>/avatar.png" alt="User avatar">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="https://example.com/<%= user.id %>/avatar.png" alt="User avatar">')
   })
 
   test("passes for data URI with SVG and embedded ERB", () => {
-    const html = '<img src="data:image/svg+xml,<svg><text><%= user_name %></text></svg>" alt="SVG">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="data:image/svg+xml,<svg><text><%= user_name %></text></svg>" alt="SVG">')
   })
 
   test("passes for data URI with PNG", () => {
-    const html = '<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO2W2n8AAAAASUVORK5CYII=" alt="1x1 transparent image">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO2W2n8AAAAASUVORK5CYII=" alt="1x1 transparent image">')
   })
 
   test("passes for data URI with PNG with ERB", () => {
-    const html = '<img src="data:image/png;base64,<%= File.read("image.png").to_base64 %>" alt="1x1 transparent image">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="data:image/png;base64,<%= File.read("image.png").to_base64 %>" alt="1x1 transparent image">')
   })
 
   test("passes for img with only https URL", () => {
-    const html = '<img src="https://example.com/image.jpg" alt="External image">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="https://example.com/image.jpg" alt="External image">')
   })
 
   test("passes for img with only http URL", () => {
-    const html = '<img src="http://example.com/image.jpg" alt="External image">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="http://example.com/image.jpg" alt="External image">')
   })
 })
diff --git a/javascript/packages/linter/test/rules/erb-require-whitespace-inside-tags.test.ts b/javascript/packages/linter/test/rules/erb-require-whitespace-inside-tags.test.ts
index 60037d6a7..0b54e3297 100644
--- a/javascript/packages/linter/test/rules/erb-require-whitespace-inside-tags.test.ts
+++ b/javascript/packages/linter/test/rules/erb-require-whitespace-inside-tags.test.ts
@@ -1,15 +1,12 @@
-import { describe, it, beforeAll, expect } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
+import { describe, it } from "vitest"
 import dedent from "dedent";
 
-import { Linter } from "../../src/linter";
 import { ERBRequireWhitespaceRule } from "../../src/rules/erb-require-whitespace-inside-tags";
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("erb-require-whitespace-inside-tags", () => {
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBRequireWhitespaceRule)
 
-  beforeAll(async () => {
-    await Herb.load()
-  })
+describe("erb-require-whitespace-inside-tags", () => {
 
   it("should not report for correct whitespace in ERB tags", () => {
     const html = dedent`
@@ -17,12 +14,8 @@ describe("erb-require-whitespace-inside-tags", () => {
         Hello, admin.
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("should require a space after <% and before %> in ERB tags", () => {
@@ -30,13 +23,10 @@ describe("erb-require-whitespace-inside-tags", () => {
       <%if true%>
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
+    expectError("Add whitespace after `<%`.")
+    expectError("Add whitespace before `%>`.")
+    assertOffenses(html)
   })
 
   it("should require a space after <%= and before %> in ERB output tags", () => {
@@ -44,13 +34,10 @@ describe("erb-require-whitespace-inside-tags", () => {
       <%=user.name%>
       <%= user.name %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
+    expectError("Add whitespace after `<%=`.")
+    expectError("Add whitespace before `%>`.")
+    assertOffenses(html)
   })
 
   it("should report errors for only missing opening whitespace", () => {
@@ -59,12 +46,9 @@ describe("erb-require-whitespace-inside-tags", () => {
         Hello, user.
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toMatch(/Add whitespace after/i)
+    expectError("Add whitespace after `<%`.")
+    assertOffenses(html)
   })
 
   it("should report errors for only missing closing whitespace", () => {
@@ -73,12 +57,9 @@ describe("erb-require-whitespace-inside-tags", () => {
         Hello, admin.
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toMatch(/Add whitespace before/i)
+    expectError("Add whitespace before `%>`.")
+    assertOffenses(html)
   })
 
   it("should report multiple errors for multiple offenses", () => {
@@ -88,12 +69,14 @@ describe("erb-require-whitespace-inside-tags", () => {
         Hello, admin.
       <%end%>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(6)
-    expect(lintResult.offenses).toHaveLength(6)
+    expectError("Add whitespace after `<%=`.")
+    expectError("Add whitespace before `%>`.")
+    expectError("Add whitespace after `<%`.")
+    expectError("Add whitespace before `%>`.")
+    expectError("Add whitespace after `<%`.")
+    expectError("Add whitespace before `%>`.")
+    assertOffenses(html)
   })
 
   it("should not report for non-ERB content", () => {
@@ -101,12 +84,8 @@ describe("erb-require-whitespace-inside-tags", () => {
       <div>Hello</div>
       <p>World</p>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("should handle mixed correct and incorrect ERB tags", () => {
@@ -117,12 +96,12 @@ describe("erb-require-whitespace-inside-tags", () => {
         <h1>Hello, admin.</h1>
       <%end%>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.offenses).toHaveLength(4)
+    expectError("Add whitespace after `<%=`.")
+    expectError("Add whitespace before `%>`.")
+    expectError("Add whitespace after `<%`.")
+    expectError("Add whitespace before `%>`.")
+    assertOffenses(html)
   })
 
   it("should handle empty erb tags", () => {
@@ -134,12 +113,8 @@ describe("erb-require-whitespace-inside-tags", () => {
 
       %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("should require whitespace after # in ERB comment tags", () => {
@@ -148,54 +123,36 @@ describe("erb-require-whitespace-inside-tags", () => {
       <%#This is a comment without spaces%>
       <%# %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses).toHaveLength(2)
-
-    expect(lintResult.offenses[0].message).toBe("Add whitespace after `<%#`.")
-    expect(lintResult.offenses[1].message).toBe("Add whitespace before `%>`.")
+    expectError("Add whitespace after `<%#`.")
+    expectError("Add whitespace before `%>`.")
+    assertOffenses(html)
   })
 
   it("should not report ERB comment tags with equals signs", () => {
     const html = dedent`
       <%#= link_to "New watch list", new_watch_list_path, class: "btn btn-ghost" %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("should report ERB comment tags with equals sign and no space after", () => {
     const html = dedent`
       <%#=link_to "New watch list", new_watch_list_path, class: "btn btn-ghost"%>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses).toHaveLength(2)
 
-    expect(lintResult.offenses[0].message).toBe("Add whitespace after `<%#=`.")
-    expect(lintResult.offenses[1].message).toBe("Add whitespace before `%>`.")
+    expectError("Add whitespace after `<%#=`.")
+    expectError("Add whitespace before `%>`.")
+    assertOffenses(html)
   })
 
   it("should not report ERB comment tags with equals followed by space", () => {
     const html = dedent`
       <%# = link_to "New watch list", new_watch_list_path, class: "btn btn-ghost" %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("should handle multi-line ERB comment tags", () => {
@@ -211,11 +168,7 @@ describe("erb-require-whitespace-inside-tags", () => {
         class: "btn btn-ghost"
       %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 })
diff --git a/javascript/packages/linter/test/rules/erb-requires-trailing-newline.test.ts b/javascript/packages/linter/test/rules/erb-requires-trailing-newline.test.ts
index 5dc5c439d..63c149b01 100644
--- a/javascript/packages/linter/test/rules/erb-requires-trailing-newline.test.ts
+++ b/javascript/packages/linter/test/rules/erb-requires-trailing-newline.test.ts
@@ -1,16 +1,13 @@
 import dedent from "dedent"
 
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 
 import { ERBRequiresTrailingNewlineRule } from "../../src/rules/erb-requires-trailing-newline.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("ERBRequiresTrailingNewlineRule", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBRequiresTrailingNewlineRule)
 
+describe("ERBRequiresTrailingNewlineRule", () => {
   test("should not report errors for files ending with a trailing newline", () => {
     const html = dedent`
       <h1>
@@ -18,22 +15,13 @@ describe("ERBRequiresTrailingNewlineRule", () => {
       </h1>
     ` + '\n'
 
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   test("should not report errors for single newline files", () => {
     const html = "\n"
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   test("should not report errors for files with multiple lines ending with newline", () => {
@@ -42,12 +30,7 @@ describe("ERBRequiresTrailingNewlineRule", () => {
       <%= render partial: "footer" %>
     ` + '\n'
 
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   test("should report errors for files without trailing newline", () => {
@@ -57,26 +40,15 @@ describe("ERBRequiresTrailingNewlineRule", () => {
       </h1>
     `
 
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: "test.html.erb" })
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].rule).toBe("erb-requires-trailing-newline")
-    expect(lintResult.offenses[0].message).toBe("File must end with trailing newline")
+    expectError("File must end with trailing newline")
+    assertOffenses(html, { fileName: "test.html.erb" })
   })
 
   test("should report errors for single line files without newline", () => {
     const html = `<%= render partial: "header" %>`
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: "test.html.erb" })
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].rule).toBe("erb-requires-trailing-newline")
-    expect(lintResult.offenses[0].message).toBe("File must end with trailing newline")
+    expectError("File must end with trailing newline")
+    assertOffenses(html, { fileName: "test.html.erb" })
   })
 
   test("should handle files with mixed content without trailing newline", () => {
@@ -89,14 +61,8 @@ describe("ERBRequiresTrailingNewlineRule", () => {
       </div>
     `
 
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: "test.html.erb" })
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].rule).toBe("erb-requires-trailing-newline")
-    expect(lintResult.offenses[0].message).toBe("File must end with trailing newline")
+    expectError("File must end with trailing newline")
+    assertOffenses(html, { fileName: "test.html.erb" })
   })
 
   test("should handle files with mixed content with trailing newline", () => {
@@ -109,56 +75,33 @@ describe("ERBRequiresTrailingNewlineRule", () => {
       </div>
     ` + '\n'
 
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   test("should handle ERB-only template without trailing newline", () => {
     const html = `<%= hello world %>`
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: "test.html.erb" })
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].rule).toBe("erb-requires-trailing-newline")
-    expect(lintResult.offenses[0].message).toBe("File must end with trailing newline")
+    expectError("File must end with trailing newline")
+    assertOffenses(html, { fileName: "test.html.erb" })
   })
 
   test("should handle ERB-only template with trailing newline", () => {
     const html = `<%= hello world %>` + '\n'
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   test("should not flag empty file", () => {
     const html = ``
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   test("should flag empty file with whitespace", () => {
     const html = ` `
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: "test.html.erb" })
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].rule).toBe("erb-requires-trailing-newline")
-    expect(lintResult.offenses[0].message).toBe("File must end with trailing newline")
+    expectError("File must end with trailing newline")
+    assertOffenses(html, { fileName: "test.html.erb" })
   })
 
   test("should not flag snippets without trailing newline (fileName: null)", () => {
@@ -168,42 +111,25 @@ describe("ERBRequiresTrailingNewlineRule", () => {
       </h1>
     `
 
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: null })
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html, { fileName: null })
   })
 
   test("should not flag single line snippets without trailing newline (fileName: null)", () => {
     const html = `<%= render partial: "header" %>`
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: null })
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html, { fileName: null })
   })
 
   test("should not flag single line snippets without trailing newline (fileName: undefined)", () => {
     const html = `<%= render partial: "header" %>`
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: undefined })
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html, { fileName: undefined })
   })
 
   test("should not flag single line snippets without trailing newline with no context", () => {
     const html = `<%= render partial: "header" %>`
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   test("should flag files without trailing newline when fileName is provided", () => {
@@ -213,13 +139,7 @@ describe("ERBRequiresTrailingNewlineRule", () => {
       </h1>
     `
 
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: "template.html.erb" })
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].rule).toBe("erb-requires-trailing-newline")
-    expect(lintResult.offenses[0].message).toBe("File must end with trailing newline")
+    expectError("File must end with trailing newline")
+    assertOffenses(html, { fileName: "template.html.erb" })
   })
 })
diff --git a/javascript/packages/linter/test/rules/erb-right-trim.test.ts b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
index 3e97321a4..958d6ff51 100644
--- a/javascript/packages/linter/test/rules/erb-right-trim.test.ts
+++ b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
@@ -1,147 +1,119 @@
 import dedent from "dedent"
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
-
+import { describe, test } from "vitest"
 import { ERBRightTrimRule } from "../../src/rules/erb-right-trim.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("ERBRightTrimRule", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBRightTrimRule)
 
+describe("ERBRightTrimRule", () => {
   test("when the erb tag close with %>", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <h1>
         <%= title %>
       </h1>
-    `
-    const linter = new Linter(Herb, [ERBRightTrimRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
-  test("when the erb tag close with -%>", () => {
-    const html = dedent`
+  test("when output erb tag closes with -%>", () => {
+    expectNoOffenses(dedent`
       <h1>
         <%= title -%>
       </h1>
-    `
-    const linter = new Linter(Herb, [ERBRightTrimRule])
-    const lintResult = linter.lint(html)
+    `)
+  })
 
-    expect(lintResult.offenses).toHaveLength(0)
+  test("when non-output tag uses -%>", () => {
+    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
+    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
+    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
+    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
+    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
+
+    assertOffenses(dedent`
+      <% if condition -%>
+        <p>Content</p>
+      <% elsif other_condition -%>
+        <p>Content</p>
+      <% elsif yet_another_condition -%>
+        <p>Content</p>
+      <% else -%>
+        <p>Content</p>
+      <% end -%>
+    `)
   })
 
   test("when the erb tag close with =%>", () => {
-    const html = dedent`
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines")
+
+    assertOffenses(dedent`
       <h1>
         <%= title =%>
-    `
-    const linter = new Linter(Herb, [ERBRightTrimRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("erb-right-trim")
-    expect(lintResult.offenses[0].message).toBe("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines")
+    `)
   })
 
   test("when an if block uses =%>", () => {
-    const html = dedent`
+    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
+    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
+
+    assertOffenses(dedent`
       <% if condition =%>
         <p>Content</p>
-      <% end %>
-    `
-    const linter = new Linter(Herb, [ERBRightTrimRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("erb-right-trim")
-    expect(lintResult.offenses[0].message).toBe("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
+      <% end =%>
+    `)
   })
 
-  test("when an if-else block uses =%>", () => {
-    const html = dedent`
-      <% if condition =%>
-        <p>True branch</p>
-      <% else =%>
-        <p>False branch</p>
-      <% end %>
-    `
-    const linter = new Linter(Herb, [ERBRightTrimRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
-    expect(lintResult.offenses[0].code).toBe("erb-right-trim")
-
-    expect(lintResult.offenses[0].message).toBe("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
-    expect(lintResult.offenses[1].message).toBe("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
-  })
+  test("when a loop uses =%>", () => {
+    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
 
-  test("when each block uses =%>", () => {
-    const html = dedent`
+    assertOffenses(dedent`
       <% items.each do |item| =%>
         <li><%= item %></li>
       <% end %>
-    `
-    const linter = new Linter(Herb, [ERBRightTrimRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("erb-right-trim")
-    expect(lintResult.offenses[0].message).toBe("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
+    `)
   })
 
-  test("when non-output tag uses -%>", () => {
-    const html = dedent`
-      <% if condition -%>
-        <p>Content</p>
-      <% elsif other_condition -%>
-        <p>Content</p>
-      <% elsif yet_another_condition -%>
-        <p>Content</p>
-      <% else -%>
-        <p>Content</p>
-      <% end -%>
-    `
-    const linter = new Linter(Herb, [ERBRightTrimRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(5)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(5)
-
-    expect(lintResult.offenses[0].code).toBe("erb-right-trim")
-    expect(lintResult.offenses[0].message).toBe("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
-    expect(lintResult.offenses[1].message).toBe("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
-    expect(lintResult.offenses[2].message).toBe("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
-    expect(lintResult.offenses[3].message).toBe("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
-    expect(lintResult.offenses[4].message).toBe("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
+  test("when multiple lines use =%>", () => {
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines")
+
+    assertOffenses(dedent`
+      <%= first =%>
+      <%= second =%>
+      <%= third =%>
+    `)
   })
 
-  test("when multiple non-output tags use trimming", () => {
-    const html = dedent`
-      <% items.each do |item| -%>
-        <li><%= item %></li>
-      <% end -%>
-    `
-    const linter = new Linter(Herb, [ERBRightTrimRule])
-    const lintResult = linter.lint(html)
+  test("when mixed valid and invalid syntax is used", () => {
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines")
 
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
+    assertOffenses(dedent`
+      <%= valid %>
+      <%= invalid_trim =%>
+      <%= valid_trim -%>
+      <%= another_invalid =%>
+    `)
+  })
 
-    expect(lintResult.offenses[0].message).toBe("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
-    expect(lintResult.offenses[1].message).toBe("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
+  test("when silent ERB uses =%>", () => {
+    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
+
+    assertOffenses(dedent`
+      <% silent_operation =%>
+    `)
+  })
+
+  test("handles =%> in nested structures", () => {
+    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
+    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
+
+    assertOffenses(dedent`
+      <% if outer_condition =%>
+        <% if inner_condition =%>
+          <p>Nested content</p>
+        <% end %>
+      <% end %>
+    `)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-anchor-require-href-rule.test.ts b/javascript/packages/linter/test/rules/html-anchor-require-href-rule.test.ts
index 1ee7b3653..e26cd78f0 100644
--- a/javascript/packages/linter/test/rules/html-anchor-require-href-rule.test.ts
+++ b/javascript/packages/linter/test/rules/html-anchor-require-href-rule.test.ts
@@ -1,81 +1,38 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLAnchorRequireHrefRule } from "../../src/rules/html-anchor-require-href.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-anchor-require-href", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAnchorRequireHrefRule)
 
+describe("html-anchor-require-href", () => {
   test("passes for a with href attribute", () => {
-    const html = '<a href="http://example.com">My link</a>'
-    
-    const linter = new Linter(Herb, [HTMLAnchorRequireHrefRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<a href="http://example.com">My link</a>')
   })
 
   test("fails for a without href attribute", () => {
-    const html = "<a>My link</a>"
-    
-    const linter = new Linter(Herb, [HTMLAnchorRequireHrefRule])
-    const lintResult = linter.lint(html)
+    expectError("Add an `href` attribute to `<a>` to ensure it is focusable and accessible.")
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("html-anchor-require-href")
-    expect(lintResult.offenses[0].message).toBe(
-      "Add an `href` attribute to `<a>` to ensure it is focusable and accessible.",
-    )
-    expect(lintResult.offenses[0].severity).toBe("error")
+    assertOffenses("<a>My link</a>")
   })
 
   test("fails for multiple a tags without href", () => {
-    const html = "<a>My link</a><a>My other link</a>"
-    
-    const linter = new Linter(Herb, [HTMLAnchorRequireHrefRule])
-    const lintResult = linter.lint(html)
+    expectError("Add an `href` attribute to `<a>` to ensure it is focusable and accessible.")
+    expectError("Add an `href` attribute to `<a>` to ensure it is focusable and accessible.")
 
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
+    assertOffenses("<a>My link</a><a>My other link</a>")
   })
 
   test("passes for img with ERB alt attribute", () => {
-    const html = '<a href="<%= user.home_page_url %>">My Link</a>'
-    
-    const linter = new Linter(Herb, [HTMLAnchorRequireHrefRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<a href="<%= user.home_page_url %>">My Link</a>')
   })
 
   test("ignores non-a tags", () => {
-    const html = "<div>My div</div>"
-    
-    const linter = new Linter(Herb, [HTMLAnchorRequireHrefRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses("<div>My div</div>")
   })
 
   test("handles mixed case a tags", () => {
-    const html = "<A>My link</A>"
-    
-    const linter = new Linter(Herb, [HTMLAnchorRequireHrefRule])
-    const lintResult = linter.lint(html)
+    expectError("Add an `href` attribute to `<a>` to ensure it is focusable and accessible.")
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe(
-      "Add an `href` attribute to `<a>` to ensure it is focusable and accessible.",
-    )
+    assertOffenses("<A>My link</A>")
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-aria-attribute-must-be-valid.test.ts b/javascript/packages/linter/test/rules/html-aria-attribute-must-be-valid.test.ts
index a8c13cd34..3dc0666b3 100644
--- a/javascript/packages/linter/test/rules/html-aria-attribute-must-be-valid.test.ts
+++ b/javascript/packages/linter/test/rules/html-aria-attribute-must-be-valid.test.ts
@@ -1,76 +1,42 @@
 import dedent from "dedent"
-import { describe, it, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, it } from "vitest"
 import { HTMLAriaAttributeMustBeValid } from "../../src/rules/html-aria-attribute-must-be-valid.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-aria-attribute-must-be-valid", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAriaAttributeMustBeValid)
 
+describe("html-aria-attribute-must-be-valid", () => {
   it("allows a div with a valid aria attribute", () => {
     const html = '<div aria-label="Section Title"></div>'
 
-    const linter = new Linter(Herb, [HTMLAriaAttributeMustBeValid])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("ignores non-aria attributes", () => {
     const html = '<div class="foo"></div>'
 
-    const linter = new Linter(Herb, [HTMLAriaAttributeMustBeValid])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("fails when a div has an invalid aria attribute", () => {
     const html = '<div aria-bogus="foo"></div>'
 
-    const linter = new Linter(Herb, [HTMLAriaAttributeMustBeValid])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe(
-      'The attribute `aria-bogus` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.'
-    )
+    expectError('The attribute `aria-bogus` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.')
+    assertOffenses(html)
   })
 
   it("fails for mistyped aria name", () => {
     const html = '<input type="text" aria-lable="Search" />'
 
-    const linter = new Linter(Herb, [HTMLAriaAttributeMustBeValid])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe(
-      'The attribute `aria-lable` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.'
-    )
+    expectError('The attribute `aria-lable` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.')
+    assertOffenses(html)
   })
 
   it("fails for aria-", () => {
     const html = '<input type="text" aria-="Search" />'
 
-    const linter = new Linter(Herb, [HTMLAriaAttributeMustBeValid])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe(
-      'The attribute `aria-` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.'
-    )
+    expectError('The attribute `aria-` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.')
+    assertOffenses(html)
   })
 
   it("fails for aria-labelled-by", () => {
@@ -79,15 +45,8 @@ describe("html-aria-attribute-must-be-valid", () => {
       <span id="tac">I agree to the Terms and Conditions.</span>
     `
 
-    const linter = new Linter(Herb, [HTMLAriaAttributeMustBeValid])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe(
-      'The attribute `aria-labelled-by` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.'
-    )
+    expectError('The attribute `aria-labelled-by` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.')
+    assertOffenses(html)
   })
 
   it("fails for aria-described-by", () => {
@@ -96,14 +55,7 @@ describe("html-aria-attribute-must-be-valid", () => {
       <div id="pwd-help">Password must be at least 8 characters</div>
     `
 
-    const linter = new Linter(Herb, [HTMLAriaAttributeMustBeValid])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe(
-      'The attribute `aria-described-by` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.'
-    )
+    expectError('The attribute `aria-described-by` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.')
+    assertOffenses(html)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-aria-label-is-well-formatted.test.ts b/javascript/packages/linter/test/rules/html-aria-label-is-well-formatted.test.ts
index 0de4b1e8f..2fc2c147e 100644
--- a/javascript/packages/linter/test/rules/html-aria-label-is-well-formatted.test.ts
+++ b/javascript/packages/linter/test/rules/html-aria-label-is-well-formatted.test.ts
@@ -1,165 +1,78 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLAriaLabelIsWellFormattedRule } from "../../src/rules/html-aria-label-is-well-formatted.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-aria-label-is-well-formatted", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAriaLabelIsWellFormattedRule)
 
+describe("html-aria-label-is-well-formatted", () => {
   test("passes for properly formatted aria-label", () => {
-    const html = '<button aria-label="Close dialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<button aria-label="Close dialog">X</button>`)
   })
 
   test("passes for aria-label with proper sentence case", () => {
-    const html = '<input aria-label="Search products" type="search">'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<input aria-label="Search products" type="search">`)
   })
 
   test("fails for aria-label starting with lowercase", () => {
-    const html = '<button aria-label="close dialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-aria-label-is-well-formatted")
-    expect(lintResult.offenses[0].message).toBe("The `aria-label` attribute value text should be formatted like visual text. Use sentence case (capitalize the first letter).")
+    expectError("The `aria-label` attribute value text should be formatted like visual text. Use sentence case (capitalize the first letter).")
+    assertOffenses(`<button aria-label="close dialog">X</button>`)
   })
 
   test("fails for aria-label with line breaks", () => {
-    const html = '<button aria-label="Close\ndialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("The `aria-label` attribute value text should not contain line breaks. Use concise, single-line descriptions.")
+    expectError("The `aria-label` attribute value text should not contain line breaks. Use concise, single-line descriptions.")
+    assertOffenses(`<button aria-label="Close\ndialog">X</button>`)
   })
 
   test("fails for aria-label with carriage return", () => {
-    const html = '<button aria-label="Close\rdialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("The `aria-label` attribute value text should not contain line breaks. Use concise, single-line descriptions.")
+    expectError("The `aria-label` attribute value text should not contain line breaks. Use concise, single-line descriptions.")
+    assertOffenses(`<button aria-label="Close\rdialog">X</button>`)
   })
 
   test("fails for aria-label with HTML entity line breaks", () => {
-    const html = '<button aria-label="Close&#10;dialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("The `aria-label` attribute value text should not contain line breaks. Use concise, single-line descriptions.")
+    expectError("The `aria-label` attribute value text should not contain line breaks. Use concise, single-line descriptions.")
+    assertOffenses(`<button aria-label="Close&#10;dialog">X</button>`)
   })
 
   test("fails for snake_case aria-label", () => {
-    const html = '<button aria-label="close_dialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.")
+    expectError("The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.")
+    assertOffenses(`<button aria-label="close_dialog">X</button>`)
   })
 
   test("fails for kebab-case aria-label", () => {
-    const html = '<button aria-label="close-dialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.")
+    expectError("The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.")
+    assertOffenses(`<button aria-label="close-dialog">X</button>`)
   })
 
   test("fails for camelCase aria-label", () => {
-    const html = '<button aria-label="closeDialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.")
+    expectError("The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.")
+    assertOffenses(`<button aria-label="closeDialog">X</button>`)
   })
 
   test("passes for aria-label with spaces and proper formatting", () => {
-    const html = '<button aria-label="Close the dialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button aria-label="Close the dialog">X</button>`)
   })
 
   test("passes for aria-label with numbers", () => {
-    const html = '<button aria-label="Page 2 of 10">2</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button aria-label="Page 2 of 10">2</button>`)
   })
 
   test("ignores other attributes", () => {
-    const html = '<button aria-labelledby="close_dialog_label">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button aria-labelledby="close_dialog_label">X</button>`)
   })
 
   test("handles multiple elements", () => {
-    const html = `
+    expectError("The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.")
+    assertOffenses(`
       <button aria-label="Close dialog">X</button>
       <input aria-label="search_field" type="text">
-    `
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.")
+    `)
   })
 
   test("passes for aria-label with ERB content", () => {
-    const html = '<button aria-label="<%= action_label %>">Action</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button aria-label="<%= action_label %>">Action</button>`)
   })
 
   test("passes for mixed case attribute name", () => {
-    const html = '<button ARIA-LABEL="Close dialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button ARIA-LABEL="Close dialog">X</button>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-aria-level-must-be-valid.test.ts b/javascript/packages/linter/test/rules/html-aria-level-must-be-valid.test.ts
index 23edbf179..70ce675a7 100644
--- a/javascript/packages/linter/test/rules/html-aria-level-must-be-valid.test.ts
+++ b/javascript/packages/linter/test/rules/html-aria-level-must-be-valid.test.ts
@@ -1,257 +1,141 @@
 import dedent from "dedent"
-
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
-
+import { describe, test } from "vitest"
 import { HTMLAriaLevelMustBeValidRule } from "../../src/rules/html-aria-level-must-be-valid.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("HTMLAriaLevelMustBeValidRule", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAriaLevelMustBeValidRule)
 
+describe("HTMLAriaLevelMustBeValidRule", () => {
   test("allows valid aria-level values 1-6", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div role="heading" aria-level="1">Main</div>
       <div role="heading" aria-level="2">Section</div>
       <div role="heading" aria-level="3">Subsection</div>
       <div role="heading" aria-level="4">Sub-subsection</div>
       <div role="heading" aria-level="5">Deep heading</div>
       <div role="heading" aria-level="6">Footnote</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("allows elements without aria-level attribute", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div role="heading">No aria-level</div>
       <h1>Regular heading</h1>
       <div>Regular div</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("flags negative aria-level values", () => {
-    const html = dedent`
-      <div role="heading" aria-level="-1">Negative</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `-1`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("html-aria-level-must-be-valid")
-    expect(lintResult.offenses[0].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `-1`.',
-    )
+    assertOffenses(dedent`
+      <div role="heading" aria-level="-1">Negative</div>
+    `)
   })
 
   test("flags zero aria-level value", () => {
-    const html = dedent`
-      <div role="heading" aria-level="0">Main</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `0`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("html-aria-level-must-be-valid")
-    expect(lintResult.offenses[0].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `0`.',
-    )
+    assertOffenses(dedent`
+      <div role="heading" aria-level="0">Main</div>
+    `)
   })
 
   test("flags aria-level values greater than 6", () => {
-    const html = dedent`
-      <div role="heading" aria-level="7">Too deep</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `7`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("html-aria-level-must-be-valid")
-    expect(lintResult.offenses[0].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `7`.',
-    )
+    assertOffenses(dedent`
+      <div role="heading" aria-level="7">Too deep</div>
+    `)
   })
 
   test("flags non-numeric aria-level values", () => {
-    const html = dedent`
-      <div role="heading" aria-level="foo">Invalid</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `foo`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("html-aria-level-must-be-valid")
-    expect(lintResult.offenses[0].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `foo`.',
-    )
+    assertOffenses(dedent`
+      <div role="heading" aria-level="foo">Invalid</div>
+    `)
   })
 
   test("flags multiple invalid aria-level values", () => {
-    const html = dedent`
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `-1`.')
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `0`.')
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `7`.')
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `foo`.')
+
+    assertOffenses(dedent`
       <div role="heading" aria-level="-1">Negative</div>
       <div role="heading" aria-level="0">Zero</div>
       <div role="heading" aria-level="7">Too deep</div>
       <div role="heading" aria-level="foo">Invalid</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(4)
-
-    expect(lintResult.offenses[0].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `-1`.',
-    )
-    expect(lintResult.offenses[1].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `0`.',
-    )
-    expect(lintResult.offenses[2].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `7`.',
-    )
-    expect(lintResult.offenses[3].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `foo`.',
-    )
+    `)
   })
 
   test("handles floating point numbers", () => {
-    const html = dedent`
-      <div role="heading" aria-level="1.5">Float</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `1.5`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `1.5`.',
-    )
+    assertOffenses(dedent`
+      <div role="heading" aria-level="1.5">Float</div>
+    `)
   })
 
   test("flags whitespace in aria-level values", () => {
-    const html = dedent`
-      <div role="heading" aria-level=" 2 ">Whitespace</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got ` 2 `.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got ` 2 `.',
-    )
+    assertOffenses(dedent`
+      <div role="heading" aria-level=" 2 ">Whitespace</div>
+    `)
   })
 
   test("allows ERB expressions in aria-level values", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div aria-level="<%= @level %>">Dynamic level</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("allows mixed ERB expressions with no output in aria-level values", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div aria-level="1<% @level %>">Dynamic level</div>
       <div aria-level="<% @level %>2">Dynamic level</div>
       <div aria-level="<% @level %>3<% @level %>">Dynamic level</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("disallows mixed ERB expressions with no output in aria-level values", () => {
-    const html = dedent`
-      <div aria-level="-1<% @level %>">Dynamic level</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `-1`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe('The `aria-level` attribute must be an integer between 1 and 6, got `-1`.')
+    assertOffenses(dedent`
+      <div aria-level="-1<% @level %>">Dynamic level</div>
+    `)
   })
 
   test("disallows mixed ERB expressions with valid static value and dynamic ERB output", () => {
-    const html = dedent`
-      <div aria-level="1<%= @level %>">Dynamic level</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `1` and the ERB expression `<%= @level %>`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe('The `aria-level` attribute must be an integer between 1 and 6, got `1` and the ERB expression `<%= @level %>`.')
+    assertOffenses(dedent`
+      <div aria-level="1<%= @level %>">Dynamic level</div>
+    `)
   })
 
   test.todo("allows mixed ERB expressions in aria-level values if both branches are valid", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div aria-level="<% if valid? %>1<% else %>2<% end %>">Dynamic level</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test.todo("flags mixed ERB expressions in aria-level values if one branch is valid", () => {
-    const html = dedent`
-      <div aria-level="<% if valid? %>1<% else %>-1<% end %>">Dynamic level</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, at least one branch has an invlid value: `-1`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe('The `aria-level` attribute must be an integer between 1 and 6, at least one branch has an invlid value: `-1`.') // TODO: message can be tweaked
+    assertOffenses(dedent`
+      <div aria-level="<% if valid? %>1<% else %>-1<% end %>">Dynamic level</div>
+    `)
   })
 
   test("flags empty aria-level attribute", () => {
-    const html = dedent`
-      <div role="heading" aria-level="">Empty value</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got an empty value.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("html-aria-level-must-be-valid")
-    expect(lintResult.offenses[0].message).toBe('The `aria-level` attribute must be an integer between 1 and 6, got an empty value.')
+    assertOffenses(dedent`
+      <div role="heading" aria-level="">Empty value</div>
+    `)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-aria-role-heading-requires-level.test.ts b/javascript/packages/linter/test/rules/html-aria-role-heading-requires-level.test.ts
index 7229c6d36..7ad3c0c14 100644
--- a/javascript/packages/linter/test/rules/html-aria-role-heading-requires-level.test.ts
+++ b/javascript/packages/linter/test/rules/html-aria-role-heading-requires-level.test.ts
@@ -1,36 +1,17 @@
-import { describe, it, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, it } from "vitest"
 import { HTMLAriaRoleHeadingRequiresLevelRule } from "../../src/rules/html-aria-role-heading-requires-level.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-aria-role-heading-requires-level", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAriaRoleHeadingRequiresLevelRule)
 
+describe("html-aria-role-heading-requires-level", () => {
   it("allows a div with the proper heading", () => {
-    const html = '<div role="heading" aria-level="2">Section Title</div>'
-    
-    const linter = new Linter(Herb, [HTMLAriaRoleHeadingRequiresLevelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<div role="heading" aria-level="2">Section Title</div>')
   })
 
   it("fails when role=heading is used without aria-level", () => {
-    const html = '<div role="heading">Section Title</div>'
-
-    
-    const linter = new Linter(Herb, [HTMLAriaRoleHeadingRequiresLevelRule])
-    const lintResult = linter.lint(html)
+    expectError(`Element with \`role="heading"\` must have an \`aria-level\` attribute.`)
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe(
-      `Element with \`role="heading"\` must have an \`aria-level\` attribute.`
-    )
+    assertOffenses('<div role="heading">Section Title</div>')
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-aria-role-must-be-valid.test.ts b/javascript/packages/linter/test/rules/html-aria-role-must-be-valid.test.ts
index 79c6702cb..470ddad6d 100644
--- a/javascript/packages/linter/test/rules/html-aria-role-must-be-valid.test.ts
+++ b/javascript/packages/linter/test/rules/html-aria-role-must-be-valid.test.ts
@@ -1,55 +1,25 @@
-import { describe, it, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, it } from "vitest"
 import { HTMLAriaRoleMustBeValidRule } from "../../src/rules/html-aria-role-must-be-valid.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-aria-role-must-be-valid", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAriaRoleMustBeValidRule)
 
+describe("html-aria-role-must-be-valid", () => {
   it("should not show an error for valid attributes", () => {
-    const html = '<div role="button">Click Me</div>'
-    const linter = new Linter(Herb, [HTMLAriaRoleMustBeValidRule])
-
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<div role="button">Click Me</div>')
   })
 
   it("should show an error for an invalid attrbute", () => {
-    const html = `<div role="invalid-role"></div>`
-    const linter = new Linter(Herb, [HTMLAriaRoleMustBeValidRule])
+    expectError("The `role` attribute must be a valid ARIA role. Role `invalid-role` is not recognized.")
 
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("The `role` attribute must be a valid ARIA role. Role `invalid-role` is not recognized.")
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    assertOffenses(`<div role="invalid-role"></div>`)
   })
 
   it("should not show an error for ERB content", () => {
-    const html = `<div role="<%= role %>"></div>`
-    const linter = new Linter(Herb, [HTMLAriaRoleMustBeValidRule])
-
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div role="<%= role %>"></div>`)
   })
 
   it("should not show an error for static and ERB content", () => {
-    const html = `<div role="invalid-role-<%= role %>"></div>`
-    const linter = new Linter(Herb, [HTMLAriaRoleMustBeValidRule])
-
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div role="invalid-role-<%= role %>"></div>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-attribute-double-quotes.test.ts b/javascript/packages/linter/test/rules/html-attribute-double-quotes.test.ts
index 2c5d13ce5..4ef25566f 100644
--- a/javascript/packages/linter/test/rules/html-attribute-double-quotes.test.ts
+++ b/javascript/packages/linter/test/rules/html-attribute-double-quotes.test.ts
@@ -1,152 +1,67 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLAttributeDoubleQuotesRule } from "../../src/rules/html-attribute-double-quotes.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-attribute-double-quotes", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectWarning, assertOffenses } = createLinterTest(HTMLAttributeDoubleQuotesRule)
 
+describe("html-attribute-double-quotes", () => {
   test("passes for double quoted attributes", () => {
-    const html = '<input type="text" value="Username">'
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<input type="text" value="Username">`)
   })
 
   test("fails for single quoted attributes", () => {
-    const html = "<input type='text' value='Username'>"
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(2)
-    expect(lintResult.offenses).toHaveLength(2)
-
-    expect(lintResult.offenses[0].rule).toBe("html-attribute-double-quotes")
-    expect(lintResult.offenses[0].message).toBe('Attribute `type` uses single quotes. Prefer double quotes for HTML attribute values: `type="text"`.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
-
-    expect(lintResult.offenses[1].rule).toBe("html-attribute-double-quotes")
-    expect(lintResult.offenses[1].message).toBe('Attribute `value` uses single quotes. Prefer double quotes for HTML attribute values: `value="Username"`.')
-    expect(lintResult.offenses[1].severity).toBe("warning")
+    expectWarning('Attribute `type` uses single quotes. Prefer double quotes for HTML attribute values: `type="text"`.')
+    expectWarning('Attribute `value` uses single quotes. Prefer double quotes for HTML attribute values: `value="Username"`.')
+    assertOffenses(`<input type='text' value='Username'>`)
   })
 
   test("passes for mixed content with double quotes", () => {
-    const html = '<a href="/profile" title="User Profile" data-controller="dropdown">Profile</a>'
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<a href="/profile" title="User Profile" data-controller="dropdown">Profile</a>`)
   })
 
   test("fails for mixed content with single quotes", () => {
-    const html = "<a href='/profile' title='User Profile' data-controller='dropdown'>Profile</a>"
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(3)
-    expect(lintResult.offenses[0].message).toBe('Attribute `href` uses single quotes. Prefer double quotes for HTML attribute values: `href="/profile"`.')
-    expect(lintResult.offenses[1].message).toBe('Attribute `title` uses single quotes. Prefer double quotes for HTML attribute values: `title="User Profile"`.')
-    expect(lintResult.offenses[2].message).toBe('Attribute `data-controller` uses single quotes. Prefer double quotes for HTML attribute values: `data-controller="dropdown"`.')
+    expectWarning('Attribute `href` uses single quotes. Prefer double quotes for HTML attribute values: `href="/profile"`.')
+    expectWarning('Attribute `title` uses single quotes. Prefer double quotes for HTML attribute values: `title="User Profile"`.')
+    expectWarning('Attribute `data-controller` uses single quotes. Prefer double quotes for HTML attribute values: `data-controller="dropdown"`.')
+    assertOffenses(`<a href='/profile' title='User Profile' data-controller='dropdown'>Profile</a>`)
   })
 
   test("passes for unquoted attributes (handled by other rule)", () => {
-    const html = '<input type=text value=Username>'
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<input type=text value=Username>`)
   })
 
   test("passes for attributes without values", () => {
-    const html = '<input type="checkbox" checked disabled>'
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<input type="checkbox" checked disabled>`)
   })
 
   test("handles self-closing tags with single quotes", () => {
-    const html = "<img src='/image.jpg' alt='Description' />"
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(2)
-    expect(lintResult.offenses[0].message).toBe('Attribute `src` uses single quotes. Prefer double quotes for HTML attribute values: `src="/image.jpg"`.')
-    expect(lintResult.offenses[1].message).toBe('Attribute `alt` uses single quotes. Prefer double quotes for HTML attribute values: `alt="Description"`.')
+    expectWarning('Attribute `src` uses single quotes. Prefer double quotes for HTML attribute values: `src="/image.jpg"`.')
+    expectWarning('Attribute `alt` uses single quotes. Prefer double quotes for HTML attribute values: `alt="Description"`.')
+    assertOffenses(`<img src='/image.jpg' alt='Description' />`)
   })
 
   test("handles ERB with single quoted attributes", () => {
-    const html = "<div data-controller='<%= controller_name %>' data-action='click->toggle#action'>Content</div>"
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(2)
-    expect(lintResult.offenses[0].message).toBe('Attribute `data-controller` uses single quotes. Prefer double quotes for HTML attribute values: `data-controller="<%= controller_name %>"`.')
-    expect(lintResult.offenses[1].message).toBe('Attribute `data-action` uses single quotes. Prefer double quotes for HTML attribute values: `data-action="click->toggle#action"`.')
+    expectWarning('Attribute `data-controller` uses single quotes. Prefer double quotes for HTML attribute values: `data-controller="<%= controller_name %>"`.')
+    expectWarning('Attribute `data-action` uses single quotes. Prefer double quotes for HTML attribute values: `data-action="click->toggle#action"`.')
+    assertOffenses(`<div data-controller='<%= controller_name %>' data-action='click->toggle#action'>Content</div>`)
   })
 
   test("handles mixed ERB with single quoted attributes", () => {
-    const html = "<div class='static <%= class_list %> another-static'>Content</div>"
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Attribute `class` uses single quotes. Prefer double quotes for HTML attribute values: `class="static <%= class_list %> another-static"`.')
+    expectWarning('Attribute `class` uses single quotes. Prefer double quotes for HTML attribute values: `class="static <%= class_list %> another-static"`.')
+    assertOffenses(`<div class='static <%= class_list %> another-static'>Content</div>`)
   })
 
   test("allows single quotes when value contains double quotes", () => {
-    const html = `<div id='"hello"' class='Say "Hello" to the world'></div>`
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div id='"hello"' class='Say "Hello" to the world'></div>`)
   })
 
   test("allows single quotes when value contains double quotes and ERB content", () => {
-    const html = `<div class='Say "Hello" to <%= name %>'></div>`
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div class='Say "Hello" to <%= name %>'></div>`)
   })
 
   test("still fails for single quotes when value has no double quotes", () => {
-    const html = "<div id='hello' class='world'></div>"
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(2)
-    expect(lintResult.offenses[0].message).toBe('Attribute `id` uses single quotes. Prefer double quotes for HTML attribute values: `id="hello"`.')
-    expect(lintResult.offenses[1].message).toBe('Attribute `class` uses single quotes. Prefer double quotes for HTML attribute values: `class="world"`.')
+    expectWarning('Attribute `id` uses single quotes. Prefer double quotes for HTML attribute values: `id="hello"`.')
+    expectWarning('Attribute `class` uses single quotes. Prefer double quotes for HTML attribute values: `class="world"`.')
+    assertOffenses(`<div id='hello' class='world'></div>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-attribute-equals-spacing.test.ts b/javascript/packages/linter/test/rules/html-attribute-equals-spacing.test.ts
index 54283b74e..a04c77769 100644
--- a/javascript/packages/linter/test/rules/html-attribute-equals-spacing.test.ts
+++ b/javascript/packages/linter/test/rules/html-attribute-equals-spacing.test.ts
@@ -1,180 +1,96 @@
 import dedent from "dedent"
-
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
-
+import { describe, test } from "vitest"
 import { HTMLAttributeEqualsSpacingRule } from "../../src/rules/html-attribute-equals-spacing.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("HTMLAttributeEqualsSpacingRule", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAttributeEqualsSpacingRule)
 
+describe("HTMLAttributeEqualsSpacingRule", () => {
   test("valid attributes with no spacing around equals", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div class="container"></div>
       <img src="/logo.png" alt="Logo">
       <input type="text" value="<%= @value %>">
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("attribute with space before equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace before `=` in HTML attribute")
+    assertOffenses(dedent`
       <div class ="container"></div>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].code).toBe("html-attribute-equals-spacing")
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace before `=` in HTML attribute")
+    `)
   })
 
   test("attribute with space after equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace after `=` in HTML attribute")
+    assertOffenses(dedent`
       <img src= "/logo.png">
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].code).toBe("html-attribute-equals-spacing")
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace after `=` in HTML attribute")
+    `)
   })
 
   test("attribute with spaces both before and after equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace before `=` in HTML attribute")
+    expectError("Remove whitespace after `=` in HTML attribute")
+    assertOffenses(dedent`
       <input type = "text">
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
-
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace before `=` in HTML attribute")
-    expect(lintResult.offenses[1].message).toBe("Remove whitespace after `=` in HTML attribute")
+    `)
   })
 
   test("attribute value without quotes and spaces after equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace after `=` in HTML attribute")
+    assertOffenses(dedent`
       <div class=  data></div>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace after `=` in HTML attribute")
+    `)
   })
 
   test("attribute with static and dynamic ERB before equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace before `=` in HTML attribute")
+    assertOffenses(dedent`
       <div data-<%= key %>  ="value"></div>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace before `=` in HTML attribute")
+    `)
   })
 
   test("attribute with ERB before equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace before `=` in HTML attribute")
+    assertOffenses(dedent`
       <div <%= key %>  ="value"></div>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace before `=` in HTML attribute")
+    `)
   })
 
   test("attribute with static, dynamic ERB, static before equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace before `=` in HTML attribute")
+    assertOffenses(dedent`
       <div data-<%= key %>-user  ="value"></div>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace before `=` in HTML attribute")
+    `)
   })
 
   test("attribute value with ERB and spaces after equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace after `=` in HTML attribute")
+    assertOffenses(dedent`
       <div class=   <%= key %>></div>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace after `=` in HTML attribute")
+    `)
   })
 
   test("attribute with static, dynamic ERB, static after equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace after `=` in HTML attribute")
+    assertOffenses(dedent`
       <div class=  "data-<%= key %>-user  "></div>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace after `=` in HTML attribute")
+    `)
   })
 
   test("multiple attributes with various spacing issues", () => {
-    const html = dedent`
+    expectError("Remove whitespace before `=` in HTML attribute")
+    expectError("Remove whitespace after `=` in HTML attribute")
+    expectError("Remove whitespace before `=` in HTML attribute")
+    expectError("Remove whitespace after `=` in HTML attribute")
+    assertOffenses(dedent`
       <div class ="container" id= "main" data-value = "test"></div>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(4)
+    `)
   })
 
   test("attributes without values should not trigger rule", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <input disabled required>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-attribute-values-require-quotes.test.ts b/javascript/packages/linter/test/rules/html-attribute-values-require-quotes.test.ts
index 4a9d7de80..7d7a781b9 100644
--- a/javascript/packages/linter/test/rules/html-attribute-values-require-quotes.test.ts
+++ b/javascript/packages/linter/test/rules/html-attribute-values-require-quotes.test.ts
@@ -1,119 +1,53 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLAttributeValuesRequireQuotesRule } from "../../src/rules/html-attribute-values-require-quotes.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-attribute-values-require-quotes", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAttributeValuesRequireQuotesRule)
 
+describe("html-attribute-values-require-quotes", () => {
   test("passes for quoted attribute values", () => {
-    const html = '<div id="hello" class="container">'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div id="hello" class="container">`)
   })
 
   test("fails for unquoted attribute values", () => {
-    const html = '<div id=hello class=container>'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2) // Both id and class are unquoted
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
-
-    expect(lintResult.offenses[0].rule).toBe("html-attribute-values-require-quotes")
-    expect(lintResult.offenses[0].severity).toBe("error")
-
-    expect(lintResult.offenses[0].message).toBe('Attribute value should be quoted: `id="hello"`. Always wrap attribute values in quotes.')
-    expect(lintResult.offenses[1].message).toBe('Attribute value should be quoted: `class="container"`. Always wrap attribute values in quotes.')
+    expectError('Attribute value should be quoted: `id="hello"`. Always wrap attribute values in quotes.')
+    expectError('Attribute value should be quoted: `class="container"`. Always wrap attribute values in quotes.')
+    assertOffenses(`<div id=hello class=container>`)
   })
 
   test("passes for single-quoted values", () => {
-    const html = "<div id='hello' class='container'>"
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div id='hello' class='container'>`)
   })
 
   test("passes for boolean attributes without values", () => {
-    const html = '<input type="text" disabled>'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<input type="text" disabled>`)
   })
 
   test("handles mixed quoted and unquoted", () => {
-    const html = '<input type="text" name=username value="test">'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1) // Only name is unquoted
-    expect(lintResult.offenses[0].message).toBe('Attribute value should be quoted: `name="username"`. Always wrap attribute values in quotes.')
+    expectError('Attribute value should be quoted: `name="username"`. Always wrap attribute values in quotes.')
+    assertOffenses(`<input type="text" name=username value="test">`)
   })
 
   test("handles ERB in quoted attributes", () => {
-    const html = '<div class="<%= classes %>" data-id="<%= item.id %>">'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div class="<%= classes %>" data-id="<%= item.id %>">`)
   })
 
   test("handles ERB in unquoted attributes", () => {
-    const html = '<div class=<%= classes %>'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses[0].message).toBe('Attribute value should be quoted: `class="<%= classes %>"`. Always wrap attribute values in quotes.')
+    expectError('Attribute value should be quoted: `class="<%= classes %>"`. Always wrap attribute values in quotes.')
+    assertOffenses(`<div class=<%= classes %>`)
   })
 
   test("handles self-closing tags", () => {
-    const html = '<img src=photo.jpg alt="Photo">'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Attribute value should be quoted: `src="photo"`. Always wrap attribute values in quotes.')
+    expectError('Attribute value should be quoted: `src="photo"`. Always wrap attribute values in quotes.')
+    assertOffenses(`<img src=photo.jpg alt="Photo">`)
   })
 
   test("handles complex attribute values", () => {
-    const html = '<a href="/profile" title=User\\ Profile>'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Attribute value should be quoted: `title="User"`. Always wrap attribute values in quotes.')
+    expectError('Attribute value should be quoted: `title="User"`. Always wrap attribute values in quotes.')
+    assertOffenses(`<a href="/profile" title=User\\ Profile>`)
   })
 
   test("ignores closing tags", () => {
-    const html = '<div class="test"></div>'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div class="test"></div>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-avoid-both-disabled-and-aria-disabled.test.ts b/javascript/packages/linter/test/rules/html-avoid-both-disabled-and-aria-disabled.test.ts
index 0892eda84..dc6a08692 100644
--- a/javascript/packages/linter/test/rules/html-avoid-both-disabled-and-aria-disabled.test.ts
+++ b/javascript/packages/linter/test/rules/html-avoid-both-disabled-and-aria-disabled.test.ts
@@ -1,170 +1,87 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLAvoidBothDisabledAndAriaDisabledRule } from "../../src/rules/html-avoid-both-disabled-and-aria-disabled.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-avoid-both-disabled-and-aria-disabled", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAvoidBothDisabledAndAriaDisabledRule)
 
+describe("html-avoid-both-disabled-and-aria-disabled", () => {
   test("passes for button with only disabled", () => {
-    const html = '<button disabled>Click me</button>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<button disabled>Click me</button>`)
   })
 
   test("passes for button with only aria-disabled", () => {
-    const html = '<button aria-disabled="true">Click me</button>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button aria-disabled="true">Click me</button>`)
   })
 
   test("passes for button with neither attribute", () => {
-    const html = '<button>Click me</button>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button>Click me</button>`)
   })
 
   test("fails for button with both disabled and aria-disabled", () => {
-    const html = '<button disabled aria-disabled="true">Click me</button>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-avoid-both-disabled-and-aria-disabled")
-    expect(lintResult.offenses[0].message).toBe("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<button disabled aria-disabled="true">Click me</button>`)
   })
 
   test("fails for input with both attributes", () => {
-    const html = '<input type="text" disabled aria-disabled="false">'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-avoid-both-disabled-and-aria-disabled")
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<input type="text" disabled aria-disabled="false">`)
   })
 
   test("fails for textarea with both attributes", () => {
-    const html = '<textarea disabled aria-disabled="true"></textarea>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<textarea disabled aria-disabled="true"></textarea>`)
   })
 
   test("fails for select with both attributes", () => {
-    const html = '<select disabled aria-disabled="true"><option>Test</option></select>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<select disabled aria-disabled="true"><option>Test</option></select>`)
   })
 
   test("fails for fieldset with both attributes", () => {
-    const html = '<fieldset disabled aria-disabled="true"><input type="text"></fieldset>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<fieldset disabled aria-disabled="true"><input type="text"></fieldset>`)
   })
 
   test("fails for option with both attributes", () => {
-    const html = '<option disabled aria-disabled="true">Test option</option>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<option disabled aria-disabled="true">Test option</option>`)
   })
 
   test("fails for optgroup with both attributes", () => {
-    const html = '<optgroup disabled aria-disabled="true" label="Test"><option>Test</option></optgroup>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<optgroup disabled aria-disabled="true" label="Test"><option>Test</option></optgroup>`)
   })
 
   test("ignores elements that don't support disabled attribute", () => {
-    const html = '<div disabled aria-disabled="true">Not a form element</div>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div disabled aria-disabled="true">Not a form element</div>`)
   })
 
   test("ignores anchor elements with both attributes", () => {
-    const html = '<a href="#" disabled aria-disabled="true">Link</a>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<a href="#" disabled aria-disabled="true">Link</a>`)
   })
 
   test("handles mixed case attribute names", () => {
-    const html = '<button DISABLED ARIA-DISABLED="true">Mixed case</button>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<button DISABLED ARIA-DISABLED="true">Mixed case</button>`)
   })
 
   test("handles boolean disabled attribute", () => {
-    const html = '<button disabled="disabled" aria-disabled="true">Boolean disabled</button>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<button disabled="disabled" aria-disabled="true">Boolean disabled</button>`)
   })
 
   test("handles multiple form elements", () => {
-    const html = `
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`
       <button disabled>OK</button>
       <input type="text" disabled aria-disabled="true">
       <select aria-disabled="true"><option>Test</option></select>
       <textarea disabled aria-disabled="false"></textarea>
-    `
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses).toHaveLength(2)
+    `)
   })
 
   test("passes when attributes have ERB content", () => {
-    const html = '<button disabled="<%= is_disabled %>" aria-disabled="<%= aria_disabled %>">Dynamic</button>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button disabled="<%= is_disabled %>" aria-disabled="<%= aria_disabled %>">Dynamic</button>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-boolean-attributes-no-value.test.ts b/javascript/packages/linter/test/rules/html-boolean-attributes-no-value.test.ts
index f125acf33..bd771671a 100644
--- a/javascript/packages/linter/test/rules/html-boolean-attributes-no-value.test.ts
+++ b/javascript/packages/linter/test/rules/html-boolean-attributes-no-value.test.ts
@@ -1,144 +1,78 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLBooleanAttributesNoValueRule } from "../../src/rules/html-boolean-attributes-no-value.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-boolean-attributes-no-value", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLBooleanAttributesNoValueRule)
 
+describe("html-boolean-attributes-no-value", () => {
   test("passes for boolean attributes without values", () => {
-    const html = '<input type="checkbox" checked disabled>'
-
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<input type="checkbox" checked disabled>')
   })
 
   test("fails for boolean attributes with explicit values", () => {
-    const html = '<input type="checkbox" checked="checked" disabled="disabled">'
+    expectError('Boolean attribute `checked` should not have a value. Use `checked` instead of `checked="checked"`.')
+    expectError('Boolean attribute `disabled` should not have a value. Use `disabled` instead of `disabled="disabled"`.')
 
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
-
-    expect(lintResult.offenses[0].rule).toBe("html-boolean-attributes-no-value")
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `checked` should not have a value. Use `checked` instead of `checked="checked"`.')
-    expect(lintResult.offenses[0].severity).toBe("error")
-
-    expect(lintResult.offenses[1].rule).toBe("html-boolean-attributes-no-value")
-    expect(lintResult.offenses[1].message).toBe('Boolean attribute `disabled` should not have a value. Use `disabled` instead of `disabled="disabled"`.')
-    expect(lintResult.offenses[1].severity).toBe("error")
+    assertOffenses('<input type="checkbox" checked="checked" disabled="disabled">')
   })
 
   test("fails for boolean attributes with true/false values", () => {
-    const html = '<button disabled="true">Submit</button>'
+    expectError('Boolean attribute `disabled` should not have a value. Use `disabled` instead of `disabled="true"`.')
 
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `disabled` should not have a value. Use `disabled` instead of `disabled="true"`.')
+    assertOffenses('<button disabled="true">Submit</button>')
   })
 
   test("passes for non-boolean attributes with values", () => {
-    const html = '<input type="text" value="Username" name="user">'
-
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<input type="text" value="Username" name="user">')
   })
 
   test("handles multiple boolean attributes", () => {
-    const html = '<select multiple="multiple"><option selected="selected">Option 1</option></select>'
-
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
+    expectError('Boolean attribute `multiple` should not have a value. Use `multiple` instead of `multiple="multiple"`.')
+    expectError('Boolean attribute `selected` should not have a value. Use `selected` instead of `selected="selected"`.')
 
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `multiple` should not have a value. Use `multiple` instead of `multiple="multiple"`.')
-    expect(lintResult.offenses[1].message).toBe('Boolean attribute `selected` should not have a value. Use `selected` instead of `selected="selected"`.')
+    assertOffenses('<select multiple="multiple"><option selected="selected">Option 1</option></select>')
   })
 
   test("handles self-closing tags with boolean attributes", () => {
-    const html = '<input type="checkbox" checked="checked" required="true" />'
-
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
+    expectError('Boolean attribute `checked` should not have a value. Use `checked` instead of `checked="checked"`.')
+    expectError('Boolean attribute `required` should not have a value. Use `required` instead of `required="true"`.')
 
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `checked` should not have a value. Use `checked` instead of `checked="checked"`.')
-    expect(lintResult.offenses[1].message).toBe('Boolean attribute `required` should not have a value. Use `required` instead of `required="true"`.')
+    assertOffenses('<input type="checkbox" checked="checked" required="true" />')
   })
 
   test("handles case insensitive boolean attributes", () => {
-    const html = '<input CHECKED="CHECKED" DISABLED="disabled">'
+    expectError('Boolean attribute `CHECKED` should not have a value. Use `checked` instead of `CHECKED="CHECKED"`.')
+    expectError('Boolean attribute `DISABLED` should not have a value. Use `disabled` instead of `DISABLED="disabled"`.')
 
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `CHECKED` should not have a value. Use `checked` instead of `CHECKED="CHECKED"`.')
-    expect(lintResult.offenses[1].message).toBe('Boolean attribute `DISABLED` should not have a value. Use `disabled` instead of `DISABLED="disabled"`.')
+    assertOffenses('<input CHECKED="CHECKED" DISABLED="disabled">')
   })
 
   test("passes for video controls", () => {
-    const html = '<video controls>'
-
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<video controls>')
   })
 
   test("fails for video controls with value", () => {
-    const html = '<video controls="controls" autoplay="autoplay">'
-
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
+    expectError('Boolean attribute `controls` should not have a value. Use `controls` instead of `controls="controls"`.')
+    expectError('Boolean attribute `autoplay` should not have a value. Use `autoplay` instead of `autoplay="autoplay"`.')
 
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `controls` should not have a value. Use `controls` instead of `controls="controls"`.')
-    expect(lintResult.offenses[1].message).toBe('Boolean attribute `autoplay` should not have a value. Use `autoplay` instead of `autoplay="autoplay"`.')
+    assertOffenses('<video controls="controls" autoplay="autoplay">')
   })
 
   test("fails for boolean attribute with different value", () => {
-    const html = '<video controls="something-else">'
-
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
+    expectError('Boolean attribute `controls` should not have a value. Use `controls` instead of `controls="something-else"`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `controls` should not have a value. Use `controls` instead of `controls="something-else"`.')
+    assertOffenses('<video controls="something-else">')
   })
 
   test("handles mixed boolean and regular attributes", () => {
-    const html = '<form novalidate="novalidate" action="/submit" method="post">'
+    expectError('Boolean attribute `novalidate` should not have a value. Use `novalidate` instead of `novalidate="novalidate"`.')
 
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `novalidate` should not have a value. Use `novalidate` instead of `novalidate="novalidate"`.')
+    assertOffenses('<form novalidate="novalidate" action="/submit" method="post">')
   })
 
   test("fails for boolean attributes with ERB output value", () => {
-    const html = '<button disabled="<%= disabled? %>">Submit</button>'
-
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
+    expectError('Boolean attribute `disabled` should not have a value. Use `disabled` instead of `disabled="<%= disabled? %>"`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `disabled` should not have a value. Use `disabled` instead of `disabled="<%= disabled? %>"`.')
+    assertOffenses('<button disabled="<%= disabled? %>">Submit</button>')
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-iframe-has-title.test.ts b/javascript/packages/linter/test/rules/html-iframe-has-title.test.ts
index bad9a8462..0b2bfa3cc 100644
--- a/javascript/packages/linter/test/rules/html-iframe-has-title.test.ts
+++ b/javascript/packages/linter/test/rules/html-iframe-has-title.test.ts
@@ -1,168 +1,78 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLIframeHasTitleRule } from "../../src/rules/html-iframe-has-title.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-iframe-has-title", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLIframeHasTitleRule)
 
+describe("html-iframe-has-title", () => {
   test("passes for iframe with title attribute", () => {
-    const html = '<iframe src="https://example.com" title="Example website content"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<iframe src="https://example.com" title="Example website content"></iframe>`)
   })
 
   test("fails for iframe with empty title attribute", () => {
-    const html = '<iframe src="https://example.com" title=""></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses[0].message).toBe("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    expectError("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    assertOffenses(`<iframe src="https://example.com" title=""></iframe>`)
   })
 
   test("fails for iframe with empty title attribute", () => {
-    const html = '<iframe src="https://example.com" title=" "></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses[0].message).toBe("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    expectError("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    assertOffenses(`<iframe src="https://example.com" title=" "></iframe>`)
   })
 
   test("fails for iframe without title attribute", () => {
-    const html = '<iframe src="https://example.com"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-iframe-has-title")
-    expect(lintResult.offenses[0].message).toBe("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    expectError("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    assertOffenses(`<iframe src="https://example.com"></iframe>`)
   })
 
   test("fails for self-closing iframe without title", () => {
-    const html = '<iframe src="https://example.com" />'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-iframe-has-title")
+    expectError("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    assertOffenses(`<iframe src="https://example.com" />`)
   })
 
   test("passes for iframe with descriptive title", () => {
-    const html = '<iframe src="https://youtube.com/embed/123" title="Product demonstration video"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<iframe src="https://youtube.com/embed/123" title="Product demonstration video"></iframe>`)
   })
 
   test("ignores non-iframe elements", () => {
-    const html = '<div src="https://example.com">Not an iframe</div>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div src="https://example.com">Not an iframe</div>`)
   })
 
   test("ignores frame elements (different tag)", () => {
-    const html = '<frame src="https://example.com">'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<frame src="https://example.com">`)
   })
 
   test("handles mixed case iframe tag", () => {
-    const html = '<IFRAME src="https://example.com"></IFRAME>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-iframe-has-title")
+    expectError("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    assertOffenses(`<IFRAME src="https://example.com"></IFRAME>`)
   })
 
   test("passes for mixed case title attribute", () => {
-    const html = '<iframe src="https://example.com" TITLE="Example content"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<iframe src="https://example.com" TITLE="Example content"></iframe>`)
   })
 
   test("handles multiple iframe elements", () => {
-    const html = `
+    expectError("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    assertOffenses(`
       <iframe src="https://example1.com" title="First iframe"></iframe>
       <iframe src="https://example2.com"></iframe>
       <iframe src="https://example3.com" title="Third iframe"></iframe>
-    `
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
+    `)
   })
 
   test("passes for iframe with ERB title content", () => {
-    const html = '<iframe src="https://example.com" title="<%= content_title %>"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<iframe src="https://example.com" title="<%= content_title %>"></iframe>`)
   })
 
   test("passes for iframe with multiple attributes", () => {
-    const html = '<iframe src="https://example.com" width="600" height="400" frameborder="0" title="Embedded content"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<iframe src="https://example.com" width="600" height="400" frameborder="0" title="Embedded content"></iframe>`)
   })
 
   test("fails for iframe with other attributes but no title", () => {
-    const html = '<iframe src="https://example.com" width="600" height="400" frameborder="0"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-iframe-has-title")
+    expectError("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    assertOffenses(`<iframe src="https://example.com" width="600" height="400" frameborder="0"></iframe>`)
   })
 
   test("passes for iframe with aria-hidden='true'", () => {
-    const html = '<iframe aria-hidden="true"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<iframe aria-hidden="true"></iframe>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-img-require-alt.test.ts b/javascript/packages/linter/test/rules/html-img-require-alt.test.ts
index 42c3bd0ad..766f46751 100644
--- a/javascript/packages/linter/test/rules/html-img-require-alt.test.ts
+++ b/javascript/packages/linter/test/rules/html-img-require-alt.test.ts
@@ -1,108 +1,48 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLImgRequireAltRule } from "../../src/rules/html-img-require-alt.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-img-require-alt", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLImgRequireAltRule)
 
+describe("html-img-require-alt", () => {
   test("passes for img with alt attribute", () => {
-    const html = '<img src="/logo.png" alt="Company logo">'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="/logo.png" alt="Company logo">')
   })
 
   test("passes for img with empty alt attribute", () => {
-    const html = '<img src="/divider.png" alt="">'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="/divider.png" alt="">')
   })
 
   test("fails for img without alt attribute", () => {
-    const html = '<img src="/logo.png">'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("html-img-require-alt")
-    expect(lintResult.offenses[0].message).toBe('Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.')
-    expect(lintResult.offenses[0].severity).toBe("error")
+    expectError('Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.')
+    assertOffenses('<img src="/logo.png">')
   })
 
   test("fails for multiple img tags without alt", () => {
-    const html = '<img src="/logo.png"><img src="/banner.jpg">'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
+    expectError('Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.')
+    expectError('Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.')
+    assertOffenses('<img src="/logo.png"><img src="/banner.jpg">')
   })
 
   test("handles mixed case img tags", () => {
-    const html = '<IMG src="/logo.png">'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.')
+    expectError('Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.')
+    assertOffenses('<IMG src="/logo.png">')
   })
 
   test("passes for img with ERB alt attribute", () => {
-    const html = '<img src="/avatar.jpg" alt="<%= user.name %>\'s profile picture">'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<img src="/avatar.jpg" alt="<%= user.name %>\'s profile picture">')
   })
 
   test("ignores non-img tags", () => {
-    const html = '<div src="/something.png"></div>'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<div src="/something.png"></div>')
   })
 
   test("handles self-closing img tags", () => {
-    const html = '<img src="/logo.png" />'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.')
+    expectError('Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.')
+    assertOffenses('<img src="/logo.png" />')
   })
 
   test("passes for case-insensitive alt attribute", () => {
-    const html = '<img src="/logo.png" ALT="Logo">'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<img src="/logo.png" ALT="Logo">')
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-navigation-has-label.test.ts b/javascript/packages/linter/test/rules/html-navigation-has-label.test.ts
index b6744a93a..9a9c18dd9 100644
--- a/javascript/packages/linter/test/rules/html-navigation-has-label.test.ts
+++ b/javascript/packages/linter/test/rules/html-navigation-has-label.test.ts
@@ -1,167 +1,74 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNavigationHasLabelRule } from "../../src/rules/html-navigation-has-label.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-navigation-has-label", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNavigationHasLabelRule)
 
+describe("html-navigation-has-label", () => {
   test("passes for nav with aria-label", () => {
-    const html = '<nav aria-label="Main navigation"><a href="/">Home</a></nav>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<nav aria-label="Main navigation"><a href="/">Home</a></nav>`)
   })
 
   test("passes for nav with aria-labelledby", () => {
-    const html = '<nav aria-labelledby="nav-heading"><h2 id="nav-heading">Site Navigation</h2><a href="/">Home</a></nav>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<nav aria-labelledby="nav-heading"><h2 id="nav-heading">Site Navigation</h2><a href="/">Home</a></nav>`)
   })
 
   test("passes for nav with both aria-label and aria-labelledby", () => {
-    const html = '<nav aria-label="Primary" aria-labelledby="nav-heading"><h2 id="nav-heading">Navigation</h2><a href="/">Home</a></nav>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<nav aria-label="Primary" aria-labelledby="nav-heading"><h2 id="nav-heading">Navigation</h2><a href="/">Home</a></nav>`)
   })
 
   test("fails for nav without aria-label or aria-labelledby", () => {
-    const html = '<nav><a href="/">Home</a><a href="/about">About</a></nav>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-navigation-has-label")
-    expect(lintResult.offenses[0].message).toBe("The navigation landmark should have a unique accessible name via `aria-label` or `aria-labelledby`. Remember that the name does not need to include \"navigation\" or \"nav\" since it will already be announced.")
+    expectError("The navigation landmark should have a unique accessible name via `aria-label` or `aria-labelledby`. Remember that the name does not need to include \"navigation\" or \"nav\" since it will already be announced.")
+    assertOffenses(`<nav><a href="/">Home</a><a href="/about">About</a></nav>`)
   })
 
   test("passes for element with role=navigation and aria-label", () => {
-    const html = '<div role="navigation" aria-label="Breadcrumb navigation"><a href="/">Home</a></div>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div role="navigation" aria-label="Breadcrumb navigation"><a href="/">Home</a></div>`)
   })
 
   test("passes for element with role=navigation and aria-labelledby", () => {
-    const html = '<div role="navigation" aria-labelledby="breadcrumb-label"><span id="breadcrumb-label">Breadcrumb</span><a href="/">Home</a></div>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div role="navigation" aria-labelledby="breadcrumb-label"><span id="breadcrumb-label">Breadcrumb</span><a href="/">Home</a></div>`)
   })
 
   test("fails for element with role=navigation without labeling", () => {
-    const html = '<div role="navigation"><a href="/">Home</a><a href="/about">About</a></div>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-navigation-has-label")
-    expect(lintResult.offenses[0].message).toBe("The navigation landmark should have a unique accessible name via `aria-label` or `aria-labelledby`. Remember that the name does not need to include \"navigation\" or \"nav\" since it will already be announced. Additionally, you can safely drop the `role=\"navigation\"` and replace it with the native HTML `<nav>` element.")
+    expectError("The navigation landmark should have a unique accessible name via `aria-label` or `aria-labelledby`. Remember that the name does not need to include \"navigation\" or \"nav\" since it will already be announced. Additionally, you can safely drop the `role=\"navigation\"` and replace it with the native HTML `<nav>` element.")
+    assertOffenses(`<div role="navigation"><a href="/">Home</a><a href="/about">About</a></div>`)
   })
 
   test("ignores elements without navigation role", () => {
-    const html = '<div><a href="/">Home</a><a href="/about">About</a></div>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div><a href="/">Home</a><a href="/about">About</a></div>`)
   })
 
   test("ignores elements with other roles", () => {
-    const html = '<div role="banner"><a href="/">Home</a></div>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div role="banner"><a href="/">Home</a></div>`)
   })
 
   test("handles mixed case attributes", () => {
-    const html = '<nav ARIA-LABEL="Main navigation"><a href="/">Home</a></nav>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<nav ARIA-LABEL="Main navigation"><a href="/">Home</a></nav>`)
   })
 
   test("handles mixed case nav tag", () => {
-    const html = '<NAV aria-label="Main navigation"><a href="/">Home</a></NAV>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<NAV aria-label="Main navigation"><a href="/">Home</a></NAV>`)
   })
 
   test("handles multiple navigation elements", () => {
-    const html = `
+    expectError("The navigation landmark should have a unique accessible name via `aria-label` or `aria-labelledby`. Remember that the name does not need to include \"navigation\" or \"nav\" since it will already be announced.")
+    assertOffenses(`
       <nav aria-label="Primary navigation"><a href="/">Home</a></nav>
       <nav><a href="/sitemap">Sitemap</a></nav>
       <div role="navigation" aria-label="Breadcrumb"><a href="/">Home</a></div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
+    `)
   })
 
   test("passes for navigation with ERB content in labels", () => {
-    const html = '<nav aria-label="<%= navigation_label %>"><a href="/">Home</a></nav>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<nav aria-label="<%= navigation_label %>"><a href="/">Home</a></nav>`)
   })
 
   test("passes for empty aria-label (technically has the attribute)", () => {
-    const html = '<nav aria-label=""><a href="/">Home</a></nav>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<nav aria-label=""><a href="/">Home</a></nav>`)
   })
 
   test("passes for empty aria-labelledby (technically has the attribute)", () => {
-    const html = '<nav aria-labelledby=""><a href="/">Home</a></nav>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<nav aria-labelledby=""><a href="/">Home</a></nav>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-aria-hidden-on-focusable.test.ts b/javascript/packages/linter/test/rules/html-no-aria-hidden-on-focusable.test.ts
index 0bfdcbb6c..1a53fd86d 100644
--- a/javascript/packages/linter/test/rules/html-no-aria-hidden-on-focusable.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-aria-hidden-on-focusable.test.ts
@@ -1,209 +1,104 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNoAriaHiddenOnFocusableRule } from "../../src/rules/html-no-aria-hidden-on-focusable.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-aria-hidden-on-focusable", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoAriaHiddenOnFocusableRule)
 
+describe("html-no-aria-hidden-on-focusable", () => {
   test("passes for focusable element without aria-hidden", () => {
-    const html = '<button>Click me</button>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<button>Click me</button>`)
   })
 
   test("passes for focusable element with aria-hidden='false'", () => {
-    const html = '<button aria-hidden="false">Click me</button>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button aria-hidden="false">Click me</button>`)
   })
 
   test("passes for non-focusable element with aria-hidden='true'", () => {
-    const html = '<div aria-hidden="true">Hidden content</div>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div aria-hidden="true">Hidden content</div>`)
   })
 
   test("fails for button with aria-hidden='true'", () => {
-    const html = '<button aria-hidden="true">Hidden button</button>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-no-aria-hidden-on-focusable")
-    expect(lintResult.offenses[0].message).toBe("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<button aria-hidden="true">Hidden button</button>`)
   })
 
   test("fails for input with aria-hidden='true'", () => {
-    const html = '<input type="text" aria-hidden="true">'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-no-aria-hidden-on-focusable")
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<input type="text" aria-hidden="true">`)
   })
 
   test("fails for select with aria-hidden='true'", () => {
-    const html = '<select aria-hidden="true"><option>Test</option></select>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<select aria-hidden="true"><option>Test</option></select>`)
   })
 
   test("fails for textarea with aria-hidden='true'", () => {
-    const html = '<textarea aria-hidden="true"></textarea>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<textarea aria-hidden="true"></textarea>`)
   })
 
   test("fails for anchor with href and aria-hidden='true'", () => {
-    const html = '<a href="/" aria-hidden="true">Link</a>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<a href="/" aria-hidden="true">Link</a>`)
   })
 
   test("fails for summary with aria-hidden='true'", () => {
-    const html = '<details><summary aria-hidden="true">Details</summary><p>Content</p></details>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<details><summary aria-hidden="true">Details</summary><p>Content</p></details>`)
   })
 
   test("passes for anchor without href and aria-hidden='true'", () => {
-    const html = '<a aria-hidden="true">Not a link</a>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<a aria-hidden="true">Not a link</a>`)
   })
 
   test("fails for div with tabindex='0' and aria-hidden='true'", () => {
-    const html = '<div tabindex="0" aria-hidden="true">Focusable div</div>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<div tabindex="0" aria-hidden="true">Focusable div</div>`)
   })
 
   test("passes for div with tabindex='-1' and aria-hidden='true'", () => {
-    const html = '<div tabindex="-1" aria-hidden="true">Programmatically focusable div</div>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div tabindex="-1" aria-hidden="true">Programmatically focusable div</div>`)
   })
 
   test("fails for span with tabindex='1' and aria-hidden='true'", () => {
-    const html = '<span tabindex="1" aria-hidden="true">Focusable span</span>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<span tabindex="1" aria-hidden="true">Focusable span</span>`)
   })
 
   test("passes for button with tabindex='-1' and aria-hidden='true'", () => {
-    const html = '<button tabindex="-1" aria-hidden="true">Button removed from tab order</button>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button tabindex="-1" aria-hidden="true">Button removed from tab order</button>`)
   })
 
   test("handles mixed case attributes", () => {
-    const html = '<button ARIA-HIDDEN="true">Hidden button</button>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<button ARIA-HIDDEN="true">Hidden button</button>`)
   })
 
   test("handles mixed case element names", () => {
-    const html = '<BUTTON aria-hidden="true">Hidden button</BUTTON>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<BUTTON aria-hidden="true">Hidden button</BUTTON>`)
   })
 
   test("handles multiple elements", () => {
-    const html = `
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`
       <button aria-hidden="true">Bad button</button>
       <div aria-hidden="true">OK div</div>
       <input type="text" aria-hidden="true">
       <div tabindex="0" aria-hidden="false">OK focusable div</div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses).toHaveLength(2)
+    `)
   })
 
   test("ignores aria-hidden with non-boolean values", () => {
-    const html = '<button aria-hidden="maybe">Button</button>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button aria-hidden="maybe">Button</button>`)
   })
 
   test("passes for elements with ERB content in aria-hidden", () => {
-    const html = '<button aria-hidden="<%= hidden_state %>">Dynamic button</button>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button aria-hidden="<%= hidden_state %>">Dynamic button</button>`)
   })
 
   test("passes for elements with ERB content in tabindex", () => {
-    const html = '<div tabindex="<%= tab_index %>" aria-hidden="true">Dynamic tabindex</div>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div tabindex="<%= tab_index %>" aria-hidden="true">Dynamic tabindex</div>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-block-inside-inline.test.ts b/javascript/packages/linter/test/rules/html-no-block-inside-inline.test.ts
index adc2533fc..5b3597303 100644
--- a/javascript/packages/linter/test/rules/html-no-block-inside-inline.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-block-inside-inline.test.ts
@@ -1,270 +1,130 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNoBlockInsideInlineRule } from "../../src/rules/html-no-block-inside-inline.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-block-inside-inline", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoBlockInsideInlineRule)
 
+describe("html-no-block-inside-inline", () => {
   test("passes for inline elements containing other inline elements", () => {
-    const html = '<span>Hello <strong>World</strong></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<span>Hello <strong>World</strong></span>`)
   })
 
   test("passes for block elements containing block elements", () => {
-    const html = '<div><p>Paragraph inside div (valid)</p></div>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div><p>Paragraph inside div (valid)</p></div>`)
   })
 
   test("fails for div inside span", () => {
-    const html = '<span><div>Invalid block inside span</div></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-block-inside-inline")
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<div>` cannot be placed inside inline element `<span>`.')
-    expect(lintResult.offenses[0].severity).toBe("error")
+    expectError('Block-level element `<div>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><div>Invalid block inside span</div></span>`)
   })
 
   test("fails for paragraph inside span", () => {
-    const html = '<span><p>Paragraph inside span (invalid)</p></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<p>` cannot be placed inside inline element `<span>`.')
+    expectError('Block-level element `<p>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><p>Paragraph inside span (invalid)</p></span>`)
   })
 
   test("fails for multiple block elements inside inline", () => {
-    const html = '<span><div>First</div><p>Second</p></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
+    expectError('Block-level element `<div>` cannot be placed inside inline element `<span>`.')
+    expectError('Block-level element `<p>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><div>First</div><p>Second</p></span>`)
   })
 
   test("fails for block inside anchor tag", () => {
-    const html = '<a href="#"><div>Link with div</div></a>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<div>` cannot be placed inside inline element `<a>`.')
+    expectError('Block-level element `<div>` cannot be placed inside inline element `<a>`.')
+    assertOffenses(`<a href="#"><div>Link with div</div></a>`)
   })
 
   test("fails for heading inside strong", () => {
-    const html = '<strong><h1>Heading in strong</h1></strong>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<h1>` cannot be placed inside inline element `<strong>`.')
+    expectError('Block-level element `<h1>` cannot be placed inside inline element `<strong>`.')
+    assertOffenses(`<strong><h1>Heading in strong</h1></strong>`)
   })
 
   test("fails for section inside em", () => {
-    const html = '<em><section>Section in em</section></em>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<section>` cannot be placed inside inline element `<em>`.')
+    expectError('Block-level element `<section>` cannot be placed inside inline element `<em>`.')
+    assertOffenses(`<em><section>Section in em</section></em>`)
   })
 
   test("passes for nested inline elements", () => {
-    const html = '<span><a href="#"><em><strong>Valid nesting</strong></em></a></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<span><a href="#"><em><strong>Valid nesting</strong></em></a></span>`)
   })
 
   test("fails for deeply nested block in inline", () => {
-    const html = '<span><em><strong><div>Deeply nested div</div></strong></em></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<div>` cannot be placed inside inline element `<strong>`.')
+    expectError('Block-level element `<div>` cannot be placed inside inline element `<strong>`.')
+    assertOffenses(`<span><em><strong><div>Deeply nested div</div></strong></em></span>`)
   })
 
   test("passes for inline elements with text and inline children", () => {
-    const html = '<span>Text before <code>code</code> text after</span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<span>Text before <code>code</code> text after</span>`)
   })
 
   test("fails for list inside inline element", () => {
-    const html = '<span><ul><li>Item</li></ul></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<ul>` cannot be placed inside inline element `<span>`.')
+    expectError('Block-level element `<ul>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><ul><li>Item</li></ul></span>`)
   })
 
   test("handles ERB templates correctly", () => {
-    const html = '<span><%= render partial: "some/partial" %></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<span><%= render partial: "some/partial" %></span>`)
   })
 
   test("fails for form inside button", () => {
-    const html = '<button><form action="/submit">Submit</form></button>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<form>` cannot be placed inside inline element `<button>`.')
+    expectError('Block-level element `<form>` cannot be placed inside inline element `<button>`.')
+    assertOffenses(`<button><form action="/submit">Submit</form></button>`)
   })
 
   test("fails for table inside label", () => {
-    const html = '<label><table><tr><td>Cell</td></tr></table></label>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<table>` cannot be placed inside inline element `<label>`.')
+    expectError('Block-level element `<table>` cannot be placed inside inline element `<label>`.')
+    assertOffenses(`<label><table><tr><td>Cell</td></tr></table></label>`)
   })
 
   test("fails for custom elements inside inline elements", () => {
-    const html = '<span><my-component>Custom content</my-component></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Unknown element `<my-component>` cannot be placed inside inline element `<span>`.')
+    expectError('Unknown element `<my-component>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><my-component>Custom content</my-component></span>`)
   })
 
   test("passes for block elements inside custom elements", () => {
-    const html = '<my-inline-component><div>Block inside custom</div></my-inline-component>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<my-inline-component><div>Block inside custom</div></my-inline-component>`)
   })
 
   test("fails for custom elements with various naming patterns inside inline", () => {
-    const html = `
+    expectError('Unknown element `<x-button>` cannot be placed inside inline element `<span>`.')
+    expectError('Unknown element `<app-icon>` cannot be placed inside inline element `<span>`.')
+    expectError('Unknown element `<my-very-long-component-name>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`
       <span>
         <x-button>Click me</x-button>
         <app-icon></app-icon>
         <my-very-long-component-name>Content</my-very-long-component-name>
       </span>
-    `
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(3)
-    expect(lintResult.offenses[0].message).toBe('Unknown element `<x-button>` cannot be placed inside inline element `<span>`.')
-    expect(lintResult.offenses[1].message).toBe('Unknown element `<app-icon>` cannot be placed inside inline element `<span>`.')
-    expect(lintResult.offenses[2].message).toBe('Unknown element `<my-very-long-component-name>` cannot be placed inside inline element `<span>`.')
+    `)
   })
 
   test("still fails for standard block elements after custom elements", () => {
-    const html = '<span><my-component>Custom</my-component><div>Block div</div></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses[0].message).toBe('Unknown element `<my-component>` cannot be placed inside inline element `<span>`.')
-    expect(lintResult.offenses[1].message).toBe('Block-level element `<div>` cannot be placed inside inline element `<span>`.')
+    expectError('Unknown element `<my-component>` cannot be placed inside inline element `<span>`.')
+    expectError('Block-level element `<div>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><my-component>Custom</my-component><div>Block div</div></span>`)
   })
 
   test("fails for nested custom elements inside inline", () => {
-    const html = '<span><outer-component><inner-component><div>Content</div></inner-component></outer-component></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Unknown element `<outer-component>` cannot be placed inside inline element `<span>`.')
+    expectError('Unknown element `<outer-component>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><outer-component><inner-component><div>Content</div></inner-component></outer-component></span>`)
   })
 
   test("fails for single-word custom elements inside inline", () => {
-    const html = '<span><customtag><div>Block inside unknown element</div></customtag></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Unknown element `<customtag>` cannot be placed inside inline element `<span>`.')
+    expectError('Unknown element `<customtag>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><customtag><div>Block inside unknown element</div></customtag></span>`)
   })
 
   test("fails for unknown elements inside inline but allows content inside unknown elements", () => {
-    const html = '<span><unknownelement><randomtag><div>Block content</div></randomtag></unknownelement></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Unknown element `<unknownelement>` cannot be placed inside inline element `<span>`.')
+    expectError('Unknown element `<unknownelement>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><unknownelement><randomtag><div>Block content</div></randomtag></unknownelement></span>`)
   })
 
   test("passes for custom elements at top level", () => {
-    const html = '<my-component><div>Block inside custom</div></my-component>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<my-component><div>Block inside custom</div></my-component>`)
   })
 
   test("fails for inline element containg erb node containing block node", () => {
-    const html = '<span><% if true %><div>Not allowed</div><% end %></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<div>` cannot be placed inside inline element `<span>`.')
+    expectError('Block-level element `<div>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><% if true %><div>Not allowed</div><% end %></span>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-duplicate-attributes.test.ts b/javascript/packages/linter/test/rules/html-no-duplicate-attributes.test.ts
index 37247f13e..2f9946bd6 100644
--- a/javascript/packages/linter/test/rules/html-no-duplicate-attributes.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-duplicate-attributes.test.ts
@@ -1,97 +1,44 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNoDuplicateAttributesRule } from "../../src/rules/html-no-duplicate-attributes.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-duplicate-attributes", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoDuplicateAttributesRule)
 
+describe("html-no-duplicate-attributes", () => {
   test("passes for unique attributes", () => {
-    const html = '<input type="text" name="username" id="user-id">'
-    
-    const linter = new Linter(Herb, [HTMLNoDuplicateAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<input type="text" name="username" id="user-id">`)
   })
 
   test("fails for duplicate attributes", () => {
-    const html = '<input type="text" type="password" name="username">'
-    
-    const linter = new Linter(Herb, [HTMLNoDuplicateAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-duplicate-attributes")
-    expect(lintResult.offenses[0].message).toBe('Duplicate attribute `type` found on tag. Remove the duplicate occurrence.')
-    expect(lintResult.offenses[0].severity).toBe("error")
+    expectError('Duplicate attribute `type` found on tag. Remove the duplicate occurrence.')
+    assertOffenses(`<input type="text" type="password" name="username">`)
   })
 
   test("fails for multiple duplicate attributes", () => {
-    const html = '<button type="submit" type="button" class="btn" class="primary">'
-    
-    const linter = new Linter(Herb, [HTMLNoDuplicateAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2) // One for type, one for class
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
+    expectError('Duplicate attribute `type` found on tag. Remove the duplicate occurrence.')
+    expectError('Duplicate attribute `class` found on tag. Remove the duplicate occurrence.')
+    assertOffenses(`<button type="submit" type="button" class="btn" class="primary">`)
   })
 
   test("handles case-insensitive duplicates", () => {
-    const html = '<div Class="container" class="active">'
-    
-    const linter = new Linter(Herb, [HTMLNoDuplicateAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Duplicate attribute `class` found on tag. Remove the duplicate occurrence.')
+    expectError('Duplicate attribute `class` found on tag. Remove the duplicate occurrence.')
+    assertOffenses(`<div Class="container" class="active">`)
   })
 
   test("passes for different attributes", () => {
-    const html = '<div class="container" id="main" data-value="test">'
-    
-    const linter = new Linter(Herb, [HTMLNoDuplicateAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div class="container" id="main" data-value="test">`)
   })
 
   test("handles self-closing tags", () => {
-    const html = '<img src="/logo.png" src="/backup.png" alt="Logo">'
-    
-    const linter = new Linter(Herb, [HTMLNoDuplicateAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Duplicate attribute `src` found on tag. Remove the duplicate occurrence.')
+    expectError('Duplicate attribute `src` found on tag. Remove the duplicate occurrence.')
+    assertOffenses(`<img src="/logo.png" src="/backup.png" alt="Logo">`)
   })
 
   test("handles ERB templates with attributes", () => {
-    const html = '<div class="<%= classes %>" data-id="<%= item.id %>">'
-    
-    const linter = new Linter(Herb, [HTMLNoDuplicateAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div class="<%= classes %>" data-id="<%= item.id %>">`)
   })
 
   test("ignores closing tags", () => {
-    const html = '<div class="test"></div>'
-    
-    const linter = new Linter(Herb, [HTMLNoDuplicateAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div class="test"></div>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-duplicate-ids.test.ts b/javascript/packages/linter/test/rules/html-no-duplicate-ids.test.ts
index ca25f3b61..573b89f45 100644
--- a/javascript/packages/linter/test/rules/html-no-duplicate-ids.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-duplicate-ids.test.ts
@@ -1,127 +1,66 @@
 import dedent from "dedent"
-import { Herb } from "@herb-tools/node-wasm";
-import { beforeAll, describe, expect, test } from "vitest";
-import { Linter } from "../../src/linter.js";
-import { HTMLNoDuplicateIdsRule } from "../../src/rules/html-no-duplicate-ids.js";
+import { describe, test } from "vitest"
+import { HTMLNoDuplicateIdsRule } from "../../src/rules/html-no-duplicate-ids.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-duplicate-ids", () => {
-  beforeAll(async () => {
-    await Herb.load();
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoDuplicateIdsRule)
 
+describe("html-no-duplicate-ids", () => {
   test("passes for unique IDs", () => {
-    const html = '<div id="unique1"></div><span id="unique2"></span>';
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    expectNoOffenses(`<div id="unique1"></div><span id="unique2"></span>`)
   })
 
   test("fails for duplicate IDs", () => {
-    const html = '<div id="duplicate"></div><span id="duplicate"></span>';
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-duplicate-ids");
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `duplicate` found. IDs must be unique within a document.');
-    expect(lintResult.offenses[0].severity).toBe("error");
+    expectError('Duplicate ID `duplicate` found. IDs must be unique within a document.')
+    assertOffenses(`<div id="duplicate"></div><span id="duplicate"></span>`)
   })
 
   test("passes for missing IDs", () => {
-    const html = '<div></div><span></span>';
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    expectNoOffenses(`<div></div><span></span>`)
   })
 
   test("passes for IDs without value", () => {
-    const html = '<div id=""></div><span id="  "></span>';
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    expectNoOffenses(`<div id=""></div><span id="  "></span>`)
   })
 
   test("passes for other attributes with equal value", () => {
-    const html = '<div class="value"></div><div class="value"></div>';
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    expectNoOffenses(`<div class="value"></div><div class="value"></div>`)
   })
 
   test("passes when using ERB in ID", () => {
-    const html = '<div id="<%= user.id %>"></div>';
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    expectNoOffenses(`<div id="<%= user.id %>"></div>`)
   })
 
   // TODO: this should also warn if it's in the same "context"
   test.todo("fails for multiple duplicate IDs in ERB in the same context", () => {
-    const html = '<div id="<%= user.id %>"></div><span id="<%= user.id %>"></span>';
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `<%= user.id %>` found. IDs must be unique within a document.');
+    expectError('Duplicate ID `<%= user.id %>` found. IDs must be unique within a document.')
+    assertOffenses(`<div id="<%= user.id %>"></div><span id="<%= user.id %>"></span>`)
   })
 
   test("passes for IDs in mutually exclusive if/else branches", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% if some_condition? %>
         <span id="my-id">content1</span>
       <% else %>
         <span id="my-id">content2</span>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("passes for IDs in mutually exclusive unless/else branches", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% unless some_condition? %>
         <span id="my-id">content1</span>
       <% else %>
         <span id="my-id">content2</span>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("fails for IDs in mutually exclusive unless/else branches and global", () => {
-    const html = dedent`
+    expectError('Duplicate ID `my-id` found. IDs must be unique within a document.')
+    expectError('Duplicate ID `my-id` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <span id="my-id">content</span>
 
       <% unless some_condition? %>
@@ -129,21 +68,11 @@ describe("html-no-duplicate-ids", () => {
       <% else %>
         <span id="my-id">content2</span>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(2);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(2);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `my-id` found. IDs must be unique within a document.');
-    expect(lintResult.offenses[1].message).toBe('Duplicate ID `my-id` found. IDs must be unique within a document.');
+    `)
   })
 
   test("passes for IDs in mutually exclusive case/when branches", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% case status %>
       <% when 'active' %>
         <div id="status-indicator">Active</div>
@@ -152,18 +81,14 @@ describe("html-no-duplicate-ids", () => {
       <% else %>
         <div id="status-indicator">Unknown</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("fails for IDs in mutually exclusive case/when branches and global", () => {
-    const html = dedent`
+    expectError('Duplicate ID `status-indicator` found. IDs must be unique within a document.')
+    expectError('Duplicate ID `status-indicator` found. IDs must be unique within a document.')
+    expectError('Duplicate ID `status-indicator` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <div id="status-indicator">Active</div>
 
       <% case status %>
@@ -174,40 +99,22 @@ describe("html-no-duplicate-ids", () => {
       <% else %>
         <div id="status-indicator">Unknown</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(3);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(3);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `status-indicator` found. IDs must be unique within a document.');
-    expect(lintResult.offenses[1].message).toBe('Duplicate ID `status-indicator` found. IDs must be unique within a document.');
-    expect(lintResult.offenses[2].message).toBe('Duplicate ID `status-indicator` found. IDs must be unique within a document.');
+    `)
   })
 
   test("fails for duplicate IDs within same control flow branch", () => {
-    const html = dedent`
+    expectError('Duplicate ID `duplicate-in-branch` found within the same control flow branch. IDs must be unique within the same control flow branch.')
+    assertOffenses(dedent`
       <% if some_condition? %>
         <span id="duplicate-in-branch">content1</span>
         <span id="duplicate-in-branch">content2</span>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `duplicate-in-branch` found within the same control flow branch. IDs must be unique within the same control flow branch.');
+    `)
   })
 
   test("fails for IDs duplicated outside of control flow", () => {
-    const html = dedent`
+    expectError('Duplicate ID `global-duplicate` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <div id="global-duplicate">outside</div>
 
       <% if some_condition? %>
@@ -215,58 +122,34 @@ describe("html-no-duplicate-ids", () => {
       <% end %>
 
       <div id="global-duplicate">outside again</div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `global-duplicate` found. IDs must be unique within a document.');
+    `)
   })
 
   test("fails for IDs duplicated outside before control flow", () => {
-    const html = dedent`
+    expectError('Duplicate ID `global-duplicate` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <div id="global-duplicate">outside</div>
 
       <% if some_condition? %>
         <span id="global-duplicate">inside branch</span>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `global-duplicate` found. IDs must be unique within a document.');
+    `)
   })
 
   test("fails for IDs duplicated outside after control flow", () => {
-    const html = dedent`
+    expectError('Duplicate ID `global-duplicate` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <% if some_condition? %>
         <span id="global-duplicate">inside branch</span>
       <% end %>
 
       <div id="global-duplicate">outside</div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `global-duplicate` found. IDs must be unique within a document.');
+    `)
   })
 
   test("fails for IDs duplicated outside after control flow", () => {
-    const html = dedent`
+    expectError('Duplicate ID `global-duplicate` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <% if some_condition? %>
         <!-- empty -->
       <% elsif another_condition? %>
@@ -276,20 +159,12 @@ describe("html-no-duplicate-ids", () => {
       <% end %>
 
       <div id="global-duplicate">outside</div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `global-duplicate` found. IDs must be unique within a document.');
+    `)
   })
 
   test("fails for IDs duplicated outside after control flow", () => {
-    const html = dedent`
+    expectError('Duplicate ID `global-duplicate` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <% if some_condition? %>
         <!-- empty -->
       <% elsif other_condition? %>
@@ -297,20 +172,11 @@ describe("html-no-duplicate-ids", () => {
       <% end %>
 
       <div id="global-duplicate">outside</div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `global-duplicate` found. IDs must be unique within a document.');
+    `)
   })
 
   test("passes for IDs duplicated in elsif and else", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% if some_condition? %>
         <!-- empty -->
       <% elsif other_condition? %>
@@ -318,18 +184,11 @@ describe("html-no-duplicate-ids", () => {
       <% else other_condition? %>
         <span id="global-duplicate">inside branch</span>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("handles nested control flow properly", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% if outer_condition? %>
         <% if inner_condition? %>
           <div id="nested-id">inner true</div>
@@ -339,33 +198,20 @@ describe("html-no-duplicate-ids", () => {
       <% else %>
         <div id="nested-id">outer false</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("passes for ID tag.div (ERBBlockNode)", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% tag.div do %>
         <div id="user">User</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("passes for output ERB IDs in loops (unique per iteration)", () => {
-    const html = dedent`
+    expectError('Duplicate ID `user-<%= user.id %>` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <% users.each do |user| %>
         <div id="user-<%= user.id %>">User</div>
       <% end %>
@@ -373,38 +219,21 @@ describe("html-no-duplicate-ids", () => {
       <% users.each do |user| %>
         <div id="user-<%= user.id %>">User again</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `user-<%= user.id %>` found. IDs must be unique within a document.');
+    `)
   })
 
   test("fails for non-output ERB IDs in loops (same value repeated)", () => {
-    const html = dedent`
+    expectError('Duplicate ID `user-` found within the same control flow branch. IDs must be unique within the same control flow branch.')
+    assertOffenses(dedent`
       <% users.each do |user| %>
         <div id="user-<% 'static' %>">User</div>
         <div id="user-<% 'static' %>">Duplicate</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `user-` found within the same control flow branch. IDs must be unique within the same control flow branch.');
+    `)
   })
 
   test("passes for output ERB IDs in while loops", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% counter = 0 %>
       <% count = 0 %>
 
@@ -414,156 +243,82 @@ describe("html-no-duplicate-ids", () => {
         <div id="post-<%= counter %>">Post</div>
         <% counter += 1 %>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("fails for static ID in while loops", () => {
-    const html = dedent`
+    expectError('Duplicate ID `static-id` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <% while condition %>
         <div id="static-id">Item</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `static-id` found. IDs must be unique within a document.');
+    `)
   })
 
   test("fails for non-dynamic ID in until loops", () => {
-    const html = dedent`
+    expectError('Duplicate ID `static-id` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <% until condition %>
         <div id="static-id">Item</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `static-id` found. IDs must be unique within a document.');
+    `)
   })
 
   test("handles output ERB IDs in conditional flow normally", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% if condition %>
         <div id="user-<%= user.id %>">User A</div>
       <% else %>
         <div id="user-<%= user.id %>">User B</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("fails for duplicate output ERB IDs within same conditional branch", () => {
-    const html = dedent`
+    expectError('Duplicate ID `user-<%= user.id %>` found within the same control flow branch. IDs must be unique within the same control flow branch.')
+    assertOffenses(dedent`
       <% if condition %>
         <div id="user-<%= user.id %>">User A</div>
         <div id="user-<%= user.id %>">User A duplicate</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `user-<%= user.id %>` found within the same control flow branch. IDs must be unique within the same control flow branch.');
+    `)
   })
 
   test("passes for static ID conflicting with dynamic ID prefix", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div id="hello">Static</div>
       <div id="hello<%= suffix %>">Dynamic</div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("passes for dynamic ID conflicting with existing static ID", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div id="hello<%= suffix %>">Dynamic</div>
       <div id="hello">Static</div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("passes for non-conflicting static and dynamic IDs", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div id="hello">Static</div>
       <div id="goodbye<%= suffix %>">Dynamic</div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test.todo("fails for static attribute in a loop context", () => {
-    const html = dedent`
+    expectError('Duplicate ID `user` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <% @users.each do |user| %>
         <div id="user"></div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `user` found. IDs must be unique within a document.');
+    `)
   })
 
   test("passes for dynamic attribute in a ERBBlockNode each context", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% @users.each do |user| %>
         <div id="<%= user.id %>"></div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-empty-attributes.test.ts b/javascript/packages/linter/test/rules/html-no-empty-attributes.test.ts
index 6a71543b4..7a4d17d21 100644
--- a/javascript/packages/linter/test/rules/html-no-empty-attributes.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-empty-attributes.test.ts
@@ -1,362 +1,146 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNoEmptyAttributesRule } from "../../src/rules/html-no-empty-attributes.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-empty-attributes", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectWarning, assertOffenses } = createLinterTest(HTMLNoEmptyAttributesRule)
 
+describe("html-no-empty-attributes", () => {
   test("passes for attributes with meaningful values", () => {
-    const html = '<div id="header" class="container" name="main"></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div id="header" class="container" name="main"></div>`)
   })
 
   test("fails for empty id attribute", () => {
-    const html = '<div id=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `id` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `id` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<div id=""></div>`)
   })
 
   test("fails for empty class attribute", () => {
-    const html = '<div class=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `class` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `class` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<div class=""></div>`)
   })
 
   test("fails for empty name attribute", () => {
-    const html = '<input name="">'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `name` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `name` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<input name="">`)
   })
 
   test("fails for empty for attribute", () => {
-    const html = '<label for="">Label</label>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `for` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `for` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<label for="">Label</label>`)
   })
 
   test("fails for empty src attribute", () => {
-    const html = '<img src="" alt="Image">'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `src` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `src` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<img src="" alt="Image">`)
   })
 
   test("fails for empty href attribute", () => {
-    const html = '<a href="">Link</a>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `href` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `href` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<a href="">Link</a>`)
   })
 
   test("fails for empty title attribute", () => {
-    const html = '<a href="https://example.com" title="">Link</a>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `title` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `title` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<a href="https://example.com" title="">Link</a>`)
   })
 
   test("fails for empty data attribute", () => {
-    const html = '<div data=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `data` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `data` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<div data=""></div>`)
   })
 
   test("fails for data-* attributes with empty values", () => {
-    const html = '<div data-value="" data-config=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(2)
-
-    expect(lintResult.offenses[0].message).toBe('Data attribute `data-value` should not have an empty value. Either provide a meaningful value or use `data-value` instead of `data-value=""`.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
-    expect(lintResult.offenses[1].message).toBe('Data attribute `data-config` should not have an empty value. Either provide a meaningful value or use `data-config` instead of `data-config=""`.')
-    expect(lintResult.offenses[1].severity).toBe("warning")
+    expectWarning('Data attribute `data-value` should not have an empty value. Either provide a meaningful value or use `data-value` instead of `data-value=""`.')
+    expectWarning('Data attribute `data-config` should not have an empty value. Either provide a meaningful value or use `data-config` instead of `data-config=""`.')
+    assertOffenses(`<div data-value="" data-config=""></div>`)
   })
 
   test("fails for aria-* attributes with empty values", () => {
-    const html = '<button aria-label="" aria-describedby="">Button</button>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(2)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `aria-label` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
-    expect(lintResult.offenses[1].message).toBe('Attribute `aria-describedby` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[1].severity).toBe("warning")
+    expectWarning('Attribute `aria-label` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    expectWarning('Attribute `aria-describedby` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<button aria-label="" aria-describedby="">Button</button>`)
   })
 
   test("fails for role attribute with empty value", () => {
-    const html = '<div role=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `role` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `role` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<div role=""></div>`)
   })
 
   test("fails for multiple empty attributes", () => {
-    const html = '<div id="" class="" data-test=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(3)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `id` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
-    expect(lintResult.offenses[1].message).toBe('Attribute `class` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[1].severity).toBe("warning")
-    expect(lintResult.offenses[2].message).toBe('Data attribute `data-test` should not have an empty value. Either provide a meaningful value or use `data-test` instead of `data-test=""`.')
-    expect(lintResult.offenses[2].severity).toBe("warning")
+    expectWarning('Attribute `id` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    expectWarning('Attribute `class` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    expectWarning('Data attribute `data-test` should not have an empty value. Either provide a meaningful value or use `data-test` instead of `data-test=""`.')
+    assertOffenses(`<div id="" class="" data-test=""></div>`)
   })
 
   test("fails for whitespace-only values", () => {
-    const html = '<div id="   " class=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(2)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `id` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
-    expect(lintResult.offenses[1].message).toBe('Attribute `class` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[1].severity).toBe("warning")
+    expectWarning('Attribute `id` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    expectWarning('Attribute `class` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<div id="   " class=""></div>`)
   })
 
   test("passes for attributes with ERB output", () => {
-    const html = '<div id="<%= element_id %>" class="<%= css_classes %>"></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div id="<%= element_id %>" class="<%= css_classes %>"></div>`)
   })
 
   test("passes for mixed static and ERB content", () => {
-    const html = '<div class="base <%= additional_classes %>"></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div class="base <%= additional_classes %>"></div>`)
   })
 
   test("fails for dynamic data-* attribute name with empty value", () => {
-    const html = '<div data-<%= key %>=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Data attribute `data-<%= key %>` should not have an empty value. Either provide a meaningful value or use `data-<%= key %>` instead of `data-<%= key %>=""`.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Data attribute `data-<%= key %>` should not have an empty value. Either provide a meaningful value or use `data-<%= key %>` instead of `data-<%= key %>=""`.')
+    assertOffenses(`<div data-<%= key %>=""></div>`)
   })
 
   test("fails for dynamic data-* composite name with empty value", () => {
-    const html = '<div data-<%= key %>-id=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Data attribute `data-<%= key %>-id` should not have an empty value. Either provide a meaningful value or use `data-<%= key %>-id` instead of `data-<%= key %>-id=""`.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Data attribute `data-<%= key %>-id` should not have an empty value. Either provide a meaningful value or use `data-<%= key %>-id` instead of `data-<%= key %>-id=""`.')
+    assertOffenses(`<div data-<%= key %>-id=""></div>`)
   })
 
   test("fails for dynamic data-* attribute name with whitespace-only value", () => {
-    const html = '<div data-<%= key %>="   "></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Data attribute `data-<%= key %>` should not have an empty value. Either provide a meaningful value or use `data-<%= key %>` instead of `data-<%= key %>="   "`.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Data attribute `data-<%= key %>` should not have an empty value. Either provide a meaningful value or use `data-<%= key %>` instead of `data-<%= key %>="   "`.')
+    assertOffenses(`<div data-<%= key %>="   "></div>`)
   })
 
   test("fails for dynamic aria-* attribute name with empty value", () => {
-    const html = '<button aria-<%= prop %>=""></button>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Attribute `aria-<%= prop %>` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `aria-<%= prop %>` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<button aria-<%= prop %>=""></button>`)
   })
 
   test("passes for dynamic attribute name with ERB value", () => {
-    const html = '<div data-<%= key %>="<%= value %>"></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div data-<%= key %>="<%= value %>"></div>`)
   })
 
   test("fails for attribute with ERB that doesn't output anything", () => {
-    const html = '<div class="<% value %>"></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Attribute `class` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    expectWarning('Attribute `class` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<div class="<% value %>"></div>`)
   })
 
   test("passes for attribute with static value and ERB that doesn't output anything", () => {
-    const html = '<div class="something.<% value %>"></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div class="something.<% value %>"></div>`)
   })
 
   test("passes for data-* attributes without explicit values", () => {
-    const html = '<div data-test data-value data-config></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div data-test data-value data-config></div>`)
   })
 
   test("fails for data-* attributes with explicit empty string values", () => {
-    const html = '<div data-test="" data-value=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(2)
-
-    expect(lintResult.offenses[0].message).toBe('Data attribute `data-test` should not have an empty value. Either provide a meaningful value or use `data-test` instead of `data-test=""`.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
-    expect(lintResult.offenses[1].message).toBe('Data attribute `data-value` should not have an empty value. Either provide a meaningful value or use `data-value` instead of `data-value=""`.')
-    expect(lintResult.offenses[1].severity).toBe("warning")
+    expectWarning('Data attribute `data-test` should not have an empty value. Either provide a meaningful value or use `data-test` instead of `data-test=""`.')
+    expectWarning('Data attribute `data-value` should not have an empty value. Either provide a meaningful value or use `data-value` instead of `data-value=""`.')
+    assertOffenses(`<div data-test="" data-value=""></div>`)
   })
 
   test("mixed data attributes: passes for implicit values, fails for explicit empty values", () => {
-    const html = '<div data-test data-config="" data-value></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Data attribute `data-config` should not have an empty value. Either provide a meaningful value or use `data-config` instead of `data-config=""`.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Data attribute `data-config` should not have an empty value. Either provide a meaningful value or use `data-config` instead of `data-config=""`.')
+    assertOffenses(`<div data-test data-config="" data-value></div>`)
   })
 
   test("passes for data-turbo-permanent without value", () => {
-    const html = '<div data-turbo-permanent>Content</div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div data-turbo-permanent>Content</div>`)
   })
 
   test("fails for data-turbo-permanent with explicit empty value", () => {
-    const html = '<div data-turbo-permanent="">Content</div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Data attribute `data-turbo-permanent` should not have an empty value. Either provide a meaningful value or use `data-turbo-permanent` instead of `data-turbo-permanent=""`.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Data attribute `data-turbo-permanent` should not have an empty value. Either provide a meaningful value or use `data-turbo-permanent` instead of `data-turbo-permanent=""`.')
+    assertOffenses(`<div data-turbo-permanent="">Content</div>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-empty-headings.test.ts b/javascript/packages/linter/test/rules/html-no-empty-headings.test.ts
index 151398aec..b6aeca11a 100644
--- a/javascript/packages/linter/test/rules/html-no-empty-headings.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-empty-headings.test.ts
@@ -1,310 +1,138 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNoEmptyHeadingsRule } from "../../src/rules/html-no-empty-headings.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-empty-headings", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoEmptyHeadingsRule)
 
+describe("html-no-empty-headings", () => {
   test("passes for heading with text content", () => {
-    const html = '<h1>Heading Content</h1>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<h1>Heading Content</h1>')
   })
 
   test("passes for heading with nested elements", () => {
-    const html = '<h2><span>Text</span></h2>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<h2><span>Text</span></h2>')
   })
 
   test("passes for heading with ERB content", () => {
-    const html = '<h3><%= title %></h3>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<h3><%= title %></h3>')
   })
 
   test("fails for empty heading", () => {
-    const html = '<h1></h1>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
+    expectError("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-empty-headings")
-    expect(lintResult.offenses[0].message).toBe("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
-    expect(lintResult.offenses[0].severity).toBe("error")
+    assertOffenses('<h1></h1>')
   })
 
   test("fails for heading with only whitespace", () => {
-    const html = '<h2>   \n\t  </h2>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectError("Heading element `<h2>` must not be empty. Provide accessible text content for screen readers and SEO.")
 
-    expect(lintResult.offenses[0].rule).toBe("html-no-empty-headings")
-    expect(lintResult.offenses[0].message).toBe("Heading element `<h2>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    assertOffenses('<h2>   \n\t  </h2>')
   })
 
   test("fails for self-closing heading", () => {
-    const html = '<h3 />'
+    expectError("Heading element `<h3>` must not be empty. Provide accessible text content for screen readers and SEO.")
 
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-empty-headings")
-    expect(lintResult.offenses[0].message).toBe("Heading element `<h3>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    assertOffenses('<h3 />')
   })
 
   test("handles all heading levels h1-h6", () => {
-    const html = '<h1></h1><h2></h2><h3></h3><h4></h4><h5></h5><h6></h6>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
+    expectError("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    expectError("Heading element `<h2>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    expectError("Heading element `<h3>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    expectError("Heading element `<h4>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    expectError("Heading element `<h5>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    expectError("Heading element `<h6>` must not be empty. Provide accessible text content for screen readers and SEO.")
 
-    expect(lintResult.errors).toBe(6)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(6)
-
-    expect(lintResult.offenses[0].message).toBe("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
-    expect(lintResult.offenses[1].message).toBe("Heading element `<h2>` must not be empty. Provide accessible text content for screen readers and SEO.")
-    expect(lintResult.offenses[5].message).toBe("Heading element `<h6>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    assertOffenses('<h1></h1><h2></h2><h3></h3><h4></h4><h5></h5><h6></h6>')
   })
 
   test("handles mixed case heading tags", () => {
-    const html = '<H1></H1>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
+    expectError("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    assertOffenses('<H1></H1>')
   })
 
   test("ignores non-heading tags", () => {
-    const html = '<div></div><p></p>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<div></div><p></p>')
   })
 
   test("passes for headings with mixed content", () => {
-    const html = '<h1>Welcome <%= user.name %>!</h1>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<h1>Welcome <%= user.name %>!</h1>')
   })
 
   test("passes for heading with only ERB", () => {
-    const html = '<h1><%= page.title %></h1>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<h1><%= page.title %></h1>')
   })
 
   test("handles multiple empty headings", () => {
-    const html = '<h1></h1><h2>Valid</h2><h3></h3>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
+    expectError("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    expectError("Heading element `<h3>` must not be empty. Provide accessible text content for screen readers and SEO.")
 
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
+    assertOffenses('<h1></h1><h2>Valid</h2><h3></h3>')
   })
 
   test("passes for div with role='heading' and content", () => {
-    const html = '<div role="heading" aria-level="1">Heading Content</div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<div role="heading" aria-level="1">Heading Content</div>')
   })
 
   test("fails for empty div with role='heading'", () => {
-    const html = '<div role="heading" aria-level="1"></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectError('Heading element `<div role="heading">` must not be empty. Provide accessible text content for screen readers and SEO.')
 
-    expect(lintResult.offenses[0].rule).toBe("html-no-empty-headings")
-    expect(lintResult.offenses[0].message).toBe('Heading element `<div role="heading">` must not be empty. Provide accessible text content for screen readers and SEO.')
-    expect(lintResult.offenses[0].severity).toBe("error")
+    assertOffenses('<div role="heading" aria-level="1"></div>')
   })
 
   test("fails for div with role='heading' containing only whitespace", () => {
-    const html = '<div role="heading" aria-level="2">   </div>'
+    expectError('Heading element `<div role="heading">` must not be empty. Provide accessible text content for screen readers and SEO.')
 
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].message).toBe('Heading element `<div role="heading">` must not be empty. Provide accessible text content for screen readers and SEO.')
+    assertOffenses('<div role="heading" aria-level="2">   </div>')
   })
 
   test("fails for self-closing div with role='heading'", () => {
-    const html = '<div role="heading" aria-level="3" />'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
+    expectError('Heading element `<div role="heading">` must not be empty. Provide accessible text content for screen readers and SEO.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].message).toBe('Heading element `<div role="heading">` must not be empty. Provide accessible text content for screen readers and SEO.')
+    assertOffenses('<div role="heading" aria-level="3" />')
   })
 
   test("ignores div without role='heading'", () => {
-    const html = '<div></div><div role="button">Button</div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<div></div><div role="button">Button</div>')
   })
 
   test("handles mixed standard headings and ARIA headings", () => {
-    const html = '<h1></h1><div role="heading">Valid</div><h2>Valid</h2><div role="heading"></div>'
+    expectError("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    expectError('Heading element `<div role="heading">` must not be empty. Provide accessible text content for screen readers and SEO.')
 
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
-
-    expect(lintResult.offenses[0].message).toBe("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
-    expect(lintResult.offenses[1].message).toBe('Heading element `<div role="heading">` must not be empty. Provide accessible text content for screen readers and SEO.')
+    assertOffenses('<h1></h1><div role="heading">Valid</div><h2>Valid</h2><div role="heading"></div>')
   })
 
   test("fails for heading with only aria-hidden content", () => {
-    const html = '<h1><span aria-hidden="true">Inaccessible text</span></h1>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
+    expectError("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-empty-headings")
-    expect(lintResult.offenses[0].message).toBe("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
-    expect(lintResult.offenses[0].severity).toBe("error")
+    assertOffenses('<h1><span aria-hidden="true">Inaccessible text</span></h1>')
   })
 
   test("fails for heading with mixed accessible and inaccessible content", () => {
-    const html = '<h2><span aria-hidden="true">Hidden</span><span aria-hidden="true">Also hidden</span></h2>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
+    expectError("Heading element `<h2>` must not be empty. Provide accessible text content for screen readers and SEO.")
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    assertOffenses('<h2><span aria-hidden="true">Hidden</span><span aria-hidden="true">Also hidden</span></h2>')
   })
 
   test("passes for heading with mix of accessible and inaccessible content", () => {
-    const html = '<h3>Visible text<span aria-hidden="true">Hidden text</span></h3>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<h3>Visible text<span aria-hidden="true">Hidden text</span></h3>')
   })
 
   test("passes for heading itself with aria-hidden='true' but has content", () => {
-    const html = '<h1 aria-hidden="true">Heading Content</h1>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<h1 aria-hidden="true">Heading Content</h1>')
   })
 
   test("passes for heading itself with hidden attribute but has content", () => {
-    const html = '<h2 hidden>Heading Content</h2>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<h2 hidden>Heading Content</h2>')
   })
 
   test("passes for heading with nested span containing text", () => {
-    const html = '<h3><span>Text</span></h3>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<h3><span>Text</span></h3>')
   })
 
   test("passes for heading with nested span containing text", () => {
-    const html = '<h2 class="class" data-turbo-temporary><%= content %></h2>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<h2 class="class" data-turbo-temporary><%= content %></h2>')
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-nested-links.test.ts b/javascript/packages/linter/test/rules/html-no-nested-links.test.ts
index 0af945fe6..ce8c051be 100644
--- a/javascript/packages/linter/test/rules/html-no-nested-links.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-nested-links.test.ts
@@ -1,108 +1,48 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNoNestedLinksRule } from "../../src/rules/html-no-nested-links.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-nested-links", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoNestedLinksRule)
 
+describe("html-no-nested-links", () => {
   test("passes for separate links", () => {
-    const html = '<a href="/products">View products</a><a href="/about">About us</a>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<a href="/products">View products</a><a href="/about">About us</a>`)
   })
 
   test("fails for directly nested links", () => {
-    const html = '<a href="/products">View <a href="/special-offer">special offer</a></a>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-nested-links")
-    expect(lintResult.offenses[0].message).toBe("Nested `<a>` elements are not allowed. Links cannot contain other links.")
-    expect(lintResult.offenses[0].severity).toBe("error")
+    expectError("Nested `<a>` elements are not allowed. Links cannot contain other links.")
+    assertOffenses(`<a href="/products">View <a href="/special-offer">special offer</a></a>`)
   })
 
   test("fails for indirectly nested links", () => {
-    const html = '<a href="/main"><div><span><a href="/nested">Nested link</a></span></div></a>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("Nested `<a>` elements are not allowed. Links cannot contain other links.")
+    expectError("Nested `<a>` elements are not allowed. Links cannot contain other links.")
+    assertOffenses(`<a href="/main"><div><span><a href="/nested">Nested link</a></span></div></a>`)
   })
 
   test("passes for links in different containers", () => {
-    const html = '<div><a href="/products">Products</a></div><div><a href="/special-offer">Special offer</a></div>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div><a href="/products">Products</a></div><div><a href="/special-offer">Special offer</a></div>`)
   })
 
   test("fails for multiple levels of nesting", () => {
-    const html = '<a href="/level1"><a href="/level2"><a href="/level3">Deep nesting</a></a></a>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2) // Second and third links are nested
-    expect(lintResult.warnings).toBe(0)
+    expectError("Nested `<a>` elements are not allowed. Links cannot contain other links.")
+    expectError("Nested `<a>` elements are not allowed. Links cannot contain other links.")
+    assertOffenses(`<a href="/level1"><a href="/level2"><a href="/level3">Deep nesting</a></a></a>`)
   })
 
   test("handles mixed case anchor tags", () => {
-    const html = '<a href="/main"><A href="/nested">Nested</A></a>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("Nested `<a>` elements are not allowed. Links cannot contain other links.")
+    expectError("Nested `<a>` elements are not allowed. Links cannot contain other links.")
+    assertOffenses(`<a href="/main"><A href="/nested">Nested</A></a>`)
   })
 
   test("passes for links with complex content", () => {
-    const html = '<a href="/profile"><img src="/avatar.jpg" alt="Avatar"><span>User Name</span></a>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<a href="/profile"><img src="/avatar.jpg" alt="Avatar"><span>User Name</span></a>`)
   })
 
   test("handles ERB templates with links", () => {
-    const html = '<div><% items.each do |item| %><a href="<%= item.url %>"><%= item.name %></a><% end %></div>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div><% items.each do |item| %><a href="<%= item.url %>"><%= item.name %></a><% end %></div>`)
   })
 
   test("fails for nested links in ERB", () => {
-    const html = '<%= link_to "Products", products_path do %><%= link_to "Special offer", offer_path %><% end %>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    // This test might not catch ERB helpers since they're not parsed as HTML elements
-    // but we're testing the structure we can detect
-    expect(lintResult.errors).toBe(0) // ERB helper calls are not HTML elements
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<%= link_to "Products", products_path do %><%= link_to "Special offer", offer_path %><% end %>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-positive-tab-index.test.ts b/javascript/packages/linter/test/rules/html-no-positive-tab-index.test.ts
index 3af933582..bd0c56256 100644
--- a/javascript/packages/linter/test/rules/html-no-positive-tab-index.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-positive-tab-index.test.ts
@@ -1,148 +1,71 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNoPositiveTabIndexRule } from "../../src/rules/html-no-positive-tab-index.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-positive-tab-index", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoPositiveTabIndexRule)
 
+describe("html-no-positive-tab-index", () => {
   test("passes for element without tabindex", () => {
-    const html = '<button>Click me</button>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<button>Click me</button>`)
   })
 
   test("passes for tabindex=\"0\"", () => {
-    const html = '<div tabindex="0">Focusable div</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div tabindex="0">Focusable div</div>`)
   })
 
   test("passes for tabindex=\"-1\"", () => {
-    const html = '<div tabindex="-1">Programmatically focusable div</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div tabindex="-1">Programmatically focusable div</div>`)
   })
 
   test("passes for negative tabindex values", () => {
-    const html = '<div tabindex="-5">Skip in tab order</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div tabindex="-5">Skip in tab order</div>`)
   })
 
   test("fails for tabindex=\"1\"", () => {
-    const html = '<div tabindex="1">Bad tabindex</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-no-positive-tab-index")
-    expect(lintResult.offenses[0].message).toBe("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
+    expectError("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
+    assertOffenses(`<div tabindex="1">Bad tabindex</div>`)
   })
 
   test("fails for tabindex=\"2\"", () => {
-    const html = '<button tabindex="2">Bad button</button>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-no-positive-tab-index")
+    expectError("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
+    assertOffenses(`<button tabindex="2">Bad button</button>`)
   })
 
   test("fails for high positive tabindex", () => {
-    const html = '<input tabindex="999" type="text">'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-no-positive-tab-index")
+    expectError("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
+    assertOffenses(`<input tabindex="999" type="text">`)
   })
 
   test("handles multiple elements with mixed tabindex values", () => {
-    const html = `
+    expectError("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
+    expectError("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
+    assertOffenses(`
       <button tabindex="0">OK</button>
       <button tabindex="1">Bad</button>
       <button tabindex="-1">Skip</button>
       <button tabindex="2">Also bad</button>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses).toHaveLength(2)
+    `)
   })
 
   test("passes for non-numeric tabindex values", () => {
-    const html = '<div tabindex="invalid">Should be handled by other rules</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div tabindex="invalid">Should be handled by other rules</div>`)
   })
 
   test("passes for empty tabindex", () => {
-    const html = '<div tabindex="">Empty value</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div tabindex="">Empty value</div>`)
   })
 
   test("passes for tabindex with ERB content", () => {
-    const html = '<div tabindex="<%= tab_index %>">Dynamic tabindex</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div tabindex="<%= tab_index %>">Dynamic tabindex</div>`)
   })
 
   test("handles mixed case attribute names", () => {
-    const html = '<div TABINDEX="1">Mixed case</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
-    expect(lintResult.offenses[0].rule).toBe("html-no-positive-tab-index")
+    expectError("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
+    assertOffenses(`<div TABINDEX="1">Mixed case</div>`)
   })
 
   test("handles tabindex with leading/trailing spaces", () => {
-    const html = '<div tabindex="  1  ">With spaces</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-no-positive-tab-index")
+    expectError("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
+    assertOffenses(`<div tabindex="  1  ">With spaces</div>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-self-closing.test.ts b/javascript/packages/linter/test/rules/html-no-self-closing.test.ts
index c0d648cb5..0f7ce3523 100644
--- a/javascript/packages/linter/test/rules/html-no-self-closing.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-self-closing.test.ts
@@ -1,15 +1,12 @@
-import { Herb } from "@herb-tools/node-wasm";
-import { beforeAll, describe, expect, test } from "vitest";
-import { Linter } from "../../src/linter.js";
-import { HTMLNoSelfClosingRule } from "../../src/rules/html-no-self-closing.js";
+import { describe, test } from "vitest"
+import { HTMLNoSelfClosingRule } from "../../src/rules/html-no-self-closing.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-self-closing", () => {
-  beforeAll(async () => {
-    await Herb.load();
-  });
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoSelfClosingRule)
 
+describe("html-no-self-closing", () => {
   test("passes for standard HTML tags", () => {
-    const html = `
+    expectNoOffenses(`
       <div></div>
       <span></span>
       <section></section>
@@ -18,151 +15,95 @@ describe("html-no-self-closing", () => {
       <input type="text">
       <br>
       <hr>
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
-  });
+    `)
+  })
 
   test("fails for self-closing non-void elements", () => {
-    const html = `
+    expectError('Use `<div></div>` instead of self-closing `<div />` for HTML compatibility.')
+    expectError('Use `<span></span>` instead of self-closing `<span />` for HTML compatibility.')
+    expectError('Use `<section></section>` instead of self-closing `<section />` for HTML compatibility.')
+    expectError('Use `<custom-element></custom-element>` instead of self-closing `<custom-element />` for HTML compatibility.')
+    expectError('Use `<svg></svg>` instead of self-closing `<svg />` for HTML compatibility.')
+    assertOffenses(`
       <div />
       <span />
       <section />
       <custom-element />
       <svg />
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(5);
-    expect(lintResult.offenses).toHaveLength(5);
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-self-closing");
-    expect(lintResult.offenses[0].severity).toBe("error");
-
-    expect(lintResult.offenses[0].message).toBe('Use `<div></div>` instead of self-closing `<div />` for HTML compatibility.')
-    expect(lintResult.offenses[1].message).toBe('Use `<span></span>` instead of self-closing `<span />` for HTML compatibility.')
-    expect(lintResult.offenses[2].message).toBe('Use `<section></section>` instead of self-closing `<section />` for HTML compatibility.')
-    expect(lintResult.offenses[3].message).toBe('Use `<custom-element></custom-element>` instead of self-closing `<custom-element />` for HTML compatibility.')
-    expect(lintResult.offenses[4].message).toBe('Use `<svg></svg>` instead of self-closing `<svg />` for HTML compatibility.')
-  });
+    `)
+  })
 
   test("fails for self-closing void elements", () => {
-    const html = `
+    expectError('Use `<img>` instead of self-closing `<img />` for HTML compatibility.')
+    expectError('Use `<input>` instead of self-closing `<input />` for HTML compatibility.')
+    expectError('Use `<br>` instead of self-closing `<br />` for HTML compatibility.')
+    expectError('Use `<hr>` instead of self-closing `<hr />` for HTML compatibility.')
+    assertOffenses(`
       <img src="/logo.png" alt="Logo" />
       <input type="text" />
       <br />
       <hr />
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(4);
-    expect(lintResult.offenses).toHaveLength(4);
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-self-closing");
-    expect(lintResult.offenses[0].severity).toBe("error");
-
-    expect(lintResult.offenses[0].message).toBe('Use `<img>` instead of self-closing `<img />` for HTML compatibility.')
-    expect(lintResult.offenses[1].message).toBe('Use `<input>` instead of self-closing `<input />` for HTML compatibility.')
-    expect(lintResult.offenses[2].message).toBe('Use `<br>` instead of self-closing `<br />` for HTML compatibility.')
-    expect(lintResult.offenses[3].message).toBe('Use `<hr>` instead of self-closing `<hr />` for HTML compatibility.')
-  });
+    `)
+  })
 
   test("passes for mixed correct and incorrect tags", () => {
-    const html = `
+    expectError('Use `<span></span>` instead of self-closing `<span />` for HTML compatibility.')
+    expectError('Use `<input>` instead of self-closing `<input />` for HTML compatibility.')
+    assertOffenses(`
       <div></div>
       <span />
       <input type="text">
       <input type="text" />
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(2);
-    expect(lintResult.offenses).toHaveLength(2);
-
-    expect(lintResult.offenses[0].message).toBe('Use `<span></span>` instead of self-closing `<span />` for HTML compatibility.')
-    expect(lintResult.offenses[1].message).toBe('Use `<input>` instead of self-closing `<input />` for HTML compatibility.')
-  });
+    `)
+  })
 
   test("passes for nested non-self-closing tags", () => {
-    const html = `
+    expectNoOffenses(`
       <div>
         <span></span>
         <section></section>
       </div>
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
-  });
+    `)
+  })
 
   test("fails for nested self-closing tags", () => {
-    const html = `
+    expectError('Use `<span></span>` instead of self-closing `<span />` for HTML compatibility.')
+    expectError('Use `<section></section>` instead of self-closing `<section />` for HTML compatibility.')
+    assertOffenses(`
       <div>
         <span />
         <section />
       </div>
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(2);
-    expect(lintResult.offenses).toHaveLength(2);
-
-    expect(lintResult.offenses[0].message).toBe('Use `<span></span>` instead of self-closing `<span />` for HTML compatibility.')
-    expect(lintResult.offenses[1].message).toBe('Use `<section></section>` instead of self-closing `<section />` for HTML compatibility.')
-  });
+    `)
+  })
 
   test("passes for custom elements without self-closing", () => {
-    const html = `
+    expectNoOffenses(`
       <custom-element></custom-element>
       <another-custom></another-custom>
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
-  });
+    `)
+  })
 
   test("fails for custom elements with self-closing", () => {
-    const html = `
+    expectError('Use `<custom-element></custom-element>` instead of self-closing `<custom-element />` for HTML compatibility.')
+    expectError('Use `<another-custom></another-custom>` instead of self-closing `<another-custom />` for HTML compatibility.')
+    assertOffenses(`
       <custom-element />
       <another-custom />
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(2);
-    expect(lintResult.offenses).toHaveLength(2);
-
-    expect(lintResult.offenses[0].message).toBe('Use `<custom-element></custom-element>` instead of self-closing `<custom-element />` for HTML compatibility.')
-    expect(lintResult.offenses[1].message).toBe('Use `<another-custom></another-custom>` instead of self-closing `<another-custom />` for HTML compatibility.')
-  });
+    `)
+  })
 
   test("passes for void elements without self-closing", () => {
-    const html = `
+    expectNoOffenses(`
       <img src="/logo.png" alt="Logo">
       <input type="text">
       <br>
       <hr>
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
-  });
+    `)
+  })
 
   test("passes for self-closing elements inside SVG", () => {
-    const html = `
+    expectNoOffenses(`
       <div class="flex items-center text-xs text-gray-500 mt-1">
         <svg class="w-3 h-3 mr-1 fill-gray-400" viewBox="0 0 24 24">
           <path d="M12 2C8.13 2 5 5.13 5 9c0 5.25 7 13 7 13s7-7.75 7-13c0-3.87-3.13-7-7-7zm0 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z" />
@@ -170,30 +111,19 @@ describe("html-no-self-closing", () => {
           <rect x="0" y="0" width="24" height="24" />
         </svg>
       </div>
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
-  });
+    `)
+  })
 
   test("fails for self-closing elements outside SVG but passes inside SVG", () => {
-    const html = `
+    expectError('Use `<div></div>` instead of self-closing `<div />` for HTML compatibility.')
+    expectError('Use `<span></span>` instead of self-closing `<span />` for HTML compatibility.')
+    assertOffenses(`
       <div />
       <svg class="w-3 h-3" viewBox="0 0 24 24">
         <path d="M12 2C8.13 2 5 5.13 5 9c0 5.25 7 13 7 13s7-7.75 7-13c0-3.87-3.13-7-7-7zm0 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z" />
         <circle cx="12" cy="12" r="10" />
       </svg>
       <span />
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(2);
-    expect(lintResult.offenses).toHaveLength(2);
-
-    expect(lintResult.offenses[0].message).toBe('Use `<div></div>` instead of self-closing `<div />` for HTML compatibility.');
-    expect(lintResult.offenses[1].message).toBe('Use `<span></span>` instead of self-closing `<span />` for HTML compatibility.');
-  });
-});
+    `)
+  })
+})
diff --git a/javascript/packages/linter/test/rules/html-no-title-attribute.test.ts b/javascript/packages/linter/test/rules/html-no-title-attribute.test.ts
index 29d3f36e6..304cc0db2 100644
--- a/javascript/packages/linter/test/rules/html-no-title-attribute.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-title-attribute.test.ts
@@ -1,188 +1,112 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNoTitleAttributeRule } from "../../src/rules/html-no-title-attribute.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-title-attribute", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoTitleAttributeRule)
 
+describe("html-no-title-attribute", () => {
   test("passes for elements without title attribute", () => {
-    const html = '<button>Click me</button>'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<button>Click me</button>')
   })
 
   test("passes for iframe with title attribute", () => {
-    const html = '<iframe src="https://example.com" title="Example content"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<iframe src="https://example.com" title="Example content"></iframe>')
   })
 
   test("passes for link with title attribute", () => {
-    const html = '<link rel="stylesheet" href="styles.css" title="Main styles">'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<link rel="stylesheet" href="styles.css" title="Main styles">')
   })
 
   test("fails for button with title attribute", () => {
-    const html = '<button title="Click to submit">Submit</button>'
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-no-title-attribute")
-    expect(lintResult.offenses[0].message).toBe("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
+    assertOffenses('<button title="Click to submit">Submit</button>')
   })
 
   test("fails for div with title attribute", () => {
-    const html = '<div title="Additional information">Content</div>'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-no-title-attribute")
+    assertOffenses('<div title="Additional information">Content</div>')
   })
 
   test("fails for span with title attribute", () => {
-    const html = '<span title="Tooltip text">Hover me</span>'
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<span title="Tooltip text">Hover me</span>')
   })
 
   test("fails for input with title attribute", () => {
-    const html = '<input type="text" title="Enter your name" placeholder="Name">'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<input type="text" title="Enter your name" placeholder="Name">')
   })
 
   test("fails for img with title attribute", () => {
-    const html = '<img src="image.jpg" alt="Description" title="Additional info">'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<img src="image.jpg" alt="Description" title="Additional info">')
   })
 
   test("fails for anchor with title attribute", () => {
-    const html = '<a href="/" title="Go to homepage">Home</a>'
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<a href="/" title="Go to homepage">Home</a>')
   })
 
   test("fails for abbr with title attribute", () => {
-    const html = '<abbr title="World Wide Web">WWW</abbr>'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<abbr title="World Wide Web">WWW</abbr>')
   })
 
   test("handles mixed case element names", () => {
-    const html = '<BUTTON title="Submit form">Submit</BUTTON>'
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<BUTTON title="Submit form">Submit</BUTTON>')
   })
 
   test("handles mixed case title attribute", () => {
-    const html = '<button TITLE="Submit form">Submit</button>'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<button TITLE="Submit form">Submit</button>')
   })
 
   test("passes for mixed case allowed elements", () => {
-    const html = '<IFRAME src="https://example.com" title="Content"></IFRAME>'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<IFRAME src="https://example.com" title="Content"></IFRAME>')
   })
 
   test("handles multiple elements", () => {
-    const html = `
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
+
+    assertOffenses(`
       <iframe src="https://example.com" title="OK iframe"></iframe>
       <button title="Bad button">Click</button>
       <link rel="stylesheet" href="styles.css" title="OK link">
       <div title="Bad div">Content</div>
       <span>OK span</span>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses).toHaveLength(2)
+    `)
   })
 
   test("passes for empty title attribute", () => {
-    const html = '<button title="">Empty title</button>'
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<button title="">Empty title</button>')
   })
 
   test("passes for title attribute with ERB content", () => {
-    const html = '<button title="<%= tooltip_text %>">Dynamic tooltip</button>'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<button title="<%= tooltip_text %>">Dynamic tooltip</button>')
   })
 
   test("ignores elements with proper accessible alternatives", () => {
-    const html = '<button aria-label="Submit form">Submit</button>'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<button aria-label="Submit form">Submit</button>')
   })
 
   test("fails for self-closing elements with title", () => {
-    const html = '<input type="text" title="Enter name" />'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<input type="text" title="Enter name" />')
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-underscores-in-attribute-names.test.ts b/javascript/packages/linter/test/rules/html-no-underscores-in-attribute-names.test.ts
index bc96257d8..df87ef2b9 100644
--- a/javascript/packages/linter/test/rules/html-no-underscores-in-attribute-names.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-underscores-in-attribute-names.test.ts
@@ -1,78 +1,47 @@
 import dedent from "dedent"
-
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src"
+import { describe, test } from "vitest"
 import { HTMLNoUnderscoresInAttributeNamesRule } from "../../src"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-underscores-in-attribute-names", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectWarning, assertOffenses } = createLinterTest(HTMLNoUnderscoresInAttributeNamesRule)
 
+describe("html-no-underscores-in-attribute-names", () => {
   test("passes for valid attribute names (hyphens, letters, digits, colon)", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div data-user-id="123" aria-label="Close"></div>
       <input data123-value="ok">
-    `
-
-    const linter = new Linter(Herb, [HTMLNoUnderscoresInAttributeNamesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("fails for attribute names with underscores", () => {
-    const html = dedent`
+    expectWarning("Attribute `data_user_id` should not contain underscores. Use hyphens (-) instead.")
+    expectWarning("Attribute `aria_label` should not contain underscores. Use hyphens (-) instead.")
+    expectWarning("Attribute `custom_attr` should not contain underscores. Use hyphens (-) instead.")
+
+    assertOffenses(dedent`
       <div data_user_id="123"></div>
       <img aria_label="Close">
       <custom-element custom_attr="x"></custom-element>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoUnderscoresInAttributeNamesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.warnings).toBe(3)
-    expect(lintResult.offenses).toHaveLength(3)
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-underscores-in-attribute-names")
-    expect(lintResult.offenses[0].severity).toBe("warning")
-
-    expect(lintResult.offenses[0].message).toBe("Attribute `data_user_id` should not contain underscores. Use hyphens (-) instead.")
-    expect(lintResult.offenses[1].message).toBe("Attribute `aria_label` should not contain underscores. Use hyphens (-) instead.")
-    expect(lintResult.offenses[2].message).toBe("Attribute `custom_attr` should not contain underscores. Use hyphens (-) instead.")
+    `)
   })
 
   test("does not flag dynamic attribute names", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div data-<%=  %>="value"></div>
       <div <%= dynamic_name %>="value"></div>
       <div data-<%= key %>-test="value"></div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoUnderscoresInAttributeNamesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("fails for dynamic attribute names with underscores", () => {
-    const html = dedent`
+    expectWarning("Attribute `data_<%= key %>` should not contain underscores. Use hyphens (-) instead.")
+    expectWarning("Attribute `data_<%= key %>-test` should not contain underscores. Use hyphens (-) instead.")
+    expectWarning("Attribute `data-<%= key %>_test` should not contain underscores. Use hyphens (-) instead.")
+
+    assertOffenses(dedent`
       <div data_<%= key %>="value"></div>
       <div data_<%= key %>-test="value"></div>
       <div data-<%= key %>_test="value"></div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoUnderscoresInAttributeNamesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.warnings).toBe(3)
-    expect(lintResult.offenses).toHaveLength(3)
-
-    expect(lintResult.offenses[0].message).toBe("Attribute `data_<%= key %>` should not contain underscores. Use hyphens (-) instead.")
-    expect(lintResult.offenses[1].message).toBe("Attribute `data_<%= key %>-test` should not contain underscores. Use hyphens (-) instead.")
-    expect(lintResult.offenses[2].message).toBe("Attribute `data-<%= key %>_test` should not contain underscores. Use hyphens (-) instead.")
+    `)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-tag-name-lowercase.test.ts b/javascript/packages/linter/test/rules/html-tag-name-lowercase.test.ts
index ebe6ae896..7e1919c94 100644
--- a/javascript/packages/linter/test/rules/html-tag-name-lowercase.test.ts
+++ b/javascript/packages/linter/test/rules/html-tag-name-lowercase.test.ts
@@ -1,89 +1,49 @@
 import dedent from "dedent"
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLTagNameLowercaseRule } from "../../src/rules/html-tag-name-lowercase.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-tag-name-lowercase", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLTagNameLowercaseRule)
 
+describe("html-tag-name-lowercase", () => {
   test("passes for lowercase tag names", () => {
-    const html = '<div class="container"><span>Hello</span></div>'
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<div class="container"><span>Hello</span></div>')
   })
 
   test("fails for uppercase tag names", () => {
-    const html = '<DIV class="container"><SPAN>Hello</SPAN></DIV>'
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
+    expectError('Opening tag name `<DIV>` should be lowercase. Use `<div>` instead.')
+    expectError('Opening tag name `<SPAN>` should be lowercase. Use `<span>` instead.')
+    expectError('Closing tag name `</SPAN>` should be lowercase. Use `</span>` instead.')
+    expectError('Closing tag name `</DIV>` should be lowercase. Use `</div>` instead.')
 
-    expect(lintResult.errors).toBe(4) // DIV open, DIV close, SPAN open, SPAN close
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(4)
-
-    expect(lintResult.offenses[0].rule).toBe("html-tag-name-lowercase")
-    expect(lintResult.offenses[0].severity).toBe("error")
-
-    expect(lintResult.offenses[0].message).toBe('Opening tag name `<DIV>` should be lowercase. Use `<div>` instead.')
-    expect(lintResult.offenses[1].message).toBe('Opening tag name `<SPAN>` should be lowercase. Use `<span>` instead.')
-    expect(lintResult.offenses[2].message).toBe('Closing tag name `</SPAN>` should be lowercase. Use `</span>` instead.')
-    expect(lintResult.offenses[3].message).toBe('Closing tag name `</DIV>` should be lowercase. Use `</div>` instead.')
+    assertOffenses('<DIV class="container"><SPAN>Hello</SPAN></DIV>')
   })
 
   test("fails for mixed case tag names", () => {
-    const html = '<Div class="container"><Span>Hello</Span></Div>'
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
+    expectError('Opening tag name `<Div>` should be lowercase. Use `<div>` instead.')
+    expectError('Opening tag name `<Span>` should be lowercase. Use `<span>` instead.')
+    expectError('Closing tag name `</Span>` should be lowercase. Use `</span>` instead.')
+    expectError('Closing tag name `</Div>` should be lowercase. Use `</div>` instead.')
 
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(4)
-
-    expect(lintResult.offenses[0].message).toBe('Opening tag name `<Div>` should be lowercase. Use `<div>` instead.')
+    assertOffenses('<Div class="container"><Span>Hello</Span></Div>')
   })
 
   test("handles self-closing tags", () => {
-    const html = '<IMG src="photo.jpg" />'
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
+    expectError('Opening tag name `<IMG>` should be lowercase. Use `<img>` instead.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Opening tag name `<IMG>` should be lowercase. Use `<img>` instead.')
+    assertOffenses('<IMG src="photo.jpg" />')
   })
 
   test("passes for valid self-closing tags", () => {
-    const html = '<img src="photo.jpg" />'
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<img src="photo.jpg" />')
   })
 
   test.skip("handles ERB templates", () => {
-    const html = '<div class="container"><%= content_tag(:DIV, "Hello world!") %></div>'
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<div class="container"><%= content_tag(:DIV, "Hello world!") %></div>')
   })
 
   test("handles common HTML5 elements", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <article>
         <header><h1>Title</h1></header>
         <section>
@@ -92,17 +52,26 @@ describe("html-tag-name-lowercase", () => {
         </section>
         <footer>Footer</footer>
       </article>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    `)
   })
 
   test("fails for uppercase HTML5 elements", () => {
-    const html = dedent`
+    expectError('Opening tag name `<ARTICLE>` should be lowercase. Use `<article>` instead.')
+    expectError('Opening tag name `<HEADER>` should be lowercase. Use `<header>` instead.')
+    expectError('Opening tag name `<H1>` should be lowercase. Use `<h1>` instead.')
+    expectError('Closing tag name `</H1>` should be lowercase. Use `</h1>` instead.')
+    expectError('Closing tag name `</HEADER>` should be lowercase. Use `</header>` instead.')
+    expectError('Opening tag name `<SECTION>` should be lowercase. Use `<section>` instead.')
+    expectError('Opening tag name `<P>` should be lowercase. Use `<p>` instead.')
+    expectError('Closing tag name `</P>` should be lowercase. Use `</p>` instead.')
+    expectError('Opening tag name `<ASIDE>` should be lowercase. Use `<aside>` instead.')
+    expectError('Closing tag name `</ASIDE>` should be lowercase. Use `</aside>` instead.')
+    expectError('Closing tag name `</SECTION>` should be lowercase. Use `</section>` instead.')
+    expectError('Opening tag name `<FOOTER>` should be lowercase. Use `<footer>` instead.')
+    expectError('Closing tag name `</FOOTER>` should be lowercase. Use `</footer>` instead.')
+    expectError('Closing tag name `</ARTICLE>` should be lowercase. Use `</article>` instead.')
+
+    assertOffenses(dedent`
       <ARTICLE>
         <HEADER><H1>Title</H1></HEADER>
         <SECTION>
@@ -111,49 +80,26 @@ describe("html-tag-name-lowercase", () => {
         </SECTION>
         <FOOTER>Footer</FOOTER>
       </ARTICLE>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(14)
-    expect(lintResult.warnings).toBe(0)
-
-    const errorMessages = lintResult.offenses.map(message => message.message)
-    expect(errorMessages.some(msg => msg.includes('ARTICLE'))).toBe(true)
-    expect(errorMessages.some(msg => msg.includes('HEADER'))).toBe(true)
-    expect(errorMessages.some(msg => msg.includes('H1'))).toBe(true)
+    `)
   })
 
   test("handles empty tags", () => {
-    const html = '<div></div>'
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<div></div>')
   })
 
   test("handles nested ERB within HTML", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div class="<%= user.active? ? 'active' : 'inactive' %>">
         <h1><%= user.name %></h1>
         <% if user.admin? %>
           <span class="admin-badge">Admin</span>
         <% end %>
       </div>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    `)
   })
 
   test("ignores SVG child elements (handled by svg-tag-name-capitalization rule)", () => {
-    const html = `
+    expectNoOffenses(`
       <svg>
         <linearGradient id="grad1">
           <stop offset="0%" />
@@ -165,66 +111,46 @@ describe("html-tag-name-lowercase", () => {
           <stop offset="50%" />
         </lineargradient>
       </svg>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("still checks SVG tag itself for lowercase", () => {
-    const html = `
+    expectError('Opening tag name `<SVG>` should be lowercase. Use `<svg>` instead.')
+    expectError('Closing tag name `</SVG>` should be lowercase. Use `</svg>` instead.')
+
+    assertOffenses(`
       <SVG>
         <linearGradient id="grad1">
           <stop offset="0%" />
         </linearGradient>
       </SVG>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2) // opening and closing SVG tags
-    expect(lintResult.offenses[0].message).toBe('Opening tag name `<SVG>` should be lowercase. Use `<svg>` instead.')
-    expect(lintResult.offenses[1].message).toBe('Closing tag name `</SVG>` should be lowercase. Use `</svg>` instead.')
+    `)
   })
 
   test("is disabled when XMLDeclarationNode is present", () => {
-    const xml = dedent`
+    expectNoOffenses(dedent`
       <?xml version="1.0" encoding="UTF-8"?>
       <ROOT>
         <ELEMENT>Content</ELEMENT>
       </ROOT>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(xml)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("still works normally without XMLDeclarationNode", () => {
-    const html = dedent`
+    expectError('Opening tag name `<ROOT>` should be lowercase. Use `<root>` instead.')
+    expectError('Opening tag name `<ELEMENT>` should be lowercase. Use `<element>` instead.')
+    expectError('Closing tag name `</ELEMENT>` should be lowercase. Use `</element>` instead.')
+    expectError('Closing tag name `</ROOT>` should be lowercase. Use `</root>` instead.')
+
+    assertOffenses(dedent`
       <ROOT>
         <ELEMENT>Content</ELEMENT>
       </ROOT>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(4) // ROOT open, ELEMENT open, ELEMENT close, ROOT close
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(4)
+    `)
   })
 
   test("is disabled with complex XML document", () => {
-    const xml = dedent`
+    expectNoOffenses(dedent`
       <?xml version="1.0" encoding="UTF-8"?>
       <CATALOG>
         <BOOK id="1">
@@ -238,34 +164,25 @@ describe("html-tag-name-lowercase", () => {
           <PRICE>19.99</PRICE>
         </BOOK>
       </CATALOG>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(xml)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("still works normally for regular .erb files", () => {
-    const htmlErb = dedent`
+    expectError('Opening tag name `<DIV>` should be lowercase. Use `<div>` instead.')
+    expectError('Opening tag name `<SECTION>` should be lowercase. Use `<section>` instead.')
+    expectError('Closing tag name `</SECTION>` should be lowercase. Use `</section>` instead.')
+    expectError('Closing tag name `</DIV>` should be lowercase. Use `</div>` instead.')
+
+    assertOffenses(dedent`
       <DIV>
         <%= render 'shared/header' %>
         <SECTION>Content</SECTION>
       </DIV>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(htmlErb, { fileName: 'template.html.erb' })
-
-    expect(lintResult.errors).toBe(4) // DIV open, DIV close, SECTION open, SECTION close
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(4)
+    `)
   })
 
   test("is disabled for .xml.erb files", () => {
-    const xmlErb = dedent`
+    expectNoOffenses(dedent`
       <CONFIGURATION>
         <%= render 'shared/settings' %>
         <DATABASE>
@@ -273,18 +190,11 @@ describe("html-tag-name-lowercase", () => {
           <PORT><%= db_port %></PORT>
         </DATABASE>
       </CONFIGURATION>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(xmlErb, { fileName: 'config.xml.erb' })
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `, { fileName: "config.xml.erb" })
   })
 
   test("handles .xml.erb files without XMLDeclarationNode", () => {
-    const xmlErb = dedent`
+    expectNoOffenses(dedent`
       <FEED>
         <% items.each do |item| %>
           <ITEM>
@@ -293,31 +203,17 @@ describe("html-tag-name-lowercase", () => {
           </ITEM>
         <% end %>
       </FEED>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(xmlErb, { fileName: 'feed.xml.erb' })
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `, { fileName: "feed.xml.erb" })
   })
 
   test("is disabled for .xml files", () => {
-    const xml = dedent`
+    expectNoOffenses(dedent`
       <CONFIGURATION>
         <DATABASE>
           <HOST>localhost</HOST>
           <PORT>5432</PORT>
         </DATABASE>
       </CONFIGURATION>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(xml, { fileName: 'config.xml' })
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `, { fileName: "config.xml" })
   })
 })
diff --git a/javascript/packages/linter/test/rules/parser-no-errors.test.ts b/javascript/packages/linter/test/rules/parser-no-errors.test.ts
index 2fde56509..5196c72c9 100644
--- a/javascript/packages/linter/test/rules/parser-no-errors.test.ts
+++ b/javascript/packages/linter/test/rules/parser-no-errors.test.ts
@@ -1,221 +1,119 @@
 import dedent from "dedent"
-
-import { describe, test, expect, beforeAll } from "vitest"
-
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
-
+import { describe, test } from "vitest"
 import { ParserNoErrorsRule } from "../../src/rules/parser-no-errors.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("ParserNoErrorsRule", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ParserNoErrorsRule)
 
+describe("ParserNoErrorsRule", () => {
   test("should not report errors for valid HTML", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <h1>Hello World</h1>
       <p>This is a paragraph.</p>
       <div>
         <%= user.name %>
       </div>
-    `
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("should report errors for mismatched tag names", () => {
-    const html = dedent`
+    expectError("Tag `<h3>` opened at (3:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Tag `<h2>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Opening tag `<h2>` at (1:1) doesn't have a matching closing tag `</h2>`. (`MISSING_CLOSING_TAG_ERROR`)")
+    expectError("Opening tag `<h3>` at (3:1) doesn't have a matching closing tag `</h3>`. (`MISSING_CLOSING_TAG_ERROR`)")
+    assertOffenses(dedent`
       <h2>
         Some content
       <h3>
-    `
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.offenses).toHaveLength(4)
-    expect(lintResult.offenses[0].rule).toBe("parser-no-errors")
-    expect(lintResult.offenses[0].severity).toBe("error")
-
-    expect(lintResult.offenses[0].message).toBe("Tag `<h3>` opened at (3:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
-    expect(lintResult.offenses[1].message).toBe("Tag `<h2>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
-    expect(lintResult.offenses[2].message).toBe("Opening tag `<h2>` at (1:1) doesn't have a matching closing tag `</h2>`. (`MISSING_CLOSING_TAG_ERROR`)")
-    expect(lintResult.offenses[3].message).toBe("Opening tag `<h3>` at (3:1) doesn't have a matching closing tag `</h3>`. (`MISSING_CLOSING_TAG_ERROR`)")
+    `)
   })
 
   test("should report errors for unclosed elements", () => {
-    const html = dedent`
+    expectError("Tag `<p>` opened at (2:3) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Tag `<div>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Opening tag `<div>` at (1:1) doesn't have a matching closing tag `</div>`. (`MISSING_CLOSING_TAG_ERROR`)")
+    expectError("Opening tag `<p>` at (2:3) closed with `</div>` at (3:2). (`TAG_NAMES_MISMATCH_ERROR`)")
+    assertOffenses(dedent`
       <div>
         <p>Some content
       </div>
-    `
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.offenses).toHaveLength(4)
-    expect(lintResult.offenses[0].rule).toBe("parser-no-errors")
-    expect(lintResult.offenses[0].severity).toBe("error")
-    expect(lintResult.offenses[0].message).toBe("Tag `<p>` opened at (2:3) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    `)
   })
 
   test("should report errors for void elements with closing tags", () => {
-    const html = `<img src="test.jpg" alt="test"></img>`
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].rule).toBe("parser-no-errors")
-    expect(lintResult.offenses[0].severity).toBe("error")
-    expect(lintResult.offenses[0].message).toBe("`img` is a void element and should not be used as a closing tag. Use `<img>` or `<img />` instead of `</img>`. (`VOID_ELEMENT_CLOSING_TAG_ERROR`)")
+    expectError("`img` is a void element and should not be used as a closing tag. Use `<img>` or `<img />` instead of `</img>`. (`VOID_ELEMENT_CLOSING_TAG_ERROR`)")
+    assertOffenses(`<img src="test.jpg" alt="test"></img>`)
   })
 
   test("should report errors for missing opening tags", () => {
-    const html = dedent`
+    expectError("Found closing tag `</div>` at (2:2) without a matching opening tag. (`MISSING_OPENING_TAG_ERROR`)")
+    assertOffenses(dedent`
       Some content
       </div>
-    `
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].rule).toBe("parser-no-errors")
-    expect(lintResult.offenses[0].severity).toBe("error")
-    expect(lintResult.offenses[0].message).toBe("Found closing tag `</div>` at (2:2) without a matching opening tag. (`MISSING_OPENING_TAG_ERROR`)")
+    `)
   })
 
   test("should report errors for mismatched quotes in attributes", () => {
-    const html = `<div class="test'></div>`
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(3)
-    expect(lintResult.offenses).toHaveLength(3)
-    expect(lintResult.offenses[0].rule).toBe("parser-no-errors")
-    expect(lintResult.offenses[0].severity).toBe("error")
-    expect(lintResult.offenses[0].message).toBe("Found `TOKEN_EOF` when expecting `TOKEN_HTML_TAG_SELF_CLOSE` at (1:24). (`UNEXPECTED_TOKEN_ERROR`)")
+    expectError("Found `TOKEN_EOF` when expecting `TOKEN_HTML_TAG_SELF_CLOSE` at (1:24). (`UNEXPECTED_TOKEN_ERROR`)")
+    expectError("Found `TOKEN_EOF` when expecting `TOKEN_QUOTE` at (1:24). (`UNEXPECTED_TOKEN_ERROR`)")
+    expectError("String opened with \" but closed with  at (1:24). (`QUOTES_MISMATCH_ERROR`)")
+    assertOffenses(`<div class="test'></div>`)
   })
 
   test("should report Ruby parse errors in ERB tags", () => {
-    const html = `<%= 1 + %>`
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("parser-no-errors")
-    expect(lintResult.offenses[0].severity).toBe("error")
-    expect(lintResult.offenses[0].message).toBe("expect_expression_after_operator: unexpected ';'; expected an expression after the operator (`RUBY_PARSE_ERROR`)")
+    expectError("expect_expression_after_operator: unexpected ';'; expected an expression after the operator (`RUBY_PARSE_ERROR`)")
+    assertOffenses(`<%= 1 + %>`)
   })
 
   test("should report multiple parser errors", () => {
-    const html = dedent`
+    expectError("Tag `<p>` opened at (2:3) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Tag `<h2>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Opening tag `<p>` at (2:3) closed with `</div>` at (4:2). (`TAG_NAMES_MISMATCH_ERROR`)")
+    expectError("Opening tag `<p>` at (2:3) closed with `</h3>` at (3:2). (`TAG_NAMES_MISMATCH_ERROR`)")
+    assertOffenses(dedent`
       <h2>
         <p>Unclosed paragraph
       </h3>
       </div>
-    `
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.offenses).toHaveLength(4)
-
-    expect(lintResult.offenses[0].rule).toBe("parser-no-errors")
-    expect(lintResult.offenses[0].severity).toBe("error")
-    expect(lintResult.offenses[0].message).toBe("Tag `<p>` opened at (2:3) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
-
-    expect(lintResult.offenses[1].message).toBe("Tag `<h2>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
-    expect(lintResult.offenses[2].message).toBe("Opening tag `<p>` at (2:3) closed with `</div>` at (4:2). (`TAG_NAMES_MISMATCH_ERROR`)")
-    expect(lintResult.offenses[3].message).toBe("Opening tag `<p>` at (2:3) closed with `</h3>` at (3:2). (`TAG_NAMES_MISMATCH_ERROR`)")
+    `)
   })
 
   test("should work alongside other linting rules", () => {
-    const html = dedent`
+    expectError("Tag `<h2>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Opening tag `<h2>` at (1:1) closed with `</h3>` at (3:2). (`TAG_NAMES_MISMATCH_ERROR`)")
+    assertOffenses(dedent`
       <h2>
         <% %>
       </h3>
-    `
-    const linter = new Linter(Herb)
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(3)
-    expect(lintResult.offenses).toHaveLength(3)
-
-    const parserErrors = lintResult.offenses.filter(offense => offense.rule === "parser-no-errors")
-    const erbErrors = lintResult.offenses.filter(offense => offense.rule === "erb-no-empty-tags")
-
-    expect(parserErrors).toHaveLength(2)
-    expect(erbErrors).toHaveLength(1)
-
-    expect(parserErrors[0].message).toBe("Tag `<h2>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
-    expect(parserErrors[1].message).toBe("Opening tag `<h2>` at (1:1) closed with `</h3>` at (3:2). (`TAG_NAMES_MISMATCH_ERROR`)")
-    expect(erbErrors[0].message).toBe("ERB tag should not be empty. Remove empty ERB tags or add content.")
+    `)
   })
 
   test("should include error location information", () => {
-    const html = dedent`
+    expectError("Tag `<h2>` opened at (2:3) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Tag `<div>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Opening tag `<h2>` at (2:3) closed with `</div>` at (3:2). (`TAG_NAMES_MISMATCH_ERROR`)")
+    expectError("Opening tag `<h2>` at (2:3) closed with `</h3>` at (2:15). (`TAG_NAMES_MISMATCH_ERROR`)")
+    assertOffenses(dedent`
       <div>
         <h2>Content</h3>
       </div>
-    `
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.offenses).toHaveLength(4)
-
-    const offense = lintResult.offenses[0]
-    expect(offense.rule).toBe("parser-no-errors")
-    expect(offense.severity).toBe("error")
-    expect(offense.message).toBe("Tag `<h2>` opened at (2:3) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
-
-    expect(offense.location).toBeDefined()
-    expect(offense.location.start).toBeDefined()
-    expect(offense.location.end).toBeDefined()
-    expect(offense.location.start.line).toBe(3)
-    expect(offense.location.start.column).toBe(6)
-
-    expect(lintResult.offenses[1].message).toBe("Tag `<div>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    `)
   })
 
   test("should handle the specific case from issue #359", () => {
-    const html = dedent`
+    expectError("Tag `<h2>` opened at (1:25) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Tag `<h2>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Opening tag `<h2>` at (1:1) doesn't have a matching closing tag `</h2>`. (`MISSING_CLOSING_TAG_ERROR`)")
+    expectError("Opening tag `<h2>` at (1:25) doesn't have a matching closing tag `</h2>`. (`MISSING_CLOSING_TAG_ERROR`)")
+    assertOffenses(dedent`
       <h2>Some heading content<h2>
-    `
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.offenses).toHaveLength(4)
-
-    expect(lintResult.offenses[0].rule).toBe("parser-no-errors")
-    expect(lintResult.offenses[0].severity).toBe("error")
-    expect(lintResult.offenses[0].message).toBe("Tag `<h2>` opened at (1:25) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
-
-    expect(lintResult.offenses[1].message).toBe("Tag `<h2>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
-    expect(lintResult.offenses[2].message).toBe("Opening tag `<h2>` at (1:1) doesn't have a matching closing tag `</h2>`. (`MISSING_CLOSING_TAG_ERROR`)")
-    expect(lintResult.offenses[3].message).toBe("Opening tag `<h2>` at (1:25) doesn't have a matching closing tag `</h2>`. (`MISSING_CLOSING_TAG_ERROR`)")
+    `)
   })
 
   test("html element ending with boolean attribute followed by ERB tag", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <link crossorigin>
       <%= hello %>
-    `
-
-    const linter = new Linter(Herb, [ParserNoErrorsRule ])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 })
diff --git a/javascript/packages/linter/test/rules/svg-tag-name-capitalization.test.ts b/javascript/packages/linter/test/rules/svg-tag-name-capitalization.test.ts
index f28bef453..1d93705cc 100644
--- a/javascript/packages/linter/test/rules/svg-tag-name-capitalization.test.ts
+++ b/javascript/packages/linter/test/rules/svg-tag-name-capitalization.test.ts
@@ -1,15 +1,12 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { SVGTagNameCapitalizationRule } from "../../src/rules/svg-tag-name-capitalization.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("svg-tag-name-capitalization", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(SVGTagNameCapitalizationRule)
 
+describe("svg-tag-name-capitalization", () => {
   test("passes for correctly cased SVG elements", () => {
-    const html = `
+    expectNoOffenses(`
       <svg>
         <linearGradient id="grad1" x1="0%" y1="0%" x2="100%" y2="0%">
           <stop offset="0%" style="stop-color:rgb(255,255,0);stop-opacity:1" />
@@ -29,18 +26,11 @@ describe("svg-tag-name-capitalization", () => {
           <textPath href="#path">Text along a path</textPath>
         </text>
       </svg>
-    `
-    
-    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("passes for SVG filter elements with correct camelCase", () => {
-    const html = `
+    expectNoOffenses(`
       <svg>
         <filter id="blur">
           <feGaussianBlur in="SourceGraphic" stdDeviation="5" />
@@ -52,17 +42,18 @@ describe("svg-tag-name-capitalization", () => {
           </feMerge>
         </filter>
       </svg>
-    `
-    
-    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    `)
   })
 
   test("fails for incorrectly cased SVG elements", () => {
-    const html = `
+    expectError('Opening SVG tag name `LINEARGRADIENT` should use proper capitalization. Use `linearGradient` instead.')
+    expectError('Closing SVG tag name `LINEARGRADIENT` should use proper capitalization. Use `linearGradient` instead.')
+    expectError('Opening SVG tag name `lineargradient` should use proper capitalization. Use `linearGradient` instead.')
+    expectError('Closing SVG tag name `lineargradient` should use proper capitalization. Use `linearGradient` instead.')
+    expectError('Opening SVG tag name `CLIPPATH` should use proper capitalization. Use `clipPath` instead.')
+    expectError('Closing SVG tag name `CLIPPATH` should use proper capitalization. Use `clipPath` instead.')
+
+    assertOffenses(`
       <svg>
         <LINEARGRADIENT id="grad1">
           <stop offset="0%" />
@@ -74,22 +65,11 @@ describe("svg-tag-name-capitalization", () => {
           <rect x="0" y="0" width="100" height="100" />
         </CLIPPATH>
       </svg>
-    `
-    
-    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(6) // 3 opening + 3 closing tags
-    expect(lintResult.offenses[0].message).toBe('Opening SVG tag name `LINEARGRADIENT` should use proper capitalization. Use `linearGradient` instead.')
-    expect(lintResult.offenses[1].message).toBe('Closing SVG tag name `LINEARGRADIENT` should use proper capitalization. Use `linearGradient` instead.')
-    expect(lintResult.offenses[2].message).toBe('Opening SVG tag name `lineargradient` should use proper capitalization. Use `linearGradient` instead.')
-    expect(lintResult.offenses[3].message).toBe('Closing SVG tag name `lineargradient` should use proper capitalization. Use `linearGradient` instead.')
-    expect(lintResult.offenses[4].message).toBe('Opening SVG tag name `CLIPPATH` should use proper capitalization. Use `clipPath` instead.')
-    expect(lintResult.offenses[5].message).toBe('Closing SVG tag name `CLIPPATH` should use proper capitalization. Use `clipPath` instead.')
+    `)
   })
 
   test("passes for animateMotion and animateTransform", () => {
-    const html = `
+    expectNoOffenses(`
       <svg>
         <animateMotion dur="10s" repeatCount="indefinite">
           <mpath href="#path1" />
@@ -102,17 +82,11 @@ describe("svg-tag-name-capitalization", () => {
           dur="10s"
           repeatCount="indefinite" />
       </svg>
-    `
-    
-    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    `)
   })
 
   test("ignores non-SVG elements", () => {
-    const html = `
+    expectNoOffenses(`
       <div>
         <LINEARGRADIENT id="grad1">
           <stop offset="0%" />
@@ -121,18 +95,14 @@ describe("svg-tag-name-capitalization", () => {
           <rect x="0" y="0" width="100" height="100" />
         </clipPath>
       </div>
-    `
-    
-    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("only checks elements within SVG context", () => {
-    const html = `
+    expectError('Opening SVG tag name `LINEARGRADIENT` should use proper capitalization. Use `linearGradient` instead.')
+    expectError('Closing SVG tag name `LINEARGRADIENT` should use proper capitalization. Use `linearGradient` instead.')
+
+    assertOffenses(`
       <div>
         <P>Outside SVG</P>
         <svg>
@@ -141,12 +111,6 @@ describe("svg-tag-name-capitalization", () => {
         </svg>
         <P>Outside SVG again</P>
       </div>
-    `
-    
-    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2) // 1 opening + 1 closing tag
-    expect(lintResult.offenses[0].message).toBe('Opening SVG tag name `LINEARGRADIENT` should use proper capitalization. Use `linearGradient` instead.')
+    `)
   })
 })

From 79d1991c33a60cd2efa218cb3dfde818924d6688 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Thu, 9 Oct 2025 07:01:18 +0200
Subject: [PATCH 25/97] C: Split lexer/parser alloc and init into separate
 steps (#513)

This PR changes the way lexers and parsers are initialized.

Instead of making an allocation for the lexer/parser inside the init
function of the respective system, it allows the caller of the init
function to decide whether the lexer/parser data is going to live on the
stack or heap.

The lexer/parser lifetimes are limited to the scope of a single function
making it possible to use a stack variable.
---
 src/herb.c           | 18 +++++++++---------
 src/include/lexer.h  |  4 +---
 src/include/parser.h |  2 +-
 src/lexer.c          | 16 +---------------
 src/parser.c         |  7 +------
 5 files changed, 13 insertions(+), 34 deletions(-)

diff --git a/src/herb.c b/src/herb.c
index dab7971be..c6a217347 100644
--- a/src/herb.c
+++ b/src/herb.c
@@ -11,30 +11,30 @@
 #include <stdlib.h>
 
 array_T* herb_lex(const char* source) {
-  lexer_T* lexer = lexer_init(source);
+  lexer_T lexer = { 0 };
+  lexer_init(&lexer, source);
+
   token_T* token = NULL;
   array_T* tokens = array_init(128);
 
-  while ((token = lexer_next_token(lexer))->type != TOKEN_EOF) {
+  while ((token = lexer_next_token(&lexer))->type != TOKEN_EOF) {
     array_append(tokens, token);
   }
 
   array_append(tokens, token);
 
-  lexer_free(lexer);
-
   return tokens;
 }
 
 AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options) {
   if (!source) { source = ""; }
 
-  lexer_T* lexer = lexer_init(source);
-  parser_T* parser = herb_parser_init(lexer, options);
-
-  AST_DOCUMENT_NODE_T* document = herb_parser_parse(parser);
+  lexer_T lexer = { 0 };
+  lexer_init(&lexer, source);
+  parser_T parser = { 0 };
+  herb_parser_init(&parser, &lexer, options);
 
-  parser_free(parser);
+  AST_DOCUMENT_NODE_T* document = herb_parser_parse(&parser);
 
   return document;
 }
diff --git a/src/include/lexer.h b/src/include/lexer.h
index 01ac0551f..142f3fb1c 100644
--- a/src/include/lexer.h
+++ b/src/include/lexer.h
@@ -4,10 +4,8 @@
 #include "lexer_struct.h"
 #include "token_struct.h"
 
-lexer_T* lexer_init(const char* source);
+void lexer_init(lexer_T* lexer, const char* source);
 token_T* lexer_next_token(lexer_T* lexer);
 token_T* lexer_error(lexer_T* lexer, const char* message);
 
-void lexer_free(lexer_T* lexer);
-
 #endif
diff --git a/src/include/parser.h b/src/include/parser.h
index 138c53594..fd5509ef7 100644
--- a/src/include/parser.h
+++ b/src/include/parser.h
@@ -28,7 +28,7 @@ typedef struct PARSER_STRUCT {
   parser_options_T* options;
 } parser_T;
 
-parser_T* herb_parser_init(lexer_T* lexer, parser_options_T* options);
+void herb_parser_init(parser_T* parser, lexer_T* lexer, parser_options_T* options);
 
 AST_DOCUMENT_NODE_T* herb_parser_parse(parser_T* parser);
 
diff --git a/src/lexer.c b/src/lexer.c
index 1eaac649a..c069e269c 100644
--- a/src/lexer.c
+++ b/src/lexer.c
@@ -9,10 +9,6 @@
 
 #define LEXER_STALL_LIMIT 5
 
-static size_t lexer_sizeof(void) {
-  return sizeof(struct LEXER_STRUCT);
-}
-
 static bool lexer_eof(const lexer_T* lexer) {
   return lexer->current_character == '\0' || lexer->stalled;
 }
@@ -34,11 +30,9 @@ static bool lexer_stalled(lexer_T* lexer) {
   return lexer->stalled;
 }
 
-lexer_T* lexer_init(const char* source) {
+void lexer_init(lexer_T* lexer, const char* source) {
   if (source == NULL) { source = ""; }
 
-  lexer_T* lexer = calloc(1, lexer_sizeof());
-
   lexer->state = STATE_DATA;
 
   lexer->source = source;
@@ -56,8 +50,6 @@ lexer_T* lexer_init(const char* source) {
   lexer->stall_counter = 0;
   lexer->last_position = 0;
   lexer->stalled = false;
-
-  return lexer;
 }
 
 token_T* lexer_error(lexer_T* lexer, const char* message) {
@@ -357,9 +349,3 @@ token_T* lexer_next_token(lexer_T* lexer) {
     }
   }
 }
-
-void lexer_free(lexer_T* lexer) {
-  if (lexer == NULL) { return; }
-
-  free(lexer);
-}
diff --git a/src/parser.c b/src/parser.c
index 9877f2538..a45e1e941 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -31,9 +31,7 @@ size_t parser_sizeof(void) {
   return sizeof(struct PARSER_STRUCT);
 }
 
-parser_T* herb_parser_init(lexer_T* lexer, parser_options_T* options) {
-  parser_T* parser = calloc(1, parser_sizeof());
-
+void herb_parser_init(parser_T* parser, lexer_T* lexer, parser_options_T* options) {
   parser->lexer = lexer;
   parser->current_token = lexer_next_token(lexer);
   parser->open_tags_stack = array_init(16);
@@ -46,8 +44,6 @@ parser_T* herb_parser_init(lexer_T* lexer, parser_options_T* options) {
   } else {
     parser->options = NULL;
   }
-
-  return parser;
 }
 
 static AST_CDATA_NODE_T* parser_parse_cdata(parser_T* parser) {
@@ -1242,7 +1238,6 @@ static void parser_consume_whitespace(parser_T* parser, array_T* children) {
 void parser_free(parser_T* parser) {
   if (parser == NULL) { return; }
 
-  if (parser->lexer != NULL) { lexer_free(parser->lexer); }
   if (parser->current_token != NULL) { token_free(parser->current_token); }
   if (parser->open_tags_stack != NULL) { array_free(&parser->open_tags_stack); }
   if (parser->options != NULL) { free(parser->options); }

From 079dc431db7b6520a7287633460a15c9e265453b Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Thu, 9 Oct 2025 11:53:04 +0200
Subject: [PATCH 26/97] Engine: Fix compiling `case/in` nodes in HTML+ERB
 templates (#596)

This pull request fixes a bug in the Herb Engine that wouldn't allow
compiling `case/in` nodes in HTML+ERB templates.

It's now possible to compile and render the following template:

```html+erb
<% case {} %>
<% in {} %>
  "matched"
<% else %>
  "not matched"
<% end %>
```

Resolves #594
---
 examples/case_in.html.erb                                 | 6 ++++++
 lib/herb/engine/compiler.rb                               | 2 +-
 ...se_in_compilation_6f13b7233db413c987e289ad2b3e3a3a.txt | 8 ++++++++
 ...when_compilation_3ee70e5b90c1ff368a7783c49c6dc611.txt} | 0
 ...ment_compilation_da96aac1987dbb33d41eb4a121419b47.txt} | 0
 ...tent_compilation_2b3c4e3c244db77468813a7472298e82.txt} | 0
 ...type_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt} | 0
 ..._erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt} | 0
 ..._for_compilation_eeecb969def01ab8005c7b9f23686fed.txt} | 0
 ...else_compilation_1437d0425640509570342c24b30de571.txt} | 0
 ...wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt} | 0
 ...lock_compilation_4ddb2a17755d3e775e3225970bc60a96.txt} | 0
 ...ocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt} | 0
 ...lock_compilation_1729fad3a77618acdc687c9fb671b75b.txt} | 0
 ..._erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt} | 0
 ...test_compilation_9c22f391d1d03fa66b3d18095354a236.txt} | 0
 ...ntil_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt} | 0
 ...utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt} | 0
 ...hile_compilation_a705eb5ed83b4db368d7204baa136b36.txt} | 0
 19 files changed, 15 insertions(+), 1 deletion(-)
 create mode 100644 examples/case_in.html.erb
 create mode 100644 test/snapshots/engine/examples_compilation_test/test_0005_case_in_compilation_6f13b7233db413c987e289ad2b3e3a3a.txt
 rename test/snapshots/engine/examples_compilation_test/{test_0005_case_when_compilation_3ee70e5b90c1ff368a7783c49c6dc611.txt => test_0006_case_when_compilation_3ee70e5b90c1ff368a7783c49c6dc611.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0006_comment_compilation_da96aac1987dbb33d41eb4a121419b47.txt => test_0007_comment_compilation_da96aac1987dbb33d41eb4a121419b47.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0007_comment_before_content_compilation_2b3c4e3c244db77468813a7472298e82.txt => test_0008_comment_before_content_compilation_2b3c4e3c244db77468813a7472298e82.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0008_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt => test_0009_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0009_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt => test_0010_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0010_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt => test_0011_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0011_if_else_compilation_1437d0425640509570342c24b30de571.txt => test_0012_if_else_compilation_1437d0425640509570342c24b30de571.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0012_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt => test_0013_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0013_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt => test_0014_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0014_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt => test_0015_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0015_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt => test_0016_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0016_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt => test_0017_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0017_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt => test_0018_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0018_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt => test_0019_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0019_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt => test_0020_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0020_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt => test_0021_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt} (100%)

diff --git a/examples/case_in.html.erb b/examples/case_in.html.erb
new file mode 100644
index 000000000..ff4e756d0
--- /dev/null
+++ b/examples/case_in.html.erb
@@ -0,0 +1,6 @@
+<% case {} %>
+<% in {} %>
+  "matched"
+<% else %>
+  "not matched"
+<% end %>
diff --git a/lib/herb/engine/compiler.rb b/lib/herb/engine/compiler.rb
index 3e9870265..7e8e90f66 100644
--- a/lib/herb/engine/compiler.rb
+++ b/lib/herb/engine/compiler.rb
@@ -227,7 +227,7 @@ def visit_erb_end_node(node)
       end
 
       def visit_erb_case_match_node(node)
-        visit_erb_control_with_parts(node, :children, :conditions, :else_clause, :end_node)
+        visit_erb_control_with_parts(node, :conditions, :else_clause, :end_node)
       end
 
       def visit_erb_in_node(node)
diff --git a/test/snapshots/engine/examples_compilation_test/test_0005_case_in_compilation_6f13b7233db413c987e289ad2b3e3a3a.txt b/test/snapshots/engine/examples_compilation_test/test_0005_case_in_compilation_6f13b7233db413c987e289ad2b3e3a3a.txt
new file mode 100644
index 000000000..218a1f6eb
--- /dev/null
+++ b/test/snapshots/engine/examples_compilation_test/test_0005_case_in_compilation_6f13b7233db413c987e289ad2b3e3a3a.txt
@@ -0,0 +1,8 @@
+_buf = ::String.new;
+ case {}; in {}; _buf << '
+  "matched"
+'.freeze; else; _buf << '
+  "not matched"
+'.freeze; end; _buf << '
+'.freeze;
+_buf.to_s
diff --git a/test/snapshots/engine/examples_compilation_test/test_0005_case_when_compilation_3ee70e5b90c1ff368a7783c49c6dc611.txt b/test/snapshots/engine/examples_compilation_test/test_0006_case_when_compilation_3ee70e5b90c1ff368a7783c49c6dc611.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0005_case_when_compilation_3ee70e5b90c1ff368a7783c49c6dc611.txt
rename to test/snapshots/engine/examples_compilation_test/test_0006_case_when_compilation_3ee70e5b90c1ff368a7783c49c6dc611.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0006_comment_compilation_da96aac1987dbb33d41eb4a121419b47.txt b/test/snapshots/engine/examples_compilation_test/test_0007_comment_compilation_da96aac1987dbb33d41eb4a121419b47.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0006_comment_compilation_da96aac1987dbb33d41eb4a121419b47.txt
rename to test/snapshots/engine/examples_compilation_test/test_0007_comment_compilation_da96aac1987dbb33d41eb4a121419b47.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0007_comment_before_content_compilation_2b3c4e3c244db77468813a7472298e82.txt b/test/snapshots/engine/examples_compilation_test/test_0008_comment_before_content_compilation_2b3c4e3c244db77468813a7472298e82.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0007_comment_before_content_compilation_2b3c4e3c244db77468813a7472298e82.txt
rename to test/snapshots/engine/examples_compilation_test/test_0008_comment_before_content_compilation_2b3c4e3c244db77468813a7472298e82.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0008_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt b/test/snapshots/engine/examples_compilation_test/test_0009_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0008_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt
rename to test/snapshots/engine/examples_compilation_test/test_0009_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0009_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt b/test/snapshots/engine/examples_compilation_test/test_0010_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0009_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt
rename to test/snapshots/engine/examples_compilation_test/test_0010_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0010_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt b/test/snapshots/engine/examples_compilation_test/test_0011_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0010_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt
rename to test/snapshots/engine/examples_compilation_test/test_0011_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0011_if_else_compilation_1437d0425640509570342c24b30de571.txt b/test/snapshots/engine/examples_compilation_test/test_0012_if_else_compilation_1437d0425640509570342c24b30de571.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0011_if_else_compilation_1437d0425640509570342c24b30de571.txt
rename to test/snapshots/engine/examples_compilation_test/test_0012_if_else_compilation_1437d0425640509570342c24b30de571.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0012_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt b/test/snapshots/engine/examples_compilation_test/test_0013_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0012_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt
rename to test/snapshots/engine/examples_compilation_test/test_0013_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0013_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt b/test/snapshots/engine/examples_compilation_test/test_0014_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0013_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt
rename to test/snapshots/engine/examples_compilation_test/test_0014_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0014_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt b/test/snapshots/engine/examples_compilation_test/test_0015_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0014_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt
rename to test/snapshots/engine/examples_compilation_test/test_0015_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0015_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt b/test/snapshots/engine/examples_compilation_test/test_0016_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0015_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt
rename to test/snapshots/engine/examples_compilation_test/test_0016_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0016_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt b/test/snapshots/engine/examples_compilation_test/test_0017_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0016_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt
rename to test/snapshots/engine/examples_compilation_test/test_0017_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0017_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt b/test/snapshots/engine/examples_compilation_test/test_0018_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0017_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt
rename to test/snapshots/engine/examples_compilation_test/test_0018_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0018_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt b/test/snapshots/engine/examples_compilation_test/test_0019_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0018_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt
rename to test/snapshots/engine/examples_compilation_test/test_0019_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0019_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt b/test/snapshots/engine/examples_compilation_test/test_0020_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0019_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt
rename to test/snapshots/engine/examples_compilation_test/test_0020_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0020_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt b/test/snapshots/engine/examples_compilation_test/test_0021_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0020_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt
rename to test/snapshots/engine/examples_compilation_test/test_0021_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt

From 892b6dba1cbf41c1634afa6cbe4f6eb5a54d5a17 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Thu, 9 Oct 2025 11:58:49 +0200
Subject: [PATCH 27/97] Formatter: Fix punctuation splitting and content
 duplication issues (#591)

This pull request fixes a bug in the Formatter where it was incorrectly
inserting whitespace between ERB interpolations/inline elements and
adjacent punctuation.

This pull request also fixes a bug in the Formatter which was
duplicating content when formatting inline elements with long text
content.

Resolves #436
Resolves #469
Resolves #564
Resolves #588
Resolves #590
---
 .../packages/formatter/src/format-helpers.ts  |  136 ++
 .../packages/formatter/src/format-printer.ts  |  579 ++++++--
 .../erb-formatter-additional.test.ts          |   12 +-
 .../erb-formatter-compat.test.ts              |    9 +-
 .../packages/formatter/test/erb/erb.test.ts   | 1294 ++++++++++++++++-
 .../formatter/test/html/comments.test.ts      |   15 +-
 .../formatter/test/html/headings.test.ts      |   43 +
 .../formatter/test/html/lists.test.ts         |   58 +
 .../test/formatting_service.test.ts           |   10 +-
 9 files changed, 1966 insertions(+), 190 deletions(-)
 create mode 100644 javascript/packages/formatter/src/format-helpers.ts
 create mode 100644 javascript/packages/formatter/test/html/headings.test.ts
 create mode 100644 javascript/packages/formatter/test/html/lists.test.ts

diff --git a/javascript/packages/formatter/src/format-helpers.ts b/javascript/packages/formatter/src/format-helpers.ts
new file mode 100644
index 000000000..ce266df9e
--- /dev/null
+++ b/javascript/packages/formatter/src/format-helpers.ts
@@ -0,0 +1,136 @@
+import { isNode } from "@herb-tools/core"
+import { Node, HTMLTextNode, WhitespaceNode } from "@herb-tools/core"
+
+// --- Node Utility Functions ---
+
+/**
+ * Check if a node is pure whitespace (empty text node with only whitespace)
+ */
+export function isPureWhitespaceNode(node: Node): boolean {
+  return isNode(node, HTMLTextNode) && node.content.trim() === ""
+}
+
+/**
+ * Check if a node is non-whitespace (has meaningful content)
+ */
+export function isNonWhitespaceNode(node: Node): boolean {
+  if (isNode(node, WhitespaceNode)) return false
+  if (isNode(node, HTMLTextNode)) return node.content.trim() !== ""
+
+  return true
+}
+
+/**
+ * Find the previous meaningful (non-whitespace) sibling
+ * Returns -1 if no meaningful sibling is found
+ */
+export function findPreviousMeaningfulSibling(siblings: Node[], currentIndex: number): number {
+  for (let i = currentIndex - 1; i >= 0; i--) {
+    if (isNonWhitespaceNode(siblings[i])) {
+      return i
+    }
+  }
+
+  return -1
+}
+
+/**
+ * Check if there's whitespace between two indices in children array
+ */
+export function hasWhitespaceBetween(children: Node[], startIndex: number, endIndex: number): boolean {
+  for (let j = startIndex + 1; j < endIndex; j++) {
+    if (isNode(children[j], WhitespaceNode) || isPureWhitespaceNode(children[j])) {
+      return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * Filter children to remove insignificant whitespace
+ */
+export function filterSignificantChildren(body: Node[]): Node[] {
+  return body.filter(child => {
+    if (isNode(child, WhitespaceNode)) return false
+
+    if (isNode(child, HTMLTextNode)) {
+      if (child.content === " ") return true
+
+      return child.content.trim() !== ""
+    }
+
+    return true
+  })
+}
+
+/**
+ * Filter out empty text nodes and whitespace nodes
+ */
+export function filterEmptyNodes(nodes: Node[]): Node[] {
+  return nodes.filter(child =>
+    !isNode(child, WhitespaceNode) && !(isNode(child, HTMLTextNode) && child.content.trim() === "")
+  )
+}
+
+// --- Punctuation and Word Spacing Functions ---
+
+/**
+ * Check if a word is standalone closing punctuation
+ */
+export function isClosingPunctuation(word: string): boolean {
+  return /^[.,;:!?)\]]+$/.test(word)
+}
+
+/**
+ * Check if a line ends with opening punctuation
+ */
+export function lineEndsWithOpeningPunctuation(line: string): boolean {
+  return /[(\[]$/.test(line)
+}
+
+/**
+ * Check if a string is an ERB tag
+ */
+export function isERBTag(text: string): boolean {
+  return /^<%.*?%>$/.test(text.trim())
+}
+
+/**
+ * Check if a string ends with an ERB tag
+ */
+export function endsWithERBTag(text: string): boolean {
+  return /%>$/.test(text.trim())
+}
+
+/**
+ * Check if a string starts with an ERB tag
+ */
+export function startsWithERBTag(text: string): boolean {
+  return /^<%/.test(text.trim())
+}
+
+/**
+ * Determine if space is needed between the current line and the next word
+ */
+export function needsSpaceBetween(currentLine: string, word: string): boolean {
+  if (isClosingPunctuation(word)) return false
+  if (lineEndsWithOpeningPunctuation(currentLine)) return false
+  if (currentLine.endsWith(' ')) return false
+  if (endsWithERBTag(currentLine) && startsWithERBTag(word)) return false
+
+  return true
+}
+
+/**
+ * Build a line by adding a word with appropriate spacing
+ */
+export function buildLineWithWord(currentLine: string, word: string): string {
+  if (!currentLine) return word
+
+  if (word === ' ') {
+    return currentLine.endsWith(' ') ? currentLine : `${currentLine} `
+  }
+
+  return needsSpaceBetween(currentLine, word) ? `${currentLine} ${word}` : `${currentLine}${word}`
+}
diff --git a/javascript/packages/formatter/src/format-printer.ts b/javascript/packages/formatter/src/format-printer.ts
index 02a6f8c66..13e005205 100644
--- a/javascript/packages/formatter/src/format-printer.ts
+++ b/javascript/packages/formatter/src/format-printer.ts
@@ -15,6 +15,18 @@ import {
   hasERBOutput,
 } from "@herb-tools/core"
 import { Printer, IdentityPrinter } from "@herb-tools/printer"
+import {
+  isPureWhitespaceNode,
+  isNonWhitespaceNode,
+  findPreviousMeaningfulSibling,
+  hasWhitespaceBetween,
+  filterSignificantChildren,
+  filterEmptyNodes,
+  isClosingPunctuation,
+  lineEndsWithOpeningPunctuation,
+  needsSpaceBetween,
+  buildLineWithWord,
+} from "./format-helpers.js"
 
 import {
   ParseResult,
@@ -65,6 +77,17 @@ interface ElementFormattingAnalysis {
   closeTagInline: boolean
 }
 
+/**
+ * Content unit represents a piece of content in text flow
+ * Can be atomic (inline elements, ERB) or splittable (text)
+ */
+interface ContentUnit {
+  content: string
+  type: 'text' | 'inline' | 'erb' | 'block'
+  isAtomic: boolean
+  breaksFlow: boolean
+}
+
 // TODO: we can probably expand this list with more tags/attributes
 const FORMATTABLE_ATTRIBUTES: Record<string, string[]> = {
   '*': ['class'],
@@ -320,7 +343,7 @@ export class FormatPrinter extends Printer {
       return false
     }
 
-    const meaningfulSiblings = siblings.filter(child => this.isNonWhitespaceNode(child))
+    const meaningfulSiblings = siblings.filter(child => isNonWhitespaceNode(child))
 
     if (meaningfulSiblings.length < FormatPrinter.SPACING_THRESHOLD) {
       return false
@@ -339,7 +362,7 @@ export class FormatPrinter extends Printer {
     }
 
     const currentNode = siblings[currentIndex]
-    const previousMeaningfulIndex = this.findPreviousMeaningfulSibling(siblings, currentIndex)
+    const previousMeaningfulIndex = findPreviousMeaningfulSibling(siblings, currentIndex)
     const isCurrentComment = isCommentNode(currentNode)
 
     if (previousMeaningfulIndex !== -1) {
@@ -394,17 +417,6 @@ export class FormatPrinter extends Printer {
            FormatPrinter.TOKEN_LIST_ATTRIBUTES.has(this.currentAttributeName)
   }
 
-  /**
-   * Find the previous meaningful (non-whitespace) sibling
-   */
-  private findPreviousMeaningfulSibling(siblings: Node[], currentIndex: number): number {
-    for (let i = currentIndex - 1; i >= 0; i--) {
-      if (this.isNonWhitespaceNode(siblings[i])) {
-        return i
-      }
-    }
-    return -1
-  }
 
   /**
    * Check if a node represents a block-level element
@@ -680,31 +692,30 @@ export class FormatPrinter extends Printer {
     for (let i = 0; i < node.children.length; i++) {
       const child = node.children[i]
 
-      if (isNode(child, HTMLTextNode)) {
-        const isWhitespaceOnly = child.content.trim() === ""
-
-        if (isWhitespaceOnly) {
-          const hasPreviousNonWhitespace = i > 0 && this.isNonWhitespaceNode(node.children[i - 1])
-          const hasNextNonWhitespace = i < node.children.length - 1 && this.isNonWhitespaceNode(node.children[i + 1])
-
-          const hasMultipleNewlines = child.content.includes('\n\n')
+      if (this.shouldPreserveUserSpacing(child, node.children, i)) {
+        this.push("")
+        hasHandledSpacing = true
+        continue
+      }
 
-          if (hasPreviousNonWhitespace && hasNextNonWhitespace && hasMultipleNewlines) {
-            this.push("")
-            hasHandledSpacing = true
-          }
+      if (isPureWhitespaceNode(child)) {
+        continue
+      }
 
-          continue
-        }
+      if (this.shouldAppendToLastLine(child, node.children, i)) {
+        this.appendChildToLastLine(child, node.children, i)
+        lastWasMeaningful = true
+        hasHandledSpacing = false
+        continue
       }
 
-      if (this.isNonWhitespaceNode(child) && lastWasMeaningful && !hasHandledSpacing) {
+      if (isNonWhitespaceNode(child) && lastWasMeaningful && !hasHandledSpacing) {
         this.push("")
       }
 
       this.visit(child)
 
-      if (this.isNonWhitespaceNode(child)) {
+      if (isNonWhitespaceNode(child)) {
         lastWasMeaningful = true
         hasHandledSpacing = false
       }
@@ -749,7 +760,7 @@ export class FormatPrinter extends Printer {
 
     const analysis = this.elementFormattingAnalysis.get(element)
     const hasTextFlow = this.isInTextFlowContext(null, body)
-    const children = this.filterSignificantChildren(body, hasTextFlow)
+    const children = filterSignificantChildren(body)
 
     if (analysis?.elementContentInline) {
       if (children.length === 0) return
@@ -771,10 +782,13 @@ export class FormatPrinter extends Printer {
                 this.push(' ')
               }
             } else {
-              const normalizedContent = child.content.replace(/\s+/g, ' ').trim()
+              const normalizedContent = child.content.replace(/\s+/g, ' ')
+              const trimmedContent = normalizedContent.trim()
 
-              if (normalizedContent) {
-                this.push(normalizedContent)
+              if (trimmedContent) {
+                this.push(trimmedContent)
+              } else if (normalizedContent === ' ') {
+                this.push(' ')
               }
             }
           } else if (isNode(child, WhitespaceNode)) {
@@ -822,8 +836,8 @@ export class FormatPrinter extends Printer {
         const isWhitespaceOnly = child.content.trim() === ""
 
         if (isWhitespaceOnly) {
-          const hasPreviousNonWhitespace = i > 0 && this.isNonWhitespaceNode(body[i - 1])
-          const hasNextNonWhitespace = i < body.length - 1 && this.isNonWhitespaceNode(body[i + 1])
+          const hasPreviousNonWhitespace = i > 0 && isNonWhitespaceNode(body[i - 1])
+          const hasNextNonWhitespace = i < body.length - 1 && isNonWhitespaceNode(body[i + 1])
 
           const hasMultipleNewlines = child.content.includes('\n\n')
 
@@ -836,7 +850,7 @@ export class FormatPrinter extends Printer {
         }
       }
 
-      if (this.isNonWhitespaceNode(child) && lastWasMeaningful && !hasHandledSpacing) {
+      if (isNonWhitespaceNode(child) && lastWasMeaningful && !hasHandledSpacing) {
         const element = body[i - 1]
         const hasExistingSpacing = i > 0 && isNode(element, HTMLTextNode) && element.content.trim() === "" && (element.content.includes('\n\n') || element.content.split('\n').length > 2)
 
@@ -854,7 +868,7 @@ export class FormatPrinter extends Printer {
 
       this.visit(child)
 
-      if (this.isNonWhitespaceNode(child)) {
+      if (isNonWhitespaceNode(child)) {
         lastWasMeaningful = true
         hasHandledSpacing = false
       }
@@ -1275,7 +1289,7 @@ export class FormatPrinter extends Printer {
    */
   private shouldRenderElementContentInline(node: HTMLElementNode): boolean {
     const tagName = getTagName(node)
-    const children = this.filterSignificantChildren(node.body, this.isInTextFlowContext(null, node.body))
+    const children = filterSignificantChildren(node.body)
     const isInlineElement = this.isInlineElement(tagName)
     const openTagInline = this.shouldRenderOpenTagInline(node)
 
@@ -1283,7 +1297,7 @@ export class FormatPrinter extends Printer {
     if (children.length === 0) return true
 
     if (isInlineElement) {
-      const fullInlineResult = this.tryRenderInlineFull(node, tagName, filterNodes(node.open_tag?.children, HTMLAttributeNode), children)
+      const fullInlineResult = this.tryRenderInlineFull(node, tagName, filterNodes(node.open_tag?.children, HTMLAttributeNode), node.body)
 
       if (fullInlineResult) {
         const totalLength = this.indent.length + fullInlineResult.length
@@ -1298,7 +1312,7 @@ export class FormatPrinter extends Printer {
     const hasMixedContent = this.hasMixedTextAndInlineContent(children)
 
     if (allNestedAreInline && (!hasMultilineText || hasMixedContent)) {
-      const fullInlineResult = this.tryRenderInlineFull(node, tagName, filterNodes(node.open_tag?.children, HTMLAttributeNode), children)
+      const fullInlineResult = this.tryRenderInlineFull(node, tagName, filterNodes(node.open_tag?.children, HTMLAttributeNode), node.body)
 
       if (fullInlineResult) {
         const totalLength = this.indent.length + fullInlineResult.length
@@ -1339,7 +1353,7 @@ export class FormatPrinter extends Printer {
     if (node.open_tag?.tag_closing?.value === "/>") return true
     if (this.isContentPreserving(node)) return true
 
-    const children = this.filterSignificantChildren(node.body, this.isInTextFlowContext(null, node.body))
+    const children = filterSignificantChildren(node.body)
 
     if (children.length === 0) return true
 
@@ -1349,13 +1363,104 @@ export class FormatPrinter extends Printer {
 
   // --- Utility methods ---
 
-  private isNonWhitespaceNode(node: Node): boolean {
-    if (isNode(node, WhitespaceNode)) return false
-    if (isNode(node, HTMLTextNode)) return node.content.trim() !== ""
+  /**
+   * Check if user-intentional spacing should be preserved (double newlines between elements)
+   */
+  private shouldPreserveUserSpacing(child: Node, siblings: Node[], index: number): boolean {
+    if (!isPureWhitespaceNode(child)) return false
 
-    return true
+    const hasPreviousNonWhitespace = index > 0 && isNonWhitespaceNode(siblings[index - 1])
+    const hasNextNonWhitespace = index < siblings.length - 1 && isNonWhitespaceNode(siblings[index + 1])
+    const hasMultipleNewlines = isNode(child, HTMLTextNode) && child.content.includes('\n\n')
+
+    return hasPreviousNonWhitespace && hasNextNonWhitespace && hasMultipleNewlines
+  }
+
+  /**
+   * Check if a node should be appended to the last line (for adjacent inline elements and punctuation)
+   */
+  private shouldAppendToLastLine(child: Node, siblings: Node[], index: number): boolean {
+    if (index === 0) return false
+
+    if (isNode(child, HTMLTextNode) && !/^\s/.test(child.content)) {
+      const prevNode = siblings[index - 1]
+      return this.isInlineOrERBNode(prevNode)
+    }
+
+    if (isNode(child, HTMLElementNode) && this.isInlineElement(getTagName(child))) {
+      return this.isAdjacentToPreviousInline(siblings, index)
+    }
+
+    if (isNode(child, ERBContentNode)) {
+      for (let i = index - 1; i >= 0; i--) {
+        const previousSibling = siblings[i]
+
+        if (isPureWhitespaceNode(previousSibling) || isNode(previousSibling, WhitespaceNode)) {
+          continue
+        }
+
+        if (previousSibling.location && child.location) {
+          return previousSibling.location.end.line === child.location.start.line
+        }
+
+        break
+      }
+    }
+
+    return false
+  }
+
+  /**
+   * Check if a node is an inline element or ERB node
+   */
+  private isInlineOrERBNode(node: Node): boolean {
+    return isERBNode(node) || (isNode(node, HTMLElementNode) && this.isInlineElement(getTagName(node)))
   }
 
+  /**
+   * Check if the current inline element is adjacent to a previous inline element (no whitespace between)
+   */
+  private isAdjacentToPreviousInline(siblings: Node[], index: number): boolean {
+    const prevNode = siblings[index - 1]
+
+    if (this.isInlineOrERBNode(prevNode)) {
+      return true
+    }
+
+    if (index > 1 && isNode(prevNode, HTMLTextNode) && !/^\s/.test(prevNode.content)) {
+      const twoBack = siblings[index - 2]
+      return this.isInlineOrERBNode(twoBack)
+    }
+
+    return false
+  }
+
+  /**
+   * Append a child node to the last output line
+   */
+  private appendChildToLastLine(child: Node, siblings?: Node[], index?: number): void {
+    if (isNode(child, HTMLTextNode)) {
+      this.pushToLastLine(child.content.trim())
+    } else {
+      let hasSpaceBefore = false
+
+      if (siblings && index !== undefined && index > 0) {
+        const prevSibling = siblings[index - 1]
+
+        if (isPureWhitespaceNode(prevSibling) || isNode(prevSibling, WhitespaceNode)) {
+          hasSpaceBefore = true
+        }
+      }
+
+      const oldInlineMode = this.inlineMode
+      this.inlineMode = true
+      const inlineContent = this.capture(() => this.visit(child)).join("")
+      this.inlineMode = oldInlineMode
+      this.pushToLastLine((hasSpaceBefore ? " " : "") + inlineContent)
+    }
+  }
+
+
   /**
    * Check if an element should be treated as inline based on its tag name
    */
@@ -1364,115 +1469,296 @@ export class FormatPrinter extends Printer {
   }
 
   /**
-   * Check if we're in a text flow context (parent contains mixed text and inline elements)
+   * Visit children in a text flow context (mixed text and inline elements)
+   * Handles word wrapping and keeps adjacent inline elements together
    */
   private visitTextFlowChildren(children: Node[]) {
-    let currentLineContent = ""
+    const adjacentInlineCount = this.countAdjacentInlineElements(children)
 
-    for (const child of children) {
-      if (isNode(child, HTMLTextNode)) {
-        const content = child.content
+    if (adjacentInlineCount >= 2) {
+      this.renderAdjacentInlineElements(children, adjacentInlineCount)
+      this.visitRemainingChildren(children, adjacentInlineCount)
 
-        let processedContent = content.replace(/\s+/g, ' ').trim()
+      return
+    }
 
-        if (processedContent) {
-          const hasLeadingSpace = /^\s/.test(content)
+    this.buildAndWrapTextFlow(children)
+  }
 
-          if (currentLineContent && hasLeadingSpace && !currentLineContent.endsWith(' ')) {
-            currentLineContent += ' '
-          }
+  /**
+   * Count consecutive inline elements/ERB at the start of children (with no whitespace between)
+   */
+  private countAdjacentInlineElements(children: Node[]): number {
+    let count = 0
+    let lastSignificantIndex = -1
 
-          currentLineContent += processedContent
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i]
 
-          const hasTrailingSpace = /\s$/.test(content)
+      if (isPureWhitespaceNode(child) || isNode(child, WhitespaceNode)) {
+        continue
+      }
 
-          if (hasTrailingSpace && !currentLineContent.endsWith(' ')) {
-            currentLineContent += ' '
-          }
+      const isInlineOrERB = (isNode(child, HTMLElementNode) && this.isInlineElement(getTagName(child))) || isNode(child, ERBContentNode)
 
-          if ((this.indent.length + currentLineContent.length) > Math.max(this.maxLineLength, 120)) {
-            children.forEach(child => this.visit(child))
+      if (!isInlineOrERB) {
+        break
+      }
 
-            return
-          }
-        }
-      } else if (isNode(child, HTMLElementNode)) {
-        const childTagName = getTagName(child)
+      if (lastSignificantIndex >= 0 && hasWhitespaceBetween(children, lastSignificantIndex, i)) {
+        break
+      }
 
-        if (this.isInlineElement(childTagName)) {
-          const childInline = this.tryRenderInlineFull(child, childTagName,
-            filterNodes(child.open_tag?.children, HTMLAttributeNode),
-            this.filterEmptyNodes(child.body)
-          )
+      count++
+      lastSignificantIndex = i
+    }
 
-          if (childInline) {
-            currentLineContent += childInline
+    return count
+  }
 
-            if ((this.indent.length + currentLineContent.length) > this.maxLineLength) {
-              children.forEach(child => this.visit(child))
 
-              return
-            }
-          } else {
-            if (currentLineContent.trim()) {
-              this.pushWithIndent(currentLineContent.trim())
-              currentLineContent = ""
-            }
+  /**
+   * Render adjacent inline elements together on one line
+   */
+  private renderAdjacentInlineElements(children: Node[], count: number): void {
+    let inlineContent = ""
+    let processedCount = 0
 
-            this.visit(child)
-          }
-        } else {
-          if (currentLineContent.trim()) {
-            this.pushWithIndent(currentLineContent.trim())
-            currentLineContent = ""
-          }
+    for (let i = 0; i < children.length && processedCount < count; i++) {
+      const child = children[i]
 
-          this.visit(child)
-        }
+      if (isPureWhitespaceNode(child) || isNode(child, WhitespaceNode)) {
+        continue
+      }
+
+      if (isNode(child, HTMLElementNode) && this.isInlineElement(getTagName(child))) {
+        inlineContent += this.renderInlineElementAsString(child)
+        processedCount++
       } else if (isNode(child, ERBContentNode)) {
-        const oldLines = this.lines
-        const oldInlineMode = this.inlineMode
+        inlineContent += this.renderERBAsString(child)
+        processedCount++
+      }
+    }
 
-        // TODO: use this.capture
-        try {
-          this.lines = []
-          this.inlineMode = true
-          this.visit(child)
-          const erbContent = this.lines.join("")
-          currentLineContent += erbContent
+    if (inlineContent) {
+      this.pushWithIndent(inlineContent)
+    }
+  }
 
-          if ((this.indent.length + currentLineContent.length) > Math.max(this.maxLineLength, 120)) {
-            this.lines = oldLines
-            this.inlineMode = oldInlineMode
-            children.forEach(child => this.visit(child))
+  /**
+   * Render an inline element as a string
+   */
+  private renderInlineElementAsString(element: HTMLElementNode): string {
+    const tagName = getTagName(element)
 
-            return
-          }
-        } finally {
-          this.lines = oldLines
-          this.inlineMode = oldInlineMode
+    if (element.is_void || element.open_tag?.tag_closing?.value === "/>") {
+      const attributes = filterNodes(element.open_tag?.children, HTMLAttributeNode)
+      const attributesString = this.renderAttributesString(attributes)
+      const isSelfClosing = element.open_tag?.tag_closing?.value === "/>"
+      return `<${tagName}${attributesString}${isSelfClosing ? " />" : ">"}`
+    }
+
+    const childInline = this.tryRenderInlineFull(element, tagName,
+      filterNodes(element.open_tag?.children, HTMLAttributeNode),
+      filterEmptyNodes(element.body)
+    )
+
+    return childInline !== null ? childInline : ""
+  }
+
+  /**
+   * Render an ERB node as a string
+   */
+  private renderERBAsString(node: ERBContentNode): string {
+    return this.capture(() => {
+      this.inlineMode = true
+      this.visit(node)
+    }).join("")
+  }
+
+  /**
+   * Visit remaining children after processing adjacent inline elements
+   */
+  private visitRemainingChildren(children: Node[], skipCount: number): void {
+    let skipped = 0
+
+    for (const child of children) {
+      if (isPureWhitespaceNode(child) || isNode(child, WhitespaceNode)) {
+        continue
+      }
+
+      if (skipped < skipCount) {
+        skipped++
+        continue
+      }
+
+      this.visit(child)
+    }
+  }
+
+  /**
+   * Build words array from text/inline/ERB and wrap them
+   */
+  private buildAndWrapTextFlow(children: Node[]): void {
+    const unitsWithNodes = this.buildContentUnitsWithNodes(children)
+    const words: string[] = []
+
+    for (const { unit, node } of unitsWithNodes) {
+      if (unit.breaksFlow) {
+        this.flushWords(words)
+
+        if (node) {
+          this.visit(node)
         }
+      } else if (unit.isAtomic) {
+        words.push(unit.content)
       } else {
-        if (currentLineContent.trim()) {
-          this.pushWithIndent(currentLineContent.trim())
-          currentLineContent = ""
+        const text = unit.content.replace(/\s+/g, ' ').trim()
+
+        if (text) {
+          words.push(...text.split(' '))
         }
+      }
+    }
+
+    this.flushWords(words)
+  }
+
+  /**
+   * Convert AST nodes to content units with node references
+   */
+  private buildContentUnitsWithNodes(children: Node[]): Array<{ unit: ContentUnit; node: Node | null }> {
+    const result: Array<{ unit: ContentUnit; node: Node | null }> = []
+
+    for (const child of children) {
+      if (isNode(child, WhitespaceNode)) {
+        continue
+      }
 
-        this.visit(child)
+      if (isPureWhitespaceNode(child) && !(isNode(child, HTMLTextNode) && child.content === ' ')) {
+        continue
+      }
+
+      if (isNode(child, HTMLTextNode)) {
+        const isAtomic = child.content === ' '
+
+        result.push({
+          unit: { content: child.content, type: 'text', isAtomic, breaksFlow: false },
+          node: child
+        })
+      } else if (isNode(child, HTMLElementNode)) {
+        const tagName = getTagName(child)
+        if (this.isInlineElement(tagName)) {
+          const inlineContent = this.tryRenderInlineFull(
+            child,
+            tagName,
+            filterNodes(child.open_tag?.children, HTMLAttributeNode),
+            filterEmptyNodes(child.body)
+          )
+
+          if (inlineContent !== null) {
+            result.push({
+              unit: {
+                content: inlineContent,
+                type: 'inline',
+                isAtomic: true,
+                breaksFlow: false
+              },
+              node: child
+            })
+          } else {
+            result.push({
+              unit: {
+                content: '',
+                type: 'block',
+                isAtomic: false,
+                breaksFlow: true
+              },
+              node: child
+            })
+          }
+        } else {
+          result.push({
+            unit: {
+              content: '',
+              type: 'block',
+              isAtomic: false,
+              breaksFlow: true
+            },
+            node: child
+          })
+        }
+      } else if (isNode(child, ERBContentNode)) {
+        result.push({
+          unit: {
+            content: this.renderERBAsString(child),
+            type: 'erb',
+            isAtomic: true,
+            breaksFlow: false
+          },
+          node: child
+        })
+      } else {
+        result.push({
+          unit: {
+            content: '',
+            type: 'block',
+            isAtomic: false,
+            breaksFlow: true
+          },
+          node: child
+        })
       }
     }
 
-    if (currentLineContent.trim()) {
-      const finalLine = this.indent + currentLineContent.trim()
+    return result
+  }
 
-      if (finalLine.length > Math.max(this.maxLineLength, 120)) {
-        this.visitAll(children)
+  /**
+   * Flush accumulated words to output with wrapping
+   */
+  private flushWords(words: string[]): void {
+    if (words.length > 0) {
+      this.wrapAndPushWords(words)
+      words.length = 0
+    }
+  }
 
-        return
+  /**
+   * Wrap words to fit within line length and push to output
+   * Handles punctuation spacing intelligently
+   */
+  private wrapAndPushWords(words: string[]): void {
+    const wrapWidth = this.maxLineLength - this.indent.length
+    const lines: string[] = []
+    let currentLine = ""
+
+    for (const word of words) {
+      const nextLine = buildLineWithWord(currentLine, word)
+
+      if (this.shouldWrapToNextLine(nextLine, currentLine, word, wrapWidth)) {
+        lines.push(this.indent + currentLine)
+        currentLine = word
+      } else {
+        currentLine = nextLine
       }
+    }
 
-      this.push(finalLine)
+    if (currentLine) {
+      lines.push(this.indent + currentLine)
     }
+
+    lines.forEach(line => this.push(line))
+  }
+
+  /**
+   * Determine if we should wrap to the next line
+   */
+  private shouldWrapToNextLine(testLine: string, currentLine: string, word: string, wrapWidth: number): boolean {
+    if (!currentLine) return false
+    if (isClosingPunctuation(word)) return false
+
+    return testLine.length > wrapWidth
   }
 
   private isInTextFlowContext(_parent: Node | null, children: Node[]): boolean {
@@ -1632,6 +1918,7 @@ export class FormatPrinter extends Printer {
    */
   private tryRenderChildrenInline(children: Node[]): string | null {
     let result = ""
+    let hasInternalWhitespace = false
 
     for (const child of children) {
       if (isNode(child, HTMLTextNode)) {
@@ -1655,9 +1942,15 @@ export class FormatPrinter extends Printer {
         } else if (hasLeadingSpace || hasTrailingSpace) {
           if (result && !result.endsWith(' ')) {
             result += ' '
+            hasInternalWhitespace = true
           }
         }
 
+      } else if (isNode(child, WhitespaceNode)) {
+        if (result && !result.endsWith(' ')) {
+          result += ' '
+          hasInternalWhitespace = true
+        }
       } else if (isNode(child, HTMLElementNode)) {
         const tagName = getTagName(child)
 
@@ -1667,7 +1960,7 @@ export class FormatPrinter extends Printer {
 
         const childInline = this.tryRenderInlineFull(child, tagName,
           filterNodes(child.open_tag?.children, HTMLAttributeNode),
-          this.filterEmptyNodes(child.body)
+          filterEmptyNodes(child.body)
         )
 
         if (!childInline) {
@@ -1676,11 +1969,18 @@ export class FormatPrinter extends Printer {
 
         result += childInline
       } else {
-        result += this.capture(() => this.visit(child)).join("")
+        const wasInlineMode = this.inlineMode
+        this.inlineMode = true
+
+        const captured = this.capture(() => this.visit(child)).join("")
+
+        this.inlineMode = wasInlineMode
+
+        result += captured
       }
     }
 
-    return result.trim()
+    return hasInternalWhitespace ? result : result.trim()
   }
 
   /**
@@ -1749,7 +2049,7 @@ export class FormatPrinter extends Printer {
       }
 
       if (isNode(child, HTMLElementNode)) {
-        const nestedChildren = this.filterEmptyNodes(child.body)
+        const nestedChildren = filterEmptyNodes(child.body)
 
         if (this.hasMultilineTextContent(nestedChildren)) {
           return true
@@ -1770,7 +2070,7 @@ export class FormatPrinter extends Printer {
           return false
         }
 
-        const nestedChildren = this.filterEmptyNodes(child.body)
+        const nestedChildren = filterEmptyNodes(child.body)
 
         if (!this.areAllNestedElementsInline(nestedChildren)) {
           return false
@@ -1803,34 +2103,9 @@ export class FormatPrinter extends Printer {
     })
   }
 
-  /**
-   * Filter children to remove insignificant whitespace
-   */
-  private filterSignificantChildren(body: Node[], hasTextFlow: boolean): Node[] {
-    return body.filter(child => {
-      if (isNode(child, WhitespaceNode)) return false
-
-      if (isNode(child, HTMLTextNode)) {
-        if (hasTextFlow && child.content === " ") return true
-
-        return child.content.trim() !== ""
-      }
-
-      return true
-    })
-  }
-
-  /**
-   * Filter out empty text nodes and whitespace nodes
-   */
-  private filterEmptyNodes(nodes: Node[]): Node[] {
-    return nodes.filter(child =>
-      !isNode(child, WhitespaceNode) && !(isNode(child, HTMLTextNode) && child.content.trim() === "")
-    )
-  }
 
   private renderElementInline(element: HTMLElementNode): string {
-    const children = this.filterEmptyNodes(element.body)
+    const children = filterEmptyNodes(element.body)
 
     return this.renderChildrenInline(children)
   }
diff --git a/javascript/packages/formatter/test/erb-formatter/erb-formatter-additional.test.ts b/javascript/packages/formatter/test/erb-formatter/erb-formatter-additional.test.ts
index 34966f819..5a5f212bb 100644
--- a/javascript/packages/formatter/test/erb-formatter/erb-formatter-additional.test.ts
+++ b/javascript/packages/formatter/test/erb-formatter/erb-formatter-additional.test.ts
@@ -44,11 +44,10 @@ describe("ERB Formatter Additional Tests", () => {
           Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
           tempor incididunt ut labore et dolore magna aliqua. 🍰🍰🍰🍰🍰🍰🍰🍰🍰🍰Ut
           enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut
-          aliquip ex ea commodo
-          <span>co<strong>nse</strong>quat.</span>
-          Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore
-          eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt
-          in culpa qui officia deserunt mollit anim id est laborum.
+          aliquip ex ea commodo <span>co<strong>nse</strong>quat.</span> Duis aute irure
+          dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla
+          pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui
+          officia deserunt mollit anim id est laborum.
         </p>
       `)
     })
@@ -70,7 +69,8 @@ describe("ERB Formatter Additional Tests", () => {
 
     test("handles complex ERB with vite and stylesheet tags", () => {
       const source = dedent`
-        <%- vite_client_tag %> <%= vite_typescript_tag "application", "data-turbo-track": "reload", defer: true %>
+        <%- vite_client_tag %>
+        <%= vite_typescript_tag "application", "data-turbo-track": "reload", defer: true %>
         <%= stylesheet_link_tag "tailwind",
         "inter-font",
         "data-turbo-track": "reload",
diff --git a/javascript/packages/formatter/test/erb-formatter/erb-formatter-compat.test.ts b/javascript/packages/formatter/test/erb-formatter/erb-formatter-compat.test.ts
index 614b073e7..76dbaeeb8 100644
--- a/javascript/packages/formatter/test/erb-formatter/erb-formatter-compat.test.ts
+++ b/javascript/packages/formatter/test/erb-formatter/erb-formatter-compat.test.ts
@@ -221,11 +221,10 @@ describe("ERB Formatter Compatibility Tests", () => {
           Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
           tempor incididunt ut labore et dolore magna aliqua. 🍰🍰🍰🍰🍰🍰🍰🍰🍰🍰Ut
           enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut
-          aliquip ex ea commodo
-          <span>co<strong>nse</strong>quat.</span>
-          Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore
-          eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt
-          in culpa qui officia deserunt mollit anim id est laborum.
+          aliquip ex ea commodo <span>co<strong>nse</strong>quat.</span> Duis aute irure
+          dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla
+          pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui
+          officia deserunt mollit anim id est laborum.
         </p>
       `)
     })
diff --git a/javascript/packages/formatter/test/erb/erb.test.ts b/javascript/packages/formatter/test/erb/erb.test.ts
index a42a1857f..3646286be 100644
--- a/javascript/packages/formatter/test/erb/erb.test.ts
+++ b/javascript/packages/formatter/test/erb/erb.test.ts
@@ -12,12 +12,12 @@ describe("@herb-tools/formatter", () => {
 
     formatter = new Formatter(Herb, {
       indentWidth: 2,
-      maxLineLength: 80
+      maxLineLength: 80,
     })
   })
 
   test("formats simple HTML with ERB content", () => {
-    const source = '<div><%= "Hello" %> World</div>'
+    const source = `<div><%= "Hello" %> World</div>`
     const result = formatter.format(source)
     expect(result).toEqual(dedent`
       <div><%= "Hello" %> World</div>
@@ -25,11 +25,49 @@ describe("@herb-tools/formatter", () => {
   })
 
   test("formats standalone ERB", () => {
-    const source = '<% title %>'
+    const source = `<% title %>`
     const result = formatter.format(source)
     expect(result).toEqual(`<% title %>`)
   })
 
+  test("ERB output tags on two lines on top-level", () => {
+    const source = dedent`
+      <%= title %>
+      <%= title %>
+    `
+    const expected = dedent`
+      <%= title %>
+
+      <%= title %>
+    `
+    const result = formatter.format(source)
+    expect(result).toEqual(expected)
+  })
+
+  test("adjecent ERB output tags without space on top-level", () => {
+    const source = `<%= title %><%= title %>`
+    const result = formatter.format(source)
+    expect(result).toEqual(`<%= title %><%= title %>`)
+  })
+
+  test("adjecent ERB output tags with space on top-level", () => {
+    const source = `<%= title %> <%= title %>`
+    const result = formatter.format(source)
+    expect(result).toEqual(`<%= title %> <%= title %>`)
+  })
+
+  test("adjecent ERB output tags without space within <p>", () => {
+    const source = `<p><%= title %><%= title %></p>`
+    const result = formatter.format(source)
+    expect(result).toEqual(`<p><%= title %><%= title %></p>`)
+  })
+
+  test("adjecent ERB output tags with space within <p>", () => {
+    const source = `<p><%= title %> <%= title %></p>`
+    const result = formatter.format(source)
+    expect(result).toEqual(`<p><%= title %> <%= title %></p>`)
+  })
+
   test("formats nested blocks with final example", () => {
     const source = `
       <div id="output">
@@ -105,11 +143,11 @@ describe("@herb-tools/formatter", () => {
       '<%= link_to "test" %>',
       '<%= link_to "test", class: "btn" %>',
       '<%= render "partial" %>',
-      '<% if something? %>',
-      '<%= tag.div("content") %>'
+      "<% if something? %>",
+      '<%= tag.div("content") %>',
     ]
 
-    inputs.forEach(input => {
+    inputs.forEach((input) => {
       const result = formatter.format(input)
       expect(result).not.toContain("% %>")
       expect(result).toBe(input)
@@ -127,12 +165,8 @@ describe("@herb-tools/formatter", () => {
 
     expect(result).toBe(dedent`
       <h3>
-        <%= link_to "Start", start_path %>
-        &rsquo;s overview of
-        <%= link_to "Section", section_path %>
-        ,
-        <%= link_to "End", end_path %>
-        .
+        <%= link_to "Start", start_path %> &rsquo;s overview of
+        <%= link_to "Section", section_path %>, <%= link_to "End", end_path %>.
       </h3>
     `)
   })
@@ -148,12 +182,1238 @@ describe("@herb-tools/formatter", () => {
 
     expect(result).toBe(dedent`
       <p class="info-text">
-        For assistance, contact us at
-        <%= config.phone_number %>
-        or
-        <%= mail_to(config.support_email, class: "email-link") %>
-        if you need help with your account.
+        For assistance, contact us at <%= config.phone_number %> or
+        <%= mail_to(config.support_email, class: "email-link") %> if you need help
+        with your account.
+      </p>
+    `)
+  })
+
+  test("issue 469: keeps punctuation attached to ERB interpolations and inline elements", () => {
+    const input = `<%= @user.translated_greeting %>,<br>`
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(`<%= @user.translated_greeting %>,<br>`)
+  })
+
+  test("issue 590: does not duplicate content with inline elements and long lines", () => {
+    const input = dedent`
+      <p>
+        <strong>Hi</strong><br>
+        0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567
+      </p>
+    `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+      <p>
+        <strong>Hi</strong><br>
+        0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567
+      </p>
+    `)
+  })
+
+  test("issue 588: does not recursively duplicate text and br tags", () => {
+    const input = dedent`
+      <%= form_with model: @article do |form| %>
+        <div>
+          <p>
+            Text 1
+            <br>
+            The lantern flickered softly in the wind as the old clock struck midnight
+            across the quiet village, casting long shadows that danced upon the
+            cobblestone streets.
+          </p>
+        </div>
+      <% end %>
+    `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+      <%= form_with model: @article do |form| %>
+        <div>
+          <p>
+            Text 1
+            <br>
+            The lantern flickered softly in the wind as the old clock struck midnight
+            across the quiet village, casting long shadows that danced upon the
+            cobblestone streets.
+          </p>
+        </div>
+      <% end %>
+    `)
+
+    const secondFormat = formatter.format(result)
+    expect(secondFormat).toBe(result)
+  })
+
+  test("issue 564: does not duplicate multiline text with br elements", () => {
+    const input = dedent`
+      <span>
+        Par défaut, un dossier déposé peut être complété ou corrigé par le demandeur jusqu'à sa mise en instruction.
+        <br>
+        Dans une démarche déclarative, une fois déposé, un dossier ne peut plus être modifié. Soit il passe immédiatement en instruction
+      </span>
+    `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+      <span>
+        Par défaut, un dossier déposé peut être complété ou corrigé par le demandeur
+        jusqu'à sa mise en instruction.
+        <br>
+        Dans une démarche déclarative, une fois déposé, un dossier ne peut plus être
+        modifié. Soit il passe immédiatement en instruction
+      </span>
+    `)
+
+    const secondFormat = formatter.format(result)
+    expect(secondFormat).toBe(result)
+  })
+
+  test("https://github.com/hanakai-rb/site/blob/8adc128d9d464f3e37615be2aa29d57979904533/app/templates/pages/home.html.erb", () => {
+    const input = dedent`
+      <h1>Hanakai</h1>
+
+      <p>This is the upcoming Hanakai website.</p>
+
+      <p>This will be the all-in-one home for everything to do with <a href="https://hanamirb.org">Hanami</a>, <a href="https://dry-rb.org">Dry</a> and <a href="https://rom-rb.org">Rom</a>.</p>
+    `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+      <h1>Hanakai</h1>
+
+      <p>This is the upcoming Hanakai website.</p>
+
+      <p>
+        This will be the all-in-one home for everything to do with
+        <a href="https://hanamirb.org">Hanami</a>,
+        <a href="https://dry-rb.org">Dry</a> and <a href="https://rom-rb.org">Rom</a>.
       </p>
     `)
+
+    expect(formatter.format(result)).toBe(result)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issuecomment-3220198776", () => {
+    const input = dedent`
+      <p
+        style="margin: 0px; color: #2f2f2b; text-align: center; font-size: 14px; line-height: 20px;"
+      >
+        Here is some text.
+        <br />
+        Tel:
+        <a
+          href="#"
+          style="color: #2f2f2b; font-size: 16px; text-decoration: none;"
+          itemprop="telephone"
+        >
+          08-123 456 78
+        </a>
+      </p>
+    `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+      <p
+        style="margin: 0px; color: #2f2f2b; text-align: center; font-size: 14px; line-height: 20px;"
+      >
+        Here is some text.
+        <br />
+        Tel:
+        <a href="#" style="color: #2f2f2b; font-size: 16px; text-decoration: none;" itemprop="telephone">08-123 456 78</a>
+      </p>
+    `)
+
+    expect(formatter.format(result)).toBe(result)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/564#issuecomment-3371485687", () => {
+    const input = dedent`
+      <p>Should not be duplicated.<br />Text with a inline element<a href="mailto:something@something.com">something@something.com</a> and some more text after</p>
+    `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+      <p>
+        Should not be duplicated.
+        <br />
+        Text with a inline element
+        <a href="mailto:something@something.com">something@something.com</a> and some
+        more text after
+      </p>
+    `)
+
+    expect(formatter.format(result)).toBe(result)
+  })
+
+  test("handles inline HTML elements with long text content", () => {
+    const input = dedent`
+       <p>
+         Visit <a href="/products">our amazing product catalog with hundreds of items</a> or <a href="/support">contact our customer support team</a> for assistance with your order.
+       </p>
+     `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+       <p>
+         Visit
+         <a href="/products">our amazing product catalog with hundreds of items</a> or
+         <a href="/support">contact our customer support team</a> for assistance with
+         your order.
+       </p>
+     `)
+  })
+
+  test("handles multiple inline elements with adjacent text", () => {
+    const input = dedent`
+       <div>
+         Call us at <strong>555-123-4567</strong>, email <a href="mailto:help@example.com">help@example.com</a>, or visit <em>our downtown office</em> during business hours.
+       </div>
+     `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+       <div>
+         Call us at <strong>555-123-4567</strong>, email
+         <a href="mailto:help@example.com">help@example.com</a>, or visit
+         <em>our downtown office</em> during business hours.
+       </div>
+     `)
+  })
+
+  test("handles inline elements with punctuation attachment", () => {
+    const input = dedent`
+       <p>
+         Read the <a href="/terms">terms and conditions</a>, review our <a href="/privacy">privacy policy</a>, and check the <a href="/faq">frequently asked questions</a>.
+       </p>
+     `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+       <p>
+         Read the <a href="/terms">terms and conditions</a>, review our
+         <a href="/privacy">privacy policy</a>, and check the
+         <a href="/faq">frequently asked questions</a>.
+       </p>
+     `)
+  })
+
+  test("handles nested inline elements with line wrapping", () => {
+    const input = dedent`
+       <p>
+         Please review <strong>Chapter <em>3: Advanced Techniques</em> in the <a href="/manual">user manual</a></strong> for detailed instructions on configuration.
+       </p>
+     `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+       <p>
+         Please review
+         <strong>Chapter <em>3: Advanced Techniques</em> in the <a href="/manual">user manual</a></strong>
+         for detailed instructions on configuration.
+       </p>
+     `)
+  })
+
+  test("handles inline elements immediately followed by punctuation", () => {
+    const input = dedent`
+       <div>
+         Download the <a href="/app.zip">latest version</a>; install it quickly; then restart your <strong>computer</strong>!
+       </div>
+     `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+       <div>
+         Download the <a href="/app.zip">latest version</a>; install it quickly; then
+         restart your <strong>computer</strong>!
+       </div>
+     `)
+  })
+
+  test("handles mixed content with inline elements and long URLs", () => {
+    const input = dedent`
+       <p>
+         For more information, visit <a href="https://example.com/very/long/path/to/documentation/page">our comprehensive documentation</a> or contact support.
+       </p>
+     `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+       <p>
+         For more information, visit
+         <a href="https://example.com/very/long/path/to/documentation/page">our comprehensive documentation</a>
+         or contact support.
+       </p>
+     `)
+  })
+
+  test("handles anchor tags with content that forces line breaks", () => {
+    const input = dedent`
+       <p>
+         For more information, visit <a href="https://example.com/very/long/path/to/documentation/page/so/long/that/it/should/break/the/content/of/the/tag">our comprehensive documentation</a> or contact support.
+       </p>
+     `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+       <p>
+         For more information, visit
+         <a href="https://example.com/very/long/path/to/documentation/page/so/long/that/it/should/break/the/content/of/the/tag">our comprehensive documentation</a>
+         or contact support.
+       </p>
+     `)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/469#issue-3379906221", () => {
+    const input = dedent`
+       <%= @user.translated_greeting %>,<br>
+     `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+       <%= @user.translated_greeting %>,<br>
+     `)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issue-3351228515", () => {
+    const input = dedent`
+      <!DOCTYPE html>
+      <html xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office" data-theme="light">
+        <head>
+          <meta charset="utf-8">
+          <meta http-equiv="x-ua-compatible" content="ie=edge">
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+          <meta name="format-detection" content="telephone=no, date=no, address=no, email=no, url=no">
+          <meta name="x-apple-disable-message-reformatting">
+          <title><%= message.subject %> | Company</title>
+          <%= stylesheet_link_tag "mailer", media: "all" %>
+          <style>
+            @import url('https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;600;700&display=swap');
+          </style>
+          <style>
+            @media only screen and (max-width: 600px) {
+              .hidden-mobile {
+                display: none !important;
+              }
+            }
+            @media only screen and (min-width: 601px) {
+              .hidden-desktop {
+                display: none !important;
+              }
+            }
+          </style>
+        </head>
+        <body  style="font-family: 'DM Sans', Arial, sans-serif;">
+          <% if content_for?(:preheader) %>
+            <div class="hidden">
+              <%= yield :preheader %>
+            </div>
+          <% end %>
+          <div role="article" aria-roledescription="email" aria-label="<%= message.subject %>" lang="en">
+            <table border="0" cellpadding="0" cellspacing="0" width="100%" class="bg-background leading-normal text-base">
+              <tr>
+                <td height="32"></td>
+              </tr>
+              <tr>
+                <td align="center">
+                  <table border="0" cellpadding="0" cellspacing="0" class="w-full max-w-[684px] px-0 sm:w-[684px] sm-px-2" width="100%">
+                    <tr>
+                      <td>
+                        <div class="shadow-xl border border-border-secondary rounded-lg overflow-hidden">
+                          <div class="space-y-2 bg-primary-foreground p-4"><% if content_for?(:header) %>
+                              <%= yield :header %>
+                            <% else %>
+                              <%= hosted_image_tag('mailer/header-logo.png', class: 'h-[35px] block mb-3') %>
+                            <% end %>
+                            <%= yield %>
+                          </div>
+                          <div class="p-4 bg-primary-foreground text-center border-t border-border-secondary">
+                            <%= hosted_image_tag('mailer/footer-logo.png', class: 'h-[48px] mb-1') %>
+                            <p class="text-muted-foreground text-sm leading-5">
+                              &copy;<%= Time.current.year %> - Company Inc, All rights reserved.
+                              <br />
+                              Main Street, San Francisco, CAs, USA 12345
+                              <br />
+                              <a href="mailto:support@company.com">Contact Support</a> | <a href="https://company.com/terms">Terms of Service</a> | <a href="https://company.com/privacy">Privacy Policy</a>
+                            </p>
+                          </div>
+                        </div>
+                      </td>
+                    </tr>
+                  </table>
+                </td>
+              </tr>
+              <tr>
+                <td height="32"></td>
+              </tr>
+            </table>
+          </div>
+        </body>
+      </html>
+    `
+
+    const expected = dedent`
+      <!DOCTYPE html>
+
+      <html
+        xmlns:v="urn:schemas-microsoft-com:vml"
+        xmlns:o="urn:schemas-microsoft-com:office:office"
+        data-theme="light"
+      >
+        <head>
+          <meta charset="utf-8">
+
+          <meta http-equiv="x-ua-compatible" content="ie=edge">
+
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+
+          <meta
+            name="format-detection"
+            content="telephone=no, date=no, address=no, email=no, url=no"
+          >
+
+          <meta name="x-apple-disable-message-reformatting">
+
+          <title><%= message.subject %> | Company</title>
+
+          <%= stylesheet_link_tag "mailer", media: "all" %>
+          <style>
+            @import url('https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;600;700&display=swap');
+          </style>
+
+          <style>
+            @media only screen and (max-width: 600px) {
+              .hidden-mobile {
+                display: none !important;
+              }
+            }
+            @media only screen and (min-width: 601px) {
+              .hidden-desktop {
+                display: none !important;
+              }
+            }
+          </style>
+        </head>
+        <body style="font-family: 'DM Sans', Arial, sans-serif;">
+          <% if content_for?(:preheader) %>
+            <div class="hidden"><%= yield :preheader %></div>
+          <% end %>
+          <div
+            role="article"
+            aria-roledescription="email"
+            aria-label="<%= message.subject %>"
+            lang="en"
+          >
+            <table
+              border="0"
+              cellpadding="0"
+              cellspacing="0"
+              width="100%"
+              class="bg-background leading-normal text-base"
+            >
+              <tr>
+                <td height="32"></td>
+              </tr>
+              <tr>
+                <td align="center">
+                  <table
+                    border="0"
+                    cellpadding="0"
+                    cellspacing="0"
+                    class="w-full max-w-[684px] px-0 sm:w-[684px] sm-px-2"
+                    width="100%"
+                  >
+                    <tr>
+                      <td>
+                        <div
+                          class="
+                            shadow-xl border border-border-secondary rounded-lg
+                            overflow-hidden
+                          "
+                        >
+                          <div class="space-y-2 bg-primary-foreground p-4">
+                            <% if content_for?(:header) %>
+                              <%= yield :header %>
+                            <% else %>
+                              <%= hosted_image_tag('mailer/header-logo.png', class: 'h-[35px] block mb-3') %>
+                            <% end %>
+                            <%= yield %>
+                          </div>
+                          <div
+                            class="
+                              p-4 bg-primary-foreground text-center border-t
+                              border-border-secondary
+                            "
+                          >
+                            <%= hosted_image_tag('mailer/footer-logo.png', class: 'h-[48px] mb-1') %>
+                            <p class="text-muted-foreground text-sm leading-5">
+                              &copy; <%= Time.current.year %> - Company Inc, All
+                              rights reserved.
+                              <br />
+                              Main Street, San Francisco, CAs, USA 12345
+                              <br />
+                              <a href="mailto:support@company.com">Contact Support</a>
+                              |
+                              <a href="https://company.com/terms">Terms of Service</a>
+                              |
+                              <a href="https://company.com/privacy">Privacy Policy</a>
+                            </p>
+                          </div>
+                        </div>
+                      </td>
+                    </tr>
+                  </table>
+                </td>
+              </tr>
+              <tr>
+                <td height="32"></td>
+              </tr>
+            </table>
+          </div>
+        </body>
+      </html>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issuecomment-3219820557 Example 1", () => {
+    const input = dedent`
+      <% unless skip_sidebar? || sidebar_sections_for_action.blank? %>
+      <!-- <details class="d-collapse overflow-visible d-collapse-arrow border" <%= 'open' if params[:commit] == "Filter" && params[:q].present? %>> -->
+        <!-- <summary class="d-collapse-title text-xl font-medium">Filters</summary> -->
+        <!-- <div class="d-collapse-content"> </div> -->
+      <!-- </details> -->
+      <%= render "active_admin/shared/sidebar_sections" %>
+      <% end %>
+    `
+
+    const expected = dedent`
+      <% unless skip_sidebar? || sidebar_sections_for_action.blank? %>
+        <!-- <details class="d-collapse overflow-visible d-collapse-arrow border" <%= 'open' if params[:commit] == "Filter" && params[:q].present? %>> -->
+        <!-- <summary class="d-collapse-title text-xl font-medium">Filters</summary> -->
+        <!-- <div class="d-collapse-content"> </div> -->
+        <!-- </details> -->
+        <%= render "active_admin/shared/sidebar_sections" %>
+      <% end %>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issuecomment-3219820557 Example 2", () => {
+    const input = dedent`
+      <div class="relative">
+      <button id="column-toggle-btn" class="d-btn d-btn-sm d-btn-secondary">
+        <span>Show/Hide Columns</span>
+      </button>
+      <div id="column-dropdown" class="absolute right-0 mt-1 bg-white border rounded-md shadow-lg z-10 p-2 hidden">
+        <div class="flex flex-col space-y-1 min-w-[200px]">
+          <% columns.each do |column| %>
+            <div class="form-control">
+              <label class="cursor-pointer label justify-start gap-2">
+                <input type="checkbox" class="column-toggle checkbox checkbox-sm" data-column="<%= column[:name] %>" <%= 'checked' if column[:default_visible] %>>
+                <span class="label-text text-muted-foreground">
+                  <%= column[:label] %>
+                </span>
+              </label>
+            </div>
+          <% end %>
+        </div>
+      </div>
+      </div>
+
+      <script>
+      document.addEventListener('DOMContentLoaded', function() {
+        // Column toggle functionality
+        const columnToggleBtn = document.getElementById('column-toggle-btn');
+        const columnDropdown = document.getElementById('column-dropdown');
+
+        // Toggle dropdown visibility
+        columnToggleBtn.addEventListener('click', function() {
+          columnDropdown.classList.toggle('hidden');
+        });
+
+        // Close dropdown when clicking outside
+        document.addEventListener('click', function(event) {
+          if (!columnToggleBtn.contains(event.target) && !columnDropdown.contains(event.target)) {
+            columnDropdown.classList.add('hidden');
+          }
+        });
+
+        // Handle column visibility toggles
+        const columnToggles = document.querySelectorAll('.column-toggle');
+        columnToggles.forEach(toggle => {
+          toggle.addEventListener('change', function() {
+            const columnName = this.dataset.column;
+            const columnCells = document.querySelectorAll(\`.column-\${columnName}\`);
+
+            columnCells.forEach(cell => {
+              if (this.checked) {
+                cell.style.display = '';
+              } else {
+                cell.style.display = 'none';
+              }
+            });
+
+            // Save column visibility preferences to localStorage
+            localStorage.setItem(\`column_\${columnName}\`, this.checked ? 'visible' : 'hidden');
+          });
+
+          // Apply saved preferences on load
+          const columnName = toggle.dataset.column;
+          const savedPreference = localStorage.getItem(\`column_\${columnName}\`);
+
+          if (savedPreference === 'hidden') {
+            toggle.checked = false;
+            const columnCells = document.querySelectorAll(\`.column-\${columnName}\`);
+            columnCells.forEach(cell => {
+              cell.style.display = 'none';
+            });
+          }
+        });
+
+         columnToggles.forEach(toggle => {
+          if (!toggle.checked) {
+            const columnName = toggle.dataset.column;
+            const columnCells = document.querySelectorAll(\`.column-\${columnName}\`);
+            columnCells.forEach(cell => {
+              cell.style.display = 'none';
+            });
+          }
+        });
+      });
+      </script>
+     `
+
+     const expected = dedent`
+       <div class="relative">
+         <button id="column-toggle-btn" class="d-btn d-btn-sm d-btn-secondary">
+           <span>Show/Hide Columns</span>
+         </button>
+         <div
+           id="column-dropdown"
+           class="
+             absolute right-0 mt-1 bg-white border rounded-md shadow-lg z-10 p-2
+             hidden
+           "
+         >
+           <div class="flex flex-col space-y-1 min-w-[200px]">
+             <% columns.each do |column| %>
+               <div class="form-control">
+                 <label class="cursor-pointer label justify-start gap-2">
+                   <input
+                     type="checkbox"
+                     class="column-toggle checkbox checkbox-sm"
+                     data-column="<%= column[:name] %>"
+                     <%= 'checked' if column[:default_visible] %>
+                   >
+                   <span class="label-text text-muted-foreground"><%= column[:label] %></span>
+                 </label>
+               </div>
+             <% end %>
+           </div>
+         </div>
+       </div>
+
+       <script>
+       document.addEventListener('DOMContentLoaded', function() {
+         // Column toggle functionality
+         const columnToggleBtn = document.getElementById('column-toggle-btn');
+         const columnDropdown = document.getElementById('column-dropdown');
+
+         // Toggle dropdown visibility
+         columnToggleBtn.addEventListener('click', function() {
+           columnDropdown.classList.toggle('hidden');
+         });
+
+         // Close dropdown when clicking outside
+         document.addEventListener('click', function(event) {
+           if (!columnToggleBtn.contains(event.target) && !columnDropdown.contains(event.target)) {
+             columnDropdown.classList.add('hidden');
+           }
+         });
+
+         // Handle column visibility toggles
+         const columnToggles = document.querySelectorAll('.column-toggle');
+         columnToggles.forEach(toggle => {
+           toggle.addEventListener('change', function() {
+             const columnName = this.dataset.column;
+             const columnCells = document.querySelectorAll(\`.column-\${columnName}\`);
+
+             columnCells.forEach(cell => {
+               if (this.checked) {
+                 cell.style.display = '';
+               } else {
+                 cell.style.display = 'none';
+               }
+             });
+
+             // Save column visibility preferences to localStorage
+             localStorage.setItem(\`column_\${columnName}\`, this.checked ? 'visible' : 'hidden');
+           });
+
+           // Apply saved preferences on load
+           const columnName = toggle.dataset.column;
+           const savedPreference = localStorage.getItem(\`column_\${columnName}\`);
+
+           if (savedPreference === 'hidden') {
+             toggle.checked = false;
+             const columnCells = document.querySelectorAll(\`.column-\${columnName}\`);
+             columnCells.forEach(cell => {
+               cell.style.display = 'none';
+             });
+           }
+         });
+
+          columnToggles.forEach(toggle => {
+           if (!toggle.checked) {
+             const columnName = toggle.dataset.column;
+             const columnCells = document.querySelectorAll(\`.column-\${columnName}\`);
+             columnCells.forEach(cell => {
+               cell.style.display = 'none';
+             });
+           }
+         });
+       });
+       </script>
+     `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issuecomment-3219820557 Example 3", () => {
+    const input = dedent`
+      <style>
+        [data-test-page-header] {
+          margin-bottom: 0px;
+        }
+
+        @media (max-width: 768px) {
+          [data-test-page-header] nav {
+            display: none;
+          }
+        }
+      </style>
+
+      <% content_for :head do %>
+        <%= javascript_import_module_tag "src/chat" %>
+      <% end %>
+
+      <script>
+        window.chat_id = <%= chat.id %>;
+        window.chat_display_name = <%= chat.display_name.to_json.html_safe %>;
+        window.messages = <%= messages.to_json.html_safe %>;
+        window.settings = <%= chat.settings.to_json.html_safe %>;
+      </script>
+
+      <div class="pt-3" id="chat"></div>
+     `
+
+    const result = formatter.format(input)
+    expect(result).toBe(input)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issuecomment-3219820557 Example 4", () => {
+    const input = dedent`
+      <% prices = params.dig("subscription", "prices") || resource.price_list.dig("products")&.map { |key, value| {product_id: key, stripe_price_id: value} } || [{product_id: Product::PUBLIC_IDS[:overweight]}] %>
+      <%= semantic_form_for [:admin, resource], url: override_prices_admin_subscription_path(resource), method: :post do |f| %>
+        <div>
+          <%= f.inputs do %>
+            <div id="price-inputs-container">
+              <% prices.each_with_index do |price, index| %>
+                <% stripe_price = Rails.cache.fetch("stripe_price_#{price[:stripe_price_id]}", expires_in: 1.hour) { Stripe::Price.retrieve(price[:stripe_price_id]) } if price[:stripe_price_id].present? %>
+
+                <div class="price-override-item">
+                  <%= f.input :product_id,
+                    as: :select,
+                    collection: Product.all,
+                    selected: price[:product_id],
+                    label: "Product #{index + 1}",
+                    value_field: :public_id,
+                    input_html: {
+                      name: "subscription[prices][#{index}][product_id]",
+                    } %>
+
+                  <%= f.input :amount,
+                    as: :number,
+                    label: "Price",
+                    input_html: {
+                      name: "subscription[prices][#{index}][amount]",
+                      value: price[:amount]&.to_i || stripe_price&.unit_amount&./(100) || 0,
+                      min: 0
+                    } %>
+
+                  <% if index > 0 %>
+                    <a
+                      href="#"
+                      class="remove-price-item link text-red-500 hover:text-red-700"
+                    >
+                      Remove Product
+                    </a>
+                  <% end %>
+                </div>
+              <% end %>
+            </div>
+
+            <div class="add-price-section">
+              <%= link_to "Add Another Product", "#", id: "add-price-btn", class: "button secondary" %>
+            </div>
+          <% end %>
+        </div>
+
+        <script id="price_item_template" type="text/template">
+          <div class="price-override-item">
+            <%= f.input :product_id,
+              as: :select,
+              collection: Product.all,
+              label: "Product INDEX_LABEL",
+              class: "select required",
+              value_field: :public_id,
+              input_html: {
+                id: "subscription_prices_INDEX_product_id",
+                name: "subscription[prices][INDEX][product_id]",
+                data: {
+                  searchable_field: "name",
+                  display_field: "display_name",
+                  search_url: "/admin/products.json?order=id_desc&q%5Bname_cont%5D={{query}}&commit=Filter"
+                }
+              } %>
+            <%= f.input :amount,
+              label: "Custom Price",
+              as: :number,
+              input_html: {
+                id: "subscription_prices_INDEX_amount",
+                name: "subscription[prices][INDEX][amount]",
+                value: 0,
+                min: 0,
+              } %>
+
+            <a href="#" class="remove-price-item link text-red-500 hover:text-red-700">Remove Product</a>
+          </div>
+        </script>
+
+        <div>
+          <%= f.actions do %>
+            <%= f.action :submit, label: "Override Prices" %>
+            <%= link_to "Cancel", resource_path(resource), class: "button" %>
+          <% end %>
+        </div>
+      <% end %>
+
+      <script>
+        document.addEventListener('DOMContentLoaded', function() {
+          var addPriceBtn = document.querySelector('#add-price-btn');
+          var container = document.querySelector('#price-inputs-container');
+          var template = document.querySelector('#price_item_template').innerHTML;
+          var priceItemCounter = <%= prices.length %>;
+
+          addPriceBtn.addEventListener('click', function(e) {
+            e.preventDefault();
+            var newTemplate = template
+              .replace(/INDEX_LABEL/g, priceItemCounter + 1)
+              .replace(/INDEX/g, priceItemCounter);
+            container.insertAdjacentHTML('beforeend', newTemplate);
+
+            var newItem = container.querySelector('.price-override-item:last-child');
+            var selectElement = newItem.querySelector('select');
+
+            if (selectElement && selectElement.dataset.searchUrl) {
+              new TomSelect(selectElement, {
+                allowEmptyOption: true,
+                create: false,
+                itemClass: "text-foreground px-1 py-0.5 rounded",
+                valueField: selectElement.dataset.valueField,
+                labelField: selectElement.dataset.displayField,
+                searchField: [selectElement.dataset.displayField],
+                plugins: ['dropdown_input'],
+
+                render: {
+                  option: function(data, escape) {
+                    return '<div>' + escape(data[selectElement.dataset.displayField] || '[blank]') + '</div>';
+                  },
+                  item: function(data, escape) {
+                    return '<div>' + escape(data[selectElement.dataset.displayField] || '[blank]') + '</div>';
+                  },
+                },
+
+                load: function(query, callback) {
+                  if (!query.length) return callback();
+                  fetch(selectElement.dataset.searchUrl.replace('{{query}}', encodeURIComponent(query)))
+                    .then(function(response) {
+                      return response.json();
+                    })
+                    .then(function(json) {
+                      const augmentedJson = json.map(item => ({ ...item, search_term: Object.values(item).join(' ') }))
+                      callback(augmentedJson);
+                    }).catch(function() {
+                      callback();
+                    });
+                },
+              });
+            }
+
+            priceItemCounter++;
+          });
+
+          container.addEventListener('click', function(e) {
+            if (e.target && e.target.classList.contains('remove-price-item')) {
+              e.preventDefault();
+              var priceItem = e.target.closest('.price-override-item');
+              if (priceItem) {
+                var destroyInput = priceItem.querySelector('input[type="hidden"][name*="[_destroy]"]');
+                if (destroyInput) {
+                  destroyInput.value = '1';
+                  priceItem.style.display = 'none';
+                } else {
+                  priceItem.remove();
+                }
+              }
+            }
+          });
+        });
+      </script>
+     `
+
+     const expected = dedent`
+       <% prices = params.dig("subscription", "prices") || resource.price_list.dig("products")&.map { |key, value| {product_id: key, stripe_price_id: value} } || [{product_id: Product::PUBLIC_IDS[:overweight]}] %>
+
+       <%= semantic_form_for [:admin, resource], url: override_prices_admin_subscription_path(resource), method: :post do |f| %>
+         <div>
+           <%= f.inputs do %>
+             <div id="price-inputs-container">
+               <% prices.each_with_index do |price, index| %>
+                 <% stripe_price = Rails.cache.fetch("stripe_price_#{price[:stripe_price_id]}", expires_in: 1.hour) { Stripe::Price.retrieve(price[:stripe_price_id]) } if price[:stripe_price_id].present? %>
+
+                 <div class="price-override-item">
+                   <%= f.input :product_id,
+                     as: :select,
+                     collection: Product.all,
+                     selected: price[:product_id],
+                     label: "Product #{index + 1}",
+                     value_field: :public_id,
+                     input_html: {
+                       name: "subscription[prices][#{index}][product_id]",
+                     } %>
+
+                   <%= f.input :amount,
+                     as: :number,
+                     label: "Price",
+                     input_html: {
+                       name: "subscription[prices][#{index}][amount]",
+                       value: price[:amount]&.to_i || stripe_price&.unit_amount&./(100) || 0,
+                       min: 0
+                     } %>
+
+                   <% if index > 0 %>
+                     <a
+                       href="#"
+                       class="remove-price-item link text-red-500 hover:text-red-700"
+                     >
+                       Remove Product
+                     </a>
+                   <% end %>
+                 </div>
+               <% end %>
+             </div>
+
+             <div class="add-price-section">
+               <%= link_to "Add Another Product", "#", id: "add-price-btn", class: "button secondary" %>
+             </div>
+           <% end %>
+         </div>
+
+         <script id="price_item_template" type="text/template">
+           <div class="price-override-item">
+             <%= f.input :product_id,
+               as: :select,
+               collection: Product.all,
+               label: "Product INDEX_LABEL",
+               class: "select required",
+               value_field: :public_id,
+               input_html: {
+                 id: "subscription_prices_INDEX_product_id",
+                 name: "subscription[prices][INDEX][product_id]",
+                 data: {
+                   searchable_field: "name",
+                   display_field: "display_name",
+                   search_url: "/admin/products.json?order=id_desc&q%5Bname_cont%5D={{query}}&commit=Filter"
+                 }
+               } %>
+             <%= f.input :amount,
+               label: "Custom Price",
+               as: :number,
+               input_html: {
+                 id: "subscription_prices_INDEX_amount",
+                 name: "subscription[prices][INDEX][amount]",
+                 value: 0,
+                 min: 0,
+               } %>
+
+             <a href="#" class="remove-price-item link text-red-500 hover:text-red-700">Remove Product</a>
+           </div>
+         </script>
+
+         <div>
+           <%= f.actions do %>
+             <%= f.action :submit, label: "Override Prices" %>
+             <%= link_to "Cancel", resource_path(resource), class: "button" %>
+           <% end %>
+         </div>
+       <% end %>
+
+       <script>
+         document.addEventListener('DOMContentLoaded', function() {
+           var addPriceBtn = document.querySelector('#add-price-btn');
+           var container = document.querySelector('#price-inputs-container');
+           var template = document.querySelector('#price_item_template').innerHTML;
+           var priceItemCounter = <%= prices.length %>;
+
+           addPriceBtn.addEventListener('click', function(e) {
+             e.preventDefault();
+             var newTemplate = template
+               .replace(/INDEX_LABEL/g, priceItemCounter + 1)
+               .replace(/INDEX/g, priceItemCounter);
+             container.insertAdjacentHTML('beforeend', newTemplate);
+
+             var newItem = container.querySelector('.price-override-item:last-child');
+             var selectElement = newItem.querySelector('select');
+
+             if (selectElement && selectElement.dataset.searchUrl) {
+               new TomSelect(selectElement, {
+                 allowEmptyOption: true,
+                 create: false,
+                 itemClass: "text-foreground px-1 py-0.5 rounded",
+                 valueField: selectElement.dataset.valueField,
+                 labelField: selectElement.dataset.displayField,
+                 searchField: [selectElement.dataset.displayField],
+                 plugins: ['dropdown_input'],
+
+                 render: {
+                   option: function(data, escape) {
+                     return '<div>' + escape(data[selectElement.dataset.displayField] || '[blank]') + '</div>';
+                   },
+                   item: function(data, escape) {
+                     return '<div>' + escape(data[selectElement.dataset.displayField] || '[blank]') + '</div>';
+                   },
+                 },
+
+                 load: function(query, callback) {
+                   if (!query.length) return callback();
+                   fetch(selectElement.dataset.searchUrl.replace('{{query}}', encodeURIComponent(query)))
+                     .then(function(response) {
+                       return response.json();
+                     })
+                     .then(function(json) {
+                       const augmentedJson = json.map(item => ({ ...item, search_term: Object.values(item).join(' ') }))
+                       callback(augmentedJson);
+                     }).catch(function() {
+                       callback();
+                     });
+                 },
+               });
+             }
+
+             priceItemCounter++;
+           });
+
+           container.addEventListener('click', function(e) {
+             if (e.target && e.target.classList.contains('remove-price-item')) {
+               e.preventDefault();
+               var priceItem = e.target.closest('.price-override-item');
+               if (priceItem) {
+                 var destroyInput = priceItem.querySelector('input[type="hidden"][name*="[_destroy]"]');
+                 if (destroyInput) {
+                   destroyInput.value = '1';
+                   priceItem.style.display = 'none';
+                 } else {
+                   priceItem.remove();
+                 }
+               }
+             }
+           });
+         });
+       </script>
+     `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issuecomment-3219820557 Example 5", () => {
+    const input = dedent`
+      <%# Non-link tag that stands for skipped pages...
+        - available local variables
+          current_page:  a page object for the currently displayed page
+          total_pages:   total number of pages
+          per_page:      number of items to fetch per page
+          remote:        data-remote
+      -%>
+      <span class="flex items-center justify-center px-2.5 py-3 h-8 leading-tight text-gray-500 dark:text-gray-400">
+        <%= t('views.pagination.truncate').html_safe %>
+      </span>
+     `
+    const expected = dedent`
+      <%#
+        Non-link tag that stands for skipped pages...
+        - available local variables
+          current_page:  a page object for the currently displayed page
+          total_pages:   total number of pages
+          per_page:      number of items to fetch per page
+          remote:        data-remote
+      -%>
+
+      <span
+        class="
+          flex items-center justify-center px-2.5 py-3 h-8 leading-tight
+          text-gray-500 dark:text-gray-400
+        "
+      >
+        <%= t('views.pagination.truncate').html_safe %>
+      </span>
+     `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issuecomment-3219820557 Example 6", () => {
+    const input = dedent`
+      <%= render 'user_mailer/greeting' %>
+      <p>
+        Welcome back! Your subscription to the <b><%= @subscription.plan&.name || "Custom Plan" %></b> has been successfully resumed.
+      </p>
+      <p>
+      Subscription Details:<br>
+      Plan Name: <b><%= @subscription.plan&.name || "Custom Plan" %></b><br>
+      Resumption Date: <b><%= render_date(Time.current, format: '%B %e, %Y') %></b><br>
+      Pickups Left: <b><%= @subscription.credit_service.available_credits.values.first || 0 %><%= " (#{@subscription.loads * 20}lbs per pickup)" if @subscription.loads > 0 %></b><br>
+      Next Billing Date: <b><%= render_date(@subscription.current_period_end, format: '%B %e, %Y') %></b><br>
+      </p>
+
+      <p>Why wait now? Schedule your next pickup today!</p>
+
+      <%= render "user_mailer/schedule_now" %>
+      <%= render "user_subscription_mailer/more_info" %>
+      <%= render "user_mailer/questions" %>
+      <p>
+      Thank you for choosing Company again. We look forward to serving you!
+      </p>
+      <%= render "user_mailer/thanks" %>
+     `
+
+    const expected = dedent`
+      <%= render 'user_mailer/greeting' %>
+
+      <p>
+        Welcome back! Your subscription to the
+        <b><%= @subscription.plan&.name || "Custom Plan" %></b> has been successfully
+        resumed.
+      </p>
+
+      <p>
+        Subscription Details:
+        <br>
+        Plan Name: <b><%= @subscription.plan&.name || "Custom Plan" %></b>
+        <br>
+        Resumption Date: <b><%= render_date(Time.current, format: '%B %e, %Y') %></b>
+        <br>
+        Pickups Left:
+        <b><%= @subscription.credit_service.available_credits.values.first || 0 %><%= " (#{@subscription.loads * 20}lbs per pickup)" if @subscription.loads > 0 %></b>
+        <br>
+        Next Billing Date:
+        <b><%= render_date(@subscription.current_period_end, format: '%B %e, %Y') %></b>
+        <br>
+      </p>
+
+      <p>Why wait now? Schedule your next pickup today!</p>
+
+      <%= render "user_mailer/schedule_now" %>
+
+      <%= render "user_subscription_mailer/more_info" %>
+
+      <%= render "user_mailer/questions" %>
+
+      <p>
+        Thank you for choosing Company again. We look forward to serving you!
+      </p>
+
+      <%= render "user_mailer/thanks" %>
+     `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issuecomment-3356738094", () => {
+    const input = dedent`
+      <% if cover.present? %>
+        <figure class="figure">
+          <%= image_tag attachment_url(cover), size: "460x249", class: "img-fluid figure-img" %>
+          <figcaption class="figure-caption text-center">
+            <span>
+              <strong>Cover Image</strong><br>
+              Dimensions
+              <strong><%= "#{cover.metadata['width']}x#{cover.metadata['height']}" %></strong>
+              &mdash;
+              <%= link_to "View original", rails_blob_path(cover), target: "_blank", rel: "noopener" %>
+            </span>
+          </figcaption>
+        </figure>
+      <% end %>
+     `
+
+    const result = formatter.format(input)
+    expect(result).toBe(input)
+  })
+
+  test("adjecent ERB text within elements", () => {
+    const input = dedent`
+      <div>
+        <div>
+          <div>
+            <p><%= formatted %> text that needs <%= needs %> <%= to_be_formatted %> without being reset to the <b><i>start of the line</i></b>. Text <%= also_with %><%= ERB_tags_next_to_each_other %> and after.</p>
+          </div>
+        </div>
+      </div>
+    `
+
+    const expected = dedent`
+      <div>
+        <div>
+          <div>
+            <p>
+              <%= formatted %> text that needs <%= needs %> <%= to_be_formatted %>
+              without being reset to the <b><i>start of the line</i></b>. Text
+              <%= also_with %><%= ERB_tags_next_to_each_other %> and after.
+            </p>
+          </div>
+        </div>
+      </div>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
   })
 })
diff --git a/javascript/packages/formatter/test/html/comments.test.ts b/javascript/packages/formatter/test/html/comments.test.ts
index bfb55845b..02f70b1fe 100644
--- a/javascript/packages/formatter/test/html/comments.test.ts
+++ b/javascript/packages/formatter/test/html/comments.test.ts
@@ -36,11 +36,22 @@ describe("@herb-tools/formatter", () => {
     `)
   })
 
-  test("formats HTML comments and ERB comments", () => {
+  test("formats HTML comments and ERB comments on the same line", () => {
     const source = dedent`
       <!-- HTML Comment --><%# ERB Comment %>
     `
     const result = formatter.format(source)
+    expect(result).toEqual(dedent`
+      <!-- HTML Comment --><%# ERB Comment %>
+    `)
+  })
+
+  test("formats HTML comments and ERB comments on mutli-line", () => {
+    const source = dedent`
+      <!-- HTML Comment -->
+      <%# ERB Comment %>
+    `
+    const result = formatter.format(source)
     expect(result).toEqual(dedent`
       <!-- HTML Comment -->
 
@@ -118,7 +129,7 @@ describe("@herb-tools/formatter", () => {
     `)
   })
 
-  test.todo("indents multi-line HTML comment with ERB if", () => {
+  test.fails("indents multi-line HTML comment with ERB if", () => {
     const source = dedent`
       <!--
       <% if Rails.env.development? %>
diff --git a/javascript/packages/formatter/test/html/headings.test.ts b/javascript/packages/formatter/test/html/headings.test.ts
new file mode 100644
index 000000000..7cd84551a
--- /dev/null
+++ b/javascript/packages/formatter/test/html/headings.test.ts
@@ -0,0 +1,43 @@
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Formatter } from "../../src"
+
+import dedent from "dedent"
+
+let formatter: Formatter
+
+describe("@herb-tools/formatter", () => {
+  beforeAll(async () => {
+    await Herb.load()
+
+    formatter = new Formatter(Herb, {
+      indentWidth: 2,
+      maxLineLength: 80
+    })
+  })
+
+  test("formats headings", () => {
+    const source = dedent`
+      <h1>Heading Level 1</h1>
+      <h2>Heading Level 2</h2>
+      <h3>Heading Level 3</h3>
+      <h4>Heading Level 4</h4>
+      <h5>Heading Level 5</h5>
+      <h6>Heading Level 6</h6>
+    `
+    const result = formatter.format(source)
+    expect(result).toEqual(dedent`
+      <h1>Heading Level 1</h1>
+
+      <h2>Heading Level 2</h2>
+
+      <h3>Heading Level 3</h3>
+
+      <h4>Heading Level 4</h4>
+
+      <h5>Heading Level 5</h5>
+
+      <h6>Heading Level 6</h6>
+    `)
+  })
+})
diff --git a/javascript/packages/formatter/test/html/lists.test.ts b/javascript/packages/formatter/test/html/lists.test.ts
new file mode 100644
index 000000000..3c59a19b3
--- /dev/null
+++ b/javascript/packages/formatter/test/html/lists.test.ts
@@ -0,0 +1,58 @@
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Formatter } from "../../src"
+
+import dedent from "dedent"
+
+let formatter: Formatter
+
+describe("@herb-tools/formatter", () => {
+  beforeAll(async () => {
+    await Herb.load()
+
+    formatter = new Formatter(Herb, {
+      indentWidth: 2,
+      maxLineLength: 80
+    })
+  })
+
+  test("formats <ul>", () => {
+    const source = dedent`
+      <ul>
+      <li>List Item 1</li>
+      <li>List Item 2</li>
+      <li>List Item 3</li>
+      <li>List Item 4</li>
+      </ul>
+    `
+    const result = formatter.format(source)
+    expect(result).toEqual(dedent`
+      <ul>
+        <li>List Item 1</li>
+        <li>List Item 2</li>
+        <li>List Item 3</li>
+        <li>List Item 4</li>
+      </ul>
+    `)
+  })
+
+  test("formats <ol>", () => {
+    const source = dedent`
+      <ol>
+      <li>List Item 1</li>
+      <li>List Item 2</li>
+      <li>List Item 3</li>
+      <li>List Item 4</li>
+      </ol>
+    `
+    const result = formatter.format(source)
+    expect(result).toEqual(dedent`
+      <ol>
+        <li>List Item 1</li>
+        <li>List Item 2</li>
+        <li>List Item 3</li>
+        <li>List Item 4</li>
+      </ol>
+    `)
+  })
+})
diff --git a/javascript/packages/language-server/test/formatting_service.test.ts b/javascript/packages/language-server/test/formatting_service.test.ts
index 719f83f59..690c1fc43 100644
--- a/javascript/packages/language-server/test/formatting_service.test.ts
+++ b/javascript/packages/language-server/test/formatting_service.test.ts
@@ -403,14 +403,8 @@ describe('FormattingService', () => {
 
       expect(result[0].newText).toBe(
         '      <p>\n' +
-        '        some\n' +
-        '        <%= formatted %>\n' +
-        '        text, that needs\n' +
-        '        <% needs %>\n' +
-        '        <% to_be_formatted %>\n' +
-        '        without being reset to the\n' +
-        '        <b><i>start of the line</i></b>\n' +
-        '        .\n' +
+        '        some <%= formatted %> text, that needs <% needs %> <% to_be_formatted %>\n' +
+        '        without being reset to the <b><i>start of the line</i></b>.\n' +
         '      </p>\n'
       )
     })

From c2dd6ffa1d16ff66cb29d434acd28c11b4f84b9a Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Thu, 9 Oct 2025 12:20:01 +0200
Subject: [PATCH 28/97] Formatter: Extract and refactor Format Helper Functions
 and Constants (#597)

This pull request reactors the `FormatPrinter` by extracting the
independent format helper functions to the `format-helpers.ts` file.

Follow up on #591.
---
 .../packages/formatter/src/format-helpers.ts  | 304 +++++++++++-
 .../packages/formatter/src/format-printer.ts  | 446 +++---------------
 2 files changed, 375 insertions(+), 375 deletions(-)

diff --git a/javascript/packages/formatter/src/format-helpers.ts b/javascript/packages/formatter/src/format-helpers.ts
index ce266df9e..01279ac95 100644
--- a/javascript/packages/formatter/src/format-helpers.ts
+++ b/javascript/packages/formatter/src/format-helpers.ts
@@ -1,5 +1,71 @@
-import { isNode } from "@herb-tools/core"
-import { Node, HTMLTextNode, WhitespaceNode } from "@herb-tools/core"
+import { isNode, isERBNode, getTagName, isAnyOf, isERBControlFlowNode, hasERBOutput } from "@herb-tools/core"
+import { Node, HTMLDoctypeNode, HTMLTextNode, HTMLElementNode, HTMLCommentNode, HTMLOpenTagNode, HTMLCloseTagNode, ERBIfNode, ERBContentNode, WhitespaceNode } from "@herb-tools/core"
+
+// --- Types ---
+
+/**
+ * Analysis result for HTMLElementNode formatting decisions
+ */
+export interface ElementFormattingAnalysis {
+  openTagInline: boolean
+  elementContentInline: boolean
+  closeTagInline: boolean
+}
+
+/**
+ * Content unit represents a piece of content in text flow
+ * Can be atomic (inline elements, ERB) or splittable (text)
+ */
+export interface ContentUnit {
+  content: string
+  type: 'text' | 'inline' | 'erb' | 'block'
+  isAtomic: boolean
+  breaksFlow: boolean
+}
+
+// --- Constants ---
+
+// TODO: we can probably expand this list with more tags/attributes
+export const FORMATTABLE_ATTRIBUTES: Record<string, string[]> = {
+  '*': ['class'],
+  'img': ['srcset', 'sizes']
+}
+
+export const INLINE_ELEMENTS = new Set([
+  'a', 'abbr', 'acronym', 'b', 'bdo', 'big', 'br', 'cite', 'code',
+  'dfn', 'em', 'i', 'img', 'kbd', 'label', 'map', 'object', 'q',
+  'samp', 'small', 'span', 'strong', 'sub', 'sup',
+  'tt', 'var', 'del', 'ins', 'mark', 's', 'u', 'time', 'wbr'
+])
+
+export const CONTENT_PRESERVING_ELEMENTS = new Set([
+  'script', 'style', 'pre', 'textarea'
+])
+
+export const SPACEABLE_CONTAINERS = new Set([
+  'div', 'section', 'article', 'main', 'header', 'footer', 'aside',
+  'figure', 'details', 'summary', 'dialog', 'fieldset'
+])
+
+export const TIGHT_GROUP_PARENTS = new Set([
+  'ul', 'ol', 'nav', 'select', 'datalist', 'optgroup', 'tr', 'thead',
+  'tbody', 'tfoot'
+])
+
+export const TIGHT_GROUP_CHILDREN = new Set([
+  'li', 'option', 'td', 'th', 'dt', 'dd'
+])
+
+export const SPACING_THRESHOLD = 3
+
+/**
+ * Token list attributes that contain space-separated values and benefit from
+ * spacing around ERB content for readability
+ */
+export const TOKEN_LIST_ATTRIBUTES = new Set([
+  'class', 'data-controller', 'data-action'
+])
+
 
 // --- Node Utility Functions ---
 
@@ -134,3 +200,237 @@ export function buildLineWithWord(currentLine: string, word: string): string {
 
   return needsSpaceBetween(currentLine, word) ? `${currentLine} ${word}` : `${currentLine}${word}`
 }
+
+/**
+ * Check if a node is an inline element or ERB node
+ */
+export function isInlineOrERBNode(node: Node): boolean {
+  return isERBNode(node) || (isNode(node, HTMLElementNode) && isInlineElement(getTagName(node)))
+}
+
+/**
+ * Check if an element should be treated as inline based on its tag name
+ */
+export function isInlineElement(tagName: string): boolean {
+  return INLINE_ELEMENTS.has(tagName.toLowerCase())
+}
+
+/**
+ * Check if the current inline element is adjacent to a previous inline element (no whitespace between)
+ */
+export function isAdjacentToPreviousInline(siblings: Node[], index: number): boolean {
+  const previousNode = siblings[index - 1]
+
+  if (isInlineOrERBNode(previousNode)) {
+    return true
+  }
+
+  if (index > 1 && isNode(previousNode, HTMLTextNode) && !/^\s/.test(previousNode.content)) {
+    const twoBack = siblings[index - 2]
+
+    return isInlineOrERBNode(twoBack)
+  }
+
+  return false
+}
+
+/**
+ * Check if a node should be appended to the last line (for adjacent inline elements and punctuation)
+ */
+export function shouldAppendToLastLine(child: Node, siblings: Node[], index: number): boolean {
+  if (index === 0) return false
+
+  if (isNode(child, HTMLTextNode) && !/^\s/.test(child.content)) {
+    const previousNode = siblings[index - 1]
+
+    return isInlineOrERBNode(previousNode)
+  }
+
+  if (isNode(child, HTMLElementNode) && isInlineElement(getTagName(child))) {
+    return isAdjacentToPreviousInline(siblings, index)
+  }
+
+  if (isNode(child, ERBContentNode)) {
+    for (let i = index - 1; i >= 0; i--) {
+      const previousSibling = siblings[i]
+
+      if (isPureWhitespaceNode(previousSibling) || isNode(previousSibling, WhitespaceNode)) {
+        continue
+      }
+
+      if (previousSibling.location && child.location) {
+        return previousSibling.location.end.line === child.location.start.line
+      }
+
+      break
+    }
+  }
+
+  return false
+}
+
+/**
+ * Check if user-intentional spacing should be preserved (double newlines between elements)
+ */
+export function shouldPreserveUserSpacing(child: Node, siblings: Node[], index: number): boolean {
+  if (!isPureWhitespaceNode(child)) return false
+
+  const hasPreviousNonWhitespace = index > 0 && isNonWhitespaceNode(siblings[index - 1])
+  const hasNextNonWhitespace = index < siblings.length - 1 && isNonWhitespaceNode(siblings[index + 1])
+  const hasMultipleNewlines = isNode(child, HTMLTextNode) && child.content.includes('\n\n')
+
+  return hasPreviousNonWhitespace && hasNextNonWhitespace && hasMultipleNewlines
+}
+
+
+/**
+ * Check if children contain any text content with newlines
+ */
+export function hasMultilineTextContent(children: Node[]): boolean {
+  for (const child of children) {
+    if (isNode(child, HTMLTextNode)) {
+      return child.content.includes('\n')
+    }
+
+    if (isNode(child, HTMLElementNode)) {
+      const nestedChildren = filterEmptyNodes(child.body)
+
+      if (hasMultilineTextContent(nestedChildren)) {
+        return true
+      }
+    }
+  }
+
+  return false
+}
+
+/**
+ * Check if all nested elements in the children are inline elements
+ */
+export function areAllNestedElementsInline(children: Node[]): boolean {
+  for (const child of children) {
+    if (isNode(child, HTMLElementNode)) {
+      if (!isInlineElement(getTagName(child))) {
+        return false
+      }
+
+      const nestedChildren = filterEmptyNodes(child.body)
+
+      if (!areAllNestedElementsInline(nestedChildren)) {
+        return false
+      }
+    } else if (isAnyOf(child, HTMLDoctypeNode, HTMLCommentNode, isERBControlFlowNode)) {
+      return false
+    }
+  }
+
+  return true
+}
+
+/**
+ * Check if element has complex ERB control flow
+ */
+export function hasComplexERBControlFlow(inlineNodes: Node[]): boolean {
+  return inlineNodes.some(node => {
+    if (isNode(node, ERBIfNode)) {
+      if (node.statements.length > 0 && node.location) {
+        const startLine = node.location.start.line
+        const endLine = node.location.end.line
+
+        return startLine !== endLine
+      }
+
+      return false
+    }
+
+    return false
+  })
+}
+
+/**
+ * Check if children contain mixed text and inline elements (like "text<em>inline</em>text")
+ * or mixed ERB output and text (like "<%= value %> text")
+ * This indicates content that should be formatted inline even with structural newlines
+ */
+export function hasMixedTextAndInlineContent(children: Node[]): boolean {
+  let hasText = false
+  let hasInlineElements = false
+
+  for (const child of children) {
+    if (isNode(child, HTMLTextNode)) {
+      if (child.content.trim() !== "") {
+        hasText = true
+      }
+    } else if (isNode(child, HTMLElementNode)) {
+      if (isInlineElement(getTagName(child))) {
+        hasInlineElements = true
+      }
+    }
+  }
+
+  return (hasText && hasInlineElements) || (hasERBOutput(children) && hasText)
+}
+
+export function isContentPreserving(element: HTMLElementNode | HTMLOpenTagNode | HTMLCloseTagNode): boolean {
+  const tagName = getTagName(element)
+
+  return CONTENT_PRESERVING_ELEMENTS.has(tagName)
+}
+
+/**
+ * Count consecutive inline elements/ERB at the start of children (with no whitespace between)
+ */
+export function countAdjacentInlineElements(children: Node[]): number {
+  let count = 0
+  let lastSignificantIndex = -1
+
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i]
+
+    if (isPureWhitespaceNode(child) || isNode(child, WhitespaceNode)) {
+      continue
+    }
+
+    const isInlineOrERB = (isNode(child, HTMLElementNode) && isInlineElement(getTagName(child))) || isNode(child, ERBContentNode)
+
+    if (!isInlineOrERB) {
+      break
+    }
+
+    if (lastSignificantIndex >= 0 && hasWhitespaceBetween(children, lastSignificantIndex, i)) {
+      break
+    }
+
+    count++
+    lastSignificantIndex = i
+  }
+
+  return count
+}
+
+/**
+ * Determine if we should wrap to the next line
+ */
+export function shouldWrapToNextLine(testLine: string, currentLine: string, word: string, wrapWidth: number): boolean {
+  if (!currentLine) return false
+  if (isClosingPunctuation(word)) return false
+
+  return testLine.length > wrapWidth
+}
+
+/**
+ * Check if a node represents a block-level element
+ */
+export function isBlockLevelNode(node: Node): boolean {
+  if (!isNode(node, HTMLElementNode)) {
+    return false
+  }
+
+  const tagName = getTagName(node)
+
+  if (INLINE_ELEMENTS.has(tagName)) {
+    return false
+  }
+
+  return true
+}
diff --git a/javascript/packages/formatter/src/format-printer.ts b/javascript/packages/formatter/src/format-printer.ts
index 13e005205..b79837721 100644
--- a/javascript/packages/formatter/src/format-printer.ts
+++ b/javascript/packages/formatter/src/format-printer.ts
@@ -1,4 +1,5 @@
 import dedent from "dedent"
+
 import {
   getTagName,
   getCombinedAttributeName,
@@ -6,26 +7,48 @@ import {
   isNode,
   isToken,
   isParseResult,
-  isAnyOf,
   isNoneOf,
   isERBNode,
   isCommentNode,
   isERBControlFlowNode,
   filterNodes,
-  hasERBOutput,
 } from "@herb-tools/core"
+
 import { Printer, IdentityPrinter } from "@herb-tools/printer"
+
 import {
-  isPureWhitespaceNode,
-  isNonWhitespaceNode,
-  findPreviousMeaningfulSibling,
-  hasWhitespaceBetween,
-  filterSignificantChildren,
-  filterEmptyNodes,
-  isClosingPunctuation,
-  lineEndsWithOpeningPunctuation,
-  needsSpaceBetween,
+  areAllNestedElementsInline,
   buildLineWithWord,
+  countAdjacentInlineElements,
+  filterEmptyNodes,
+  filterSignificantChildren,
+  findPreviousMeaningfulSibling,
+  hasComplexERBControlFlow,
+  hasMixedTextAndInlineContent,
+  hasMultilineTextContent,
+  isBlockLevelNode,
+  isContentPreserving,
+  isInlineElement,
+  isNonWhitespaceNode,
+  isPureWhitespaceNode,
+  shouldAppendToLastLine,
+  shouldPreserveUserSpacing,
+  shouldWrapToNextLine,
+} from "./format-helpers.js"
+
+import {
+  FORMATTABLE_ATTRIBUTES,
+  INLINE_ELEMENTS,
+  SPACEABLE_CONTAINERS,
+  SPACING_THRESHOLD,
+  TIGHT_GROUP_CHILDREN,
+  TIGHT_GROUP_PARENTS,
+  TOKEN_LIST_ATTRIBUTES,
+} from "./format-helpers.js"
+
+import type {
+  ContentUnit,
+  ElementFormattingAnalysis,
 } from "./format-helpers.js"
 
 import {
@@ -68,32 +91,6 @@ import {
 import type { ERBNode } from "@herb-tools/core"
 import type { FormatOptions } from "./options.js"
 
-/**
- * Analysis result for HTMLElementNode formatting decisions
- */
-interface ElementFormattingAnalysis {
-  openTagInline: boolean
-  elementContentInline: boolean
-  closeTagInline: boolean
-}
-
-/**
- * Content unit represents a piece of content in text flow
- * Can be atomic (inline elements, ERB) or splittable (text)
- */
-interface ContentUnit {
-  content: string
-  type: 'text' | 'inline' | 'erb' | 'block'
-  isAtomic: boolean
-  breaksFlow: boolean
-}
-
-// TODO: we can probably expand this list with more tags/attributes
-const FORMATTABLE_ATTRIBUTES: Record<string, string[]> = {
-  '*': ['class'],
-  'img': ['srcset', 'sizes']
-}
-
 /**
  * Printer traverses the Herb AST using the Visitor pattern
  * and emits a formatted string with proper indentation, line breaks, and attribute wrapping.
@@ -121,34 +118,6 @@ export class FormatPrinter extends Printer {
 
   public source: string
 
-  // TODO: extract
-  private static readonly INLINE_ELEMENTS = new Set([
-    'a', 'abbr', 'acronym', 'b', 'bdo', 'big', 'br', 'cite', 'code',
-    'dfn', 'em', 'i', 'img', 'kbd', 'label', 'map', 'object', 'q',
-    'samp', 'small', 'span', 'strong', 'sub', 'sup',
-    'tt', 'var', 'del', 'ins', 'mark', 's', 'u', 'time', 'wbr'
-  ])
-
-  private static readonly CONTENT_PRESERVING_ELEMENTS = new Set([
-    'script', 'style', 'pre', 'textarea'
-  ])
-
-  private static readonly SPACEABLE_CONTAINERS = new Set([
-    'div', 'section', 'article', 'main', 'header', 'footer', 'aside',
-    'figure', 'details', 'summary', 'dialog', 'fieldset'
-  ])
-
-  private static readonly TIGHT_GROUP_PARENTS = new Set([
-    'ul', 'ol', 'nav', 'select', 'datalist', 'optgroup', 'tr', 'thead',
-    'tbody', 'tfoot'
-  ])
-
-  private static readonly TIGHT_GROUP_CHILDREN = new Set([
-    'li', 'option', 'td', 'th', 'dt', 'dd'
-  ])
-
-  private static readonly SPACING_THRESHOLD = 3
-
   constructor(source: string, options: Required<FormatOptions>) {
     super()
 
@@ -345,17 +314,17 @@ export class FormatPrinter extends Printer {
 
     const meaningfulSiblings = siblings.filter(child => isNonWhitespaceNode(child))
 
-    if (meaningfulSiblings.length < FormatPrinter.SPACING_THRESHOLD) {
+    if (meaningfulSiblings.length < SPACING_THRESHOLD) {
       return false
     }
 
     const parentTagName = parentElement ? getTagName(parentElement) : null
 
-    if (parentTagName && FormatPrinter.TIGHT_GROUP_PARENTS.has(parentTagName)) {
+    if (parentTagName && TIGHT_GROUP_PARENTS.has(parentTagName)) {
       return false
     }
 
-    const isSpaceableContainer = !parentTagName || (parentTagName && FormatPrinter.SPACEABLE_CONTAINERS.has(parentTagName))
+    const isSpaceableContainer = !parentTagName || (parentTagName && SPACEABLE_CONTAINERS.has(parentTagName))
 
     if (!isSpaceableContainer && meaningfulSiblings.length < 5) {
       return false
@@ -381,11 +350,11 @@ export class FormatPrinter extends Printer {
     if (isNode(currentNode, HTMLElementNode)) {
       const currentTagName = getTagName(currentNode)
 
-      if (FormatPrinter.INLINE_ELEMENTS.has(currentTagName)) {
+      if (INLINE_ELEMENTS.has(currentTagName)) {
         return false
       }
 
-      if (FormatPrinter.TIGHT_GROUP_CHILDREN.has(currentTagName)) {
+      if (TIGHT_GROUP_CHILDREN.has(currentTagName)) {
         return false
       }
 
@@ -394,45 +363,18 @@ export class FormatPrinter extends Printer {
       }
     }
 
-    const isBlockElement = this.isBlockLevelNode(currentNode)
+    const isBlockElement = isBlockLevelNode(currentNode)
     const isERBBlock = isERBNode(currentNode) && isERBControlFlowNode(currentNode)
     const isComment = isCommentNode(currentNode)
 
     return isBlockElement || isERBBlock || isComment
   }
 
-  /**
-   * Token list attributes that contain space-separated values and benefit from
-   * spacing around ERB content for readability
-   */
-  private static readonly TOKEN_LIST_ATTRIBUTES = new Set([
-    'class', 'data-controller', 'data-action'
-  ])
-
   /**
    * Check if we're currently processing a token list attribute that needs spacing
    */
-  private isInTokenListAttribute(): boolean {
-    return this.currentAttributeName !== null &&
-           FormatPrinter.TOKEN_LIST_ATTRIBUTES.has(this.currentAttributeName)
-  }
-
-
-  /**
-   * Check if a node represents a block-level element
-   */
-  private isBlockLevelNode(node: Node): boolean {
-    if (!isNode(node, HTMLElementNode)) {
-      return false
-    }
-
-    const tagName = getTagName(node)
-
-    if (FormatPrinter.INLINE_ELEMENTS.has(tagName)) {
-      return false
-    }
-
-    return true
+  private get isInTokenListAttribute(): boolean {
+    return this.currentAttributeName !== null && TOKEN_LIST_ATTRIBUTES.has(this.currentAttributeName)
   }
 
   /**
@@ -485,16 +427,13 @@ export class FormatPrinter extends Printer {
     return true
   }
 
-  private getAttributeName(attribute: HTMLAttributeNode): string {
-    return attribute.name ? getCombinedAttributeName(attribute.name) : ""
-  }
-
   private wouldClassAttributeBeMultiline(content: string, indentLength: number): boolean {
     const normalizedContent = content.replace(/\s+/g, ' ').trim()
     const hasActualNewlines = /\r?\n/.test(content)
 
     if (hasActualNewlines && normalizedContent.length > 80) {
       const lines = content.split(/\r?\n/).map(line => line.trim()).filter(line => line)
+
       if (lines.length > 1) {
         return true
       }
@@ -516,6 +455,12 @@ export class FormatPrinter extends Printer {
     return false
   }
 
+  // TOOD: extract to core or reuse function from core
+  private getAttributeName(attribute: HTMLAttributeNode): string {
+    return attribute.name ? getCombinedAttributeName(attribute.name) : ""
+  }
+
+  // TOOD: extract to core or reuse function from core
   private getAttributeValue(attribute: HTMLAttributeNode): string {
     if (isNode(attribute.value, HTMLAttributeValueNode)) {
       return attribute.value.children.map(child => isNode(child, HTMLTextNode) ? child.content : IdentityPrinter.print(child)).join('')
@@ -692,7 +637,7 @@ export class FormatPrinter extends Printer {
     for (let i = 0; i < node.children.length; i++) {
       const child = node.children[i]
 
-      if (this.shouldPreserveUserSpacing(child, node.children, i)) {
+      if (shouldPreserveUserSpacing(child, node.children, i)) {
         this.push("")
         hasHandledSpacing = true
         continue
@@ -702,7 +647,7 @@ export class FormatPrinter extends Printer {
         continue
       }
 
-      if (this.shouldAppendToLastLine(child, node.children, i)) {
+      if (shouldAppendToLastLine(child, node.children, i)) {
         this.appendChildToLastLine(child, node.children, i)
         lastWasMeaningful = true
         hasHandledSpacing = false
@@ -740,7 +685,7 @@ export class FormatPrinter extends Printer {
   }
 
   visitHTMLElementBody(body: Node[], element: HTMLElementNode) {
-    if (this.isContentPreserving(element)) {
+    if (isContentPreserving(element)) {
       element.body.map(child => {
         if (isNode(child, HTMLElementNode)) {
           const wasInlineMode = this.inlineMode
@@ -1129,7 +1074,7 @@ export class FormatPrinter extends Printer {
           this.lines.push(" ")
           this.lines.push(this.renderAttribute(child))
         } else {
-          const shouldAddSpaces = this.isInTokenListAttribute()
+          const shouldAddSpaces = this.isInTokenListAttribute
 
           if (shouldAddSpaces) {
             this.lines.push(" ")
@@ -1144,7 +1089,7 @@ export class FormatPrinter extends Printer {
       })
 
       const hasHTMLAttributes = node.statements.some(child => isNode(child, HTMLAttributeNode))
-      const isTokenList = this.isInTokenListAttribute()
+      const isTokenList = this.isInTokenListAttribute
 
       if ((hasHTMLAttributes || isTokenList) && node.end_node) {
         this.lines.push(" ")
@@ -1256,7 +1201,7 @@ export class FormatPrinter extends Printer {
     const attributes = filterNodes(children, HTMLAttributeNode)
     const inlineNodes = this.extractInlineNodes(children)
     const hasERBControlFlow = inlineNodes.some(node => isERBControlFlowNode(node)) || children.some(node => isERBControlFlowNode(node))
-    const hasComplexERB = hasERBControlFlow && this.hasComplexERBControlFlow(inlineNodes)
+    const hasComplexERB = hasERBControlFlow && hasComplexERBControlFlow(inlineNodes)
 
     if (hasComplexERB) return false
 
@@ -1290,13 +1235,12 @@ export class FormatPrinter extends Printer {
   private shouldRenderElementContentInline(node: HTMLElementNode): boolean {
     const tagName = getTagName(node)
     const children = filterSignificantChildren(node.body)
-    const isInlineElement = this.isInlineElement(tagName)
     const openTagInline = this.shouldRenderOpenTagInline(node)
 
     if (!openTagInline) return false
     if (children.length === 0) return true
 
-    if (isInlineElement) {
+    if (isInlineElement(tagName)) {
       const fullInlineResult = this.tryRenderInlineFull(node, tagName, filterNodes(node.open_tag?.children, HTMLAttributeNode), node.body)
 
       if (fullInlineResult) {
@@ -1307,9 +1251,9 @@ export class FormatPrinter extends Printer {
       return false
     }
 
-    const allNestedAreInline = this.areAllNestedElementsInline(children)
-    const hasMultilineText = this.hasMultilineTextContent(children)
-    const hasMixedContent = this.hasMixedTextAndInlineContent(children)
+    const allNestedAreInline = areAllNestedElementsInline(children)
+    const hasMultilineText = hasMultilineTextContent(children)
+    const hasMixedContent = hasMixedTextAndInlineContent(children)
 
     if (allNestedAreInline && (!hasMultilineText || hasMixedContent)) {
       const fullInlineResult = this.tryRenderInlineFull(node, tagName, filterNodes(node.open_tag?.children, HTMLAttributeNode), node.body)
@@ -1351,7 +1295,7 @@ export class FormatPrinter extends Printer {
   private shouldRenderCloseTagInline(node: HTMLElementNode, elementContentInline: boolean): boolean {
     if (node.is_void) return true
     if (node.open_tag?.tag_closing?.value === "/>") return true
-    if (this.isContentPreserving(node)) return true
+    if (isContentPreserving(node)) return true
 
     const children = filterSignificantChildren(node.body)
 
@@ -1363,78 +1307,6 @@ export class FormatPrinter extends Printer {
 
   // --- Utility methods ---
 
-  /**
-   * Check if user-intentional spacing should be preserved (double newlines between elements)
-   */
-  private shouldPreserveUserSpacing(child: Node, siblings: Node[], index: number): boolean {
-    if (!isPureWhitespaceNode(child)) return false
-
-    const hasPreviousNonWhitespace = index > 0 && isNonWhitespaceNode(siblings[index - 1])
-    const hasNextNonWhitespace = index < siblings.length - 1 && isNonWhitespaceNode(siblings[index + 1])
-    const hasMultipleNewlines = isNode(child, HTMLTextNode) && child.content.includes('\n\n')
-
-    return hasPreviousNonWhitespace && hasNextNonWhitespace && hasMultipleNewlines
-  }
-
-  /**
-   * Check if a node should be appended to the last line (for adjacent inline elements and punctuation)
-   */
-  private shouldAppendToLastLine(child: Node, siblings: Node[], index: number): boolean {
-    if (index === 0) return false
-
-    if (isNode(child, HTMLTextNode) && !/^\s/.test(child.content)) {
-      const prevNode = siblings[index - 1]
-      return this.isInlineOrERBNode(prevNode)
-    }
-
-    if (isNode(child, HTMLElementNode) && this.isInlineElement(getTagName(child))) {
-      return this.isAdjacentToPreviousInline(siblings, index)
-    }
-
-    if (isNode(child, ERBContentNode)) {
-      for (let i = index - 1; i >= 0; i--) {
-        const previousSibling = siblings[i]
-
-        if (isPureWhitespaceNode(previousSibling) || isNode(previousSibling, WhitespaceNode)) {
-          continue
-        }
-
-        if (previousSibling.location && child.location) {
-          return previousSibling.location.end.line === child.location.start.line
-        }
-
-        break
-      }
-    }
-
-    return false
-  }
-
-  /**
-   * Check if a node is an inline element or ERB node
-   */
-  private isInlineOrERBNode(node: Node): boolean {
-    return isERBNode(node) || (isNode(node, HTMLElementNode) && this.isInlineElement(getTagName(node)))
-  }
-
-  /**
-   * Check if the current inline element is adjacent to a previous inline element (no whitespace between)
-   */
-  private isAdjacentToPreviousInline(siblings: Node[], index: number): boolean {
-    const prevNode = siblings[index - 1]
-
-    if (this.isInlineOrERBNode(prevNode)) {
-      return true
-    }
-
-    if (index > 1 && isNode(prevNode, HTMLTextNode) && !/^\s/.test(prevNode.content)) {
-      const twoBack = siblings[index - 2]
-      return this.isInlineOrERBNode(twoBack)
-    }
-
-    return false
-  }
-
   /**
    * Append a child node to the last output line
    */
@@ -1460,20 +1332,12 @@ export class FormatPrinter extends Printer {
     }
   }
 
-
-  /**
-   * Check if an element should be treated as inline based on its tag name
-   */
-  private isInlineElement(tagName: string): boolean {
-    return FormatPrinter.INLINE_ELEMENTS.has(tagName.toLowerCase())
-  }
-
   /**
    * Visit children in a text flow context (mixed text and inline elements)
    * Handles word wrapping and keeps adjacent inline elements together
    */
   private visitTextFlowChildren(children: Node[]) {
-    const adjacentInlineCount = this.countAdjacentInlineElements(children)
+    const adjacentInlineCount = countAdjacentInlineElements(children)
 
     if (adjacentInlineCount >= 2) {
       this.renderAdjacentInlineElements(children, adjacentInlineCount)
@@ -1485,38 +1349,6 @@ export class FormatPrinter extends Printer {
     this.buildAndWrapTextFlow(children)
   }
 
-  /**
-   * Count consecutive inline elements/ERB at the start of children (with no whitespace between)
-   */
-  private countAdjacentInlineElements(children: Node[]): number {
-    let count = 0
-    let lastSignificantIndex = -1
-
-    for (let i = 0; i < children.length; i++) {
-      const child = children[i]
-
-      if (isPureWhitespaceNode(child) || isNode(child, WhitespaceNode)) {
-        continue
-      }
-
-      const isInlineOrERB = (isNode(child, HTMLElementNode) && this.isInlineElement(getTagName(child))) || isNode(child, ERBContentNode)
-
-      if (!isInlineOrERB) {
-        break
-      }
-
-      if (lastSignificantIndex >= 0 && hasWhitespaceBetween(children, lastSignificantIndex, i)) {
-        break
-      }
-
-      count++
-      lastSignificantIndex = i
-    }
-
-    return count
-  }
-
-
   /**
    * Render adjacent inline elements together on one line
    */
@@ -1531,7 +1363,7 @@ export class FormatPrinter extends Printer {
         continue
       }
 
-      if (isNode(child, HTMLElementNode) && this.isInlineElement(getTagName(child))) {
+      if (isNode(child, HTMLElementNode) && isInlineElement(getTagName(child))) {
         inlineContent += this.renderInlineElementAsString(child)
         processedCount++
       } else if (isNode(child, ERBContentNode)) {
@@ -1648,7 +1480,7 @@ export class FormatPrinter extends Printer {
         })
       } else if (isNode(child, HTMLElementNode)) {
         const tagName = getTagName(child)
-        if (this.isInlineElement(tagName)) {
+        if (isInlineElement(tagName)) {
           const inlineContent = this.tryRenderInlineFull(
             child,
             tagName,
@@ -1658,54 +1490,29 @@ export class FormatPrinter extends Printer {
 
           if (inlineContent !== null) {
             result.push({
-              unit: {
-                content: inlineContent,
-                type: 'inline',
-                isAtomic: true,
-                breaksFlow: false
-              },
+              unit: { content: inlineContent, type: 'inline', isAtomic: true, breaksFlow: false },
               node: child
             })
           } else {
             result.push({
-              unit: {
-                content: '',
-                type: 'block',
-                isAtomic: false,
-                breaksFlow: true
-              },
+              unit: { content: '', type: 'block', isAtomic: false, breaksFlow: true },
               node: child
             })
           }
         } else {
           result.push({
-            unit: {
-              content: '',
-              type: 'block',
-              isAtomic: false,
-              breaksFlow: true
-            },
+            unit: { content: '', type: 'block', isAtomic: false, breaksFlow: true },
             node: child
           })
         }
       } else if (isNode(child, ERBContentNode)) {
         result.push({
-          unit: {
-            content: this.renderERBAsString(child),
-            type: 'erb',
-            isAtomic: true,
-            breaksFlow: false
-          },
+          unit: { content: this.renderERBAsString(child), type: 'erb', isAtomic: true, breaksFlow: false },
           node: child
         })
       } else {
         result.push({
-          unit: {
-            content: '',
-            type: 'block',
-            isAtomic: false,
-            breaksFlow: true
-          },
+          unit: { content: '', type: 'block', isAtomic: false, breaksFlow: true },
           node: child
         })
       }
@@ -1736,7 +1543,7 @@ export class FormatPrinter extends Printer {
     for (const word of words) {
       const nextLine = buildLineWithWord(currentLine, word)
 
-      if (this.shouldWrapToNextLine(nextLine, currentLine, word, wrapWidth)) {
+      if (shouldWrapToNextLine(nextLine, currentLine, word, wrapWidth)) {
         lines.push(this.indent + currentLine)
         currentLine = word
       } else {
@@ -1751,16 +1558,6 @@ export class FormatPrinter extends Printer {
     lines.forEach(line => this.push(line))
   }
 
-  /**
-   * Determine if we should wrap to the next line
-   */
-  private shouldWrapToNextLine(testLine: string, currentLine: string, word: string, wrapWidth: number): boolean {
-    if (!currentLine) return false
-    if (isClosingPunctuation(word)) return false
-
-    return testLine.length > wrapWidth
-  }
-
   private isInTextFlowContext(_parent: Node | null, children: Node[]): boolean {
     const hasTextContent = children.some(child => isNode(child, HTMLTextNode) &&child.content.trim() !== "")
     const nonTextChildren = children.filter(child => !isNode(child, HTMLTextNode))
@@ -1772,7 +1569,7 @@ export class FormatPrinter extends Printer {
       if (isNode(child, ERBContentNode)) return true
 
       if (isNode(child, HTMLElementNode)) {
-        return this.isInlineElement(getTagName(child))
+        return isInlineElement(getTagName(child))
       }
 
       return false
@@ -1862,7 +1659,7 @@ export class FormatPrinter extends Printer {
         } else {
           const printed = IdentityPrinter.print(child)
 
-          if (this.currentAttributeName && FormatPrinter.TOKEN_LIST_ATTRIBUTES.has(this.currentAttributeName)) {
+          if (this.isInTokenListAttribute) {
             return printed.replace(/%>([^<\s])/g, '%> $1').replace(/([^>\s])<%/g, '$1 <%')
           }
 
@@ -1954,7 +1751,7 @@ export class FormatPrinter extends Printer {
       } else if (isNode(child, HTMLElementNode)) {
         const tagName = getTagName(child)
 
-        if (!this.isInlineElement(tagName)) {
+        if (!isInlineElement(tagName)) {
           return null
         }
 
@@ -1994,9 +1791,7 @@ export class FormatPrinter extends Printer {
           return null
         }
       } else if (isNode(child, HTMLElementNode)) {
-        const isInlineElement = this.isInlineElement(getTagName(child))
-
-        if (!isInlineElement) {
+        if (!isInlineElement(getTagName(child))) {
           return null
         }
       } else if (isNode(child, ERBContentNode)) {
@@ -2015,95 +1810,6 @@ export class FormatPrinter extends Printer {
     return `<${tagName}>${content}</${tagName}>`
   }
 
-  /**
-   * Check if children contain mixed text and inline elements (like "text<em>inline</em>text")
-   * or mixed ERB output and text (like "<%= value %> text")
-   * This indicates content that should be formatted inline even with structural newlines
-   */
-  private hasMixedTextAndInlineContent(children: Node[]): boolean {
-    let hasText = false
-    let hasInlineElements = false
-
-    for (const child of children) {
-      if (isNode(child, HTMLTextNode)) {
-        if (child.content.trim() !== "") {
-          hasText = true
-        }
-      } else if (isNode(child, HTMLElementNode)) {
-        if (this.isInlineElement(getTagName(child))) {
-          hasInlineElements = true
-        }
-      }
-    }
-
-    return (hasText && hasInlineElements) || (hasERBOutput(children) && hasText)
-  }
-
-  /**
-   * Check if children contain any text content with newlines
-   */
-  private hasMultilineTextContent(children: Node[]): boolean {
-    for (const child of children) {
-      if (isNode(child, HTMLTextNode)) {
-        return child.content.includes('\n')
-      }
-
-      if (isNode(child, HTMLElementNode)) {
-        const nestedChildren = filterEmptyNodes(child.body)
-
-        if (this.hasMultilineTextContent(nestedChildren)) {
-          return true
-        }
-      }
-    }
-
-    return false
-  }
-
-  /**
-   * Check if all nested elements in the children are inline elements
-   */
-  private areAllNestedElementsInline(children: Node[]): boolean {
-    for (const child of children) {
-      if (isNode(child, HTMLElementNode)) {
-        if (!this.isInlineElement(getTagName(child))) {
-          return false
-        }
-
-        const nestedChildren = filterEmptyNodes(child.body)
-
-        if (!this.areAllNestedElementsInline(nestedChildren)) {
-          return false
-        }
-      } else if (isAnyOf(child, HTMLDoctypeNode, HTMLCommentNode, isERBControlFlowNode)) {
-        return false
-      }
-    }
-
-    return true
-  }
-
-  /**
-   * Check if element has complex ERB control flow
-   */
-  private hasComplexERBControlFlow(inlineNodes: Node[]): boolean {
-    return inlineNodes.some(node => {
-      if (isNode(node, ERBIfNode)) {
-        if (node.statements.length > 0 && node.location) {
-          const startLine = node.location.start.line
-          const endLine = node.location.end.line
-
-          return startLine !== endLine
-        }
-
-        return false
-      }
-
-      return false
-    })
-  }
-
-
   private renderElementInline(element: HTMLElementNode): string {
     const children = filterEmptyNodes(element.body)
 
@@ -2130,10 +1836,4 @@ export class FormatPrinter extends Printer {
 
     return content.replace(/\s+/g, ' ').trim()
   }
-
-  private isContentPreserving(element: HTMLElementNode | HTMLOpenTagNode | HTMLCloseTagNode): boolean {
-    const tagName = getTagName(element)
-
-    return FormatPrinter.CONTENT_PRESERVING_ELEMENTS.has(tagName)
-  }
 }

From 223512d9d545d35df24a2f4933b7a8da4b867659 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Thu, 9 Oct 2025 13:15:22 +0200
Subject: [PATCH 29/97] Linter: Implement `erb-no-case-node-children` linter
 rule (#598)

This pull request introduces the `erb-no-case-node-children` linter rule
which disallows having meaningful content between the `<% case %>` and
the first `<% when ... %>` or `<% in ... %>` condition.

For example, it would flag this:

```html+erb
<% case variable %>
  This content is outside of any when/else block!
<% when "a" %>
  A
<% when "b" %>
  B
<% end %>
```

Resolves #595
---
 .../packages/linter/docs/rules/README.md      |   1 +
 .../docs/rules/erb-no-case-node-children.md   |  50 ++
 .../packages/linter/src/default-rules.ts      |   2 +
 .../src/rules/erb-no-case-node-children.ts    |  62 +++
 javascript/packages/linter/src/rules/index.ts |   8 +-
 .../test/__snapshots__/cli.test.ts.snap       |   6 +-
 .../rules/erb-no-case-node-children.test.ts   | 181 +++++++
 .../packages/printer/src/identity-printer.ts  |   8 +
 javascript/packages/printer/src/printer.ts    |   2 +
 javascript/packages/vscode/package.json       |   1 +
 printer.md                                    | 472 ------------------
 11 files changed, 316 insertions(+), 477 deletions(-)
 create mode 100644 javascript/packages/linter/docs/rules/erb-no-case-node-children.md
 create mode 100644 javascript/packages/linter/src/rules/erb-no-case-node-children.ts
 create mode 100644 javascript/packages/linter/test/rules/erb-no-case-node-children.test.ts
 delete mode 100644 printer.md

diff --git a/javascript/packages/linter/docs/rules/README.md b/javascript/packages/linter/docs/rules/README.md
index 883a73b6a..7423ac157 100644
--- a/javascript/packages/linter/docs/rules/README.md
+++ b/javascript/packages/linter/docs/rules/README.md
@@ -5,6 +5,7 @@ This page contains documentation for all Herb Linter rules.
 ## Available Rules
 
 - [`erb-comment-syntax`](./erb-comment-syntax.md) - Disallow Ruby comments immediately after ERB tags
+- [`erb-no-case-node-children`](./erb-no-case-node-children.md) - Don't use `children` for `case/when` and `case/in` nodes
 - [`erb-no-empty-tags`](./erb-no-empty-tags.md) - Disallow empty ERB tags
 - [`erb-no-output-control-flow`](./erb-no-output-control-flow.md) - Prevents outputting control flow blocks
 - [`erb-no-silent-tag-in-attribute-name`](./erb-no-silent-tag-in-attribute-name.md) - Disallow ERB silent tags in HTML attribute names
diff --git a/javascript/packages/linter/docs/rules/erb-no-case-node-children.md b/javascript/packages/linter/docs/rules/erb-no-case-node-children.md
new file mode 100644
index 000000000..714bb86f1
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/erb-no-case-node-children.md
@@ -0,0 +1,50 @@
+# Linter Rule: Don't use `children` for `case/when` and `case/in` nodes
+
+**Rule:** `erb-no-case-node-children`
+
+## Description
+
+Disallow placing content or expressions directly between the opening `<% case %>` and the first `<% when %>` or `<% in %>` clause in an HTML+ERB template.
+
+In Ruby and ERB, `case` expressions are intended to branch execution. Any content placed between the `case` and its `when`/`in` clauses is not executed as part of the branching logic, and may lead to confusion, orphaned output, or silent bugs.
+
+## Rationale
+
+Including content directly inside a `case block` is likely unintended and often leads to unclear or broken rendering logic.
+
+Most developers expect that nothing happens until the first `when`/`in` matches. Content in that location is often a copy/paste or indentation mistake and should be flagged to maintain clarity and correctness in templates.
+
+This mirrors how `case` works in Ruby itself and helps avoid surprising output.
+
+## Examples
+
+### ✅ Good
+
+```erb
+<% case variable %>
+<% when "a" %>
+  A
+<% when "b" %>
+  B
+<% else %>
+  C
+<% end %>
+```
+
+### 🚫 Bad
+
+```erb
+<% case variable %>
+  This content is outside of any when/in/else block!
+<% when "a" %>
+  A
+<% when "b" %>
+  B
+<% else %>
+  C
+<% end %>
+```
+
+## References
+
+\-
diff --git a/javascript/packages/linter/src/default-rules.ts b/javascript/packages/linter/src/default-rules.ts
index 3126bc3b4..fa87b2230 100644
--- a/javascript/packages/linter/src/default-rules.ts
+++ b/javascript/packages/linter/src/default-rules.ts
@@ -1,6 +1,7 @@
 import type { RuleClass } from "./types.js"
 
 import { ERBCommentSyntax } from "./rules/erb-comment-syntax.js";
+import { ERBNoCaseNodeChildrenRule } from "./rules/erb-no-case-node-children.js"
 import { ERBNoEmptyTagsRule } from "./rules/erb-no-empty-tags.js"
 import { ERBNoOutputControlFlowRule } from "./rules/erb-no-output-control-flow.js"
 import { ERBNoSilentTagInAttributeNameRule } from "./rules/erb-no-silent-tag-in-attribute-name.js"
@@ -39,6 +40,7 @@ import { ERBRightTrimRule } from "./rules/erb-right-trim.js"
 
 export const defaultRules: RuleClass[] = [
   ERBCommentSyntax,
+  ERBNoCaseNodeChildrenRule,
   ERBNoEmptyTagsRule,
   ERBNoOutputControlFlowRule,
   ERBNoSilentTagInAttributeNameRule,
diff --git a/javascript/packages/linter/src/rules/erb-no-case-node-children.ts b/javascript/packages/linter/src/rules/erb-no-case-node-children.ts
new file mode 100644
index 000000000..eb149cdef
--- /dev/null
+++ b/javascript/packages/linter/src/rules/erb-no-case-node-children.ts
@@ -0,0 +1,62 @@
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { ParserRule } from "../types.js"
+import { isWhitespaceNode, isLiteralNode, isHTMLTextNode, isCommentNode, isERBNode } from "@herb-tools/core"
+import { IdentityPrinter } from "@herb-tools/printer"
+
+import type { LintOffense, LintContext } from "../types.js"
+import type { ParseResult, ERBCaseNode, ERBCaseMatchNode, Node } from "@herb-tools/core"
+
+class ERBNoCaseNodeChildrenVisitor extends BaseRuleVisitor {
+  visitERBCaseNode(node: ERBCaseNode): void {
+    this.checkCaseNodeChildren(node, "when")
+    this.visitChildNodes(node)
+  }
+
+  visitERBCaseMatchNode(node: ERBCaseMatchNode): void {
+    this.checkCaseNodeChildren(node, "in")
+    this.visitChildNodes(node)
+  }
+
+  private checkCaseNodeChildren(node: ERBCaseNode | ERBCaseMatchNode, type: string): void {
+    if (!node.children || node.children.length === 0) return
+
+    const caseCode = IdentityPrinter.printERBNode(node)
+    const firstCondition = node.conditions?.[0]
+    const conditionCode = firstCondition && isERBNode(firstCondition) ? IdentityPrinter.printERBNode(firstCondition) : `<% ${type} ... %>`
+
+    for (const child of node.children) {
+      if (!this.isAllowedContent(child)) {
+        const childCode = IdentityPrinter.print(child).trim()
+
+        this.addOffense(
+          `Do not place \`${childCode}\` between \`${caseCode}\` and \`${conditionCode}\`. Content here is not part of any branch and will not be rendered.`,
+          child.location,
+          "error"
+        )
+      }
+    }
+  }
+
+  private isAllowedContent(node: Node): boolean {
+    if (isWhitespaceNode(node)) return true
+    if (isCommentNode(node)) return true
+
+    if (isLiteralNode(node) || isHTMLTextNode(node)) {
+      return /^\s*$/.test(node.content)
+    }
+
+    return false
+  }
+}
+
+export class ERBNoCaseNodeChildrenRule extends ParserRule {
+  name = "erb-no-case-node-children"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ERBNoCaseNodeChildrenVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}
diff --git a/javascript/packages/linter/src/rules/index.ts b/javascript/packages/linter/src/rules/index.ts
index 92b7d97e1..a511fa727 100644
--- a/javascript/packages/linter/src/rules/index.ts
+++ b/javascript/packages/linter/src/rules/index.ts
@@ -1,10 +1,14 @@
 export * from "./rule-utils.js"
+
 export * from "./erb-comment-syntax.js"
 export * from "./erb-no-empty-tags.js"
+export * from "./erb-no-case-node-children.js"
 export * from "./erb-no-output-control-flow.js"
 export * from "./erb-no-silent-tag-in-attribute-name.js"
 export * from "./erb-prefer-image-tag-helper.js"
 export * from "./erb-requires-trailing-newline.js"
+export * from "./erb-right-trim.js"
+
 export * from "./html-anchor-require-href.js"
 export * from "./html-aria-label-is-well-formatted.js"
 export * from "./html-aria-level-must-be-valid.js"
@@ -28,7 +32,7 @@ export * from "./html-no-nested-links.js"
 export * from "./html-no-positive-tab-index.js"
 export * from "./html-no-self-closing.js"
 export * from "./html-no-title-attribute.js"
+export * from "./html-no-underscores-in-attribute-names.js"
 export * from "./html-tag-name-lowercase.js"
+
 export * from "./svg-tag-name-capitalization.js"
-export * from "./html-no-underscores-in-attribute-names.js"
-export * from "./erb-right-trim.js"
diff --git a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
index 8ba66e99b..2fe1a74e3 100644
--- a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
+++ b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
@@ -561,7 +561,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for bad file 1`]
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 33,
+    "ruleCount": 34,
     "totalErrors": 2,
     "totalOffenses": 2,
     "totalWarnings": 0,
@@ -579,7 +579,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for clean file 1`
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 0,
-    "ruleCount": 33,
+    "ruleCount": 34,
     "totalErrors": 0,
     "totalOffenses": 0,
     "totalWarnings": 0,
@@ -649,7 +649,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for file with err
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 33,
+    "ruleCount": 34,
     "totalErrors": 3,
     "totalOffenses": 3,
     "totalWarnings": 0,
diff --git a/javascript/packages/linter/test/rules/erb-no-case-node-children.test.ts b/javascript/packages/linter/test/rules/erb-no-case-node-children.test.ts
new file mode 100644
index 000000000..bc351e24f
--- /dev/null
+++ b/javascript/packages/linter/test/rules/erb-no-case-node-children.test.ts
@@ -0,0 +1,181 @@
+import dedent from "dedent"
+
+import { describe, test } from "vitest"
+
+import { ERBNoCaseNodeChildrenRule } from "../../src/rules/erb-no-case-node-children.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
+
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBNoCaseNodeChildrenRule)
+
+describe("ERBNoCaseNodeChildrenRule", () => {
+  describe("case/when", () => {
+    test("valid case/when with no children", () => {
+      expectNoOffenses(dedent`
+        <% case count %>
+        <% when 1 %>
+          1
+        <% when 2 %>
+          2
+        <% else %>
+          Other
+        <% end %>
+      `)
+    })
+
+    test("valid case/when with only whitespace children", () => {
+      expectNoOffenses(dedent`
+        <% case count %>
+
+        <% when 1 %>
+          1
+        <% when 2 %>
+          2
+        <% end %>
+      `)
+    })
+
+    test("valid case/when with newline", () => {
+      expectNoOffenses(dedent`
+        <% case count %>
+        <% when 1 %>
+          One
+        <% end %>
+      `)
+    })
+
+    test("valid case/when with HTML comment", () => {
+      expectNoOffenses(dedent`
+        <% case count %>
+          <!-- This is a comment -->
+        <% when 1 %>
+          One
+        <% end %>
+      `)
+    })
+
+    test("valid case/when with ERB comment", () => {
+      expectNoOffenses(dedent`
+        <% case count %>
+          <%# This is an ERB comment %>
+        <% when 1 %>
+          One
+        <% end %>
+      `)
+    })
+
+    test("invalid case/when with HTML content", () => {
+      expectError("Do not place `<h1>Content</h1>` between `<% case count %>` and `<% when 1 %>`. Content here is not part of any branch and will not be rendered.")
+
+      assertOffenses(dedent`
+        <% case count %>
+          <h1>Content</h1>
+        <% when 1 %>
+          1
+        <% when 2 %>
+          2
+        <% else %>
+          Other
+        <% end %>
+      `)
+    })
+
+    test("invalid case/when with text content", () => {
+      expectError("Do not place `This content is outside of any when/else block!` between `<% case variable %>` and `<% when \"a\" %>`. Content here is not part of any branch and will not be rendered.")
+
+      assertOffenses(dedent`
+        <% case variable %>
+          This content is outside of any when/else block!
+        <% when "a" %>
+          A
+        <% when "b" %>
+          B
+        <% end %>
+      `)
+    })
+
+    test("invalid case/when with mixed content", () => {
+      expectError("Do not place `<div>Invalid</div>` between `<% case status %>` and `<% when :active %>`. Content here is not part of any branch and will not be rendered.")
+
+      assertOffenses(dedent`
+        <% case status %>
+          <div>Invalid</div>
+        <% when :active %>
+          Active
+        <% end %>
+      `)
+    })
+  })
+
+  describe("case/in", () => {
+    test("valid case/in with no children", () => {
+      expectNoOffenses(dedent`
+        <% case value %>
+        <% in 1 %>
+          One
+        <% in 2 %>
+          Two
+        <% else %>
+          Other
+        <% end %>
+      `)
+    })
+
+    test("valid case/in with only whitespace children", () => {
+      expectNoOffenses(dedent`
+        <% case value %>
+
+        <% in 1 %>
+          One
+        <% in 2 %>
+          Two
+        <% end %>
+      `)
+    })
+
+    test("valid case/in with HTML comment", () => {
+      expectNoOffenses(dedent`
+        <% case value %>
+          <!-- Comment -->
+        <% in 1 %>
+          One
+        <% end %>
+      `)
+    })
+
+    test("valid case/in with ERB comment", () => {
+      expectNoOffenses(dedent`
+        <% case value %>
+          <%# Comment %>
+        <% in 1 %>
+          One
+        <% end %>
+      `)
+    })
+
+    test("invalid case/in with HTML content", () => {
+      expectError("Do not place `<p>Should not be here</p>` between `<% case value %>` and `<% in 1 %>`. Content here is not part of any branch and will not be rendered.")
+
+      assertOffenses(dedent`
+        <% case value %>
+          <p>Should not be here</p>
+        <% in 1 %>
+          One
+        <% in 2 %>
+          Two
+        <% end %>
+      `)
+    })
+
+    test("invalid case/in with text content", () => {
+      expectError("Do not place `Orphaned text` between `<% case value %>` and `<% in \"a\" %>`. Content here is not part of any branch and will not be rendered.")
+
+      assertOffenses(dedent`
+        <% case value %>
+          Orphaned text
+        <% in "a" %>
+          A
+        <% end %>
+      `)
+    })
+  })
+})
diff --git a/javascript/packages/printer/src/identity-printer.ts b/javascript/packages/printer/src/identity-printer.ts
index 6eb2c53c5..ad592cc2d 100644
--- a/javascript/packages/printer/src/identity-printer.ts
+++ b/javascript/packages/printer/src/identity-printer.ts
@@ -13,6 +13,14 @@ import type * as Nodes from "@herb-tools/core"
  * - Verifying AST round-trip fidelity
  */
 export class IdentityPrinter extends Printer {
+  static printERBNode(node: Nodes.ERBNode) {
+    const printer = new IdentityPrinter()
+
+    printer.printERBNode(node)
+
+    return printer.context.getOutput()
+  }
+
   visitLiteralNode(node: Nodes.LiteralNode): void {
     this.write(node.content)
   }
diff --git a/javascript/packages/printer/src/printer.ts b/javascript/packages/printer/src/printer.ts
index 65af1dc08..ae56187aa 100644
--- a/javascript/packages/printer/src/printer.ts
+++ b/javascript/packages/printer/src/printer.ts
@@ -1,6 +1,8 @@
 import { Node, Visitor, Token, ParseResult, isToken, isParseResult } from "@herb-tools/core"
 import { PrintContext } from "./print-context.js"
 
+import type { ERBNode } from "@herb-tools/core"
+
 /**
  * Options for controlling the printing behavior
  */
diff --git a/javascript/packages/vscode/package.json b/javascript/packages/vscode/package.json
index 5b2395279..6e7bdf021 100644
--- a/javascript/packages/vscode/package.json
+++ b/javascript/packages/vscode/package.json
@@ -62,6 +62,7 @@
             "type": "string",
             "enum": [
               "erb-comment-syntax",
+              "erb-no-case-node-children",
               "erb-no-empty-tags",
               "erb-no-output-control-flow",
               "erb-no-silent-tag-in-attribute-name",
diff --git a/printer.md b/printer.md
deleted file mode 100644
index 0bcf4fea5..000000000
--- a/printer.md
+++ /dev/null
@@ -1,472 +0,0 @@
-
-
-------
-
-
-
-
-
-
-# Printer
-
-AST-to-source code conversion for the Herb ecosystem.
-
-## Status
-**In Development** - Core functionality available
-
-## Overview
-
-The Herb Printer converts Herb AST nodes back into source code, enabling tools like the formatter and minifier to reconstruct templates after transformation. It provides fine-grained control over output formatting and serves as the foundation for code generation workflows.
-
-## Features
-
-### AST Reconstruction
-- **Complete fidelity**: Reconstructs exact source code from AST
-- **Configurable formatting**: Control indentation, spacing, and line breaks
-- **Comment preservation**: Maintains comments with position information
-- **Error handling**: Graceful handling of malformed AST nodes
-
-### Output Customization
-- **Indentation styles**: Spaces, tabs, custom patterns
-- **Line ending control**: LF, CRLF, or system default
-- **Whitespace handling**: Configurable whitespace preservation
-- **ERB tag formatting**: Control ERB tag spacing and style
-
-### Source Map Generation
-- **Position mapping**: Maps output positions back to original AST nodes
-- **Debugging support**: Enables source-level debugging of generated code
-- **Tool integration**: Compatible with development tools and debuggers
-
-## Installation
-
-```bash
-npm install @herb-tools/printer
-```
-
-For Ruby:
-```bash
-gem install herb-printer
-```
-
-## Usage
-
-### JavaScript/Node.js
-
-```javascript
-import { Printer } from '@herb-tools/printer'
-import { Herb } from '@herb-tools/node'
-
-// Parse template to AST
-const ast = Herb.parse('<div><%= @user.name %></div>')
-
-// Create printer with custom formatting
-const printer = new Printer({
-  indentSize: 2,
-  indentType: 'space',
-  lineEnding: '\n',
-  preserveWhitespace: true
-})
-
-// Convert AST back to source
-const source = printer.print(ast)
-console.log(source)
-// <div><%= @user.name %></div>
-```
-
-### Advanced Configuration
-
-```javascript
-const printer = new Printer({
-  // Indentation
-  indentSize: 2,
-  indentType: 'space', // 'space', 'tab', 'mixed'
-
-  // Line handling
-  lineEnding: '\n', // '\n', '\r\n', 'auto'
-  maxLineLength: 80,
-  wrapLongLines: true,
-
-  // ERB formatting
-  erbTagSpacing: 'compact', // 'compact', 'spaced', 'preserve'
-  erbOutputPadding: true,
-
-  // HTML formatting
-  htmlAttributeWrap: 'auto', // 'auto', 'force', 'never'
-  htmlSelfClosing: 'xml', // 'xml', 'html', 'preserve'
-
-  // Comment handling
-  preserveComments: true,
-  commentIndentation: 'align',
-
-  // Source maps
-  generateSourceMap: true,
-  sourceMapMode: 'inline' // 'inline', 'external', 'comment'
-})
-```
-
-### Ruby API
-
-```ruby
-require 'herb/printer'
-
-# Parse template
-ast = Herb.parse('<div><%= @user.name %></div>')
-
-# Create printer
-printer = Herb::Printer.new(
-  indent_size: 2,
-  indent_type: :space,
-  erb_tag_spacing: :compact
-)
-
-# Generate source code
-source = printer.print(ast)
-puts source
-```
-
-## Formatting Styles
-
-### ERB Tag Styles
-
-```javascript
-// Compact style (default)
-printer.setOption('erbTagSpacing', 'compact')
-// Output: <%=@user.name%>
-
-// Spaced style
-printer.setOption('erbTagSpacing', 'spaced')
-// Output: <%= @user.name %>
-
-// Preserve original
-printer.setOption('erbTagSpacing', 'preserve')
-// Output: (maintains original spacing)
-```
-
-### HTML Attribute Formatting
-
-```javascript
-const ast = Herb.parse('<div class="user" data-id="123" data-name="john">')
-
-// Auto wrap (default)
-printer.setOption('htmlAttributeWrap', 'auto')
-printer.setOption('maxLineLength', 40)
-// Output:
-// <div class="user"
-//      data-id="123"
-//      data-name="john">
-
-// Force single line
-printer.setOption('htmlAttributeWrap', 'never')
-// Output: <div class="user" data-id="123" data-name="john">
-```
-
-### Indentation Styles
-
-```javascript
-// Spaces (default)
-printer.setOption('indentType', 'space')
-printer.setOption('indentSize', 2)
-
-// Tabs
-printer.setOption('indentType', 'tab')
-printer.setOption('indentSize', 1)
-
-// Mixed (tabs for structure, spaces for alignment)
-printer.setOption('indentType', 'mixed')
-```
-
-## Integration with Tools
-
-### Formatter Integration
-
-```javascript
-// formatter.js
-import { Formatter } from '@herb-tools/formatter'
-import { Printer } from '@herb-tools/printer'
-
-class Formatter {
-  constructor(options) {
-    this.printer = new Printer(options.printer)
-  }
-
-  format(source) {
-    // Parse source to AST
-    const ast = this.parse(source)
-
-    // Apply formatting transformations
-    const formattedAST = this.transform(ast)
-
-    // Use printer to generate formatted source
-    return this.printer.print(formattedAST)
-  }
-}
-```
-
-### Minifier Integration
-
-```javascript
-// minifier.js
-import { Minifier } from '@herb-tools/minifier'
-import { Printer } from '@herb-tools/printer'
-
-class Minifier {
-  constructor() {
-    this.printer = new Printer({
-      indentSize: 0,
-      preserveWhitespace: false,
-      erbTagSpacing: 'compact',
-      generateSourceMap: false
-    })
-  }
-
-  minify(source) {
-    const ast = this.parse(source)
-    const minifiedAST = this.optimize(ast)
-    return this.printer.print(minifiedAST)
-  }
-}
-```
-
-### Custom Code Generator
-
-```javascript
-class TemplateGenerator {
-  constructor() {
-    this.printer = new Printer({
-      indentSize: 2,
-      erbTagSpacing: 'spaced'
-    })
-  }
-
-  generateTemplate(data) {
-    // Build AST programmatically
-    const ast = this.buildAST(data)
-
-    // Generate source code
-    return this.printer.print(ast)
-  }
-
-  buildAST(data) {
-    return {
-      type: 'Document',
-      children: [
-        {
-          type: 'HTMLElement',
-          tagName: 'div',
-          attributes: [
-            {
-              type: 'HTMLAttribute',
-              name: 'class',
-              value: data.className
-            }
-          ],
-          children: [
-            {
-              type: 'ERBContent',
-              rubyCode: `@${data.variable}.${data.method}`
-            }
-          ]
-        }
-      ]
-    }
-  }
-}
-```
-
-## Source Maps
-
-### Generating Source Maps
-
-```javascript
-const printer = new Printer({
-  generateSourceMap: true,
-  sourceMapMode: 'external'
-})
-
-const result = printer.printWithSourceMap(ast)
-console.log(result.code)     // Generated source code
-console.log(result.map)      // Source map object
-
-// Save source map to file
-fs.writeFileSync('output.erb.map', JSON.stringify(result.map))
-```
-
-### Source Map Format
-
-```json
-{
-  "version": 3,
-  "sources": ["original.erb"],
-  "names": [],
-  "mappings": "AAAA,KAAK,CAAC,KAAK",
-  "sourceRoot": "",
-  "sourcesContent": ["<div><%= @user.name %></div>"]
-}
-```
-
-### Using Source Maps
-
-```javascript
-// Debug formatted code
-const { SourceMapConsumer } = require('source-map')
-
-async function debugPosition(line, column) {
-  const consumer = await new SourceMapConsumer(sourceMap)
-  const original = consumer.originalPositionFor({ line, column })
-
-  console.log(`Generated position ${line}:${column} maps to original ${original.line}:${original.column}`)
-}
-```
-
-## API Reference
-
-### Printer Class
-
-```typescript
-class Printer {
-  constructor(options: PrinterOptions)
-
-  // Core printing methods
-  print(ast: ASTNode): string
-  printWithSourceMap(ast: ASTNode): { code: string, map: SourceMap }
-
-  // Configuration
-  setOption(key: string, value: any): void
-  setOptions(options: Partial<PrinterOptions>): void
-  getOptions(): PrinterOptions
-
-  // Utility methods
-  static defaultOptions(): PrinterOptions
-  static validateAST(ast: ASTNode): ValidationResult
-}
-
-interface PrinterOptions {
-  // Indentation
-  indentSize: number
-  indentType: 'space' | 'tab' | 'mixed'
-
-  // Line handling
-  lineEnding: '\n' | '\r\n' | 'auto'
-  maxLineLength: number
-  wrapLongLines: boolean
-
-  // ERB formatting
-  erbTagSpacing: 'compact' | 'spaced' | 'preserve'
-  erbOutputPadding: boolean
-
-  // HTML formatting
-  htmlAttributeWrap: 'auto' | 'force' | 'never'
-  htmlSelfClosing: 'xml' | 'html' | 'preserve'
-
-  // Comments
-  preserveComments: boolean
-  commentIndentation: 'align' | 'indent' | 'preserve'
-
-  // Source maps
-  generateSourceMap: boolean
-  sourceMapMode: 'inline' | 'external' | 'comment'
-}
-```
-
-### Node Handlers
-
-```javascript
-class Printer {
-  // Override specific node handlers
-  printHTMLElement(node, context) {
-    // Custom HTML element printing
-    return this.defaultPrintHTMLElement(node, context)
-  }
-
-  printERBContent(node, context) {
-    // Custom ERB content printing
-    return this.defaultPrintERBContent(node, context)
-  }
-
-  printHTMLAttribute(node, context) {
-    // Custom attribute printing
-    return this.defaultPrintHTMLAttribute(node, context)
-  }
-}
-```
-
-## Performance
-
-### Benchmarks
-
-| AST Size | Print Time | Memory Usage |
-|----------|------------|--------------|
-| Small (10 nodes) | 0.1ms | 50 KB |
-| Medium (100 nodes) | 0.8ms | 200 KB |
-| Large (1000 nodes) | 6ms | 1.5 MB |
-
-### Optimization Tips
-
-```javascript
-// Reuse printer instances
-const printer = new Printer(options)
-
-// Batch processing
-const results = asts.map(ast => printer.print(ast))
-
-// Disable source maps for production
-const prodPrinter = new Printer({
-  ...options,
-  generateSourceMap: false
-})
-
-// Stream large ASTs
-const stream = printer.printStream(largeAST)
-```
-
-## Testing
-
-### Unit Tests
-
-```javascript
-import { Printer } from '@herb-tools/printer'
-import { Herb } from '@herb-tools/node'
-
-describe('Printer', () => {
-  test('round-trip preservation', () => {
-    const source = '<div><%= @user.name %></div>'
-    const ast = Herb.parse(source)
-    const printed = new Printer().print(ast)
-
-    expect(printed).toBe(source)
-  })
-
-  test('custom formatting', () => {
-    const ast = Herb.parse('<%=@user.name%>')
-    const printer = new Printer({ erbTagSpacing: 'spaced' })
-    const printed = printer.print(ast)
-
-    expect(printed).toBe('<%= @user.name %>')
-  })
-})
-```
-
-### Integration Tests
-
-```javascript
-test('formatter integration', () => {
-  const unformatted = '<div><%=@user.name%></div>'
-  const formatted = new Formatter().format(unformatted)
-
-  expect(formatted).toBe('<div>\n  <%= @user.name %>\n</div>')
-})
-```
-
-## Contributing
-
-Areas for contribution:
-- Additional formatting options
-- Performance optimizations
-- Source map enhancements
-- Tool integrations
-
-## Resources
-
-- [GitHub Repository](https://github.com/marcoroth/herb/tree/main/javascript/packages/printer)
-- [API Documentation](https://herb-tools.dev/printer/api)
-- [Source Map Specification](https://sourcemaps.info/spec.html)

From ff53bdb70ca5d6026d9f15bd16dae442aa4c8ceb Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Thu, 9 Oct 2025 15:40:19 +0200
Subject: [PATCH 30/97] Linter: Fix crash in
 `html-no-underscores-in-attribute-names` rule (#602)

Resolves #601
---
 .../html-no-underscores-in-attribute-names.ts    |  2 +-
 ...tml-no-underscores-in-attribute-names.test.ts | 16 ++++++++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/javascript/packages/linter/src/rules/html-no-underscores-in-attribute-names.ts b/javascript/packages/linter/src/rules/html-no-underscores-in-attribute-names.ts
index e1d499ba6..31d06b701 100644
--- a/javascript/packages/linter/src/rules/html-no-underscores-in-attribute-names.ts
+++ b/javascript/packages/linter/src/rules/html-no-underscores-in-attribute-names.ts
@@ -38,7 +38,7 @@ class HTMLNoUnderscoresInAttributeNamesVisitor extends AttributeVisitorMixin {
     if (attributeName.includes("_")) {
       this.addOffense(
         `Attribute \`${IdentityPrinter.print(attributeNode.name)}\` should not contain underscores. Use hyphens (-) instead.`,
-        attributeNode.value!.location,
+        attributeNode.name?.location ?? attributeNode.location,
         "warning"
       )
     }
diff --git a/javascript/packages/linter/test/rules/html-no-underscores-in-attribute-names.test.ts b/javascript/packages/linter/test/rules/html-no-underscores-in-attribute-names.test.ts
index df87ef2b9..09283c57e 100644
--- a/javascript/packages/linter/test/rules/html-no-underscores-in-attribute-names.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-underscores-in-attribute-names.test.ts
@@ -44,4 +44,20 @@ describe("html-no-underscores-in-attribute-names", () => {
       <div data-<%= key %>_test="value"></div>
     `)
   })
+
+  test("handles malformed attributes without crashing (issue #601)", () => {
+    expectWarning("Attribute `foo_bar` should not contain underscores. Use hyphens (-) instead.")
+
+    assertOffenses(dedent`
+      <input foo_bar=I18n.t('value')>
+    `)
+  })
+
+  test("handles malformed attributes without crashing - exact snippet from issue #601", () => {
+    expectWarning("Attribute `t('foo_bar')` should not contain underscores. Use hyphens (-) instead.")
+
+    assertOffenses(dedent`
+      <input title=I18n.t('foo_bar')>
+    `)
+  })
 })

From 4ce18f4f580547abf306753bbc26b75d961943fe Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Thu, 9 Oct 2025 15:56:23 +0200
Subject: [PATCH 31/97] Add `stimulus-lint` to `.envrc`

---
 .envrc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.envrc b/.envrc
index 60f1536b5..d4a7ef2b6 100644
--- a/.envrc
+++ b/.envrc
@@ -3,3 +3,4 @@ export PATH="$PWD/javascript/packages/printer/bin:$PATH"
 export PATH="$PWD/javascript/packages/formatter/bin:$PATH"
 export PATH="$PWD/javascript/packages/language-server/bin:$PATH"
 export PATH="$PWD/javascript/packages/highlighter/bin:$PATH"
+export PATH="$PWD/javascript/packages/stimulus-lint/bin:$PATH"

From 60357663844e1984a77ad878ed388413a09b56cb Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Thu, 9 Oct 2025 16:01:06 +0200
Subject: [PATCH 32/97] Bump Prism to `v1.5.2` (#603)

This pull request updates Prism to
[`v1.5.2`](https://github.com/ruby/prism/releases/tag/v1.5.2).
---
 CONTRIBUTING.md                                      | 2 +-
 Gemfile                                              | 2 +-
 Gemfile.lock                                         | 6 +++---
 javascript/packages/browser/test/browser.test.ts     | 2 +-
 javascript/packages/node-wasm/test/node-wasm.test.ts | 2 +-
 javascript/packages/node/test/node.test.ts           | 2 +-
 test/herb_test.rb                                    | 2 +-
 7 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 17cecb7a4..41d7ed395 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -12,7 +12,7 @@ If you encounter any issues when following along with this file please dont hesi
 - [**Clang 19**](https://clang.llvm.org): The compiler used to build this project.
 - [**Clang Format 19**](https://clang.llvm.org/docs/ClangFormat.html): For formatting the project.
 - [**Clang Tidy 19**](https://clang.llvm.org/extra/clang-tidy/): For linting the project.
-- [**Prism Ruby Parser v1.5.1**](https://github.com/ruby/prism/releases/tag/v1.5.1): We use Prism for Parsing the Ruby Source Code in the HTML+ERB files.
+- [**Prism Ruby Parser v1.5.2**](https://github.com/ruby/prism/releases/tag/v1.5.2): We use Prism for Parsing the Ruby Source Code in the HTML+ERB files.
 - [**Ruby**](https://www.ruby-lang.org/en/): We need Ruby as a dependency for `bundler`.
 - [**Bundler**](https://bundler.io): We are using `bundler` to build [`prism`](https://github.com/ruby/prism) from source so we can build `herb` against it.
 - [**Emscripten**](https://emscripten.org): For the WebAssembly build of `libherb` so it can be used in the browser using the [`@herb-tools/browser`](https://github.com/marcoroth/herb/blob/main/javascript/packages/browser) package.
diff --git a/Gemfile b/Gemfile
index b23142024..426455797 100644
--- a/Gemfile
+++ b/Gemfile
@@ -4,7 +4,7 @@ source "https://rubygems.org"
 
 gemspec
 
-gem "prism", github: "ruby/prism", tag: "v1.5.1"
+gem "prism", github: "ruby/prism", tag: "v1.5.2"
 
 gem "actionview", "~> 8.0"
 gem "lz_string"
diff --git a/Gemfile.lock b/Gemfile.lock
index 2199da0f3..9f8672fca 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -9,10 +9,10 @@ GIT
 
 GIT
   remote: https://github.com/ruby/prism.git
-  revision: 23f16d31a7c57c4b927e1e3ec8f1281b45e7cb9f
-  tag: v1.5.1
+  revision: 983ecaf4790a536ad26ff444ec962887ea2aa6ba
+  tag: v1.5.2
   specs:
-    prism (1.5.1)
+    prism (1.5.2)
 
 PATH
   remote: .
diff --git a/javascript/packages/browser/test/browser.test.ts b/javascript/packages/browser/test/browser.test.ts
index 464db9da9..dd0762474 100644
--- a/javascript/packages/browser/test/browser.test.ts
+++ b/javascript/packages/browser/test/browser.test.ts
@@ -17,7 +17,7 @@ describe("@herb-tools/browser", () => {
   test("version() returns a string", async () => {
     const version = Herb.version
     expect(typeof version).toBe("string")
-    expect(version).toBe("@herb-tools/browser@0.7.5, @herb-tools/core@0.7.5, libprism@1.5.1, libherb@0.7.5 (WebAssembly)")
+    expect(version).toBe("@herb-tools/browser@0.7.5, @herb-tools/core@0.7.5, libprism@1.5.2, libherb@0.7.5 (WebAssembly)")
   })
 
   test("parse() can process a simple template", async () => {
diff --git a/javascript/packages/node-wasm/test/node-wasm.test.ts b/javascript/packages/node-wasm/test/node-wasm.test.ts
index 562da6ea2..271933f94 100644
--- a/javascript/packages/node-wasm/test/node-wasm.test.ts
+++ b/javascript/packages/node-wasm/test/node-wasm.test.ts
@@ -17,7 +17,7 @@ describe("@herb-tools/node-wasm", () => {
   test("version() returns a string", async () => {
     const version = Herb.version
     expect(typeof version).toBe("string")
-    expect(version).toBe("@herb-tools/node-wasm@0.7.5, @herb-tools/core@0.7.5, libprism@1.5.1, libherb@0.7.5 (WebAssembly)")
+    expect(version).toBe("@herb-tools/node-wasm@0.7.5, @herb-tools/core@0.7.5, libprism@1.5.2, libherb@0.7.5 (WebAssembly)")
   })
 
   test("parse() can process a simple template", async () => {
diff --git a/javascript/packages/node/test/node.test.ts b/javascript/packages/node/test/node.test.ts
index 8ac737608..83e73788d 100644
--- a/javascript/packages/node/test/node.test.ts
+++ b/javascript/packages/node/test/node.test.ts
@@ -17,7 +17,7 @@ describe("@herb-tools/node", () => {
   test("version() returns a string", async () => {
     const version = Herb.version
     expect(typeof version).toBe("string")
-    expect(version).toBe("@herb-tools/node@0.7.5, @herb-tools/core@0.7.5, libprism@1.5.1, libherb@0.7.5 (Node.js C++ native extension)")
+    expect(version).toBe("@herb-tools/node@0.7.5, @herb-tools/core@0.7.5, libprism@1.5.2, libherb@0.7.5 (Node.js C++ native extension)")
   })
 
   test("parse() can process a simple template", async () => {
diff --git a/test/herb_test.rb b/test/herb_test.rb
index c32f572d0..b74e7e34a 100644
--- a/test/herb_test.rb
+++ b/test/herb_test.rb
@@ -4,6 +4,6 @@
 
 class HerbTest < Minitest::Spec
   test "version" do
-    assert_equal "herb gem v0.7.5, libprism v1.5.1, libherb v0.7.5 (Ruby C native extension)", Herb.version
+    assert_equal "herb gem v0.7.5, libprism v1.5.2, libherb v0.7.5 (Ruby C native extension)", Herb.version
   end
 end

From 2b236ff8c2cc2b74c867fea69737b1f43d3166b3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Fri, 10 Oct 2025 08:41:41 +0200
Subject: [PATCH 33/97] C: Remove unused `html_util` functions (#607)

This PR removes html_util functions that aren't used anymore.

- is_html4_void_element
- html_opening_tag_string
---
 src/html_util.c         | 48 -----------------------------------------
 src/include/html_util.h |  2 --
 test/c/test_html_util.c |  9 --------
 3 files changed, 59 deletions(-)

diff --git a/src/html_util.c b/src/html_util.c
index b400d0709..cd2f863a0 100644
--- a/src/html_util.c
+++ b/src/html_util.c
@@ -23,54 +23,6 @@ bool is_void_element(const char* tag_name) {
   return false;
 }
 
-bool is_html4_void_element(const char* tag_name) {
-  if (tag_name == NULL) { return false; }
-
-  const char* html4_void_tags[] = {
-    "basefont", "bgsound", "command", "frame", "image", "keygen",
-  };
-
-  for (size_t i = 0; i < sizeof(html4_void_tags) / sizeof(char*); i++) {
-    if (strcasecmp(tag_name, html4_void_tags[i]) == 0) { return true; }
-  }
-
-  return false;
-}
-
-/**
- * @brief Creates an opening HTML tag string like "<tag_name>"
- *
- * @param tag_name The name of the HTML tag to be enclosed in a opening tag
- * @return A newly allocated string containing the opening tag, or NULL if memory allocation fails
- * @note The caller is responsible for freeing the returned string
- *
- * Example:
- * @code
- * char* tag = html_opening_tag_string("div");
- * if (tag) {
- *   printf("%s\n", tag); // Prints: <div>
- *   free(tag);
- * }
- * @endcode
- */
-char* html_opening_tag_string(const char* tag_name) {
-  if (tag_name == NULL) { return herb_strdup("<>"); }
-
-  size_t length = strlen(tag_name);
-  char* result = (char*) malloc(length + 3); // +3 for '<', '>', and '\0'
-
-  if (result == NULL) { return NULL; }
-
-  result[0] = '<';
-
-  memcpy(result + 1, tag_name, length);
-
-  result[length + 1] = '>';
-  result[length + 2] = '\0';
-
-  return result;
-}
-
 /**
  * @brief Creates a closing HTML tag string like "</tag_name>"
  *
diff --git a/src/include/html_util.h b/src/include/html_util.h
index 8412c9490..768660861 100644
--- a/src/include/html_util.h
+++ b/src/include/html_util.h
@@ -4,9 +4,7 @@
 #include <stdbool.h>
 
 bool is_void_element(const char* tag_name);
-bool is_html4_void_element(const char* tag_name);
 
-char* html_opening_tag_string(const char* tag_name);
 char* html_closing_tag_string(const char* tag_name);
 char* html_self_closing_tag_string(const char* tag_name);
 
diff --git a/test/c/test_html_util.c b/test/c/test_html_util.c
index 4f9d50403..9515c4b78 100644
--- a/test/c/test_html_util.c
+++ b/test/c/test_html_util.c
@@ -3,15 +3,6 @@
 #include "../../src/include/herb.h"
 #include "../../src/include/html_util.h"
 
-TEST(html_util_html_opening_tag_string)
-  ck_assert_str_eq(html_opening_tag_string(NULL), "<>");
-  ck_assert_str_eq(html_opening_tag_string(""), "<>");
-  ck_assert_str_eq(html_opening_tag_string(" "), "< >");
-  ck_assert_str_eq(html_opening_tag_string("br"), "<br>");
-  ck_assert_str_eq(html_opening_tag_string("div"), "<div>");
-  ck_assert_str_eq(html_opening_tag_string("somelongerstring"), "<somelongerstring>");
-END
-
 TEST(html_util_html_closing_tag_string)
   ck_assert_str_eq(html_closing_tag_string(NULL), "</>");
   ck_assert_str_eq(html_closing_tag_string(""), "</>");

From f18082ac07482283ba386222b4806cbfc768d51a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Fri, 10 Oct 2025 10:42:53 +0200
Subject: [PATCH 34/97] C: Remove unused functions from `util.c` (#606)

This removes functions from util.c that aren't used in the codebase
anymore.

- is_whitespace
- count_in_string
- count_newlines
- replace_char
- string_blank
- string_present
---
 src/include/util.h |  9 -------
 src/util.c         | 61 ----------------------------------------------
 test/c/test_util.c | 20 ---------------
 3 files changed, 90 deletions(-)

diff --git a/src/include/util.h b/src/include/util.h
index 18df10360..61b371605 100644
--- a/src/include/util.h
+++ b/src/include/util.h
@@ -4,20 +4,11 @@
 #include <stdbool.h>
 #include <stdlib.h>
 
-int is_whitespace(int character);
 int is_newline(int character);
 
-int count_in_string(const char* string, char character);
-int count_newlines(const char* string);
-
-char* replace_char(char* string, char find, char replace);
 char* escape_newlines(const char* input);
 char* quoted_string(const char* input);
 char* wrap_string(const char* input, char character);
-
-bool string_blank(const char* input);
-bool string_present(const char* input);
-
 char* herb_strdup(const char* s);
 
 char* size_t_to_string(size_t value);
diff --git a/src/util.c b/src/util.c
index 94589917b..63f6551c0 100644
--- a/src/util.c
+++ b/src/util.c
@@ -5,55 +5,10 @@
 #include <stdlib.h>
 #include <string.h>
 
-int is_whitespace(const int character) {
-  return character == ' ' || character == '\t';
-}
-
 int is_newline(const int character) {
   return character == 13 || character == 10;
 }
 
-int count_in_string(const char* string, const char character) {
-  int count = 0;
-
-  while (*string != '\0') {
-    if (*string == character) { count++; }
-
-    string++;
-  }
-
-  return count;
-}
-
-int count_newlines(const char* string) {
-  int count = 0;
-
-  while (*string) {
-    if (*string == '\r') {
-      count++;
-      if (*(string + 1) == '\n') { string++; }
-    } else if (*string == '\n') {
-      count++;
-    }
-
-    string++;
-  }
-
-  return count;
-}
-
-char* replace_char(char* string, const char find, const char replace) {
-  char* original_string = string;
-
-  while (*string != '\0') {
-    if (*string == find) { *string = replace; }
-
-    string++;
-  }
-
-  return original_string;
-}
-
 char* escape_newlines(const char* input) {
   char* output = calloc(strlen(input) * 2 + 1, sizeof(char));
   char* orig_output = output;
@@ -97,22 +52,6 @@ char* quoted_string(const char* input) {
   return wrap_string(input, '"');
 }
 
-// Check if a string is blank (NULL, empty, or only contains whitespace)
-bool string_blank(const char* input) {
-  if (input == NULL || input[0] == '\0') { return true; }
-
-  for (const char* p = input; *p != '\0'; p++) {
-    if (!isspace(*p)) { return false; }
-  }
-
-  return true;
-}
-
-// Check if a string is present (not blank)
-bool string_present(const char* input) {
-  return !string_blank(input);
-}
-
 char* herb_strdup(const char* s) {
   size_t len = strlen(s) + 1;
   char* copy = malloc(len);
diff --git a/test/c/test_util.c b/test/c/test_util.c
index dd678f3c5..ca249c8dc 100644
--- a/test/c/test_util.c
+++ b/test/c/test_util.c
@@ -3,16 +3,6 @@
 #include "../../src/include/herb.h"
 #include "../../src/include/util.h"
 
-TEST(util_count_newlines)
-  ck_assert_int_eq(count_newlines("\n"), 1);
-  ck_assert_int_eq(count_newlines("\n\n"), 2);
-
-  ck_assert_int_eq(count_newlines("\r"), 1);
-  ck_assert_int_eq(count_newlines("\r\r"), 2);
-
-  ck_assert_int_eq(count_newlines("\r\n"), 1);
-  ck_assert_int_eq(count_newlines("\r\n\r\n"), 2);
-END
 
 TEST(util_is_newline)
   ck_assert_int_eq(is_newline('\n'), 1);
@@ -22,20 +12,10 @@ TEST(util_is_newline)
   ck_assert_int_eq(is_newline('a'), 0);
 END
 
-TEST(util_replace_char_returns_original)
-  char str[] = "abca";
-  char *returned = replace_char(str, 'a', 'x');
-
-  ck_assert_ptr_eq(returned, str);
-  ck_assert_str_eq(str, "xbcx");
-END
-
 TCase *util_tests(void) {
   TCase *util = tcase_create("Util");
 
-  tcase_add_test(util, util_count_newlines);
   tcase_add_test(util, util_is_newline);
-  tcase_add_test(util, util_replace_char_returns_original);
 
   return util;
 }

From 8cbc7ffb6eaefd14d1317f9ffeb8ee933d9e3f2e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Fri, 10 Oct 2025 17:07:00 +0200
Subject: [PATCH 35/97] Ruby: NTFS compliant snapshot filenames (#610)

This PR changes the filenames of the snapshots used for testing to allow
checking out this project on NTFS filesystems.
---
 test/snapshot_utils.rb                        | 19 ++++++++++++++++++-
 ...line_6bf3affa07b559b73f6428e0dbd270d2.txt} |  0
 ...tags_8a842d797202d0b31c9832cd43a22686.txt} |  0
 ...fter_c5e6a4e1e9e691af8dcc74ae6c9564c9.txt} |  0
 ...alue_2e196056650e47d46886938eb88136f7.txt} |  0
 ...bute_af387b2d214ba9baadbd062f15508d2d.txt} |  0
 ...bute_dbd22dd4679133f8be271e39a3a16b03.txt} |  0
 ...fier_ad89c5b890e891eda58e590a3eaf2e82.txt} |  0
 ...alue_bf55684b694d2aa471b24fa539546339.txt} |  0
 ..._%gt_e97ed3ba194342cfe8febc1a40a3d603.txt} |  0
 ..._%gt_2d5c53c5a986076f8a5df2585ce5aa74.txt} |  0
 ..._%gt_b305aff64a566ea549c116aacb0ce86c.txt} |  0
 ...-%gt_34d2696185efe003bf3f2c2dddb924e3.txt} |  0
 ..._%gt_d59bec1a45925c1618c6d42541cb652b.txt} |  0
 ...%%gt_5856d025d70301b0cc95e2287a1d324f.txt} |  0
 ...%%gt_8bba62f5739809ebc6cf44f4206dd610.txt} |  0
 ...=%gt_344eadf6b1e04a6f534a3c7e38bbadf1.txt} |  0
 ...=%gt_273e03432c2039cc05443a602e8c633a.txt} |  0
 ..._tag_e5e99c2c84b3c9a106b8cf08b02ce9d6.txt} |  0
 ..._tag_040322f44f30d4766dc7bfe98114d53f.txt} |  0
 ..._tag_276e28a241d24b1f8016400a1c84fef1.txt} |  0
 ...e_gt_045e6b8518e8214f621854f251d1f323.txt} |  0
 ...e_gt_c39bc3d537f50940f8301bcf5be6a5e9.txt} |  0
 ...e_gt_c9d0ca9f702b1a3786a1a8ba835fb475.txt} |  0
 ...e_gt_004b02b673d57d73eb07a649eb08e705.txt} |  0
 25 files changed, 18 insertions(+), 1 deletion(-)
 rename test/snapshots/engine/block_comments_test/{test_0004_evaluation:_ruby_block_comments_with_=begin_and_=end_mutliline_6bf3affa07b559b73f6428e0dbd270d2.txt => test_0004_evaluation_ruby_block_comments_with_=begin_and_=end_mutliline_6bf3affa07b559b73f6428e0dbd270d2.txt} (100%)
 rename test/snapshots/engine/block_comments_test/{test_0005_evaluation:_ruby_block_comments_inside_erb_tags_8a842d797202d0b31c9832cd43a22686.txt => test_0005_evaluation_ruby_block_comments_inside_erb_tags_8a842d797202d0b31c9832cd43a22686.txt} (100%)
 rename test/snapshots/engine/block_comments_test/{test_0006_evaluation:_ruby_block_comments_with_code_before_and_after_c5e6a4e1e9e691af8dcc74ae6c9564c9.txt => test_0006_evaluation_ruby_block_comments_with_code_before_and_after_c5e6a4e1e9e691af8dcc74ae6c9564c9.txt} (100%)
 rename test/snapshots/lexer/attributes_test/{test_0009_attribute_value_single_quotes_with_>_value_2e196056650e47d46886938eb88136f7.txt => test_0009_attribute_value_single_quotes_with_gt_value_2e196056650e47d46886938eb88136f7.txt} (100%)
 rename test/snapshots/lexer/attributes_test/{test_0013_Alpine.js_:class_attribute_af387b2d214ba9baadbd062f15508d2d.txt => test_0013_Alpine.js_class_attribute_af387b2d214ba9baadbd062f15508d2d.txt} (100%)
 rename test/snapshots/lexer/attributes_test/{test_0014_Alpine.js_:value_attribute_dbd22dd4679133f8be271e39a3a16b03.txt => test_0014_Alpine.js_value_attribute_dbd22dd4679133f8be271e39a3a16b03.txt} (100%)
 rename test/snapshots/lexer/attributes_test/{test_0017_Alpine.js_:_without_identifier_ad89c5b890e891eda58e590a3eaf2e82.txt => test_0017_Alpine.js__without_identifier_ad89c5b890e891eda58e590a3eaf2e82.txt} (100%)
 rename test/snapshots/lexer/attributes_test/{test_0018_attribute_value_double_quotes_with_>_value_bf55684b694d2aa471b24fa539546339.txt => test_0018_attribute_value_double_quotes_with_gt_value_bf55684b694d2aa471b24fa539546339.txt} (100%)
 rename test/snapshots/lexer/erb_test/{test_0001_erb_<%_%>_e97ed3ba194342cfe8febc1a40a3d603.txt => test_0001_erb_lt%_%gt_e97ed3ba194342cfe8febc1a40a3d603.txt} (100%)
 rename test/snapshots/lexer/erb_test/{test_0002_erb_<%=_%>_2d5c53c5a986076f8a5df2585ce5aa74.txt => test_0002_erb_lt%=_%gt_2d5c53c5a986076f8a5df2585ce5aa74.txt} (100%)
 rename test/snapshots/lexer/erb_test/{test_0003_erb_<%-_%>_b305aff64a566ea549c116aacb0ce86c.txt => test_0003_erb_lt%-_%gt_b305aff64a566ea549c116aacb0ce86c.txt} (100%)
 rename test/snapshots/lexer/erb_test/{test_0004_erb_<%-_-%>_34d2696185efe003bf3f2c2dddb924e3.txt => test_0004_erb_lt%-_-%gt_34d2696185efe003bf3f2c2dddb924e3.txt} (100%)
 rename test/snapshots/lexer/erb_test/{test_0005_erb_<%#_%>_d59bec1a45925c1618c6d42541cb652b.txt => test_0005_erb_lt%#_%gt_d59bec1a45925c1618c6d42541cb652b.txt} (100%)
 rename test/snapshots/lexer/erb_test/{test_0006_erb_<%%_%%>_5856d025d70301b0cc95e2287a1d324f.txt => test_0006_erb_lt%%_%%gt_5856d025d70301b0cc95e2287a1d324f.txt} (100%)
 rename test/snapshots/lexer/erb_test/{test_0007_erb_<%%=_%%>_8bba62f5739809ebc6cf44f4206dd610.txt => test_0007_erb_lt%%=_%%gt_8bba62f5739809ebc6cf44f4206dd610.txt} (100%)
 rename test/snapshots/lexer/erb_test/{test_0008_erb_<%_=%>_344eadf6b1e04a6f534a3c7e38bbadf1.txt => test_0008_erb_lt%_=%gt_344eadf6b1e04a6f534a3c7e38bbadf1.txt} (100%)
 rename test/snapshots/lexer/erb_test/{test_0009_erb_<%=_=%>_273e03432c2039cc05443a602e8c633a.txt => test_0009_erb_lt%=_=%gt_273e03432c2039cc05443a602e8c633a.txt} (100%)
 rename test/snapshots/parser/erb_test/{test_0033_erb_output_with_=%>_close_tag_e5e99c2c84b3c9a106b8cf08b02ce9d6.txt => test_0033_erb_output_with_=%gt_close_tag_e5e99c2c84b3c9a106b8cf08b02ce9d6.txt} (100%)
 rename test/snapshots/parser/erb_test/{test_0034_erb_if_with_=%>_close_tag_040322f44f30d4766dc7bfe98114d53f.txt => test_0034_erb_if_with_=%gt_close_tag_040322f44f30d4766dc7bfe98114d53f.txt} (100%)
 rename test/snapshots/parser/erb_test/{test_0035_erb_if-elsif-else_with_=%>_close_tag_276e28a241d24b1f8016400a1c84fef1.txt => test_0035_erb_if-elsif-else_with_=%gt_close_tag_276e28a241d24b1f8016400a1c84fef1.txt} (100%)
 rename test/snapshots/parser/tags_test/{test_0047_closing_tag_with_newline_before_>_045e6b8518e8214f621854f251d1f323.txt => test_0047_closing_tag_with_newline_before_gt_045e6b8518e8214f621854f251d1f323.txt} (100%)
 rename test/snapshots/parser/tags_test/{test_0048_closing_tag_with_whitespace_and_newline_before_>_c39bc3d537f50940f8301bcf5be6a5e9.txt => test_0048_closing_tag_with_whitespace_and_newline_before_gt_c39bc3d537f50940f8301bcf5be6a5e9.txt} (100%)
 rename test/snapshots/parser/tags_test/{test_0049_multiple_closing_tags_with_newlines_before_>_c9d0ca9f702b1a3786a1a8ba835fb475.txt => test_0049_multiple_closing_tags_with_newlines_before_gt_c9d0ca9f702b1a3786a1a8ba835fb475.txt} (100%)
 rename test/snapshots/parser/tags_test/{test_0051_self-closing_tag_with_closing_tag_having_newline_before_>_004b02b673d57d73eb07a649eb08e705.txt => test_0051_self-closing_tag_with_closing_tag_having_newline_before_gt_004b02b673d57d73eb07a649eb08e705.txt} (100%)

diff --git a/test/snapshot_utils.rb b/test/snapshot_utils.rb
index 2034fc552..7de08e587 100644
--- a/test/snapshot_utils.rb
+++ b/test/snapshot_utils.rb
@@ -145,7 +145,7 @@ def snapshot_file(source, options = {})
 
     content_hash = Digest::MD5.hexdigest(source || "#{source.class}-#{source.inspect}")
 
-    test_name = name.gsub(" ", "_").gsub("/", "_")
+    test_name = sanitize_name_for_filesystem(name)
 
     if options && !options.empty?
       options_hash = Digest::MD5.hexdigest(options.inspect)
@@ -178,6 +178,23 @@ def snapshot_file(source, options = {})
 
   private
 
+  def sanitize_name_for_filesystem(name)
+    [
+      # ntfs reserved characters
+      # https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file
+      ['<', 'lt'],
+      ['>', 'gt'],
+      [':', ''],
+      ['/', '_'],
+      ['\\', ''],
+      ['|', ''],
+      ['?', ''],
+      ['*', ''],
+
+      [' ', '_']
+    ].inject(name) { |name, substitution| name.gsub(substitution[0], substitution[1]) }
+  end
+
   def underscore(string)
     string.gsub("::", "/")
           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
diff --git a/test/snapshots/engine/block_comments_test/test_0004_evaluation:_ruby_block_comments_with_=begin_and_=end_mutliline_6bf3affa07b559b73f6428e0dbd270d2.txt b/test/snapshots/engine/block_comments_test/test_0004_evaluation_ruby_block_comments_with_=begin_and_=end_mutliline_6bf3affa07b559b73f6428e0dbd270d2.txt
similarity index 100%
rename from test/snapshots/engine/block_comments_test/test_0004_evaluation:_ruby_block_comments_with_=begin_and_=end_mutliline_6bf3affa07b559b73f6428e0dbd270d2.txt
rename to test/snapshots/engine/block_comments_test/test_0004_evaluation_ruby_block_comments_with_=begin_and_=end_mutliline_6bf3affa07b559b73f6428e0dbd270d2.txt
diff --git a/test/snapshots/engine/block_comments_test/test_0005_evaluation:_ruby_block_comments_inside_erb_tags_8a842d797202d0b31c9832cd43a22686.txt b/test/snapshots/engine/block_comments_test/test_0005_evaluation_ruby_block_comments_inside_erb_tags_8a842d797202d0b31c9832cd43a22686.txt
similarity index 100%
rename from test/snapshots/engine/block_comments_test/test_0005_evaluation:_ruby_block_comments_inside_erb_tags_8a842d797202d0b31c9832cd43a22686.txt
rename to test/snapshots/engine/block_comments_test/test_0005_evaluation_ruby_block_comments_inside_erb_tags_8a842d797202d0b31c9832cd43a22686.txt
diff --git a/test/snapshots/engine/block_comments_test/test_0006_evaluation:_ruby_block_comments_with_code_before_and_after_c5e6a4e1e9e691af8dcc74ae6c9564c9.txt b/test/snapshots/engine/block_comments_test/test_0006_evaluation_ruby_block_comments_with_code_before_and_after_c5e6a4e1e9e691af8dcc74ae6c9564c9.txt
similarity index 100%
rename from test/snapshots/engine/block_comments_test/test_0006_evaluation:_ruby_block_comments_with_code_before_and_after_c5e6a4e1e9e691af8dcc74ae6c9564c9.txt
rename to test/snapshots/engine/block_comments_test/test_0006_evaluation_ruby_block_comments_with_code_before_and_after_c5e6a4e1e9e691af8dcc74ae6c9564c9.txt
diff --git a/test/snapshots/lexer/attributes_test/test_0009_attribute_value_single_quotes_with_>_value_2e196056650e47d46886938eb88136f7.txt b/test/snapshots/lexer/attributes_test/test_0009_attribute_value_single_quotes_with_gt_value_2e196056650e47d46886938eb88136f7.txt
similarity index 100%
rename from test/snapshots/lexer/attributes_test/test_0009_attribute_value_single_quotes_with_>_value_2e196056650e47d46886938eb88136f7.txt
rename to test/snapshots/lexer/attributes_test/test_0009_attribute_value_single_quotes_with_gt_value_2e196056650e47d46886938eb88136f7.txt
diff --git a/test/snapshots/lexer/attributes_test/test_0013_Alpine.js_:class_attribute_af387b2d214ba9baadbd062f15508d2d.txt b/test/snapshots/lexer/attributes_test/test_0013_Alpine.js_class_attribute_af387b2d214ba9baadbd062f15508d2d.txt
similarity index 100%
rename from test/snapshots/lexer/attributes_test/test_0013_Alpine.js_:class_attribute_af387b2d214ba9baadbd062f15508d2d.txt
rename to test/snapshots/lexer/attributes_test/test_0013_Alpine.js_class_attribute_af387b2d214ba9baadbd062f15508d2d.txt
diff --git a/test/snapshots/lexer/attributes_test/test_0014_Alpine.js_:value_attribute_dbd22dd4679133f8be271e39a3a16b03.txt b/test/snapshots/lexer/attributes_test/test_0014_Alpine.js_value_attribute_dbd22dd4679133f8be271e39a3a16b03.txt
similarity index 100%
rename from test/snapshots/lexer/attributes_test/test_0014_Alpine.js_:value_attribute_dbd22dd4679133f8be271e39a3a16b03.txt
rename to test/snapshots/lexer/attributes_test/test_0014_Alpine.js_value_attribute_dbd22dd4679133f8be271e39a3a16b03.txt
diff --git a/test/snapshots/lexer/attributes_test/test_0017_Alpine.js_:_without_identifier_ad89c5b890e891eda58e590a3eaf2e82.txt b/test/snapshots/lexer/attributes_test/test_0017_Alpine.js__without_identifier_ad89c5b890e891eda58e590a3eaf2e82.txt
similarity index 100%
rename from test/snapshots/lexer/attributes_test/test_0017_Alpine.js_:_without_identifier_ad89c5b890e891eda58e590a3eaf2e82.txt
rename to test/snapshots/lexer/attributes_test/test_0017_Alpine.js__without_identifier_ad89c5b890e891eda58e590a3eaf2e82.txt
diff --git a/test/snapshots/lexer/attributes_test/test_0018_attribute_value_double_quotes_with_>_value_bf55684b694d2aa471b24fa539546339.txt b/test/snapshots/lexer/attributes_test/test_0018_attribute_value_double_quotes_with_gt_value_bf55684b694d2aa471b24fa539546339.txt
similarity index 100%
rename from test/snapshots/lexer/attributes_test/test_0018_attribute_value_double_quotes_with_>_value_bf55684b694d2aa471b24fa539546339.txt
rename to test/snapshots/lexer/attributes_test/test_0018_attribute_value_double_quotes_with_gt_value_bf55684b694d2aa471b24fa539546339.txt
diff --git a/test/snapshots/lexer/erb_test/test_0001_erb_<%_%>_e97ed3ba194342cfe8febc1a40a3d603.txt b/test/snapshots/lexer/erb_test/test_0001_erb_lt%_%gt_e97ed3ba194342cfe8febc1a40a3d603.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0001_erb_<%_%>_e97ed3ba194342cfe8febc1a40a3d603.txt
rename to test/snapshots/lexer/erb_test/test_0001_erb_lt%_%gt_e97ed3ba194342cfe8febc1a40a3d603.txt
diff --git a/test/snapshots/lexer/erb_test/test_0002_erb_<%=_%>_2d5c53c5a986076f8a5df2585ce5aa74.txt b/test/snapshots/lexer/erb_test/test_0002_erb_lt%=_%gt_2d5c53c5a986076f8a5df2585ce5aa74.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0002_erb_<%=_%>_2d5c53c5a986076f8a5df2585ce5aa74.txt
rename to test/snapshots/lexer/erb_test/test_0002_erb_lt%=_%gt_2d5c53c5a986076f8a5df2585ce5aa74.txt
diff --git a/test/snapshots/lexer/erb_test/test_0003_erb_<%-_%>_b305aff64a566ea549c116aacb0ce86c.txt b/test/snapshots/lexer/erb_test/test_0003_erb_lt%-_%gt_b305aff64a566ea549c116aacb0ce86c.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0003_erb_<%-_%>_b305aff64a566ea549c116aacb0ce86c.txt
rename to test/snapshots/lexer/erb_test/test_0003_erb_lt%-_%gt_b305aff64a566ea549c116aacb0ce86c.txt
diff --git a/test/snapshots/lexer/erb_test/test_0004_erb_<%-_-%>_34d2696185efe003bf3f2c2dddb924e3.txt b/test/snapshots/lexer/erb_test/test_0004_erb_lt%-_-%gt_34d2696185efe003bf3f2c2dddb924e3.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0004_erb_<%-_-%>_34d2696185efe003bf3f2c2dddb924e3.txt
rename to test/snapshots/lexer/erb_test/test_0004_erb_lt%-_-%gt_34d2696185efe003bf3f2c2dddb924e3.txt
diff --git a/test/snapshots/lexer/erb_test/test_0005_erb_<%#_%>_d59bec1a45925c1618c6d42541cb652b.txt b/test/snapshots/lexer/erb_test/test_0005_erb_lt%#_%gt_d59bec1a45925c1618c6d42541cb652b.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0005_erb_<%#_%>_d59bec1a45925c1618c6d42541cb652b.txt
rename to test/snapshots/lexer/erb_test/test_0005_erb_lt%#_%gt_d59bec1a45925c1618c6d42541cb652b.txt
diff --git a/test/snapshots/lexer/erb_test/test_0006_erb_<%%_%%>_5856d025d70301b0cc95e2287a1d324f.txt b/test/snapshots/lexer/erb_test/test_0006_erb_lt%%_%%gt_5856d025d70301b0cc95e2287a1d324f.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0006_erb_<%%_%%>_5856d025d70301b0cc95e2287a1d324f.txt
rename to test/snapshots/lexer/erb_test/test_0006_erb_lt%%_%%gt_5856d025d70301b0cc95e2287a1d324f.txt
diff --git a/test/snapshots/lexer/erb_test/test_0007_erb_<%%=_%%>_8bba62f5739809ebc6cf44f4206dd610.txt b/test/snapshots/lexer/erb_test/test_0007_erb_lt%%=_%%gt_8bba62f5739809ebc6cf44f4206dd610.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0007_erb_<%%=_%%>_8bba62f5739809ebc6cf44f4206dd610.txt
rename to test/snapshots/lexer/erb_test/test_0007_erb_lt%%=_%%gt_8bba62f5739809ebc6cf44f4206dd610.txt
diff --git a/test/snapshots/lexer/erb_test/test_0008_erb_<%_=%>_344eadf6b1e04a6f534a3c7e38bbadf1.txt b/test/snapshots/lexer/erb_test/test_0008_erb_lt%_=%gt_344eadf6b1e04a6f534a3c7e38bbadf1.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0008_erb_<%_=%>_344eadf6b1e04a6f534a3c7e38bbadf1.txt
rename to test/snapshots/lexer/erb_test/test_0008_erb_lt%_=%gt_344eadf6b1e04a6f534a3c7e38bbadf1.txt
diff --git a/test/snapshots/lexer/erb_test/test_0009_erb_<%=_=%>_273e03432c2039cc05443a602e8c633a.txt b/test/snapshots/lexer/erb_test/test_0009_erb_lt%=_=%gt_273e03432c2039cc05443a602e8c633a.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0009_erb_<%=_=%>_273e03432c2039cc05443a602e8c633a.txt
rename to test/snapshots/lexer/erb_test/test_0009_erb_lt%=_=%gt_273e03432c2039cc05443a602e8c633a.txt
diff --git a/test/snapshots/parser/erb_test/test_0033_erb_output_with_=%>_close_tag_e5e99c2c84b3c9a106b8cf08b02ce9d6.txt b/test/snapshots/parser/erb_test/test_0033_erb_output_with_=%gt_close_tag_e5e99c2c84b3c9a106b8cf08b02ce9d6.txt
similarity index 100%
rename from test/snapshots/parser/erb_test/test_0033_erb_output_with_=%>_close_tag_e5e99c2c84b3c9a106b8cf08b02ce9d6.txt
rename to test/snapshots/parser/erb_test/test_0033_erb_output_with_=%gt_close_tag_e5e99c2c84b3c9a106b8cf08b02ce9d6.txt
diff --git a/test/snapshots/parser/erb_test/test_0034_erb_if_with_=%>_close_tag_040322f44f30d4766dc7bfe98114d53f.txt b/test/snapshots/parser/erb_test/test_0034_erb_if_with_=%gt_close_tag_040322f44f30d4766dc7bfe98114d53f.txt
similarity index 100%
rename from test/snapshots/parser/erb_test/test_0034_erb_if_with_=%>_close_tag_040322f44f30d4766dc7bfe98114d53f.txt
rename to test/snapshots/parser/erb_test/test_0034_erb_if_with_=%gt_close_tag_040322f44f30d4766dc7bfe98114d53f.txt
diff --git a/test/snapshots/parser/erb_test/test_0035_erb_if-elsif-else_with_=%>_close_tag_276e28a241d24b1f8016400a1c84fef1.txt b/test/snapshots/parser/erb_test/test_0035_erb_if-elsif-else_with_=%gt_close_tag_276e28a241d24b1f8016400a1c84fef1.txt
similarity index 100%
rename from test/snapshots/parser/erb_test/test_0035_erb_if-elsif-else_with_=%>_close_tag_276e28a241d24b1f8016400a1c84fef1.txt
rename to test/snapshots/parser/erb_test/test_0035_erb_if-elsif-else_with_=%gt_close_tag_276e28a241d24b1f8016400a1c84fef1.txt
diff --git a/test/snapshots/parser/tags_test/test_0047_closing_tag_with_newline_before_>_045e6b8518e8214f621854f251d1f323.txt b/test/snapshots/parser/tags_test/test_0047_closing_tag_with_newline_before_gt_045e6b8518e8214f621854f251d1f323.txt
similarity index 100%
rename from test/snapshots/parser/tags_test/test_0047_closing_tag_with_newline_before_>_045e6b8518e8214f621854f251d1f323.txt
rename to test/snapshots/parser/tags_test/test_0047_closing_tag_with_newline_before_gt_045e6b8518e8214f621854f251d1f323.txt
diff --git a/test/snapshots/parser/tags_test/test_0048_closing_tag_with_whitespace_and_newline_before_>_c39bc3d537f50940f8301bcf5be6a5e9.txt b/test/snapshots/parser/tags_test/test_0048_closing_tag_with_whitespace_and_newline_before_gt_c39bc3d537f50940f8301bcf5be6a5e9.txt
similarity index 100%
rename from test/snapshots/parser/tags_test/test_0048_closing_tag_with_whitespace_and_newline_before_>_c39bc3d537f50940f8301bcf5be6a5e9.txt
rename to test/snapshots/parser/tags_test/test_0048_closing_tag_with_whitespace_and_newline_before_gt_c39bc3d537f50940f8301bcf5be6a5e9.txt
diff --git a/test/snapshots/parser/tags_test/test_0049_multiple_closing_tags_with_newlines_before_>_c9d0ca9f702b1a3786a1a8ba835fb475.txt b/test/snapshots/parser/tags_test/test_0049_multiple_closing_tags_with_newlines_before_gt_c9d0ca9f702b1a3786a1a8ba835fb475.txt
similarity index 100%
rename from test/snapshots/parser/tags_test/test_0049_multiple_closing_tags_with_newlines_before_>_c9d0ca9f702b1a3786a1a8ba835fb475.txt
rename to test/snapshots/parser/tags_test/test_0049_multiple_closing_tags_with_newlines_before_gt_c9d0ca9f702b1a3786a1a8ba835fb475.txt
diff --git a/test/snapshots/parser/tags_test/test_0051_self-closing_tag_with_closing_tag_having_newline_before_>_004b02b673d57d73eb07a649eb08e705.txt b/test/snapshots/parser/tags_test/test_0051_self-closing_tag_with_closing_tag_having_newline_before_gt_004b02b673d57d73eb07a649eb08e705.txt
similarity index 100%
rename from test/snapshots/parser/tags_test/test_0051_self-closing_tag_with_closing_tag_having_newline_before_>_004b02b673d57d73eb07a649eb08e705.txt
rename to test/snapshots/parser/tags_test/test_0051_self-closing_tag_with_closing_tag_having_newline_before_gt_004b02b673d57d73eb07a649eb08e705.txt

From f49dee841030a02c988237fd3cebb1dc83bfc407 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Fri, 10 Oct 2025 17:38:19 +0200
Subject: [PATCH 36/97] RuboCop

---
 test/snapshot_utils.rb | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/test/snapshot_utils.rb b/test/snapshot_utils.rb
index 7de08e587..4f848230d 100644
--- a/test/snapshot_utils.rb
+++ b/test/snapshot_utils.rb
@@ -182,16 +182,16 @@ def sanitize_name_for_filesystem(name)
     [
       # ntfs reserved characters
       # https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file
-      ['<', 'lt'],
-      ['>', 'gt'],
-      [':', ''],
-      ['/', '_'],
-      ['\\', ''],
-      ['|', ''],
-      ['?', ''],
-      ['*', ''],
-
-      [' ', '_']
+      ["<", "lt"],
+      [">", "gt"],
+      [":", ""],
+      ["/", "_"],
+      ["\\", ""],
+      ["|", ""],
+      ["?", ""],
+      ["*", ""],
+
+      [" ", "_"]
     ].inject(name) { |name, substitution| name.gsub(substitution[0], substitution[1]) }
   end
 

From f4f97aa3b72635a351fe7dd4b89486f0637b01e7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Fri, 10 Oct 2025 17:48:08 +0200
Subject: [PATCH 37/97] C: Remove `memory.c` implementation in preparation for
 arena allocator (#611)

This PR removes the `safe_malloc`, `safe_realloc`,
`nullable_safe_malloc` usages from the code base and removes the
accompanying `memory` header/source files.

It replaces those usages with normal malloc/realloc function calls.

This is done as part of the move to an arena based memory allocation
strategy.
---
 javascript/packages/node/binding.gyp |  1 -
 src/array.c                          |  7 ++--
 src/buffer.c                         |  7 ++--
 src/include/memory.h                 | 12 -------
 src/memory.c                         | 53 ----------------------------
 5 files changed, 6 insertions(+), 74 deletions(-)
 delete mode 100644 src/include/memory.h
 delete mode 100644 src/memory.c

diff --git a/javascript/packages/node/binding.gyp b/javascript/packages/node/binding.gyp
index 9bba520c9..650d93a7e 100644
--- a/javascript/packages/node/binding.gyp
+++ b/javascript/packages/node/binding.gyp
@@ -27,7 +27,6 @@
         "./extension/libherb/lexer_peek_helpers.c",
         "./extension/libherb/lexer.c",
         "./extension/libherb/location.c",
-        "./extension/libherb/memory.c",
         "./extension/libherb/parser_helpers.c",
         "./extension/libherb/parser.c",
         "./extension/libherb/pretty_print.c",
diff --git a/src/array.c b/src/array.c
index cd3210b8f..fa882c0f1 100644
--- a/src/array.c
+++ b/src/array.c
@@ -3,18 +3,17 @@
 
 #include "include/array.h"
 #include "include/macros.h"
-#include "include/memory.h"
 
 size_t array_sizeof(void) {
   return sizeof(array_T);
 }
 
 array_T* array_init(const size_t capacity) {
-  array_T* array = safe_malloc(array_sizeof());
+  array_T* array = malloc(array_sizeof());
 
   array->size = 0;
   array->capacity = capacity;
-  array->items = nullable_safe_malloc(sizeof(void*) * capacity);
+  array->items = malloc(capacity * sizeof(void*));
 
   if (!array->items) {
     free(array);
@@ -45,7 +44,7 @@ void array_append(array_T* array, void* item) {
     }
 
     size_t new_size_bytes = new_capacity * sizeof(void*);
-    void* new_items = safe_realloc(array->items, new_size_bytes);
+    void* new_items = realloc(array->items, new_size_bytes);
 
     if (unlikely(new_items == NULL)) { return; }
 
diff --git a/src/buffer.c b/src/buffer.c
index adc08292e..33ddd4ce4 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -4,13 +4,12 @@
 
 #include "include/buffer.h"
 #include "include/macros.h"
-#include "include/memory.h"
 #include "include/util.h"
 
 bool buffer_init(buffer_T* buffer, const size_t capacity) {
   buffer->capacity = capacity;
   buffer->length = 0;
-  buffer->value = nullable_safe_malloc((buffer->capacity + 1) * sizeof(char));
+  buffer->value = malloc(sizeof(char) * (buffer->capacity + 1));
 
   if (!buffer->value) {
     fprintf(stderr, "Error: Failed to initialize buffer with capacity of %zu.\n", buffer->capacity);
@@ -23,7 +22,7 @@ bool buffer_init(buffer_T* buffer, const size_t capacity) {
 }
 
 buffer_T* buffer_new(const size_t capacity) {
-  buffer_T* buffer = safe_malloc(sizeof(buffer_T));
+  buffer_T* buffer = malloc(sizeof(buffer_T));
 
   if (!buffer_init(buffer, capacity)) {
     free(buffer);
@@ -82,7 +81,7 @@ bool buffer_resize(buffer_T* buffer, const size_t new_capacity) {
     exit(1);
   }
 
-  char* new_value = nullable_safe_realloc(buffer->value, new_capacity + 1);
+  char* new_value = realloc(buffer->value, new_capacity + 1);
 
   if (unlikely(new_value == NULL)) {
     fprintf(stderr, "Error: Failed to resize buffer to %zu.\n", new_capacity);
diff --git a/src/include/memory.h b/src/include/memory.h
deleted file mode 100644
index b6f942e82..000000000
--- a/src/include/memory.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef HERB_MEMORY_H
-#define HERB_MEMORY_H
-
-#include <stddef.h>
-
-void* safe_malloc(size_t size);
-void* safe_realloc(void* pointer, size_t new_size);
-
-void* nullable_safe_malloc(size_t size);
-void* nullable_safe_realloc(void* pointer, size_t new_size);
-
-#endif
diff --git a/src/memory.c b/src/memory.c
deleted file mode 100644
index f0f3ed8dc..000000000
--- a/src/memory.c
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "memory.h"
-
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-static void* safe_malloc_internal(const size_t size, const bool fail_fast) {
-  if (size == 0) { return NULL; }
-
-  void* pointer = malloc(size);
-
-  if (!pointer) {
-    fprintf(stderr, "Error: Failed to allocate %zu bytes.\n", size);
-    fflush(stderr);
-    if (fail_fast) { exit(1); }
-    return NULL;
-  }
-
-  return pointer;
-}
-
-static void* safe_realloc_internal(void* pointer, const size_t new_size, const bool fail_fast) {
-  if (new_size == 0) { return NULL; }
-
-  if (!pointer) { return safe_malloc_internal(new_size, fail_fast); }
-
-  void* new_pointer = realloc(pointer, new_size);
-
-  if (!new_pointer) {
-    fprintf(stderr, "Error: Memory reallocation failed (size: %zu bytes).\n", new_size);
-    fflush(stderr);
-    if (fail_fast) { exit(1); }
-    return NULL;
-  }
-
-  return new_pointer;
-}
-
-void* safe_malloc(const size_t size) {
-  return safe_malloc_internal(size, true);
-}
-
-void* nullable_safe_malloc(const size_t size) {
-  return safe_malloc_internal(size, false);
-}
-
-void* safe_realloc(void* pointer, const size_t new_size) {
-  return safe_realloc_internal(pointer, new_size, true);
-}
-
-void* nullable_safe_realloc(void* pointer, const size_t new_size) {
-  return safe_realloc_internal(pointer, new_size, false);
-}

From 860c7987e5c505be64063b00350d40cf0c884c33 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Fri, 10 Oct 2025 19:30:19 +0200
Subject: [PATCH 38/97] Formatter: Better respect and deal with whitespace and
 adjacent text (#612)

This pull request improves the way the formatter deals with whitespace
and formatting adjacent text next to HTML element and ERB tags.

Follow up on #591
Partially addresses #609.
---
 .../packages/formatter/src/format-helpers.ts  |  41 ++-
 .../packages/formatter/src/format-printer.ts  | 249 +++++++++++++++---
 .../test/document-formatting.test.ts          |   3 +-
 .../erb-formatter-additional.test.ts          |   8 +-
 .../erb-formatter-compat.test.ts              |   8 +-
 .../packages/formatter/test/erb/erb.test.ts   | 200 +++++++++++++-
 6 files changed, 456 insertions(+), 53 deletions(-)

diff --git a/javascript/packages/formatter/src/format-helpers.ts b/javascript/packages/formatter/src/format-helpers.ts
index 01279ac95..13c71fb2b 100644
--- a/javascript/packages/formatter/src/format-helpers.ts
+++ b/javascript/packages/formatter/src/format-helpers.ts
@@ -23,6 +23,14 @@ export interface ContentUnit {
   breaksFlow: boolean
 }
 
+/**
+ * Content unit paired with its source AST node
+ */
+export interface ContentUnitWithNode {
+  unit: ContentUnit
+  node: Node | null
+}
+
 // --- Constants ---
 
 // TODO: we can probably expand this list with more tags/attributes
@@ -415,7 +423,7 @@ export function shouldWrapToNextLine(testLine: string, currentLine: string, word
   if (!currentLine) return false
   if (isClosingPunctuation(word)) return false
 
-  return testLine.length > wrapWidth
+  return testLine.length >= wrapWidth
 }
 
 /**
@@ -434,3 +442,34 @@ export function isBlockLevelNode(node: Node): boolean {
 
   return true
 }
+
+/**
+ * Normalize text by replacing multiple spaces with single space and trim
+ * Then split into words
+ */
+export function normalizeAndSplitWords(text: string): string[] {
+  const normalized = text.replace(/\s+/g, ' ')
+  return normalized.trim().split(' ')
+}
+
+/**
+ * Check if text starts with an alphanumeric character (not punctuation)
+ */
+export function startsWithAlphanumeric(text: string): boolean {
+  const trimmed = text.trim()
+  return /^[a-zA-Z0-9]/.test(trimmed)
+}
+
+/**
+ * Check if text ends with an alphanumeric character (not punctuation)
+ */
+export function endsWithAlphanumeric(text: string): boolean {
+  return /[a-zA-Z0-9]$/.test(text)
+}
+
+/**
+ * Check if text ends with whitespace
+ */
+export function endsWithWhitespace(text: string): boolean {
+  return /\s$/.test(text)
+}
diff --git a/javascript/packages/formatter/src/format-printer.ts b/javascript/packages/formatter/src/format-printer.ts
index b79837721..327fef82c 100644
--- a/javascript/packages/formatter/src/format-printer.ts
+++ b/javascript/packages/formatter/src/format-printer.ts
@@ -20,20 +20,25 @@ import {
   areAllNestedElementsInline,
   buildLineWithWord,
   countAdjacentInlineElements,
+  endsWithAlphanumeric,
+  endsWithWhitespace,
   filterEmptyNodes,
   filterSignificantChildren,
   findPreviousMeaningfulSibling,
   hasComplexERBControlFlow,
   hasMixedTextAndInlineContent,
   hasMultilineTextContent,
+  hasWhitespaceBetween,
   isBlockLevelNode,
   isContentPreserving,
   isInlineElement,
   isNonWhitespaceNode,
   isPureWhitespaceNode,
+  normalizeAndSplitWords,
   shouldAppendToLastLine,
   shouldPreserveUserSpacing,
   shouldWrapToNextLine,
+  startsWithAlphanumeric,
 } from "./format-helpers.js"
 
 import {
@@ -48,6 +53,7 @@ import {
 
 import type {
   ContentUnit,
+  ContentUnitWithNode,
   ElementFormattingAnalysis,
 } from "./format-helpers.js"
 
@@ -1060,7 +1066,17 @@ export class FormatPrinter extends Printer {
 
   visitERBBlockNode(node: ERBBlockNode) {
     this.printERBNode(node)
-    this.withIndent(() => this.visitElementChildren(node.body, null))
+
+    this.withIndent(() => {
+      const hasTextFlow = this.isInTextFlowContext(null, node.body)
+
+      if (hasTextFlow) {
+        const children = filterSignificantChildren(node.body)
+        this.visitTextFlowChildren(children)
+      } else {
+        this.visitElementChildren(node.body, null)
+      }
+    })
 
     if (node.end_node) this.visit(node.end_node)
   }
@@ -1387,6 +1403,7 @@ export class FormatPrinter extends Printer {
       const attributes = filterNodes(element.open_tag?.children, HTMLAttributeNode)
       const attributesString = this.renderAttributesString(attributes)
       const isSelfClosing = element.open_tag?.tag_closing?.value === "/>"
+
       return `<${tagName}${attributesString}${isSelfClosing ? " />" : ">"}`
     }
 
@@ -1432,7 +1449,7 @@ export class FormatPrinter extends Printer {
    * Build words array from text/inline/ERB and wrap them
    */
   private buildAndWrapTextFlow(children: Node[]): void {
-    const unitsWithNodes = this.buildContentUnitsWithNodes(children)
+    const unitsWithNodes: ContentUnitWithNode[] = this.buildContentUnitsWithNodes(children)
     const words: string[] = []
 
     for (const { unit, node } of unitsWithNodes) {
@@ -1457,47 +1474,198 @@ export class FormatPrinter extends Printer {
   }
 
   /**
-   * Convert AST nodes to content units with node references
+   * Try to merge text that follows an atomic unit (ERB/inline) with no whitespace
+   * Returns true if merge was performed
    */
-  private buildContentUnitsWithNodes(children: Node[]): Array<{ unit: ContentUnit; node: Node | null }> {
-    const result: Array<{ unit: ContentUnit; node: Node | null }> = []
+  private tryMergeTextAfterAtomic(result: ContentUnitWithNode[], textNode: HTMLTextNode): boolean {
+    if (result.length === 0) return false
 
-    for (const child of children) {
-      if (isNode(child, WhitespaceNode)) {
-        continue
+    const lastUnit = result[result.length - 1]
+
+    if (!lastUnit.unit.isAtomic || (lastUnit.unit.type !== 'erb' && lastUnit.unit.type !== 'inline')) {
+      return false
+    }
+
+    const words = normalizeAndSplitWords(textNode.content)
+    if (words.length === 0 || !words[0]) return false
+    if (!startsWithAlphanumeric(words[0])) return false
+
+    lastUnit.unit.content += words[0]
+
+    if (words.length > 1) {
+      const remainingText = words.slice(1).join(' ')
+
+      result.push({
+        unit: { content: remainingText, type: 'text', isAtomic: false, breaksFlow: false },
+        node: textNode
+      })
+    }
+
+    return true
+  }
+
+  /**
+   * Try to merge an atomic unit (ERB/inline) with preceding text that has no whitespace
+   * Returns true if merge was performed
+   */
+  private tryMergeAtomicAfterText(result: ContentUnitWithNode[], children: Node[], lastProcessedIndex: number, atomicContent: string, atomicType: 'erb' | 'inline', atomicNode: Node): boolean {
+    if (result.length === 0) return false
+
+    const lastUnit = result[result.length - 1]
+
+    if (lastUnit.unit.type !== 'text' || lastUnit.unit.isAtomic) return false
+
+    const words = normalizeAndSplitWords(lastUnit.unit.content)
+    const lastWord = words[words.length - 1]
+
+    if (!lastWord) return false
+
+    result.pop()
+
+    if (words.length > 1) {
+      const remainingText = words.slice(0, -1).join(' ')
+
+      result.push({
+        unit: { content: remainingText, type: 'text', isAtomic: false, breaksFlow: false },
+        node: children[lastProcessedIndex]
+      })
+    }
+
+    result.push({
+      unit: { content: lastWord + atomicContent, type: atomicType, isAtomic: true, breaksFlow: false },
+      node: atomicNode
+    })
+
+    return true
+  }
+
+  /**
+   * Check if there's whitespace between current node and last processed node
+   */
+  private hasWhitespaceBeforeNode(children: Node[], lastProcessedIndex: number, currentIndex: number, currentNode: Node): boolean {
+    if (hasWhitespaceBetween(children, lastProcessedIndex, currentIndex)) {
+      return true
+    }
+
+    if (isNode(currentNode, HTMLTextNode) && /^\s/.test(currentNode.content)) {
+      return true
+    }
+
+    return false
+  }
+
+  /**
+   * Check if last unit in result ends with whitespace
+   */
+  private lastUnitEndsWithWhitespace(result: ContentUnitWithNode[]): boolean {
+    if (result.length === 0) return false
+
+    const lastUnit = result[result.length - 1]
+
+    return lastUnit.unit.type === 'text' && endsWithWhitespace(lastUnit.unit.content)
+  }
+
+  /**
+   * Process a text node and add it to results (with potential merging)
+   */
+  private processTextNode(result: ContentUnitWithNode[], children: Node[], child: HTMLTextNode, index: number, lastProcessedIndex: number): void {
+    const isAtomic = child.content === ' '
+
+    if (!isAtomic && lastProcessedIndex >= 0) {
+      const hasWhitespace = this.hasWhitespaceBeforeNode(children, lastProcessedIndex, index, child)
+
+      if (!hasWhitespace && this.tryMergeTextAfterAtomic(result, child)) {
+        return
       }
+    }
 
-      if (isPureWhitespaceNode(child) && !(isNode(child, HTMLTextNode) && child.content === ' ')) {
-        continue
+    result.push({
+      unit: { content: child.content, type: 'text', isAtomic, breaksFlow: false },
+      node: child
+    })
+  }
+
+  /**
+   * Process an inline element and add it to results (with potential merging)
+   */
+  private processInlineElement(result: ContentUnitWithNode[], children: Node[], child: HTMLElementNode, index: number, lastProcessedIndex: number): boolean {
+    const tagName = getTagName(child)
+    const inlineContent = this.tryRenderInlineFull(child, tagName, filterNodes(child.open_tag?.children, HTMLAttributeNode), filterEmptyNodes(child.body))
+
+    if (inlineContent === null) {
+      result.push({
+        unit: { content: '', type: 'block', isAtomic: false, breaksFlow: true },
+        node: child
+      })
+
+      return false
+    }
+
+    if (lastProcessedIndex >= 0) {
+      const hasWhitespace = hasWhitespaceBetween(children, lastProcessedIndex, index) || this.lastUnitEndsWithWhitespace(result)
+
+      if (!hasWhitespace && this.tryMergeAtomicAfterText(result, children, lastProcessedIndex, inlineContent, 'inline', child)) {
+        return true
+      }
+    }
+
+    result.push({
+      unit: { content: inlineContent, type: 'inline', isAtomic: true, breaksFlow: false },
+      node: child
+    })
+
+    return false
+  }
+
+  /**
+   * Process an ERB content node and add it to results (with potential merging)
+   */
+  private processERBContentNode(result: ContentUnitWithNode[], children: Node[], child: ERBContentNode, index: number, lastProcessedIndex: number): boolean {
+    const erbContent = this.renderERBAsString(child)
+
+    if (lastProcessedIndex >= 0) {
+      const hasWhitespace = hasWhitespaceBetween(children, lastProcessedIndex, index) || this.lastUnitEndsWithWhitespace(result)
+
+      if (!hasWhitespace && this.tryMergeAtomicAfterText(result, children, lastProcessedIndex, erbContent, 'erb', child)) {
+        return true
       }
+    }
+
+    result.push({
+      unit: { content: erbContent, type: 'erb', isAtomic: true, breaksFlow: false },
+      node: child
+    })
+
+    return false
+  }
+
+  /**
+   * Convert AST nodes to content units with node references
+   */
+  private buildContentUnitsWithNodes(children: Node[]): ContentUnitWithNode[] {
+    const result: ContentUnitWithNode[] = []
+    let lastProcessedIndex = -1
+
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i]
+
+      if (isNode(child, WhitespaceNode)) continue
+      if (isPureWhitespaceNode(child) && !(isNode(child, HTMLTextNode) && child.content === ' ')) continue
 
       if (isNode(child, HTMLTextNode)) {
-        const isAtomic = child.content === ' '
+        this.processTextNode(result, children, child, i, lastProcessedIndex)
 
-        result.push({
-          unit: { content: child.content, type: 'text', isAtomic, breaksFlow: false },
-          node: child
-        })
+        lastProcessedIndex = i
       } else if (isNode(child, HTMLElementNode)) {
         const tagName = getTagName(child)
+
         if (isInlineElement(tagName)) {
-          const inlineContent = this.tryRenderInlineFull(
-            child,
-            tagName,
-            filterNodes(child.open_tag?.children, HTMLAttributeNode),
-            filterEmptyNodes(child.body)
-          )
-
-          if (inlineContent !== null) {
-            result.push({
-              unit: { content: inlineContent, type: 'inline', isAtomic: true, breaksFlow: false },
-              node: child
-            })
-          } else {
-            result.push({
-              unit: { content: '', type: 'block', isAtomic: false, breaksFlow: true },
-              node: child
-            })
+          const merged = this.processInlineElement(result, children, child, i, lastProcessedIndex)
+
+          if (merged) {
+            lastProcessedIndex = i
+
+            continue
           }
         } else {
           result.push({
@@ -1505,16 +1673,25 @@ export class FormatPrinter extends Printer {
             node: child
           })
         }
+
+        lastProcessedIndex = i
       } else if (isNode(child, ERBContentNode)) {
-        result.push({
-          unit: { content: this.renderERBAsString(child), type: 'erb', isAtomic: true, breaksFlow: false },
-          node: child
-        })
+        const merged = this.processERBContentNode(result, children, child, i, lastProcessedIndex)
+
+        if (merged) {
+          lastProcessedIndex = i
+
+          continue
+        }
+
+        lastProcessedIndex = i
       } else {
         result.push({
           unit: { content: '', type: 'block', isAtomic: false, breaksFlow: true },
           node: child
         })
+
+        lastProcessedIndex = i
       }
     }
 
diff --git a/javascript/packages/formatter/test/document-formatting.test.ts b/javascript/packages/formatter/test/document-formatting.test.ts
index 60a3e1e5f..1f7d4c633 100644
--- a/javascript/packages/formatter/test/document-formatting.test.ts
+++ b/javascript/packages/formatter/test/document-formatting.test.ts
@@ -692,7 +692,8 @@ describe("Document-level formatting", () => {
                 </h1>
 
                 <h2 class="text-inherit opacity-60 text-sm line-clamp-1">
-                  <%= event.static_metadata.location %> • <%= event.formatted_dates %>
+                  <%= event.static_metadata.location %> •
+                  <%= event.formatted_dates %>
                 </h2>
 
                 <h2 class="text-inherit font-medium text-sm line-clamp-3 hidden lg:block">
diff --git a/javascript/packages/formatter/test/erb-formatter/erb-formatter-additional.test.ts b/javascript/packages/formatter/test/erb-formatter/erb-formatter-additional.test.ts
index 5a5f212bb..d9f14add6 100644
--- a/javascript/packages/formatter/test/erb-formatter/erb-formatter-additional.test.ts
+++ b/javascript/packages/formatter/test/erb-formatter/erb-formatter-additional.test.ts
@@ -44,10 +44,10 @@ describe("ERB Formatter Additional Tests", () => {
           Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
           tempor incididunt ut labore et dolore magna aliqua. 🍰🍰🍰🍰🍰🍰🍰🍰🍰🍰Ut
           enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut
-          aliquip ex ea commodo <span>co<strong>nse</strong>quat.</span> Duis aute irure
-          dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla
-          pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui
-          officia deserunt mollit anim id est laborum.
+          aliquip ex ea commodo <span>co<strong>nse</strong>quat.</span> Duis aute
+          irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat
+          nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa
+          qui officia deserunt mollit anim id est laborum.
         </p>
       `)
     })
diff --git a/javascript/packages/formatter/test/erb-formatter/erb-formatter-compat.test.ts b/javascript/packages/formatter/test/erb-formatter/erb-formatter-compat.test.ts
index 76dbaeeb8..8bb33b5dc 100644
--- a/javascript/packages/formatter/test/erb-formatter/erb-formatter-compat.test.ts
+++ b/javascript/packages/formatter/test/erb-formatter/erb-formatter-compat.test.ts
@@ -221,10 +221,10 @@ describe("ERB Formatter Compatibility Tests", () => {
           Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
           tempor incididunt ut labore et dolore magna aliqua. 🍰🍰🍰🍰🍰🍰🍰🍰🍰🍰Ut
           enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut
-          aliquip ex ea commodo <span>co<strong>nse</strong>quat.</span> Duis aute irure
-          dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla
-          pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui
-          officia deserunt mollit anim id est laborum.
+          aliquip ex ea commodo <span>co<strong>nse</strong>quat.</span> Duis aute
+          irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat
+          nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa
+          qui officia deserunt mollit anim id est laborum.
         </p>
       `)
     })
diff --git a/javascript/packages/formatter/test/erb/erb.test.ts b/javascript/packages/formatter/test/erb/erb.test.ts
index 3646286be..6f5e54554 100644
--- a/javascript/packages/formatter/test/erb/erb.test.ts
+++ b/javascript/packages/formatter/test/erb/erb.test.ts
@@ -346,9 +346,9 @@ describe("@herb-tools/formatter", () => {
       <p>
         Should not be duplicated.
         <br />
-        Text with a inline element
-        <a href="mailto:something@something.com">something@something.com</a> and some
-        more text after
+        Text with a inline
+        element<a href="mailto:something@something.com">something@something.com</a>
+        and some more text after
       </p>
     `)
 
@@ -665,7 +665,7 @@ describe("@herb-tools/formatter", () => {
                           >
                             <%= hosted_image_tag('mailer/footer-logo.png', class: 'h-[48px] mb-1') %>
                             <p class="text-muted-foreground text-sm leading-5">
-                              &copy; <%= Time.current.year %> - Company Inc, All
+                              &copy;<%= Time.current.year %> - Company Inc, All
                               rights reserved.
                               <br />
                               Main Street, San Francisco, CAs, USA 12345
@@ -1393,7 +1393,7 @@ describe("@herb-tools/formatter", () => {
       <div>
         <div>
           <div>
-            <p><%= formatted %> text that needs <%= needs %> <%= to_be_formatted %> without being reset to the <b><i>start of the line</i></b>. Text <%= also_with %><%= ERB_tags_next_to_each_other %> and after.</p>
+            <p><%= formatted %> text that needs <%= needs %> <%= to_be_formatted %> without being reset to the <b><i>start of the line</i></b>. Text<%= also_with %><%= ERB_tags_next_to_each_other %>and after.</p>
           </div>
         </div>
       </div>
@@ -1405,8 +1405,8 @@ describe("@herb-tools/formatter", () => {
           <div>
             <p>
               <%= formatted %> text that needs <%= needs %> <%= to_be_formatted %>
-              without being reset to the <b><i>start of the line</i></b>. Text
-              <%= also_with %><%= ERB_tags_next_to_each_other %> and after.
+              without being reset to the <b><i>start of the line</i></b>.
+              Text<%= also_with %><%= ERB_tags_next_to_each_other %>and after.
             </p>
           </div>
         </div>
@@ -1416,4 +1416,190 @@ describe("@herb-tools/formatter", () => {
     const result = formatter.format(input)
     expect(result).toBe(expected)
   })
+
+  test("ERB output with adjecent text within HTML element", () => {
+    const input = dedent`
+      <div><%= icon("icon") %>some text some text some text some text some text</div>
+    `
+
+    const expected = dedent`
+      <div><%= icon("icon") %>some text some text some text some text some text</div>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output after adjecent text within HTML element", () => {
+    const input = dedent`
+      <div>some text some text some text some text some text<%= icon("icon") %></div>
+    `
+
+    const expected = dedent`
+      <div>some text some text some text some text some text<%= icon("icon") %></div>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output with adjecent text within HTML element causing line-break", () => {
+    const input = dedent`
+      <div><%= icon("icon") %>some text some text some text some text some text some text some text</div>
+    `
+
+    const expected = dedent`
+      <div>
+        <%= icon("icon") %>some text some text some text some text some text some
+        text some text
+      </div>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output after adjecent text within HTML element causing line-break", () => {
+    const input = dedent`
+      <div>some text some text some text some text some text some text<%= icon("icon") %></div>
+    `
+
+    const expected = dedent`
+      <div>
+        some text some text some text some text some text some
+        text<%= icon("icon") %>
+      </div>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output before and after adjecent text within HTML element causing line-break", () => {
+    const input = dedent`
+      <div>some text some text some text some text some text some text some<%= icon("icon") %>text some text</div>
+    `
+
+    const expected = dedent`
+      <div>
+        some text some text some text some text some text some text
+        some<%= icon("icon") %>text some text
+      </div>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output with adjecent text within ERB block", () => {
+    const input = dedent`
+      <%= link_to "/" do %><%= icon("icon") %>some text some text<% end %>
+    `
+
+    const expected = dedent`
+      <%= link_to "/" do %>
+        <%= icon("icon") %>some text some text
+      <% end %>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output after adjecent text within ERB block", () => {
+    const input = dedent`
+      <%= link_to "/" do %>some text some text<%= icon("icon") %><% end %>
+    `
+
+    const expected = dedent`
+      <%= link_to "/" do %>
+        some text some text<%= icon("icon") %>
+      <% end %>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output before and after adjecent text within ERB block", () => {
+    const input = dedent`
+      <%= link_to "/" do %>some text<%= icon("icon") %>some text<% end %>
+    `
+
+    const expected = dedent`
+      <%= link_to "/" do %>
+        some text<%= icon("icon") %>some text
+      <% end %>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output with adjecent text within ERB block causing line-break", () => {
+    const input = dedent`
+      <%= link_to "/" do %><%= icon("icon") %>some text some text some text some text some text some text some text<% end %>
+    `
+
+    const expected = dedent`
+      <%= link_to "/" do %>
+        <%= icon("icon") %>some text some text some text some text some text some
+        text some text
+      <% end %>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output after adjecent text within ERB block causing line-break", () => {
+    const input = dedent`
+      <%= link_to "/" do %>some text some text some text some text some text some text some text<%= icon("icon") %><% end %>
+    `
+
+    const expected = dedent`
+      <%= link_to "/" do %>
+        some text some text some text some text some text some text some
+        text<%= icon("icon") %>
+      <% end %>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output before and after adjecent text within ERB block causing line-break", () => {
+    const input = dedent`
+      <%= link_to "/" do %>some text some text some text some text some text some text some<%= icon("icon") %>text some text<% end %>
+    `
+
+    const expected = dedent`
+      <%= link_to "/" do %>
+        some text some text some text some text some text some text
+        some<%= icon("icon") %>text some text
+      <% end %>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("keeps hyphen-attached inline element together during line wrapping", () => {
+    const input = dedent`
+      <div>
+        This is a div where we still can assume that whitespace can be inserted-<b>infront or after of this bold you can not insert whitespace</b>. Next senctence.
+      </div>
+    `
+
+    const expected = dedent`
+      <div>
+        This is a div where we still can assume that whitespace can be
+        inserted-<b>infront or after of this bold you can not insert whitespace</b>.
+        Next senctence.
+      </div>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
 })

From 89f027e243e6144d70638cf53815813efdc6483e Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Fri, 10 Oct 2025 21:25:11 +0200
Subject: [PATCH 39/97] Linter: Don't lint files with parser errors (#614)

This pull request updates the linter to not lint files with syntax
errors. This is to avoid false positives that might occur when trying to
lint a file that isn't properly parsed, which could also lead to a
"parser error" and "lint offense" diagnostic in the LSP.

Additionally, it updates the Linter test helpers to make sure all test
cases have valid syntax too. Since we have the `no-parser-errors` rule
we will still catch syntax errors, invalid syntax, and parser errors
with that rule in real applications.
---
 javascript/packages/linter/src/linter.ts      |  7 ++
 .../test/__snapshots__/cli.test.ts.snap       | 55 +++++++-------
 javascript/packages/linter/test/cli.test.ts   |  7 ++
 .../test/fixtures/few-rule-offenses.html.erb  |  2 +-
 .../test/fixtures/parser-errors.html.erb      |  3 +
 .../linter/test/helpers/linter-test-helper.ts | 71 +++++++++++++++++--
 .../test/rules/erb-no-empty-tags.test.ts      |  4 +-
 .../linter/test/rules/erb-right-trim.test.ts  |  1 +
 ...ml-attribute-values-require-quotes.test.ts | 18 ++---
 .../html-boolean-attributes-no-value.test.ts  |  8 +--
 .../test/rules/html-iframe-has-title.test.ts  |  2 +-
 .../html-no-duplicate-attributes.test.ts      |  8 +--
 ...-no-underscores-in-attribute-names.test.ts | 12 +---
 13 files changed, 137 insertions(+), 61 deletions(-)
 create mode 100644 javascript/packages/linter/test/fixtures/parser-errors.html.erb

diff --git a/javascript/packages/linter/src/linter.ts b/javascript/packages/linter/src/linter.ts
index 1b12112a4..4e0452b3a 100644
--- a/javascript/packages/linter/src/linter.ts
+++ b/javascript/packages/linter/src/linter.ts
@@ -55,6 +55,7 @@ export class Linter {
 
     const parseResult = this.herb.parse(source, { track_whitespace: true })
     const lexResult = this.herb.lex(source)
+    const hasParserErrors = parseResult.recursiveErrors().length > 0
 
     for (const RuleClass of this.rules) {
       const rule = new RuleClass()
@@ -84,6 +85,12 @@ export class Linter {
           ruleOffenses = []
         }
       } else {
+        if (hasParserErrors && rule.name !== "parser-no-errors") {
+          ruleOffenses = []
+
+          continue
+        }
+
         if (rule.isEnabled) {
           isEnabled = rule.isEnabled(parseResult, context)
         }
diff --git a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
index 2fe1a74e3..3994c54ff 100644
--- a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
+++ b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
@@ -73,6 +73,26 @@ test/fixtures/no-trailing-newline.html.erb:1:29
   Offenses     1 error | 0 warnings (1 offense across 1 file)"
 `;
 
+exports[`CLI Output Formatting > diplays only parsers errors if one is present 1`] = `
+"[error] Unexpected Token. Expected: \`TOKEN_IDENTIFIER, TOKEN_AT, TOKEN_ERB_START,TOKEN_WHITESPACE, or TOKEN_NEWLINE\`, found: \`TOKEN_CHARACTER\`. (\`UNEXPECTED_ERROR\`) (parser-no-errors)
+
+test/fixtures/parser-errors.html.erb:2:16
+
+      1 │ <div id=test class=foo>
+  →   2 │   <img src=image.jpg>
+        │                 ~
+      3 │ </div>
+      4 │
+
+ Rule offenses:
+  parser-no-errors (1 offense in 1 file)
+
+
+ Summary:
+  Checked      1 file
+  Offenses     1 error | 0 warnings (1 offense across 1 file)"
+`;
+
 exports[`CLI Output Formatting > displays most violated rules with multiple offenses 1`] = `
 "[error] Add an \`href\` attribute to \`<a>\` to ensure it is focusable and accessible. (html-anchor-require-href)
 
@@ -290,11 +310,11 @@ test/fixtures/few-rule-offenses.html.erb:2:8
       1 │ <!-- Just a few different rule offenses to test "Rule offenses:" vs "Most frequent rule offenses:" -->
   →   2 │ <div id=test class=foo>
         │         ~~~~
-      3 │   <img src=image.jpg>
+      3 │   <img src=image>
       4 │ </div>
 
 
-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/7] ⎯⎯⎯⎯
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/6] ⎯⎯⎯⎯
 
 [error] Attribute value should be quoted: \`class="foo"\`. Always wrap attribute values in quotes. (html-attribute-values-require-quotes)
 
@@ -303,11 +323,11 @@ test/fixtures/few-rule-offenses.html.erb:2:19
       1 │ <!-- Just a few different rule offenses to test "Rule offenses:" vs "Most frequent rule offenses:" -->
   →   2 │ <div id=test class=foo>
         │                    ~~~
-      3 │   <img src=image.jpg>
+      3 │   <img src=image>
       4 │ </div>
 
 
-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [2/7] ⎯⎯⎯⎯
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [2/6] ⎯⎯⎯⎯
 
 [error] Attribute value should be quoted: \`src="image"\`. Always wrap attribute values in quotes. (html-attribute-values-require-quotes)
 
@@ -315,13 +335,13 @@ test/fixtures/few-rule-offenses.html.erb:3:11
 
       1 │ <!-- Just a few different rule offenses to test "Rule offenses:" vs "Most frequent rule offenses:" -->
       2 │ <div id=test class=foo>
-  →   3 │   <img src=image.jpg>
+  →   3 │   <img src=image>
         │            ~~~~~
       4 │ </div>
       5 │
 
 
-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [3/7] ⎯⎯⎯⎯
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [3/6] ⎯⎯⎯⎯
 
 [error] Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. (html-img-require-alt)
 
@@ -329,13 +349,13 @@ test/fixtures/few-rule-offenses.html.erb:3:3
 
       1 │ <!-- Just a few different rule offenses to test "Rule offenses:" vs "Most frequent rule offenses:" -->
       2 │ <div id=test class=foo>
-  →   3 │   <img src=image.jpg>
+  →   3 │   <img src=image>
         │    ~~~
       4 │ </div>
       5 │
 
 
-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [4/7] ⎯⎯⎯⎯
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [4/6] ⎯⎯⎯⎯
 
 [error] Duplicate ID \`duplicate\` found. IDs must be unique within a document. (html-no-duplicate-ids)
 
@@ -348,7 +368,7 @@ test/fixtures/few-rule-offenses.html.erb:9:5
      10 │
 
 
-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [5/7] ⎯⎯⎯⎯
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [5/6] ⎯⎯⎯⎯
 
 [error] Heading element \`<h1>\` must not be empty. Provide accessible text content for screen readers and SEO. (html-no-empty-headings)
 
@@ -361,31 +381,16 @@ test/fixtures/few-rule-offenses.html.erb:6:0
       7 │ 
       8 │ <div id="duplicate"></div>
 
-
-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [6/7] ⎯⎯⎯⎯
-
-[error] Unexpected Token. Expected: \`TOKEN_IDENTIFIER, TOKEN_AT, TOKEN_ERB_START,TOKEN_WHITESPACE, or TOKEN_NEWLINE\`, found: \`TOKEN_CHARACTER\`. (\`UNEXPECTED_ERROR\`) (parser-no-errors)
-
-test/fixtures/few-rule-offenses.html.erb:3:16
-
-      1 │ <!-- Just a few different rule offenses to test "Rule offenses:" vs "Most frequent rule offenses:" -->
-      2 │ <div id=test class=foo>
-  →   3 │   <img src=image.jpg>
-        │                 ~
-      4 │ </div>
-      5 │
-
  Rule offenses:
   html-attribute-values-require-quotes (3 offenses in 1 file)
   html-img-require-alt (1 offense in 1 file)
   html-no-duplicate-ids (1 offense in 1 file)
   html-no-empty-headings (1 offense in 1 file)
-  parser-no-errors (1 offense in 1 file)
 
 
  Summary:
   Checked      1 file
-  Offenses     7 errors | 0 warnings (7 offenses across 1 file)"
+  Offenses     6 errors | 0 warnings (6 offenses across 1 file)"
 `;
 
 exports[`CLI Output Formatting > formats GitHub Actions output correctly for bad file 1`] = `
diff --git a/javascript/packages/linter/test/cli.test.ts b/javascript/packages/linter/test/cli.test.ts
index ca39c0489..0d3d1584f 100644
--- a/javascript/packages/linter/test/cli.test.ts
+++ b/javascript/packages/linter/test/cli.test.ts
@@ -85,6 +85,13 @@ describe("CLI Output Formatting", () => {
     expect(exitCode).toBe(1)
   })
 
+  test("diplays only parsers errors if one is present", () => {
+    const { output, exitCode } = runLinter("parser-errors.html.erb", "--no-wrap-lines")
+
+    expect(output).toMatchSnapshot()
+    expect(exitCode).toBe(1)
+  })
+
   test("enables line wrapping by default", () => {
     const { output } = runLinter("long-line.html.erb")
 
diff --git a/javascript/packages/linter/test/fixtures/few-rule-offenses.html.erb b/javascript/packages/linter/test/fixtures/few-rule-offenses.html.erb
index 0f34a9d61..154f1ff6a 100644
--- a/javascript/packages/linter/test/fixtures/few-rule-offenses.html.erb
+++ b/javascript/packages/linter/test/fixtures/few-rule-offenses.html.erb
@@ -1,6 +1,6 @@
 <!-- Just a few different rule offenses to test "Rule offenses:" vs "Most frequent rule offenses:" -->
 <div id=test class=foo>
-  <img src=image.jpg>
+  <img src=image>
 </div>
 
 <h1></h1>
diff --git a/javascript/packages/linter/test/fixtures/parser-errors.html.erb b/javascript/packages/linter/test/fixtures/parser-errors.html.erb
new file mode 100644
index 000000000..ca9fc1295
--- /dev/null
+++ b/javascript/packages/linter/test/fixtures/parser-errors.html.erb
@@ -0,0 +1,3 @@
+<div id=test class=foo>
+  <img src=image.jpg>
+</div>
diff --git a/javascript/packages/linter/test/helpers/linter-test-helper.ts b/javascript/packages/linter/test/helpers/linter-test-helper.ts
index b4bf26ce9..e1f47e95b 100644
--- a/javascript/packages/linter/test/helpers/linter-test-helper.ts
+++ b/javascript/packages/linter/test/helpers/linter-test-helper.ts
@@ -17,11 +17,16 @@ interface ExpectedOffense {
   location?: ExpectedLocation
 }
 
+interface TestOptions {
+  context?: any
+  allowInvalidSyntax?: boolean
+}
+
 interface LinterTestHelpers {
-  expectNoOffenses: (html: string, context?: any) => void
+  expectNoOffenses: (html: string, options?: any | TestOptions) => void
   expectWarning: (message: string, location?: LocationInput) => void
   expectError: (message: string, location?: LocationInput) => void
-  assertOffenses: (html: string, context?: any) => void
+  assertOffenses: (html: string, options?: any | TestOptions) => void
 }
 
 /**
@@ -51,6 +56,8 @@ export function createLinterTest(ruleClass: RuleClass): LinterTestHelpers {
   const expectedWarnings: ExpectedOffense[] = []
   const expectedErrors: ExpectedOffense[] = []
   let hasAsserted = false
+  const ruleInstance = new ruleClass()
+  const isParserNoErrorsRule = ruleInstance.name === "parser-no-errors"
 
   beforeAll(async () => {
     await Herb.load()
@@ -59,6 +66,7 @@ export function createLinterTest(ruleClass: RuleClass): LinterTestHelpers {
   afterEach(() => {
     if (!hasAsserted && (expectedWarnings.length > 0 || expectedErrors.length > 0)) {
       const pendingCount = expectedWarnings.length + expectedErrors.length
+
       throw new Error(
         `Test has ${pendingCount} pending expectation(s) that were never asserted. ` +
         `Did you forget to call assertOffenses() or expectNoOffenses()?`
@@ -70,7 +78,7 @@ export function createLinterTest(ruleClass: RuleClass): LinterTestHelpers {
     hasAsserted = false
   })
 
-  const expectNoOffenses = (html: string, context?: any) => {
+  const expectNoOffenses = (html: string, options?: any | TestOptions) => {
     if (expectedWarnings.length > 0 || expectedErrors.length > 0) {
       throw new Error(
         "Cannot call expectNoOffenses() after registering expectations with expectWarning() or expectError()"
@@ -78,6 +86,33 @@ export function createLinterTest(ruleClass: RuleClass): LinterTestHelpers {
     }
 
     hasAsserted = true
+
+    const context = options?.context ?? options
+    const allowInvalidSyntax = options?.allowInvalidSyntax ?? false
+
+    if (!isParserNoErrorsRule) {
+      const parseResult = Herb.parse(html, { track_whitespace: true })
+      const parserErrors = parseResult.recursiveErrors()
+
+      if (allowInvalidSyntax && parserErrors.length === 0) {
+        throw new Error(
+          `Test has 'allowInvalidSyntax: true' but the HTML is actually valid.\n` +
+          `Remove the 'allowInvalidSyntax' option since the HTML parses without errors.\n` +
+          `Source:\n${html}`
+        )
+      }
+
+      if (!allowInvalidSyntax && parserErrors.length > 0) {
+        const formattedErrors = parserErrors.map(error => `  - ${error.message} (${error.type}) at ${error.location.start.line}:${error.location.start.column}`).join('\n')
+
+        throw new Error(
+          `Test HTML has parser errors. Fix the HTML before testing the linter rule.\n` +
+          `Source:\n${html}\n\n` +
+          `Parser errors:\n${formattedErrors}`
+        )
+      }
+    }
+
     const linter = new Linter(Herb, [ruleClass])
     const lintResult = linter.lint(html, context)
 
@@ -104,7 +139,7 @@ export function createLinterTest(ruleClass: RuleClass): LinterTestHelpers {
     expectedErrors.push({ message, location: normalizeLocation(location) })
   }
 
-  const assertOffenses = (html: string, context?: any) => {
+  const assertOffenses = (html: string, options?: any | TestOptions) => {
     if (expectedWarnings.length === 0 && expectedErrors.length === 0) {
       throw new Error(
         "Cannot call assertOffenses() with no expectations. Use expectNoOffenses() instead."
@@ -112,10 +147,36 @@ export function createLinterTest(ruleClass: RuleClass): LinterTestHelpers {
     }
 
     hasAsserted = true
+
+    const context = options?.context ?? options
+    const allowInvalidSyntax = options?.allowInvalidSyntax ?? false
+
+    if (!isParserNoErrorsRule) {
+      const parseResult = Herb.parse(html, { track_whitespace: true })
+      const parserErrors = parseResult.recursiveErrors()
+
+      if (allowInvalidSyntax && parserErrors.length === 0) {
+        throw new Error(
+          `Test has 'allowInvalidSyntax: true' but the HTML is actually valid.\n` +
+          `Remove the 'allowInvalidSyntax' option since the HTML parses without errors.\n` +
+          `Source:\n${html}`
+        )
+      }
+
+      if (!allowInvalidSyntax && parserErrors.length > 0) {
+        const formattedErrors = parserErrors.map(error => `  - ${error.message} (${error.type}) at ${error.location.start.line}:${error.location.start.column}`).join('\n')
+
+        throw new Error(
+          `Test HTML has parser errors. Fix the HTML before testing the linter rule.\n` +
+          `Source:\n${html}\n\n` +
+          `Parser errors:\n${formattedErrors}`
+        )
+      }
+    }
+
     const linter = new Linter(Herb, [ruleClass])
     const lintResult = linter.lint(html, context)
 
-    const ruleInstance = new ruleClass()
     const ruleName = ruleInstance.name
 
     if (lintResult.errors !== expectedErrors.length) {
diff --git a/javascript/packages/linter/test/rules/erb-no-empty-tags.test.ts b/javascript/packages/linter/test/rules/erb-no-empty-tags.test.ts
index 9f901aaa0..b96873209 100644
--- a/javascript/packages/linter/test/rules/erb-no-empty-tags.test.ts
+++ b/javascript/packages/linter/test/rules/erb-no-empty-tags.test.ts
@@ -27,13 +27,13 @@ describe("ERBNoEmptyTagsRule", () => {
   test("should not report errors for incomplete erb tags", () => {
     expectNoOffenses(dedent`
       <%
-    `)
+    `, { allowInvalidSyntax: true })
   })
 
   test("should not report errors for incomplete erb output tags", () => {
     expectNoOffenses(dedent`
       <%=
-    `)
+    `, { allowInvalidSyntax: true })
   })
 
   test("should report errors for completely empty ERB tags", () => {
diff --git a/javascript/packages/linter/test/rules/erb-right-trim.test.ts b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
index 958d6ff51..8de06caeb 100644
--- a/javascript/packages/linter/test/rules/erb-right-trim.test.ts
+++ b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
@@ -48,6 +48,7 @@ describe("ERBRightTrimRule", () => {
     assertOffenses(dedent`
       <h1>
         <%= title =%>
+      </h1>
     `)
   })
 
diff --git a/javascript/packages/linter/test/rules/html-attribute-values-require-quotes.test.ts b/javascript/packages/linter/test/rules/html-attribute-values-require-quotes.test.ts
index 7d7a781b9..3260fbf50 100644
--- a/javascript/packages/linter/test/rules/html-attribute-values-require-quotes.test.ts
+++ b/javascript/packages/linter/test/rules/html-attribute-values-require-quotes.test.ts
@@ -6,45 +6,45 @@ const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLA
 
 describe("html-attribute-values-require-quotes", () => {
   test("passes for quoted attribute values", () => {
-    expectNoOffenses(`<div id="hello" class="container">`)
+    expectNoOffenses(`<div id="hello" class="container"></div>`)
   })
 
   test("fails for unquoted attribute values", () => {
     expectError('Attribute value should be quoted: `id="hello"`. Always wrap attribute values in quotes.')
     expectError('Attribute value should be quoted: `class="container"`. Always wrap attribute values in quotes.')
-    assertOffenses(`<div id=hello class=container>`)
+    assertOffenses(`<div id=hello class=container></div>`)
   })
 
   test("passes for single-quoted values", () => {
-    expectNoOffenses(`<div id='hello' class='container'>`)
+    expectNoOffenses(`<div id='hello' class='container'></div>`)
   })
 
   test("passes for boolean attributes without values", () => {
-    expectNoOffenses(`<input type="text" disabled>`)
+    expectNoOffenses(`<input type="text" disabled />`)
   })
 
   test("handles mixed quoted and unquoted", () => {
     expectError('Attribute value should be quoted: `name="username"`. Always wrap attribute values in quotes.')
-    assertOffenses(`<input type="text" name=username value="test">`)
+    assertOffenses(`<input type="text" name=username value="test" />`)
   })
 
   test("handles ERB in quoted attributes", () => {
-    expectNoOffenses(`<div class="<%= classes %>" data-id="<%= item.id %>">`)
+    expectNoOffenses(`<div class="<%= classes %>" data-id="<%= item.id %>"></div>`)
   })
 
   test("handles ERB in unquoted attributes", () => {
     expectError('Attribute value should be quoted: `class="<%= classes %>"`. Always wrap attribute values in quotes.')
-    assertOffenses(`<div class=<%= classes %>`)
+    assertOffenses(`<div class=<%= classes %>></div>`)
   })
 
   test("handles self-closing tags", () => {
     expectError('Attribute value should be quoted: `src="photo"`. Always wrap attribute values in quotes.')
-    assertOffenses(`<img src=photo.jpg alt="Photo">`)
+    assertOffenses(`<img src=photo alt="Photo" />`)
   })
 
   test("handles complex attribute values", () => {
     expectError('Attribute value should be quoted: `title="User"`. Always wrap attribute values in quotes.')
-    assertOffenses(`<a href="/profile" title=User\\ Profile>`)
+    assertOffenses(`<a href="/profile" title=User></a>`)
   })
 
   test("ignores closing tags", () => {
diff --git a/javascript/packages/linter/test/rules/html-boolean-attributes-no-value.test.ts b/javascript/packages/linter/test/rules/html-boolean-attributes-no-value.test.ts
index bd771671a..4067856a3 100644
--- a/javascript/packages/linter/test/rules/html-boolean-attributes-no-value.test.ts
+++ b/javascript/packages/linter/test/rules/html-boolean-attributes-no-value.test.ts
@@ -48,26 +48,26 @@ describe("html-boolean-attributes-no-value", () => {
   })
 
   test("passes for video controls", () => {
-    expectNoOffenses('<video controls>')
+    expectNoOffenses('<video controls></video>')
   })
 
   test("fails for video controls with value", () => {
     expectError('Boolean attribute `controls` should not have a value. Use `controls` instead of `controls="controls"`.')
     expectError('Boolean attribute `autoplay` should not have a value. Use `autoplay` instead of `autoplay="autoplay"`.')
 
-    assertOffenses('<video controls="controls" autoplay="autoplay">')
+    assertOffenses('<video controls="controls" autoplay="autoplay"></video>')
   })
 
   test("fails for boolean attribute with different value", () => {
     expectError('Boolean attribute `controls` should not have a value. Use `controls` instead of `controls="something-else"`.')
 
-    assertOffenses('<video controls="something-else">')
+    assertOffenses('<video controls="something-else"></video>')
   })
 
   test("handles mixed boolean and regular attributes", () => {
     expectError('Boolean attribute `novalidate` should not have a value. Use `novalidate` instead of `novalidate="novalidate"`.')
 
-    assertOffenses('<form novalidate="novalidate" action="/submit" method="post">')
+    assertOffenses('<form novalidate="novalidate" action="/submit" method="post"></form>')
   })
 
   test("fails for boolean attributes with ERB output value", () => {
diff --git a/javascript/packages/linter/test/rules/html-iframe-has-title.test.ts b/javascript/packages/linter/test/rules/html-iframe-has-title.test.ts
index 0b2bfa3cc..38e72e4eb 100644
--- a/javascript/packages/linter/test/rules/html-iframe-has-title.test.ts
+++ b/javascript/packages/linter/test/rules/html-iframe-has-title.test.ts
@@ -38,7 +38,7 @@ describe("html-iframe-has-title", () => {
   })
 
   test("ignores frame elements (different tag)", () => {
-    expectNoOffenses(`<frame src="https://example.com">`)
+    expectNoOffenses(`<frame src="https://example.com"></frame>`)
   })
 
   test("handles mixed case iframe tag", () => {
diff --git a/javascript/packages/linter/test/rules/html-no-duplicate-attributes.test.ts b/javascript/packages/linter/test/rules/html-no-duplicate-attributes.test.ts
index 2f9946bd6..b0b727383 100644
--- a/javascript/packages/linter/test/rules/html-no-duplicate-attributes.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-duplicate-attributes.test.ts
@@ -17,16 +17,16 @@ describe("html-no-duplicate-attributes", () => {
   test("fails for multiple duplicate attributes", () => {
     expectError('Duplicate attribute `type` found on tag. Remove the duplicate occurrence.')
     expectError('Duplicate attribute `class` found on tag. Remove the duplicate occurrence.')
-    assertOffenses(`<button type="submit" type="button" class="btn" class="primary">`)
+    assertOffenses(`<button type="submit" type="button" class="btn" class="primary"></button>`)
   })
 
   test("handles case-insensitive duplicates", () => {
     expectError('Duplicate attribute `class` found on tag. Remove the duplicate occurrence.')
-    assertOffenses(`<div Class="container" class="active">`)
+    assertOffenses(`<div Class="container" class="active"></div>`)
   })
 
   test("passes for different attributes", () => {
-    expectNoOffenses(`<div class="container" id="main" data-value="test">`)
+    expectNoOffenses(`<div class="container" id="main" data-value="test"></div>`)
   })
 
   test("handles self-closing tags", () => {
@@ -35,7 +35,7 @@ describe("html-no-duplicate-attributes", () => {
   })
 
   test("handles ERB templates with attributes", () => {
-    expectNoOffenses(`<div class="<%= classes %>" data-id="<%= item.id %>">`)
+    expectNoOffenses(`<div class="<%= classes %>" data-id="<%= item.id %>"></div>`)
   })
 
   test("ignores closing tags", () => {
diff --git a/javascript/packages/linter/test/rules/html-no-underscores-in-attribute-names.test.ts b/javascript/packages/linter/test/rules/html-no-underscores-in-attribute-names.test.ts
index 09283c57e..02a536615 100644
--- a/javascript/packages/linter/test/rules/html-no-underscores-in-attribute-names.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-underscores-in-attribute-names.test.ts
@@ -46,18 +46,10 @@ describe("html-no-underscores-in-attribute-names", () => {
   })
 
   test("handles malformed attributes without crashing (issue #601)", () => {
-    expectWarning("Attribute `foo_bar` should not contain underscores. Use hyphens (-) instead.")
-
-    assertOffenses(dedent`
-      <input foo_bar=I18n.t('value')>
-    `)
+    expectNoOffenses(`<input foo_bar=I18n.t('value')>`, { allowInvalidSyntax: true })
   })
 
   test("handles malformed attributes without crashing - exact snippet from issue #601", () => {
-    expectWarning("Attribute `t('foo_bar')` should not contain underscores. Use hyphens (-) instead.")
-
-    assertOffenses(dedent`
-      <input title=I18n.t('foo_bar')>
-    `)
+    expectNoOffenses(`<input title=I18n.t('foo_bar')>`, { allowInvalidSyntax: true })
   })
 })

From 4fc81bb2e707c6e2611f31c465a0db1f1eb19e02 Mon Sep 17 00:00:00 2001
From: Domingo Edwards <dedwards@buk.cl>
Date: Fri, 10 Oct 2025 18:04:39 -0300
Subject: [PATCH 40/97] Linter: Implement `html-no-space-in-html-tag`  linter
 rule (#559)

Implements the `SpaceInHtmlTag` rule from
[ERBLint](https://github.com/Shopify/erb_lint).

This rules avoid having whitespace in the html.

This is a Proof of concept of the implementation. I considered

1. If the parser already throws a parser error, the linter from erb-lint
makes no sense (ej: `</ div>`)
2. It follows the result that the formatter would give. For example, for
multiline, the whitespace must have 2 spaces.

Resolves #549

---------

Co-authored-by: Marco Roth <marco.roth@intergga.ch>
---
 .../packages/linter/docs/rules/README.md      |   3 +-
 .../linter/docs/rules/html-no-space-in-tag.md |  66 ++++++
 .../packages/linter/src/default-rules.ts      |  20 +-
 .../linter/src/rules/html-no-space-in-tag.ts  | 148 +++++++++++++
 javascript/packages/linter/src/rules/index.ts |   1 +
 .../test/__snapshots__/cli.test.ts.snap       |   6 +-
 .../test/rules/html-no-space-in-tag.test.ts   | 209 ++++++++++++++++++
 javascript/packages/vscode/package.json       |   1 +
 8 files changed, 444 insertions(+), 10 deletions(-)
 create mode 100644 javascript/packages/linter/docs/rules/html-no-space-in-tag.md
 create mode 100644 javascript/packages/linter/src/rules/html-no-space-in-tag.ts
 create mode 100644 javascript/packages/linter/test/rules/html-no-space-in-tag.test.ts

diff --git a/javascript/packages/linter/docs/rules/README.md b/javascript/packages/linter/docs/rules/README.md
index 7423ac157..cdbec364c 100644
--- a/javascript/packages/linter/docs/rules/README.md
+++ b/javascript/packages/linter/docs/rules/README.md
@@ -35,9 +35,10 @@ This page contains documentation for all Herb Linter rules.
 - [`html-no-nested-links`](./html-no-nested-links.md) - Prevents nested anchor tags
 - [`html-no-positive-tab-index`](./html-no-positive-tab-index.md) - Avoid positive `tabindex` values
 - [`html-no-self-closing`](./html-no-self-closing.md) - Disallow self closing tags
+- [`html-no-space-in-tag`](./html-no-space-in-tag.md) - Disallow spaces in HTML tags
 - [`html-no-title-attribute`](./html-no-title-attribute.md) - Avoid using the `title` attribute
-- [`html-tag-name-lowercase`](./html-tag-name-lowercase.md) - Enforces lowercase tag names in HTML
 - [`html-no-underscores-in-attribute-names`](./html-no-underscores-in-attribute-names.md) - Disallow underscores in HTML attribute names
+- [`html-tag-name-lowercase`](./html-tag-name-lowercase.md) - Enforces lowercase tag names in HTML
 - [`parser-no-errors`](./parser-no-errors.md) - Disallow parser errors in HTML+ERB documents
 - [`svg-tag-name-capitalization`](./svg-tag-name-capitalization.md) - Enforces proper camelCase capitalization for SVG elements
 
diff --git a/javascript/packages/linter/docs/rules/html-no-space-in-tag.md b/javascript/packages/linter/docs/rules/html-no-space-in-tag.md
new file mode 100644
index 000000000..080f2e5fd
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/html-no-space-in-tag.md
@@ -0,0 +1,66 @@
+# Linter Rule: Enforce consistent spacing within HTML tags
+
+**Rule:** `html-no-space-in-tag`
+
+## Description
+
+Enforce consistent spacing within HTML opening and closing tags. This rule ensures:
+- Exactly one space between tag name and first attribute
+- Exactly one space between attributes
+- No extra spaces before the closing `>` in non-self-closing tags
+- Exactly one space before `/>` in self-closing tags
+- No whitespace in closing tags (e.g., `</div>`)
+- Consistent indentation in multiline tags
+
+## Rationale
+
+Consistent spacing within HTML tags improves code readability and maintainability. Extra or missing spaces can make templates harder to scan and can indicate formatting inconsistencies across a codebase. This rule enforces a canonical style that is both readable and machine-parseable.
+
+Self-closing tags (`<img />`, `<br />`) should have exactly one space before the `/>` to maintain visual consistency with HTML5 and JSX conventions.
+
+## Examples
+
+### ✅ Good
+
+```erb
+<div class="foo"></div>
+
+<img src="/logo.png" alt="Logo">
+
+<input class="foo" name="bar">
+
+<div class="foo" data-x="bar"></div>
+
+<div
+  class="foo"
+  data-x="bar"
+>
+  foo
+</div>
+```
+
+### 🚫 Bad
+
+```erb
+<div  class="foo"></div>
+
+<div class="foo" ></div>
+
+<img alt="Logo" src="/logo.png"/>
+
+<div class="foo"      data-x="bar"></div>
+
+<div
+   class="foo"
+    data-x="bar"
+>
+  foo
+</div>
+
+<div >
+</  div>
+```
+
+## References
+
+- [Inspiration: ERB Lint `SpaceInHtmlTag` rule](https://github.com/shopify/erb_lint)
diff --git a/javascript/packages/linter/src/default-rules.ts b/javascript/packages/linter/src/default-rules.ts
index fa87b2230..f26236dcd 100644
--- a/javascript/packages/linter/src/default-rules.ts
+++ b/javascript/packages/linter/src/default-rules.ts
@@ -8,6 +8,8 @@ import { ERBNoSilentTagInAttributeNameRule } from "./rules/erb-no-silent-tag-in-
 import { ERBPreferImageTagHelperRule } from "./rules/erb-prefer-image-tag-helper.js"
 import { ERBRequiresTrailingNewlineRule } from "./rules/erb-requires-trailing-newline.js"
 import { ERBRequireWhitespaceRule } from "./rules/erb-require-whitespace-inside-tags.js"
+import { ERBRightTrimRule } from "./rules/erb-right-trim.js"
+
 import { HTMLAnchorRequireHrefRule } from "./rules/html-anchor-require-href.js"
 import { HTMLAriaAttributeMustBeValid } from "./rules/html-aria-attribute-must-be-valid.js"
 import { HTMLAriaLabelIsWellFormattedRule } from "./rules/html-aria-label-is-well-formatted.js"
@@ -31,12 +33,14 @@ import { HTMLNoEmptyHeadingsRule } from "./rules/html-no-empty-headings.js"
 import { HTMLNoNestedLinksRule } from "./rules/html-no-nested-links.js"
 import { HTMLNoPositiveTabIndexRule } from "./rules/html-no-positive-tab-index.js"
 import { HTMLNoSelfClosingRule } from "./rules/html-no-self-closing.js"
+import { HTMLNoSpaceInTagRule } from "./rules/html-no-space-in-tag.js"
 // import { HTMLNoTitleAttributeRule } from "./rules/html-no-title-attribute.js"
+import { HTMLNoUnderscoresInAttributeNamesRule } from "./rules/html-no-underscores-in-attribute-names.js"
 import { HTMLTagNameLowercaseRule } from "./rules/html-tag-name-lowercase.js"
-import { ParserNoErrorsRule } from "./rules/parser-no-errors.js"
+
 import { SVGTagNameCapitalizationRule } from "./rules/svg-tag-name-capitalization.js"
-import { HTMLNoUnderscoresInAttributeNamesRule } from "./rules/html-no-underscores-in-attribute-names.js"
-import { ERBRightTrimRule } from "./rules/erb-right-trim.js"
+
+import { ParserNoErrorsRule } from "./rules/parser-no-errors.js"
 
 export const defaultRules: RuleClass[] = [
   ERBCommentSyntax,
@@ -47,6 +51,8 @@ export const defaultRules: RuleClass[] = [
   ERBPreferImageTagHelperRule,
   ERBRequiresTrailingNewlineRule,
   ERBRequireWhitespaceRule,
+  ERBRightTrimRule,
+
   HTMLAnchorRequireHrefRule,
   HTMLAriaAttributeMustBeValid,
   HTMLAriaLabelIsWellFormattedRule,
@@ -70,10 +76,12 @@ export const defaultRules: RuleClass[] = [
   HTMLNoNestedLinksRule,
   HTMLNoPositiveTabIndexRule,
   HTMLNoSelfClosingRule,
+  HTMLNoSpaceInTagRule,
   // HTMLNoTitleAttributeRule,
+  HTMLNoUnderscoresInAttributeNamesRule,
   HTMLTagNameLowercaseRule,
-  ParserNoErrorsRule,
+
   SVGTagNameCapitalizationRule,
-  HTMLNoUnderscoresInAttributeNamesRule,
-  ERBRightTrimRule,
+
+  ParserNoErrorsRule,
 ]
diff --git a/javascript/packages/linter/src/rules/html-no-space-in-tag.ts b/javascript/packages/linter/src/rules/html-no-space-in-tag.ts
new file mode 100644
index 000000000..53bacd8c6
--- /dev/null
+++ b/javascript/packages/linter/src/rules/html-no-space-in-tag.ts
@@ -0,0 +1,148 @@
+import { ParserRule } from "../types.js"
+import { BaseRuleVisitor } from "./rule-utils.js"
+
+import { filterWhitespaceNodes, isWhitespaceNode,  } from "@herb-tools/core"
+
+import type { LintOffense, LintContext } from "../types.js"
+import type { ParseResult, HTMLOpenTagNode, HTMLCloseTagNode, WhitespaceNode, Node, Token } from "@herb-tools/core"
+
+const MESSAGES = {
+  EXTRA_SPACE_NO_SPACE: "Extra space detected where there should be no space.",
+  EXTRA_SPACE_SINGLE_SPACE: "Extra space detected where there should be a single space.",
+  EXTRA_SPACE_SINGLE_BREAK: "Extra space detected where there should be a single space or a single line break.",
+  NO_SPACE_SINGLE_SPACE: "No space detected where there should be a single space.",
+} as const
+
+class HTMLNoSpaceInTagVisitor extends BaseRuleVisitor {
+  visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
+    if (node.isSingleLine) {
+      this.checkSingleLineTag(node)
+    } else {
+      this.checkMultilineTag(node)
+    }
+  }
+
+  visitHTMLCloseTagNode(node: HTMLCloseTagNode): void {
+    this.reportAllWhitespace(node.children, MESSAGES.EXTRA_SPACE_NO_SPACE)
+  }
+
+  private checkSingleLineTag(node: HTMLOpenTagNode): void {
+    const { children, tag_closing } = node
+    const isSelfClosing = tag_closing ? this.isSelfClosing(tag_closing) : false
+
+    this.checkWhitespaceInSingleLineTag(children, isSelfClosing)
+    this.checkMissingSpaceBeforeSelfClosing(node, children, isSelfClosing)
+  }
+
+  private checkWhitespaceInSingleLineTag(children: Node[], isSelfClosing: boolean): void {
+    const whitespaceNodes = filterWhitespaceNodes(children)
+
+    whitespaceNodes.forEach((whitespace) => {
+      const content = this.getWhitespaceContent(whitespace)
+      if (!content) return
+
+      const isLastChild = children[children.length - 1] === whitespace
+      if (isLastChild) {
+        this.checkTrailingWhitespace(whitespace, content, isSelfClosing)
+        return
+      }
+
+      if (content.length > 1) {
+        this.addOffense(MESSAGES.EXTRA_SPACE_SINGLE_SPACE, whitespace.location)
+      }
+    })
+  }
+
+  private checkTrailingWhitespace(whitespace: WhitespaceNode, content: string, isSelfClosing: boolean): void {
+    if (isSelfClosing && content === ' ') return
+
+    this.addOffense(MESSAGES.EXTRA_SPACE_NO_SPACE, whitespace.location)
+  }
+
+  private checkMissingSpaceBeforeSelfClosing(node: HTMLOpenTagNode, children: Node[], isSelfClosing: boolean): void {
+    if (!isSelfClosing) return
+
+    const lastChild = children[children.length - 1]
+    if (lastChild && isWhitespaceNode(lastChild)) return
+
+    const lastNonWhitespace = children.filter(child => !isWhitespaceNode(child)).pop()
+    const locationToReport = lastNonWhitespace?.location ?? node.tag_name?.location ?? node.location
+
+    this.addOffense(MESSAGES.NO_SPACE_SINGLE_SPACE, locationToReport)
+  }
+
+  private checkMultilineTag(node: HTMLOpenTagNode): void {
+    const whitespaceNodes = filterWhitespaceNodes(node.children)
+    let previousWhitespace: WhitespaceNode | null = null
+
+    whitespaceNodes.forEach((whitespace, index) => {
+      const content = this.getWhitespaceContent(whitespace)
+      if (!content) return
+
+      if (this.hasConsecutiveNewlines(content, previousWhitespace)) {
+        this.addOffense(MESSAGES.EXTRA_SPACE_SINGLE_BREAK, whitespace.location)
+        previousWhitespace = whitespace
+
+        return
+      }
+
+      if (this.isNonNewlineWhitespace(content)) {
+        this.checkIndentation(whitespace, index, whitespaceNodes.length, node)
+      }
+
+      previousWhitespace = whitespace
+    })
+  }
+
+  private hasConsecutiveNewlines(content: string, previousWhitespace: WhitespaceNode | null): boolean {
+    if (content === "\n") return previousWhitespace?.value?.value === "\n"
+    if (!content.includes("\n")) return false
+
+    const newlines = content.match(/\n/g)
+
+    return (newlines?.length ?? 0) > 1
+  }
+
+  private isNonNewlineWhitespace(content: string): boolean {
+    return !content.includes("\n")
+  }
+
+  private checkIndentation(whitespace: WhitespaceNode, index: number, totalWhitespaceNodes: number, node: HTMLOpenTagNode): void {
+    const isLastWhitespace = index === totalWhitespaceNodes - 1
+    const expectedIndent = isLastWhitespace ? node.location.start.column : node.location.start.column + 2
+
+    if (whitespace.location.end.column === expectedIndent) return
+
+    this.addOffense(MESSAGES.EXTRA_SPACE_NO_SPACE, whitespace.location)
+  }
+
+  private isSelfClosing(tag_closing: Token): boolean {
+    return tag_closing?.value?.includes('/') ?? false
+  }
+
+  private getWhitespaceContent(whitespace: WhitespaceNode): string | null {
+    return whitespace.value?.value ?? null
+  }
+
+  private reportAllWhitespace(nodes: Node[] | WhitespaceNode[], message: string): void {
+    const whitespaceNodes = Array.isArray(nodes) && nodes.length > 0 && !isWhitespaceNode(nodes[0])
+      ? filterWhitespaceNodes(nodes)
+      : nodes as WhitespaceNode[]
+
+    whitespaceNodes.forEach(whitespace => {
+      this.addOffense(message, whitespace.location)
+    })
+  }
+}
+
+export class HTMLNoSpaceInTagRule extends ParserRule {
+  name = "html-no-space-in-tag"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new HTMLNoSpaceInTagVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}
diff --git a/javascript/packages/linter/src/rules/index.ts b/javascript/packages/linter/src/rules/index.ts
index a511fa727..5add5e951 100644
--- a/javascript/packages/linter/src/rules/index.ts
+++ b/javascript/packages/linter/src/rules/index.ts
@@ -31,6 +31,7 @@ export * from "./html-no-empty-headings.js"
 export * from "./html-no-nested-links.js"
 export * from "./html-no-positive-tab-index.js"
 export * from "./html-no-self-closing.js"
+export * from "./html-no-space-in-tag.js"
 export * from "./html-no-title-attribute.js"
 export * from "./html-no-underscores-in-attribute-names.js"
 export * from "./html-tag-name-lowercase.js"
diff --git a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
index 3994c54ff..73e232c47 100644
--- a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
+++ b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
@@ -566,7 +566,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for bad file 1`]
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 34,
+    "ruleCount": 35,
     "totalErrors": 2,
     "totalOffenses": 2,
     "totalWarnings": 0,
@@ -584,7 +584,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for clean file 1`
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 0,
-    "ruleCount": 34,
+    "ruleCount": 35,
     "totalErrors": 0,
     "totalOffenses": 0,
     "totalWarnings": 0,
@@ -654,7 +654,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for file with err
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 34,
+    "ruleCount": 35,
     "totalErrors": 3,
     "totalOffenses": 3,
     "totalWarnings": 0,
diff --git a/javascript/packages/linter/test/rules/html-no-space-in-tag.test.ts b/javascript/packages/linter/test/rules/html-no-space-in-tag.test.ts
new file mode 100644
index 000000000..38ade222f
--- /dev/null
+++ b/javascript/packages/linter/test/rules/html-no-space-in-tag.test.ts
@@ -0,0 +1,209 @@
+import dedent from "dedent"
+import { describe, test } from "vitest"
+import { HTMLNoSpaceInTagRule } from "../../src/rules/html-no-space-in-tag.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
+
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoSpaceInTagRule)
+
+describe("HTMLNoSpaceInTagRule", () => {
+  describe("when space is correct", () => {
+    test("plain opening tag", () => {
+      expectNoOffenses(`<div>`, { allowInvalidSyntax: true })
+    })
+
+    test("closing tag", () => {
+      expectNoOffenses(`</div>`, { allowInvalidSyntax: true })
+    })
+
+    test("tag with no name", () => {
+      expectNoOffenses(`</>`, { allowInvalidSyntax: true })
+    })
+
+    test("empty tag", () => {
+      expectNoOffenses(`<>`, { allowInvalidSyntax: true })
+    })
+
+    test("void tag", () => {
+      expectNoOffenses(`<img />`)
+    })
+
+    test("plain tag with attribute", () => {
+      expectNoOffenses(`<div class="foo"></div>`)
+    })
+
+    test("between attributes", () => {
+      expectNoOffenses(`<input class="foo" name="bar">`)
+    })
+
+    test("multi line tag", () => {
+      expectNoOffenses(dedent`
+        <input
+          type="password"
+          class="foo"
+        >
+      `)
+    })
+
+    test("tag with erb", () => {
+      expectNoOffenses(`<input <%= attributes %>>`)
+    })
+
+    test("multi line tag with erb", () => {
+      expectNoOffenses(dedent`
+        <input
+          type="password"
+          <%= attributes %>
+          class="foo"
+        >
+      `)
+    })
+
+    test("multi line tag with erb nested", () => {
+      expectNoOffenses(dedent`
+        <div>
+          <input
+            type="password"
+            <%= attributes %>
+            class="foo"
+          >
+        </div>
+      `)
+    })
+  })
+
+  describe("when no space should be present", () => {
+    test("after name", () => {
+      expectError("Extra space detected where there should be no space.")
+      assertOffenses(`<div   ></div>`)
+    })
+
+    test("before name", () => {
+      expectNoOffenses(`<   div></div>`, { allowInvalidSyntax: true })
+    })
+
+    test("before start solidus", () => {
+      expectNoOffenses(`<div><   /div>`, { allowInvalidSyntax: true })
+    })
+
+    test("after start solidus", () => {
+      expectError("Extra space detected where there should be no space.")
+      assertOffenses(`<div></   div>`)
+    })
+
+    test("after end solidus", () => {
+      expectNoOffenses(`<div><div /   >`, { allowInvalidSyntax: true })
+    })
+  })
+
+  describe("when space is missing", () => {
+    test("between attributes", () => {
+      expectNoOffenses(`<div foo='foo'bar='bar'></div>`, { allowInvalidSyntax: true })
+    })
+
+    test("between last attribute and solidus", () => {
+      expectError("No space detected where there should be a single space.")
+      assertOffenses(`<div foo='bar'/>`)
+    })
+
+    test("between name and solidus", () => {
+      expectError("No space detected where there should be a single space.")
+      assertOffenses(`<div/>`)
+    })
+  })
+
+  describe("when extra space is present", () => {
+    test("between name and end of tag", () => {
+      expectError("Extra space detected where there should be no space.")
+      assertOffenses(`<div  ></div>`)
+    })
+
+    test("between name and first attribute", () => {
+      expectError("Extra space detected where there should be a single space.")
+      assertOffenses(`<img   class="hide">`)
+    })
+
+    test("between name and end solidus", () => {
+      expectError("Extra space detected where there should be no space.")
+      assertOffenses(`<br   />`)
+    })
+
+    test("between last attribute and solidus", () => {
+      expectError("Extra space detected where there should be no space.")
+      assertOffenses(`<br class="hide"   />`)
+    })
+
+    test("between last attribute and end of tag", () => {
+      expectError("Extra space detected where there should be no space.")
+      assertOffenses(`<img class="hide"    >`)
+    })
+
+    test("between attributes", () => {
+      expectError("Extra space detected where there should be a single space.")
+      assertOffenses(`<div foo='foo'      bar='bar'></div>`)
+    })
+
+    test("extra newline between name and first attribute", () => {
+      expectError("Extra space detected where there should be a single space or a single line break.")
+      expectError("Extra space detected where there should be no space.")
+
+      assertOffenses(dedent`
+        <input
+
+          type="password" />
+      `)
+    })
+
+    test("extra newline between name and end of tag", () => {
+      expectError("Extra space detected where there should be a single space or a single line break.")
+      expectError("Extra space detected where there should be no space.")
+
+      assertOffenses(dedent`
+        <input
+
+          />
+      `)
+    })
+
+    test("extra newline between attributes", () => {
+      expectError("Extra space detected where there should be a single space or a single line break.")
+      expectError("Extra space detected where there should be no space.")
+
+      assertOffenses(dedent`
+        <input
+          type="password"
+
+          class="foo" />
+      `)
+    })
+
+    test("end solidus is on newline", () => {
+      expectError("Extra space detected where there should be no space.")
+
+      assertOffenses(dedent`
+        <input
+          type="password"
+          class="foo"
+          />
+      `)
+    })
+
+    test("end of tag is on newline", () => {
+      expectError("Extra space detected where there should be no space.")
+
+      assertOffenses(dedent`
+        <input
+          type="password"
+          class="foo"
+          >
+      `)
+    })
+
+    test("non-space detected between name and attribute", () => {
+      expectNoOffenses(`<input/class="hide" />`, { allowInvalidSyntax: true })
+    })
+
+    test("non-space detected between attributes", () => {
+      expectNoOffenses(`<input class="hide"/name="foo" />`, { allowInvalidSyntax: true })
+    })
+  })
+})
diff --git a/javascript/packages/vscode/package.json b/javascript/packages/vscode/package.json
index 6e7bdf021..39ab8b60c 100644
--- a/javascript/packages/vscode/package.json
+++ b/javascript/packages/vscode/package.json
@@ -93,6 +93,7 @@
               "html-no-nested-links",
               "html-no-positive-tab-index",
               "html-no-self-closing",
+              "html-no-space-in-tag",
               "html-no-title-attribute",
               "html-no-underscores-in-attribute-names",
               "html-tag-name-lowercase",

From 1913a5d9fd0ed4abab0db9ec2866fc61d6b6edce Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Fri, 10 Oct 2025 23:15:01 +0200
Subject: [PATCH 41/97] C: Use buffer for string operations in `html_utils.c`
 (#616)

This PR changes the implementation of the html_utils
`html_self_closing_tag_string` and `html_closing_tag_string`.

Instead of directly using malloc to allocate the string we instead use
the buffer, which not only performs bounds checks, but also encapsulates
any low level memory operations.
---
 src/html_util.c | 40 ++++++++++++++++------------------------
 1 file changed, 16 insertions(+), 24 deletions(-)

diff --git a/src/html_util.c b/src/html_util.c
index cd2f863a0..95941b10e 100644
--- a/src/html_util.c
+++ b/src/html_util.c
@@ -1,4 +1,5 @@
 #include "include/html_util.h"
+#include "include/buffer.h"
 #include "include/util.h"
 
 #include <ctype.h>
@@ -42,20 +43,16 @@ bool is_void_element(const char* tag_name) {
 char* html_closing_tag_string(const char* tag_name) {
   if (tag_name == NULL) { return herb_strdup("</>"); }
 
-  size_t length = strlen(tag_name);
-  char* result = (char*) malloc(length + 4); // +4 for '<', '/', '>', and '\0'
 
-  if (result == NULL) { return NULL; }
+  buffer_T buffer;
+  buffer_init(&buffer, strlen(tag_name) + 3);
 
-  result[0] = '<';
-  result[1] = '/';
+  buffer_append_char(&buffer, '<');
+  buffer_append_char(&buffer, '/');
+  buffer_append(&buffer, tag_name);
+  buffer_append_char(&buffer, '>');
 
-  memcpy(result + 2, tag_name, length);
-
-  result[length + 2] = '>';
-  result[length + 3] = '\0';
-
-  return result;
+  return buffer.value;
 }
 
 /**
@@ -77,19 +74,14 @@ char* html_closing_tag_string(const char* tag_name) {
 char* html_self_closing_tag_string(const char* tag_name) {
   if (tag_name == NULL) { return herb_strdup("< />"); }
 
-  size_t length = strlen(tag_name);
-  char* result = (char*) malloc(length + 5); // +5 for '<', ' ', '/', '>', and '\0'
-
-  if (result == NULL) { return NULL; }
-
-  result[0] = '<';
-
-  memcpy(result + 1, tag_name, length);
+  buffer_T buffer;
+  buffer_init(&buffer, strlen(tag_name) + 4);
 
-  result[length + 1] = ' ';
-  result[length + 2] = '/';
-  result[length + 3] = '>';
-  result[length + 4] = '\0';
+  buffer_append_char(&buffer, '<');
+  buffer_append(&buffer, tag_name);
+  buffer_append_char(&buffer, ' ');
+  buffer_append_char(&buffer, '/');
+  buffer_append_char(&buffer, '>');
 
-  return result;
+  return buffer.value;
 }

From 67573b9a8a0079e850f758367f996a0a70326852 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Fri, 10 Oct 2025 23:17:55 +0200
Subject: [PATCH 42/97] Format

---
 src/html_util.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/html_util.c b/src/html_util.c
index 95941b10e..9c4132cd8 100644
--- a/src/html_util.c
+++ b/src/html_util.c
@@ -43,7 +43,6 @@ bool is_void_element(const char* tag_name) {
 char* html_closing_tag_string(const char* tag_name) {
   if (tag_name == NULL) { return herb_strdup("</>"); }
 
-
   buffer_T buffer;
   buffer_init(&buffer, strlen(tag_name) + 3);
 

From 47835a84d44e2557ff61a0d681167de43916e749 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Fri, 10 Oct 2025 23:19:22 +0200
Subject: [PATCH 43/97] C: Remove superfluous `malloc` from
 `buffer_append_repeated` (#615)

This MR removes the malloc/free combo from the `buffer_append_repeated`
function.

Instead it expands the buffer to the required length and sets the memory
directly using `memset`.

---------

Signed-off-by: Marco Roth <marco.roth@intergga.ch>
Co-authored-by: Marco Roth <marco.roth@intergga.ch>
---
 src/buffer.c | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/src/buffer.c b/src/buffer.c
index 33ddd4ce4..d9de6506b 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -185,17 +185,13 @@ void buffer_append_char(buffer_T* buffer, const char character) {
 }
 
 void buffer_append_repeated(buffer_T* buffer, const char character, size_t length) {
-  if (length == 0) { return; }
-
-  char* spaces = malloc(length + 1);
-  if (!spaces) { return; }
-
-  memset(spaces, character, length);
-  spaces[length] = '\0';
+  if (!buffer || length == 0) { return; }
+  if (!buffer_expand_if_needed(buffer, length)) { return; }
 
-  buffer_append(buffer, spaces);
+  memset(buffer->value + buffer->length, character, length);
 
-  free(spaces);
+  buffer->length += length;
+  buffer->value[buffer->length] = '\0';
 }
 
 void buffer_append_whitespace(buffer_T* buffer, const size_t length) {

From e899331bbf476e1b794b41cebc8f71c82b8db311 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Fri, 10 Oct 2025 23:20:23 +0200
Subject: [PATCH 44/97] C: Use buffer in `escape_newlines` and `wrap_in_string`
 (#617)

This PR refactors the util functions `escape_newlines` and
`wrap_in_string` to internally use buffer instead of manually allocating
the memory and setting the null terminator.
---
 src/util.c | 50 +++++++++++++++++++++++++-------------------------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/src/util.c b/src/util.c
index 63f6551c0..483392abb 100644
--- a/src/util.c
+++ b/src/util.c
@@ -1,4 +1,5 @@
 #include "include/util.h"
+#include "include/buffer.h"
 
 #include <ctype.h>
 #include <stdio.h>
@@ -10,42 +11,41 @@ int is_newline(const int character) {
 }
 
 char* escape_newlines(const char* input) {
-  char* output = calloc(strlen(input) * 2 + 1, sizeof(char));
-  char* orig_output = output;
-
-  while (*input) {
-    if (*input == '\n') {
-      *output++ = '\\';
-      *output++ = 'n';
-    } else if (*input == '\r') {
-      *output++ = '\\';
-      *output++ = 'r';
-    } else {
-      *output++ = *input;
+  buffer_T buffer;
+
+  buffer_init(&buffer, strlen(input));
+
+  for (size_t i = 0; i < strlen(input); ++i) {
+    switch (input[i]) {
+      case '\n': {
+        buffer_append_char(&buffer, '\\');
+        buffer_append_char(&buffer, 'n');
+      } break;
+      case '\r': {
+        buffer_append_char(&buffer, '\\');
+        buffer_append_char(&buffer, 'r');
+      } break;
+      default: {
+        buffer_append_char(&buffer, input[i]);
+      }
     }
-
-    input++;
   }
 
-  *output = '\0';
-
-  return orig_output;
+  return buffer.value;
 }
 
 char* wrap_string(const char* input, const char character) {
   if (input == NULL) { return NULL; }
 
-  const size_t length = strlen(input);
-  char* wrapped = malloc(length + 3);
+  buffer_T buffer;
 
-  if (wrapped == NULL) { return NULL; }
+  buffer_init(&buffer, strlen(input) + 2);
 
-  wrapped[0] = character;
-  strcpy(wrapped + 1, input);
-  wrapped[length + 1] = character;
-  wrapped[length + 2] = '\0';
+  buffer_append_char(&buffer, character);
+  buffer_append(&buffer, input);
+  buffer_append_char(&buffer, character);
 
-  return wrapped;
+  return buffer.value;
 }
 
 char* quoted_string(const char* input) {

From 5c9980b257bb98cf648ddce812665ed3fb6b5413 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Fri, 10 Oct 2025 23:27:08 +0200
Subject: [PATCH 45/97] Docs: Exclude Maintainer and Dependabot from
 Contributors component

---
 docs/.vitepress/theme/components/GitHubContributors.vue | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/docs/.vitepress/theme/components/GitHubContributors.vue b/docs/.vitepress/theme/components/GitHubContributors.vue
index 5b94a1549..487728c64 100644
--- a/docs/.vitepress/theme/components/GitHubContributors.vue
+++ b/docs/.vitepress/theme/components/GitHubContributors.vue
@@ -23,7 +23,10 @@ const error = ref(null)
 
 onMounted(async () => {
   try {
-    contributors.value = contributorsFile.slice(0, props.limit)
+    const excludedUsernames = ['marcoroth', 'dependabot[bot]']
+    const filteredContributors = contributorsFile.filter(contributor => !excludedUsernames.includes(contributor.login))
+    contributors.value = filteredContributors.slice(0, props.limit)
+
     loading.value = false
   } catch (err) {
     error.value = `Failed to load contributors data for ${props.owner}/${props.repo}. Make sure the data file exists.`

From bc9fb9a4a1b608c161bd4c75668d73aec0bda094 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Sat, 11 Oct 2025 15:37:36 +0200
Subject: [PATCH 46/97] C: Implement `hb_string` struct (#618)

Implement a string datastructure representing a string with a known
limit, eliminating the need to always use null terminated strings.

This lays the groundwork for reducing the number of required allocations
during parsing.

See #580
---
 javascript/packages/node/binding.gyp |   1 +
 src/hb_string.c                      |  48 ++++++++++
 src/include/hb_string.h              |  35 +++++++
 test/c/main.c                        |   2 +
 test/c/test_hb_string.c              | 133 +++++++++++++++++++++++++++
 5 files changed, 219 insertions(+)
 create mode 100644 src/hb_string.c
 create mode 100644 src/include/hb_string.h
 create mode 100644 test/c/test_hb_string.c

diff --git a/javascript/packages/node/binding.gyp b/javascript/packages/node/binding.gyp
index 650d93a7e..be7da9a78 100644
--- a/javascript/packages/node/binding.gyp
+++ b/javascript/packages/node/binding.gyp
@@ -32,6 +32,7 @@
         "./extension/libherb/pretty_print.c",
         "./extension/libherb/prism_helpers.c",
         "./extension/libherb/range.c",
+        "./extension/libherb/hb_string.c",
         "./extension/libherb/token_matchers.c",
         "./extension/libherb/token.c",
         "./extension/libherb/utf8.c",
diff --git a/src/hb_string.c b/src/hb_string.c
new file mode 100644
index 000000000..93b5872c7
--- /dev/null
+++ b/src/hb_string.c
@@ -0,0 +1,48 @@
+#include "include/hb_string.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+
+hb_string_T hb_string_from_c_string(const char* null_terminated_c_string) {
+  hb_string_T string;
+
+  string.data = (char*) null_terminated_c_string;
+  string.length = strlen(null_terminated_c_string);
+
+  return string;
+}
+
+bool hb_string_equals(hb_string_T a, hb_string_T b) {
+  if (a.length != b.length) { return false; }
+
+  return strncmp(a.data, b.data, a.length) == 0;
+}
+
+bool hb_string_equals_case_insensitive(hb_string_T a, hb_string_T b) {
+  if (a.length != b.length) { return false; }
+
+  return strncasecmp(a.data, b.data, a.length) == 0;
+}
+
+bool hb_string_starts_with(hb_string_T string, hb_string_T expected_prefix) {
+  if (hb_string_is_empty(string) || hb_string_is_empty(expected_prefix)) { return false; }
+  if (string.length < expected_prefix.length) { return false; }
+
+  return strncmp(string.data, expected_prefix.data, expected_prefix.length) == 0;
+}
+
+bool hb_string_is_empty(hb_string_T string) {
+  return string.length == 0;
+}
+
+char* hb_string_to_c_string(hb_string_T string) {
+  size_t string_length_in_bytes = sizeof(char) * (string.length);
+  char* buffer = malloc(string_length_in_bytes + sizeof(char) * 1);
+
+  if (!hb_string_is_empty(string)) { memcpy(buffer, string.data, string_length_in_bytes); }
+
+  buffer[string_length_in_bytes] = '\0';
+
+  return buffer;
+}
diff --git a/src/include/hb_string.h b/src/include/hb_string.h
new file mode 100644
index 000000000..5f9f972c1
--- /dev/null
+++ b/src/include/hb_string.h
@@ -0,0 +1,35 @@
+#ifndef HERB_STRING_H
+#define HERB_STRING_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef struct STRING_STRUCT {
+  char* data;
+  size_t length;
+} hb_string_T;
+
+hb_string_T hb_string_from_c_string(const char* null_terminated_c_string);
+bool hb_string_equals(hb_string_T a, hb_string_T b);
+bool hb_string_equals_case_insensitive(hb_string_T a, hb_string_T b);
+bool hb_string_starts_with(hb_string_T string, hb_string_T expected_prefix);
+bool hb_string_is_empty(hb_string_T string);
+
+/**
+ * @brief Creates a null terminated c string version of the passed string
+ *
+ * @param string The string for which a c string version is to be created
+ * @return A heap allocated null terminated c string
+ *
+ * Example:
+ * @code
+ *
+ * hb_string_T string = hb_string_from_c_string("Hello, world");
+ * char* cstring = hb_string_to_c_string(string);
+ *
+ * free(cstring);
+ * @endcode
+ */
+char* hb_string_to_c_string(hb_string_T string);
+
+#endif
diff --git a/test/c/main.c b/test/c/main.c
index 200d92a6b..c47f68534 100644
--- a/test/c/main.c
+++ b/test/c/main.c
@@ -9,6 +9,7 @@ TCase *io_tests(void);
 TCase *lex_tests(void);
 TCase *token_tests(void);
 TCase *util_tests(void);
+TCase *hb_string_tests(void);
 
 Suite *herb_suite(void) {
   Suite *suite = suite_create("Herb Suite");
@@ -21,6 +22,7 @@ Suite *herb_suite(void) {
   suite_add_tcase(suite, lex_tests());
   suite_add_tcase(suite, token_tests());
   suite_add_tcase(suite, util_tests());
+  suite_add_tcase(suite, hb_string_tests());
 
   return suite;
 }
diff --git a/test/c/test_hb_string.c b/test/c/test_hb_string.c
new file mode 100644
index 000000000..8d6098d29
--- /dev/null
+++ b/test/c/test_hb_string.c
@@ -0,0 +1,133 @@
+#include "include/test.h"
+#include "../../src/include/hb_string.h"
+#include <string.h>
+
+TEST(hb_string_equals_tests)
+  {
+    hb_string_T a = hb_string_from_c_string("Hello, world.");
+    hb_string_T b = hb_string_from_c_string("Hello, world.");
+
+    ck_assert(hb_string_equals(a, b));
+  }
+
+  {
+    hb_string_T a = hb_string_from_c_string("Hello, world.");
+    hb_string_T b = hb_string_from_c_string("Hello, world. Longer text");
+
+    ck_assert(!hb_string_equals(a, b));
+  }
+
+  {
+    hb_string_T a = hb_string_from_c_string("Hello, world.");
+    hb_string_T b = hb_string_from_c_string("");
+
+    ck_assert(!hb_string_equals(a, b));
+  }
+END
+
+TEST(hb_string_equals_case_insensitive_tests)
+  {
+    hb_string_T a = hb_string_from_c_string("Hello, world.");
+    hb_string_T b = hb_string_from_c_string("Hello, World. Really?");
+
+    ck_assert(!hb_string_equals_case_insensitive(a, b));
+  }
+
+  {
+    hb_string_T a = hb_string_from_c_string("Hello, world.");
+    hb_string_T b = hb_string_from_c_string("Hello, World.");
+
+    ck_assert(hb_string_equals_case_insensitive(a, b));
+  }
+
+  {
+    hb_string_T a = hb_string_from_c_string("This.");
+    hb_string_T b = hb_string_from_c_string("That.");
+
+    ck_assert(!hb_string_equals_case_insensitive(a, b));
+  }
+END
+
+TEST(hb_string_is_empty_tests)
+  {
+    hb_string_T str = {
+      .length = 0,
+      .data = NULL
+    };
+
+    ck_assert(hb_string_is_empty(str));
+  }
+
+  {
+    hb_string_T str = hb_string_from_c_string("");
+
+    ck_assert(hb_string_is_empty(str));
+  }
+
+  {
+    hb_string_T str = hb_string_from_c_string("Content");
+
+    ck_assert(!hb_string_is_empty(str));
+  }
+END
+
+TEST(hb_string_starts_with_tests)
+  {
+    hb_string_T str = hb_string_from_c_string("This.");
+    hb_string_T prefix = {
+      .length = 0,
+      .data = NULL,
+    };
+
+    ck_assert(!hb_string_starts_with(str, prefix));
+  }
+
+  {
+    hb_string_T str = {
+      .length = 0,
+      .data = NULL,
+    };
+    hb_string_T prefix = hb_string_from_c_string("This.");
+
+    ck_assert(!hb_string_starts_with(str, prefix));
+  }
+
+  {
+    hb_string_T str = hb_string_from_c_string("Long text.");
+    hb_string_T prefix = hb_string_from_c_string("Long text.");
+
+    ck_assert(hb_string_starts_with(str, prefix));
+  }
+
+  {
+    hb_string_T str = hb_string_from_c_string("Long text.");
+    hb_string_T prefix = hb_string_from_c_string("Long");
+
+    ck_assert(hb_string_starts_with(str, prefix));
+  }
+
+  {
+    hb_string_T str = hb_string_from_c_string("Long text.");
+    hb_string_T prefix = hb_string_from_c_string("No");
+
+    ck_assert(!hb_string_starts_with(str, prefix));
+  }
+
+  {
+    hb_string_T str = hb_string_from_c_string("Long text.");
+    hb_string_T prefix = hb_string_from_c_string("This prefix is longer than the text");
+
+    ck_assert(!hb_string_starts_with(str, prefix));
+  }
+END
+
+TCase *hb_string_tests(void) {
+  TCase *tags = tcase_create("Str");
+
+  tcase_add_test(tags, hb_string_equals_tests);
+  tcase_add_test(tags, hb_string_equals_case_insensitive_tests);
+  tcase_add_test(tags, hb_string_is_empty_tests);
+  tcase_add_test(tags, hb_string_starts_with_tests);
+
+  return tags;
+}

From a005cd65b9b0e6ea57c617a67107b509a1b5c70d Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Sat, 11 Oct 2025 17:04:48 +0200
Subject: [PATCH 47/97] Update all HTML+ERB globs to include Action View
 Variants (#620)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

As discovered in
https://github.com/kaigionrails/conference-app/pull/601, we didn't
include templates that had an Action View Variant in the filename (like
`index.html+mobile.erb`).

This pull request now updates all file globs Herb uses to also detect
all Action View Variants.

Thanks to @nissyi-gh and @unasuke for the help! 🙏🏼
---
 javascript/packages/formatter/src/cli.ts      | 28 +++++++++----------
 .../packages/formatter/test/cli.test.ts       |  6 ++--
 .../packages/language-server/src/server.ts    |  2 +-
 javascript/packages/linter/README.md          |  4 +--
 javascript/packages/linter/src/cli.ts         |  4 +--
 .../linter/src/cli/argument-parser.ts         |  8 +++---
 javascript/packages/printer/src/cli.ts        | 12 ++++----
 javascript/packages/vscode/src/extension.ts   |  4 +--
 .../vscode/src/herb-analysis-provider.ts      |  2 +-
 lib/herb/project.rb                           |  2 +-
 10 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/javascript/packages/formatter/src/cli.ts b/javascript/packages/formatter/src/cli.ts
index a6502833d..13020443a 100644
--- a/javascript/packages/formatter/src/cli.ts
+++ b/javascript/packages/formatter/src/cli.ts
@@ -19,8 +19,8 @@ export class CLI {
     Usage: herb-format [file|directory|glob-pattern] [options]
 
     Arguments:
-      file|directory|glob-pattern   File to format, directory to format all **/*.html.erb files within,
-                                    glob pattern to match files, or '-' for stdin (omit to format all **/*.html.erb files in current directory)
+      file|directory|glob-pattern   File to format, directory to format all **/*.html{+*,}.erb files within,
+                                    glob pattern to match files, or '-' for stdin (omit to format all **/*.html{+*,}.erb files in current directory)
 
     Options:
       -c, --check                     check if files are formatted without modifying them
@@ -30,15 +30,15 @@ export class CLI {
       --max-line-length <number>      maximum line length before wrapping (default: 80)
 
     Examples:
-      herb-format                            # Format all **/*.html.erb files in current directory
-      herb-format index.html.erb             # Format and write single file
-      herb-format templates/index.html.erb   # Format and write single file
-      herb-format templates/                 # Format and **/*.html.erb within the given directory
-      herb-format "templates/**/*.html.erb"  # Format all .html.erb files in templates directory using glob pattern
-      herb-format "**/*.html.erb"            # Format all .html.erb files using glob pattern
-      herb-format "**/*.xml.erb"             # Format all .xml.erb files using glob pattern
-      herb-format --check                    # Check if all **/*.html.erb files are formatted
-      herb-format --check templates/         # Check if all **/*.html.erb files in templates/ are formatted
+      herb-format                                 # Format all **/*.html{+*,}.erb files in current directory
+      herb-format index.html.erb                  # Format and write single file
+      herb-format templates/index.html.erb        # Format and write single file
+      herb-format templates/                      # Format and **/*.html{+*,}.erb within the given directory
+      herb-format "templates/**/*.html{+*,}.erb"  # Format all .html{+*,}.erb files in templates directory using glob pattern
+      herb-format "**/*.html{+*,}.erb"            # Format all .html{+*,}.erb files using glob pattern
+      herb-format "**/*.xml.erb"                  # Format all .xml.erb files using glob pattern
+      herb-format --check                         # Check if all **/*.html{+*,}.erb files are formatted
+      herb-format --check templates/              # Check if all **/*.html{+*,}.erb files in templates/ are formatted
       herb-format --indent-width 4           # Format with 4-space indentation
       herb-format --max-line-length 100      # Format with 100-character line limit
       cat template.html.erb | herb-format    # Format from stdin to stdout
@@ -162,7 +162,7 @@ export class CLI {
         }
 
         if (isDirectory) {
-          pattern = join(file, "**/*.html.erb")
+          pattern = join(file, "**/*.html{+*,}.erb")
         } else if (isFile) {
           const source = readFileSync(file, "utf-8")
           const result = formatter.format(source)
@@ -245,10 +245,10 @@ export class CLI {
           process.exit(1)
         }
       } else {
-        const files = await glob("**/*.html.erb")
+        const files = await glob("**/*.html{+*,}.erb")
 
         if (files.length === 0) {
-          console.log(`No files found matching pattern: ${resolve("**/*.html.erb")}`)
+          console.log(`No files found matching pattern: ${resolve("**/*.html{+*,}.erb")}`)
 
           process.exit(0)
         }
diff --git a/javascript/packages/formatter/test/cli.test.ts b/javascript/packages/formatter/test/cli.test.ts
index b45f7d49c..aa17e6c6b 100644
--- a/javascript/packages/formatter/test/cli.test.ts
+++ b/javascript/packages/formatter/test/cli.test.ts
@@ -201,7 +201,7 @@ describe("CLI Binary", () => {
       expectExitCode(result, 0)
       expect(result.stderr).toContain("⚠️  Experimental Preview")
       expect(result.stdout).toContain("No files found matching pattern:")
-      expect(result.stdout).toContain("test-empty-dir/**/*.html.erb")
+      expect(result.stdout).toContain("test-empty-dir/**/*.html{+*,}.erb")
     } finally {
       await rm("test-empty-dir", { recursive: true }).catch(() => {})
     }
@@ -253,7 +253,7 @@ describe("CLI Binary", () => {
 
       expectExitCode(result, 0)
       expect(result.stdout).toContain("No files found matching pattern:")
-      expect(result.stdout).toContain("test-dir/**/*.html.erb")
+      expect(result.stdout).toContain("test-dir/**/*.html{+*,}.erb")
     } finally {
       await rm("test-dir", { recursive: true }).catch(() => {})
     }
@@ -642,7 +642,7 @@ describe("CLI Binary", () => {
 
       expectExitCode(result, 0)
       expect(result.stdout).toContain("No files found matching pattern")
-      expect(result.stdout).toContain("test-advanced/**/*.html.erb")
+      expect(result.stdout).toContain("test-advanced/**/*.html{+*,}.erb")
     })
 
     it("should handle mixed file arguments", async () => {
diff --git a/javascript/packages/language-server/src/server.ts b/javascript/packages/language-server/src/server.ts
index 4ad761e90..c946dfae5 100644
--- a/javascript/packages/language-server/src/server.ts
+++ b/javascript/packages/language-server/src/server.ts
@@ -62,7 +62,7 @@ export class Server {
 
       this.connection.client.register(DidChangeWatchedFilesNotification.type, {
         watchers: [
-          { globPattern: `**/**/*.html.erb` },
+          { globPattern: `**/**/*.html{+*,}.erb` },
           { globPattern: `**/**/.herb-lsp/config.json` },
         ],
       })
diff --git a/javascript/packages/linter/README.md b/javascript/packages/linter/README.md
index 54002f00f..8604b4384 100644
--- a/javascript/packages/linter/README.md
+++ b/javascript/packages/linter/README.md
@@ -67,7 +67,7 @@ After installing as a dev dependency, add a lint NPM script to your `package.jso
 ```json
 {
   "scripts": {
-    "herb:lint": "herb-lint '**/*.html.erb'"
+    "herb:lint": "herb-lint '**/*.html{+*,}.erb'"
   }
 }
 ```
@@ -101,7 +101,7 @@ bun run herb:lint
 Basic usage:
 ```bash
 npx @herb-tools/linter template.html.erb
-npx @herb-tools/linter "**/*.html.erb"
+npx @herb-tools/linter "**/*.html{+*,}.erb"
 npx @herb-tools/linter app/
 ```
 
diff --git a/javascript/packages/linter/src/cli.ts b/javascript/packages/linter/src/cli.ts
index eb3fbfc00..deef30c2f 100644
--- a/javascript/packages/linter/src/cli.ts
+++ b/javascript/packages/linter/src/cli.ts
@@ -105,7 +105,7 @@ export class CLI {
 
   protected adjustPattern(pattern: string | undefined): string {
     if (!pattern) {
-      return '**/*.html.erb'
+      return '**/*.html{+*,}.erb'
     }
 
     const resolvedPattern = resolve(pattern)
@@ -114,7 +114,7 @@ export class CLI {
       const stats = statSync(resolvedPattern)
 
       if (stats.isDirectory()) {
-        return '**/*.html.erb'
+        return '**/*.html{+*,}.erb'
       } else if (stats.isFile()) {
         return relative(this.projectPath, resolvedPattern)
       }
diff --git a/javascript/packages/linter/src/cli/argument-parser.ts b/javascript/packages/linter/src/cli/argument-parser.ts
index 8389119c1..7ab2cb7fc 100644
--- a/javascript/packages/linter/src/cli/argument-parser.ts
+++ b/javascript/packages/linter/src/cli/argument-parser.ts
@@ -29,8 +29,8 @@ export class ArgumentParser {
 
     Arguments:
       file             Single file to lint
-      glob-pattern     Files to lint (defaults to **/*.html.erb)
-      directory        Directory to lint (automatically appends **/*.html.erb)
+      glob-pattern     Files to lint (defaults to **/*.html{+*,}.erb)
+      directory        Directory to lint (automatically appends **/*.html{+*,}.erb)
 
     Options:
       -h, --help       show help
@@ -128,12 +128,12 @@ export class ArgumentParser {
   }
 
   private getFilePattern(positionals: string[]): string {
-    let pattern = positionals.length > 0 ? positionals[0] : "**/*.html.erb"
+    let pattern = positionals.length > 0 ? positionals[0] : "**/*.html{+*,}.erb"
 
     try {
       const stat = statSync(pattern)
       if (stat.isDirectory()) {
-        pattern = join(pattern, "**/*.html.erb")
+        pattern = join(pattern, "**/*.html{+*,}.erb")
       }
     } catch {
       // Not a file/directory, treat as glob pattern
diff --git a/javascript/packages/printer/src/cli.ts b/javascript/packages/printer/src/cli.ts
index e54e00e6c..4d4e8b8a2 100644
--- a/javascript/packages/printer/src/cli.ts
+++ b/javascript/packages/printer/src/cli.ts
@@ -74,7 +74,7 @@ export class CLI {
         -o, --output <file>          Output file path (defaults to stdout)
         --verify                     Verify that output matches input exactly
         --stats                      Show parsing and printing statistics
-        --glob                       Treat input as glob pattern (default: **/*.html.erb)
+        --glob                       Treat input as glob pattern (default: **/*.html{+*,}.erb)
         -h, --help                   Show this help message
 
       Examples:
@@ -84,11 +84,11 @@ export class CLI {
         herb-print input.html.erb --stats
 
         # Glob patterns (batch verification)
-        herb-print --glob --verify                    # All .html.erb files
-        herb-print "app/views/**/*.html.erb" --glob --verify --stats
+        herb-print --glob --verify                         # All .html{+*,}.erb files
+        herb-print "app/views/**/*.html{+*,}.erb" --glob --verify --stats
         herb-print "*.erb" --glob --verify
-        herb-print "/path/to/templates" --glob --verify    # Directory (auto-appends /**/*.html.erb)
-        herb-print "/path/to/templates/**/*.html.erb" --glob --verify
+        herb-print "/path/to/templates" --glob --verify    # Directory (auto-appends /**/*.html{+*,}.erb)
+        herb-print "/path/to/templates/**/*.html{+*,}.erb" --glob --verify
 
         # The --verify flag is useful to test parser fidelity:
         herb-print input.html.erb --verify
@@ -108,7 +108,7 @@ export class CLI {
       await Herb.load()
 
       if (options.glob) {
-        const pattern = options.input || "**/*.html.erb"
+        const pattern = options.input || "**/*.html{+*,}.erb"
         const files = await glob(pattern)
 
         if (files.length === 0) {
diff --git a/javascript/packages/vscode/src/extension.ts b/javascript/packages/vscode/src/extension.ts
index e66b88d0c..5b873283f 100644
--- a/javascript/packages/vscode/src/extension.ts
+++ b/javascript/packages/vscode/src/extension.ts
@@ -64,7 +64,7 @@ export async function activate(context: vscode.ExtensionContext) {
   )
 
   // Set up file watcher for HTML+ERB files
-  const fileWatcher = vscode.workspace.createFileSystemWatcher('**/*.html.erb')
+  const fileWatcher = vscode.workspace.createFileSystemWatcher('**/*.html{+*,}.erb')
 
   fileWatcher.onDidChange(async (uri) => {
     console.log(`File changed: ${uri.fsPath}`)
@@ -94,7 +94,7 @@ async function runAutoAnalysis() {
     return
   }
 
-  const erbFiles = await vscode.workspace.findFiles('**/*.html.erb')
+  const erbFiles = await vscode.workspace.findFiles('**/*.html{+*,}.erb')
   if (erbFiles.length === 0) {
     return
   }
diff --git a/javascript/packages/vscode/src/herb-analysis-provider.ts b/javascript/packages/vscode/src/herb-analysis-provider.ts
index 13d148516..d578f5502 100644
--- a/javascript/packages/vscode/src/herb-analysis-provider.ts
+++ b/javascript/packages/vscode/src/herb-analysis-provider.ts
@@ -46,7 +46,7 @@ export class HerbAnalysisProvider implements TreeDataProvider<TreeNode> {
   }
 
   async analyzeProject(): Promise<void> {
-    const uris = await workspace.findFiles('**/*.html.erb')
+    const uris = await workspace.findFiles('**/*.html{+*,}.erb')
 
     this.lastAnalysisTime = new Date()
 
diff --git a/lib/herb/project.rb b/lib/herb/project.rb
index aade882eb..f7b15b7be 100644
--- a/lib/herb/project.rb
+++ b/lib/herb/project.rb
@@ -30,7 +30,7 @@ def initialize(project_path, output_file: nil)
     end
 
     def glob
-      "**/*.html.erb"
+      "**/*.html{+*,}.erb"
     end
 
     def full_path_glob

From e4e330c995e02275e55db65be9afe29208fe605c Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Sat, 11 Oct 2025 17:09:49 +0200
Subject: [PATCH 48/97] Ruby CLI: Run `compile` for all files in `analyze`
 command (#621)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This pull request updates the `herb analyze` command to also run
`compile` on all HTML+ERB templates found in a directory.

This should help to statically catch any template compilation errors
before actually trying to render the templates/running the application.

```
❯ exe/herb analyze ../conference-app/
Parsing .html.erb files in: /Users/marcoroth/Development/conference-app
Total files to process: 76

Completed processing all files.
--- SUMMARY --------------------------------------------------------------------
Total files: 76
✅ Successful (parsed & compiled): 76 (100.0%)
❌ Compilation errors: 0 (0.0%)
❌ Failed to parse: 0 (0.0%)
⚠️ Parse errors: 0 (0.0%)
⏱️  Timed out: 0 (0.0%)

⏱️ Total time: 239.54ms

Results saved to 2025-10-11_17-02-43_erb_parsing_result_conference-app.log
```
---
 lib/herb/project.rb | 105 +++++++++++++++++++++++++++++++++++---------
 1 file changed, 85 insertions(+), 20 deletions(-)

diff --git a/lib/herb/project.rb b/lib/herb/project.rb
index f7b15b7be..1d9332f96 100644
--- a/lib/herb/project.rb
+++ b/lib/herb/project.rb
@@ -78,19 +78,23 @@ def parse!
         failed_files = []
         timeout_files = []
         error_files = []
+        compilation_failed_files = []
         error_outputs = {}
         file_contents = {}
         parse_errors = {}
+        compilation_errors = {}
 
         files.each_with_index do |file_path, index|
           total_failed = failed_files.count
           total_timeout = timeout_files.count
           total_errors = error_files.count
+          total_compilation_failed = compilation_failed_files.count
 
-          lines_to_clear = 6 + total_failed + total_timeout + total_errors
+          lines_to_clear = 6 + total_failed + total_timeout + total_errors + total_compilation_failed
           lines_to_clear += 3 if total_failed.positive?
           lines_to_clear += 3 if total_timeout.positive?
           lines_to_clear += 3 if total_errors.positive?
+          lines_to_clear += 3 if total_compilation_failed.positive?
 
           lines_to_clear.times { print "\e[1A\e[K" } if index.positive? && interactive?
 
@@ -129,6 +133,13 @@ def parse!
               error_files.each { |file| puts "  - #{file}" }
               puts
             end
+
+            if compilation_failed_files.any?
+              puts
+              puts "Files with compilation errors:"
+              compilation_failed_files.each { |file| puts "  - #{file}" }
+              puts
+            end
           end
 
           begin
@@ -173,7 +184,33 @@ def parse!
               case $CHILD_STATUS.exitstatus
               when 0
                 log.puts "✅ Parsed #{file_path} successfully"
-                successful_files << file_path
+
+                begin
+                  Herb::Engine.new(file_content, filename: file_path, escape: true)
+
+                  log.puts "✅ Compiled #{file_path} successfully"
+                  successful_files << file_path
+                rescue Herb::Engine::CompilationError => e
+                  log.puts "❌ Compilation failed for #{file_path}"
+
+                  compilation_failed_files << file_path
+                  compilation_errors[file_path] = {
+                    error: e.message,
+                    backtrace: e.backtrace&.first(10) || [],
+                  }
+
+                  file_contents[file_path] = file_content
+                rescue StandardError => e
+                  log.puts "❌ Unexpected compilation error for #{file_path}: #{e.class}: #{e.message}"
+
+                  compilation_failed_files << file_path
+                  compilation_errors[file_path] = {
+                    error: "#{e.class}: #{e.message}",
+                    backtrace: e.backtrace&.first(10) || [],
+                  }
+
+                  file_contents[file_path] = file_content
+                end
               when 2
                 message = "⚠️ Parsing #{file_path} completed with errors"
                 log.puts message
@@ -248,8 +285,11 @@ def parse!
         summary = [
           heading("Summary"),
           "Total files: #{files.count}",
-          "✅ Successful: #{successful_files.count} (#{percentage(successful_files.count, files.count)}%)",
-          "❌ Failed: #{failed_files.count} (#{percentage(failed_files.count, files.count)}%)",
+          "✅ Successful (parsed & compiled): #{successful_files.count} (#{percentage(successful_files.count,
+                                                                                      files.count)}%)",
+          "❌ Compilation errors: #{compilation_failed_files.count} (#{percentage(compilation_failed_files.count,
+                                                                                  files.count)}%)",
+          "❌ Failed to parse: #{failed_files.count} (#{percentage(failed_files.count, files.count)}%)",
           "⚠️ Parse errors: #{error_files.count} (#{percentage(error_files.count, files.count)}%)",
           "⏱️ Timed out: #{timeout_files.count} (#{percentage(timeout_files.count, files.count)}%)"
         ]
@@ -289,7 +329,17 @@ def parse!
           end
         end
 
-        problem_files = failed_files + timeout_files + error_files
+        if compilation_failed_files.any?
+          log.puts "\n#{heading("Files with compilation errors")}"
+          puts "\nFiles with compilation errors:"
+
+          compilation_failed_files.each do |f|
+            log.puts f
+            puts "  - #{f}"
+          end
+        end
+
+        problem_files = failed_files + timeout_files + error_files + compilation_failed_files
 
         if problem_files.any?
           log.puts "\n#{heading("FILE CONTENTS AND DETAILS")}"
@@ -331,28 +381,43 @@ def parse!
               end
             end
 
-            next unless parse_errors[file]
+            if parse_errors[file]
+              if parse_errors[file][:stdout].strip.length.positive?
+                log.puts "\n#{heading("STANDARD OUTPUT")}"
+                log.puts "```"
+                log.puts parse_errors[file][:stdout]
+                log.puts "```"
+              end
 
-            if parse_errors[file][:stdout].strip.length.positive?
-              log.puts "\n#{heading("STANDARD OUTPUT")}"
-              log.puts "```"
-              log.puts parse_errors[file][:stdout]
-              log.puts "```"
-            end
+              if parse_errors[file][:stderr].strip.length.positive?
+                log.puts "\n#{heading("ERROR OUTPUT")}"
+                log.puts "```"
+                log.puts parse_errors[file][:stderr]
+                log.puts "```"
+              end
 
-            if parse_errors[file][:stderr].strip.length.positive?
-              log.puts "\n#{heading("ERROR OUTPUT")}"
-              log.puts "```"
-              log.puts parse_errors[file][:stderr]
-              log.puts "```"
+              if parse_errors[file][:ast]
+                log.puts "\n#{heading("AST")}"
+                log.puts "```"
+                log.puts parse_errors[file][:ast]
+                log.puts "```"
+                log.puts
+              end
             end
 
-            next unless parse_errors[file][:ast]
+            next unless compilation_errors[file]
 
-            log.puts "\n#{heading("AST")}"
+            log.puts "\n#{heading("COMPILATION ERROR")}"
             log.puts "```"
-            log.puts parse_errors[file][:ast]
+            log.puts compilation_errors[file][:error]
             log.puts "```"
+
+            if compilation_errors[file][:backtrace].any?
+              log.puts "\n#{heading("BACKTRACE")}"
+              log.puts "```"
+              log.puts compilation_errors[file][:backtrace].join("\n")
+              log.puts "```"
+            end
             log.puts
           end
         end

From 052f4a57874bdd56326d0f63b15c05c75a3e4783 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Sat, 11 Oct 2025 21:30:10 +0200
Subject: [PATCH 49/97] Linter: Support auto-fixing linter offenses using
 `--fix` (#622)

This pull request implements a new `--fix` option in the Linter CLI to
autocorrect linter offenses.

This implementation is not dependent on the Herb Formatter, since it's
relying on the `@herb-tools/printer` architecture and using the
`IdentityPrinter` class. Which means the Herb Linter can autocorrect
only the offenses without touching anything else in the document other
than fixing the offense.

<img width="3272" height="2276" alt="CleanShot 2025-10-11 at 19 12
13@2x"
src="https://github.com/user-attachments/assets/b34ce9b1-2f39-45b5-9735-31bd96231476"
/>
---
 javascript/packages/core/src/location.ts      |   4 +
 javascript/packages/core/src/position.ts      |   4 +
 javascript/packages/core/src/range.ts         |   4 +
 javascript/packages/linter/src/cli.ts         |   5 +-
 .../linter/src/cli/argument-parser.ts         |   6 +-
 .../packages/linter/src/cli/file-processor.ts |  72 ++++++-
 .../src/cli/formatters/detailed-formatter.ts  |  24 ++-
 .../src/cli/formatters/simple-formatter.ts    |  32 ++-
 .../packages/linter/src/cli/output-manager.ts |   8 +-
 .../linter/src/cli/summary-reporter.ts        |  19 +-
 javascript/packages/linter/src/linter.ts      | 134 +++++++++++-
 .../erb-require-whitespace-inside-tags.ts     | 108 ++++++++--
 .../rules/erb-requires-trailing-newline.ts    |  27 ++-
 .../src/rules/html-attribute-double-quotes.ts |  43 +++-
 .../rules/html-attribute-equals-spacing.ts    |  31 ++-
 .../html-attribute-values-require-quotes.ts   |  59 +++++-
 .../rules/html-boolean-attributes-no-value.ts |  29 ++-
 .../linter/src/rules/html-no-duplicate-ids.ts |   4 +-
 .../linter/src/rules/html-no-self-closing.ts  |  69 +++++-
 .../src/rules/html-tag-name-lowercase.ts      |  40 +++-
 .../packages/linter/src/rules/rule-utils.ts   | 198 +++++++++++++++---
 .../src/rules/svg-tag-name-capitalization.ts  |  39 +++-
 javascript/packages/linter/src/types.ts       | 116 ++++++++--
 .../test/__snapshots__/cli.test.ts.snap       |  93 ++++----
 ...ire-whitespace-inside-tags.autofix.test.ts | 142 +++++++++++++
 ...-requires-trailing-newline.autofix.test.ts |  99 +++++++++
 ...ml-attribute-double-quotes.autofix.test.ts |  76 +++++++
 ...l-attribute-equals-spacing.autofix.test.ts |  66 ++++++
 ...bute-values-require-quotes.autofix.test.ts |  66 ++++++
 ...oolean-attributes-no-value.autofix.test.ts | 121 +++++++++++
 .../html-no-self-closing.autofix.test.ts      |  98 +++++++++
 .../html-tag-name-lowercase.autofix.test.ts   | 109 ++++++++++
 ...vg-tag-name-capitalization.autofix.test.ts |  88 ++++++++
 .../erb-requires-trailing-newline.test.ts     |  24 ++-
 .../packages/linter/unformatted.html.erb      |   3 +
 35 files changed, 1874 insertions(+), 186 deletions(-)
 create mode 100644 javascript/packages/linter/test/autofix/erb-require-whitespace-inside-tags.autofix.test.ts
 create mode 100644 javascript/packages/linter/test/autofix/erb-requires-trailing-newline.autofix.test.ts
 create mode 100644 javascript/packages/linter/test/autofix/html-attribute-double-quotes.autofix.test.ts
 create mode 100644 javascript/packages/linter/test/autofix/html-attribute-equals-spacing.autofix.test.ts
 create mode 100644 javascript/packages/linter/test/autofix/html-attribute-values-require-quotes.autofix.test.ts
 create mode 100644 javascript/packages/linter/test/autofix/html-boolean-attributes-no-value.autofix.test.ts
 create mode 100644 javascript/packages/linter/test/autofix/html-no-self-closing.autofix.test.ts
 create mode 100644 javascript/packages/linter/test/autofix/html-tag-name-lowercase.autofix.test.ts
 create mode 100644 javascript/packages/linter/test/autofix/svg-tag-name-capitalization.autofix.test.ts
 create mode 100644 javascript/packages/linter/unformatted.html.erb

diff --git a/javascript/packages/core/src/location.ts b/javascript/packages/core/src/location.ts
index e059ff734..32f38eec1 100644
--- a/javascript/packages/core/src/location.ts
+++ b/javascript/packages/core/src/location.ts
@@ -17,6 +17,10 @@ export class Location {
     return new Location(start, end)
   }
 
+  static get zero() {
+    return new Location(Position.zero, Position.zero)
+  }
+
   constructor(start: Position, end: Position) {
     this.start = start
     this.end = end
diff --git a/javascript/packages/core/src/position.ts b/javascript/packages/core/src/position.ts
index 7da697594..ec4e5ac6f 100644
--- a/javascript/packages/core/src/position.ts
+++ b/javascript/packages/core/src/position.ts
@@ -11,6 +11,10 @@ export class Position {
     return new Position(position.line, position.column)
   }
 
+  static get zero() {
+    return new Position(0, 0)
+  }
+
   constructor(line: number, column: number) {
     this.line = line
     this.column = column
diff --git a/javascript/packages/core/src/range.ts b/javascript/packages/core/src/range.ts
index 34c4de2b1..8cb031f63 100644
--- a/javascript/packages/core/src/range.ts
+++ b/javascript/packages/core/src/range.ts
@@ -8,6 +8,10 @@ export class Range {
     return new Range(range[0], range[1])
   }
 
+  static get zero() {
+    return new Range(0, 0)
+  }
+
   constructor(start: number, end: number) {
     this.start = start
     this.end = end
diff --git a/javascript/packages/linter/src/cli.ts b/javascript/packages/linter/src/cli.ts
index deef30c2f..96f769332 100644
--- a/javascript/packages/linter/src/cli.ts
+++ b/javascript/packages/linter/src/cli.ts
@@ -137,7 +137,7 @@ export class CLI {
     const startTime = Date.now()
     const startDate = new Date()
 
-    let { pattern, formatOption, showTiming, theme, wrapLines, truncateLines, useGitHubActions } = this.argumentParser.parse(process.argv)
+    let { pattern, formatOption, showTiming, theme, wrapLines, truncateLines, useGitHubActions, fix } = this.argumentParser.parse(process.argv)
 
     this.determineProjectPath(pattern)
 
@@ -165,7 +165,8 @@ export class CLI {
 
       const context = {
         projectPath: this.projectPath,
-        pattern: pattern
+        pattern,
+        fix
       }
 
       const results = await this.fileProcessor.processFiles(files, formatOption, context)
diff --git a/javascript/packages/linter/src/cli/argument-parser.ts b/javascript/packages/linter/src/cli/argument-parser.ts
index 7ab2cb7fc..5f9f039a0 100644
--- a/javascript/packages/linter/src/cli/argument-parser.ts
+++ b/javascript/packages/linter/src/cli/argument-parser.ts
@@ -21,6 +21,7 @@ export interface ParsedArguments {
   wrapLines: boolean
   truncateLines: boolean
   useGitHubActions: boolean
+  fix: boolean
 }
 
 export class ArgumentParser {
@@ -35,6 +36,7 @@ export class ArgumentParser {
     Options:
       -h, --help       show help
       -v, --version    show version
+      --fix            automatically fix auto-correctable offenses
       --format         output format (simple|detailed|json) [default: detailed]
       --simple         use simple output format (shortcut for --format simple)
       --json           use JSON output format (shortcut for --format json)
@@ -53,6 +55,7 @@ export class ArgumentParser {
       options: {
         help: { type: "boolean", short: "h" },
         version: { type: "boolean", short: "v" },
+        fix: { type: "boolean" },
         format: { type: "string" },
         simple: { type: "boolean" },
         json: { type: "boolean" },
@@ -123,8 +126,9 @@ export class ArgumentParser {
 
     const theme = values.theme || DEFAULT_THEME
     const pattern = this.getFilePattern(positionals)
+    const fix = values.fix || false
 
-    return { pattern, formatOption, showTiming, theme, wrapLines, truncateLines, useGitHubActions }
+    return { pattern, formatOption, showTiming, theme, wrapLines, truncateLines, useGitHubActions, fix }
   }
 
   private getFilePattern(positionals: string[]): string {
diff --git a/javascript/packages/linter/src/cli/file-processor.ts b/javascript/packages/linter/src/cli/file-processor.ts
index 9dd3b41ce..9f39e0300 100644
--- a/javascript/packages/linter/src/cli/file-processor.ts
+++ b/javascript/packages/linter/src/cli/file-processor.ts
@@ -1,8 +1,10 @@
-import { readFileSync } from "fs"
-import { resolve } from "path"
 import { Herb } from "@herb-tools/node-wasm"
 import { Linter } from "../linter.js"
+
+import { readFileSync, writeFileSync } from "fs"
+import { resolve } from "path"
 import { colorize } from "@herb-tools/highlighter"
+
 import type { Diagnostic } from "@herb-tools/core"
 import type { FormatOption } from "./argument-parser.js"
 
@@ -10,17 +12,20 @@ export interface ProcessedFile {
   filename: string
   offense: Diagnostic
   content: string
+  autocorrectable?: boolean
 }
 
 export interface ProcessingContext {
   projectPath?: string
   pattern?: string
+  fix?: boolean
 }
 
 export interface ProcessingResult {
   totalErrors: number
   totalWarnings: number
   filesWithOffenses: number
+  filesFixed: number
   ruleCount: number
   allOffenses: ProcessedFile[]
   ruleOffenses: Map<string, { count: number, files: Set<string> }>
@@ -30,17 +35,32 @@ export interface ProcessingResult {
 export class FileProcessor {
   private linter: Linter | null = null
 
+  private isRuleAutocorrectable(ruleName: string): boolean {
+    if (!this.linter) return false
+
+    const RuleClass = (this.linter as any).rules.find((rule: any) => {
+      const instance = new rule()
+
+      return instance.name === ruleName
+    })
+
+    if (!RuleClass) return false
+
+    return RuleClass.autocorrectable === true
+  }
+
   async processFiles(files: string[], formatOption: FormatOption = 'detailed', context?: ProcessingContext): Promise<ProcessingResult> {
     let totalErrors = 0
     let totalWarnings = 0
     let filesWithOffenses = 0
+    let filesFixed = 0
     let ruleCount = 0
     const allOffenses: ProcessedFile[] = []
     const ruleOffenses = new Map<string, { count: number, files: Set<string> }>()
 
     for (const filename of files) {
       const filePath = context?.projectPath ? resolve(context.projectPath, filename) : resolve(filename)
-      const content = readFileSync(filePath, "utf-8")
+      let content = readFileSync(filePath, "utf-8")
       const parseResult = Herb.parse(content)
 
       if (parseResult.errors.length > 0) {
@@ -58,6 +78,7 @@ export class FileProcessor {
 
         totalErrors++
         filesWithOffenses++
+
         continue
       }
 
@@ -71,13 +92,52 @@ export class FileProcessor {
         ruleCount = this.linter.getRuleCount()
       }
 
-      if (lintResult.offenses.length === 0) {
+      if (context?.fix && lintResult.offenses.length > 0) {
+        const autofixResult = this.linter.autofix(content, { fileName: filename })
+
+        if (autofixResult.fixed.length > 0) {
+          writeFileSync(filePath, autofixResult.source, "utf-8")
+
+          filesFixed++
+
+          if (formatOption !== 'json') {
+            console.log(`${colorize("✓", "brightGreen")} ${colorize(filename, "cyan")} - ${colorize(`Fixed ${autofixResult.fixed.length} offense(s)`, "green")}`)
+          }
+        }
+
+        content = autofixResult.source
+
+        for (const offense of autofixResult.unfixed) {
+          allOffenses.push({
+            filename,
+            offense: offense,
+            content,
+            autocorrectable: this.isRuleAutocorrectable(offense.rule)
+          })
+
+          const ruleData = ruleOffenses.get(offense.rule) || { count: 0, files: new Set() }
+          ruleData.count++
+          ruleData.files.add(filename)
+          ruleOffenses.set(offense.rule, ruleData)
+        }
+
+        if (autofixResult.unfixed.length > 0) {
+          totalErrors += autofixResult.unfixed.filter(offense => offense.severity === "error").length
+          totalWarnings += autofixResult.unfixed.filter(offense => offense.severity === "warning").length
+          filesWithOffenses++
+        }
+      } else if (lintResult.offenses.length === 0) {
         if (files.length === 1 && formatOption !== 'json') {
           console.log(`${colorize("✓", "brightGreen")} ${colorize(filename, "cyan")} - ${colorize("No issues found", "green")}`)
         }
       } else {
         for (const offense of lintResult.offenses) {
-          allOffenses.push({ filename, offense: offense, content })
+          allOffenses.push({
+            filename,
+            offense: offense,
+            content,
+            autocorrectable: this.isRuleAutocorrectable(offense.rule)
+          })
 
           const ruleData = ruleOffenses.get(offense.rule) || { count: 0, files: new Set() }
           ruleData.count++
@@ -91,6 +151,6 @@ export class FileProcessor {
       }
     }
 
-    return { totalErrors, totalWarnings, filesWithOffenses, ruleCount, allOffenses, ruleOffenses, context }
+    return { totalErrors, totalWarnings, filesWithOffenses, filesFixed, ruleCount, allOffenses, ruleOffenses, context }
   }
 }
diff --git a/javascript/packages/linter/src/cli/formatters/detailed-formatter.ts b/javascript/packages/linter/src/cli/formatters/detailed-formatter.ts
index 4a770d323..28b0870b2 100644
--- a/javascript/packages/linter/src/cli/formatters/detailed-formatter.ts
+++ b/javascript/packages/linter/src/cli/formatters/detailed-formatter.ts
@@ -29,7 +29,15 @@ export class DetailedFormatter extends BaseFormatter {
 
     if (isSingleFile) {
       const { filename, content } = allOffenses[0]
-      const diagnostics = allOffenses.map(item => item.offense)
+      const diagnostics = allOffenses.map(item => {
+        if (item.autocorrectable && item.offense.code) {
+          return {
+            ...item.offense,
+            message: `${item.offense.message} ${colorize(colorize("[Correctable]", "green"), "bold")}`
+          }
+        }
+        return item.offense
+      })
 
       const highlighted = this.highlighter.highlight(filename, content, {
         diagnostics: diagnostics,
@@ -44,8 +52,18 @@ export class DetailedFormatter extends BaseFormatter {
       const totalMessageCount = allOffenses.length
 
       for (let i = 0; i < allOffenses.length; i++) {
-        const { filename, offense, content } = allOffenses[i]
-        const formatted = this.highlighter.highlightDiagnostic(filename, offense, content, {
+        const { filename, offense, content, autocorrectable } = allOffenses[i]
+
+        let modifiedOffense = offense
+
+        if (autocorrectable && offense.code) {
+          modifiedOffense = {
+            ...offense,
+            message: `${offense.message} ${colorize(colorize("[Correctable]", "green"), "bold")}`
+          }
+        }
+
+        const formatted = this.highlighter.highlightDiagnostic(filename, modifiedOffense, content, {
           contextLines: 2,
           wrapLines: this.wrapLines,
           truncateLines: this.truncateLines
diff --git a/javascript/packages/linter/src/cli/formatters/simple-formatter.ts b/javascript/packages/linter/src/cli/formatters/simple-formatter.ts
index 30dd38341..a88e3a0ed 100644
--- a/javascript/packages/linter/src/cli/formatters/simple-formatter.ts
+++ b/javascript/packages/linter/src/cli/formatters/simple-formatter.ts
@@ -9,17 +9,17 @@ export class SimpleFormatter extends BaseFormatter {
   async format(allOffenses: ProcessedFile[]): Promise<void> {
     if (allOffenses.length === 0) return
 
-    const groupedOffenses = new Map<string, Diagnostic[]>()
+    const groupedOffenses = new Map<string, ProcessedFile[]>()
 
-    for (const { filename, offense } of allOffenses) {
-      const offenses = groupedOffenses.get(filename) || []
-      offenses.push(offense)
-      groupedOffenses.set(filename, offenses)
+    for (const processedFile of allOffenses) {
+      const offenses = groupedOffenses.get(processedFile.filename) || []
+      offenses.push(processedFile)
+      groupedOffenses.set(processedFile.filename, offenses)
     }
 
-    for (const [filename, offenses] of groupedOffenses) {
+    for (const [filename, processedFiles] of groupedOffenses) {
       console.log("")
-      this.formatFile(filename, offenses)
+      this.formatFileProcessed(filename, processedFiles)
     }
   }
 
@@ -31,10 +31,26 @@ export class SimpleFormatter extends BaseFormatter {
       const severity = isError ? colorize("✗", "brightRed") : colorize("⚠", "brightYellow")
       const rule = colorize(`(${offense.code})`, "blue")
       const locationString = `${offense.location.start.line}:${offense.location.start.column}`
-      const paddedLocation = locationString.padEnd(4) // Pad to 4 characters for alignment
+      const paddedLocation = locationString.padEnd(4)
 
       console.log(`  ${colorize(paddedLocation, "gray")} ${severity} ${offense.message} ${rule}`)
     }
     console.log("")
   }
+
+  formatFileProcessed(filename: string, processedFiles: ProcessedFile[]): void {
+    console.log(`${colorize(filename, "cyan")}:`)
+
+    for (const { offense, autocorrectable } of processedFiles) {
+      const isError = offense.severity === "error"
+      const severity = isError ? colorize("✗", "brightRed") : colorize("⚠", "brightYellow")
+      const rule = colorize(`(${offense.code})`, "blue")
+      const locationString = `${offense.location.start.line}:${offense.location.start.column}`
+      const paddedLocation = locationString.padEnd(4)
+      const correctable = autocorrectable ? colorize(colorize(" [Correctable]", "green"), "bold") : ""
+
+      console.log(`  ${colorize(paddedLocation, "gray")} ${severity} ${offense.message} ${rule}${correctable}`)
+    }
+    console.log("")
+  }
 }
diff --git a/javascript/packages/linter/src/cli/output-manager.ts b/javascript/packages/linter/src/cli/output-manager.ts
index ae1788c1c..2c5de40c7 100644
--- a/javascript/packages/linter/src/cli/output-manager.ts
+++ b/javascript/packages/linter/src/cli/output-manager.ts
@@ -29,6 +29,8 @@ export class OutputManager {
   async outputResults(results: LintResults, options: OutputOptions): Promise<void> {
     const { allOffenses, files, totalErrors, totalWarnings, filesWithOffenses, ruleCount, ruleOffenses } = results
 
+    const autofixableCount = allOffenses.filter(offense => offense.autocorrectable).length
+
     if (options.useGitHubActions) {
       const githubFormatter = new GitHubActionsFormatter(options.wrapLines, options.truncateLines)
       await githubFormatter.formatAnnotations(allOffenses)
@@ -50,7 +52,8 @@ export class OutputManager {
           startTime: options.startTime,
           startDate: options.startDate,
           showTiming: options.showTiming,
-          ruleOffenses
+          ruleOffenses,
+          autofixableCount,
         })
       }
     } else if (options.formatOption === "json") {
@@ -101,7 +104,8 @@ export class OutputManager {
         startTime: options.startTime,
         startDate: options.startDate,
         showTiming: options.showTiming,
-        ruleOffenses
+        ruleOffenses,
+        autofixableCount,
       })
     }
   }
diff --git a/javascript/packages/linter/src/cli/summary-reporter.ts b/javascript/packages/linter/src/cli/summary-reporter.ts
index ba1b08983..17712b939 100644
--- a/javascript/packages/linter/src/cli/summary-reporter.ts
+++ b/javascript/packages/linter/src/cli/summary-reporter.ts
@@ -10,6 +10,7 @@ export interface SummaryData {
   startDate: Date
   showTiming: boolean
   ruleOffenses: Map<string, { count: number, files: Set<string> }>
+  autofixableCount: number
 }
 
 export class SummaryReporter {
@@ -18,7 +19,7 @@ export class SummaryReporter {
   }
 
   displaySummary(data: SummaryData): void {
-    const { files, totalErrors, totalWarnings, filesWithOffenses, ruleCount, startTime, startDate, showTiming } = data
+    const { files, totalErrors, totalWarnings, filesWithOffenses, ruleCount, startTime, startDate, showTiming, autofixableCount } = data
 
     console.log("\n")
     console.log(` ${colorize("Summary:", "bold")}`)
@@ -75,11 +76,25 @@ export class SummaryReporter {
         detailText = `${totalOffenses} ${this.pluralize(totalOffenses, "offense")} across ${filesWithOffenses} ${this.pluralize(filesWithOffenses, "file")}`
       }
 
-      offensesSummary += ` ${colorize(colorize(`(${detailText})`, "gray"), "dim")}`
+      if (detailText) {
+        offensesSummary += ` ${colorize(colorize(`(${detailText})`, "gray"), "dim")}`
+      }
     }
 
     console.log(`  ${colorize(pad("Offenses"), "gray")} ${offensesSummary}`)
 
+    if (autofixableCount > 0 || (totalErrors + totalWarnings) > 0) {
+      const totalOffenses = totalErrors + totalWarnings
+
+      let fixableLine = `${colorize(colorize(`${totalOffenses} ${this.pluralize(totalOffenses, "offense")}`, "brightRed"), "bold")}`
+
+      if (autofixableCount > 0) {
+        fixableLine += ` | ${colorize(colorize(`${autofixableCount} autocorrectable using \`--fix\``, "green"), "bold")}`
+      }
+
+      console.log(`  ${colorize(pad("Fixable"), "gray")} ${fixableLine}`)
+    }
+
     if (showTiming) {
       const duration = Date.now() - startTime
       const timeString = startDate.toTimeString().split(' ')[0]
diff --git a/javascript/packages/linter/src/linter.ts b/javascript/packages/linter/src/linter.ts
index 4e0452b3a..5b7926a19 100644
--- a/javascript/packages/linter/src/linter.ts
+++ b/javascript/packages/linter/src/linter.ts
@@ -1,6 +1,8 @@
 import { defaultRules } from "./default-rules.js"
+import { IdentityPrinter } from "@herb-tools/printer"
+import { findNodeByLocation } from "./rules/rule-utils.js"
 
-import type { RuleClass, Rule, ParserRule, LexerRule, SourceRule, LintResult, LintOffense, LintContext } from "./types.js"
+import type { RuleClass, Rule, ParserRule, LexerRule, SourceRule, LintResult, LintOffense, LintContext, AutofixResult } from "./types.js"
 import type { HerbBackend } from "@herb-tools/core"
 
 export class Linter {
@@ -114,4 +116,134 @@ export class Linter {
       warnings
     }
   }
+
+  /**
+   * Automatically fix offenses in the source code.
+   * Uses AST mutation for parser rules and token mutation for lexer rules.
+   * @param source - The source code to fix
+   * @param context - Optional context for linting (e.g., fileName)
+   * @param offensesToFix - Optional array of specific offenses to fix. If not provided, all fixable offenses will be fixed.
+   * @returns AutofixResult containing the corrected source and lists of fixed/unfixed offenses
+   */
+  autofix(source: string, context?: Partial<LintContext>, offensesToFix?: LintOffense[]): AutofixResult {
+    const lintResult = offensesToFix ? { offenses: offensesToFix } : this.lint(source, context)
+
+    const parserOffenses: LintOffense[] = []
+    const lexerOffenses: LintOffense[] = []
+    const sourceOffenses: LintOffense[] = []
+
+    for (const offense of lintResult.offenses) {
+      const RuleClass = this.rules.find(rule => {
+        const instance = new rule()
+        return instance.name === offense.rule
+      })
+
+      if (!RuleClass) continue
+
+      if ((RuleClass as any).type === "lexer") {
+        lexerOffenses.push(offense)
+      } else if ((RuleClass as any).type === "source") {
+        sourceOffenses.push(offense)
+      } else {
+        parserOffenses.push(offense)
+      }
+    }
+
+    let currentSource = source
+    const fixed: LintOffense[] = []
+    const unfixed: LintOffense[] = []
+
+    if (parserOffenses.length > 0) {
+      const parseResult = this.herb.parse(currentSource, { track_whitespace: true })
+
+      for (const offense of parserOffenses) {
+        const RuleClass = this.rules.find(rule => new rule().name === offense.rule)
+
+        if (!RuleClass) {
+          unfixed.push(offense)
+
+          continue
+        }
+
+        const rule = new RuleClass() as ParserRule
+
+        if (!rule.autofix) {
+          unfixed.push(offense)
+
+          continue
+        }
+
+        if (offense.autofixContext) {
+          const originalNodeType = offense.autofixContext.node.type
+
+          const freshNode = findNodeByLocation(
+            parseResult.value,
+            offense.location,
+            (node) => node.type === originalNodeType
+          )
+          if (freshNode) {
+            offense.autofixContext.node = freshNode
+          } else {
+            unfixed.push(offense)
+
+            continue
+          }
+        }
+
+        const fixedResult = rule.autofix(offense, parseResult, context)
+
+        if (fixedResult) {
+          fixed.push(offense)
+        } else {
+          unfixed.push(offense)
+        }
+      }
+
+      if (fixed.length > 0) {
+        const printer = new IdentityPrinter()
+        currentSource = printer.print(parseResult.value)
+      }
+    }
+
+    if (sourceOffenses.length > 0) {
+      const sortedSourceOffenses = sourceOffenses.sort((a, b) => {
+        if (a.location.start.line !== b.location.start.line) {
+          return b.location.start.line - a.location.start.line
+        }
+
+        return b.location.start.column - a.location.start.column
+      })
+
+      for (const offense of sortedSourceOffenses) {
+        const RuleClass = this.rules.find(rule => new rule().name === offense.rule)
+
+        if (!RuleClass) {
+          unfixed.push(offense)
+          continue
+        }
+
+        const rule = new RuleClass() as SourceRule
+
+        if (!rule.autofix) {
+          unfixed.push(offense)
+          continue
+        }
+
+        const correctedSource = rule.autofix(offense, currentSource, context)
+
+        if (correctedSource) {
+          currentSource = correctedSource
+          fixed.push(offense)
+        } else {
+          unfixed.push(offense)
+        }
+      }
+    }
+
+    return {
+      source: currentSource,
+      fixed,
+      unfixed
+    }
+  }
 }
diff --git a/javascript/packages/linter/src/rules/erb-require-whitespace-inside-tags.ts b/javascript/packages/linter/src/rules/erb-require-whitespace-inside-tags.ts
index 05021794f..1c8fb84d8 100644
--- a/javascript/packages/linter/src/rules/erb-require-whitespace-inside-tags.ts
+++ b/javascript/packages/linter/src/rules/erb-require-whitespace-inside-tags.ts
@@ -1,10 +1,18 @@
-import { ParserRule } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { BaseRuleVisitor } from "./rule-utils.js"
 
-import type { LintOffense, LintContext } from "../types.js"
 import type { ParseResult, Token, ERBNode } from "@herb-tools/core"
+import type { LintOffense, LintContext } from "../types.js"
+
+interface ERBRequireWhitespaceAutofixContext extends BaseAutofixContext {
+  node: Mutable<ERBNode>
+  openTag: Token
+  closeTag: Token
+  content: string
+  fixType: "after-open" | "before-close" | "after-comment-equals"
+}
 
-class RequireWhitespaceInsideTags extends BaseRuleVisitor {
+class RequireWhitespaceInsideTags extends BaseRuleVisitor<ERBRequireWhitespaceAutofixContext> {
 
   visitERBNode(node: ERBNode): void {
     const openTag = node.tag_opening
@@ -18,25 +26,39 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
     const value = content.value
 
     if (openTag.value === "<%#") {
-      this.checkCommentTagWhitespace(openTag, closeTag, value)
+      this.checkCommentTagWhitespace(node, openTag, closeTag, value)
     } else {
-      this.checkOpenTagWhitespace(openTag, value)
-      this.checkCloseTagWhitespace(closeTag, value)
+      this.checkOpenTagWhitespace(node, openTag, closeTag, value)
+      this.checkCloseTagWhitespace(node, openTag, closeTag, value)
     }
   }
 
-  private checkCommentTagWhitespace(openTag: Token, closeTag: Token, content: string): void {
+  private checkCommentTagWhitespace(node: ERBNode, openTag: Token, closeTag: Token, content: string): void {
     if (!content.startsWith(" ") && !content.startsWith("\n") && !content.startsWith("=")) {
       this.addOffense(
         `Add whitespace after \`${openTag.value}\`.`,
         openTag.location,
-        "error"
+        "error",
+        {
+          node,
+          openTag,
+          closeTag,
+          content,
+          fixType: "after-open"
+        }
       )
     } else if (content.startsWith("=") && content.length > 1 && !content[1].match(/\s/)) {
       this.addOffense(
         `Add whitespace after \`<%#=\`.`,
         openTag.location,
-        "error"
+        "error",
+        {
+          node,
+          openTag,
+          closeTag,
+          content,
+          fixType: "after-comment-equals"
+        }
       )
     }
 
@@ -44,12 +66,19 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
       this.addOffense(
         `Add whitespace before \`${closeTag.value}\`.`,
         closeTag.location,
-        "error"
+        "error",
+        {
+          node,
+          openTag,
+          closeTag,
+          content,
+          fixType: "before-close"
+        }
       )
     }
   }
 
-  private checkOpenTagWhitespace(openTag: Token, content:string):void {
+  private checkOpenTagWhitespace(node: ERBNode, openTag: Token, closeTag: Token, content: string):void {
     if (content.startsWith(" ") || content.startsWith("\n")) {
       return
     }
@@ -57,11 +86,18 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
     this.addOffense(
       `Add whitespace after \`${openTag.value}\`.`,
       openTag.location,
-      "error"
+      "error",
+      {
+        node,
+        openTag,
+        closeTag,
+        content,
+        fixType: "after-open"
+      }
     )
   }
 
-  private checkCloseTagWhitespace(closeTag: Token, content:string):void {
+  private checkCloseTagWhitespace(node: ERBNode, openTag: Token, closeTag: Token, content: string):void {
     if (content.endsWith(" ") || content.endsWith("\n")) {
       return
     }
@@ -69,17 +105,57 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
     this.addOffense(
       `Add whitespace before \`${closeTag.value}\`.`,
       closeTag.location,
-      "error"
+      "error",
+      {
+        node,
+        openTag,
+        closeTag,
+        content,
+        fixType: "before-close"
+      }
     )
   }
 }
 
-export class ERBRequireWhitespaceRule extends ParserRule {
+export class ERBRequireWhitespaceRule extends ParserRule<ERBRequireWhitespaceAutofixContext> {
+  static autocorrectable = true
   name = "erb-require-whitespace-inside-tags"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<ERBRequireWhitespaceAutofixContext>[] {
     const visitor = new RequireWhitespaceInsideTags(this.name, context)
+
     visitor.visit(result.value)
+
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<ERBRequireWhitespaceAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node, fixType } = offense.autofixContext
+
+    if (!node.content) return null
+
+    const content = node.content.value
+
+    if (fixType === "before-close") {
+      node.content.value = content + " "
+
+      return result
+    }
+
+    if (fixType === "after-open") {
+      node.content.value = " " + content
+
+      return result
+    }
+
+    if (fixType === "after-comment-equals" && content.startsWith("=")) {
+      node.content.value = "= " + content.substring(1)
+
+      return result
+    }
+
+    return null
+  }
 }
diff --git a/javascript/packages/linter/src/rules/erb-requires-trailing-newline.ts b/javascript/packages/linter/src/rules/erb-requires-trailing-newline.ts
index aadb3fd72..c13f8e9e7 100644
--- a/javascript/packages/linter/src/rules/erb-requires-trailing-newline.ts
+++ b/javascript/packages/linter/src/rules/erb-requires-trailing-newline.ts
@@ -1,22 +1,31 @@
-import { BaseSourceRuleVisitor, createEndOfFileLocation } from "./rule-utils.js"
 import { SourceRule } from "../types.js"
+import { BaseSourceRuleVisitor, createEndOfFileLocation } from "./rule-utils.js"
+
 import type { LintOffense, LintContext } from "../types.js"
 
 class ERBRequiresTrailingNewlineVisitor extends BaseSourceRuleVisitor {
   protected visitSource(source: string): void {
     if (source.length === 0) return
-    if (source.endsWith('\n')) return
     if (!this.context.fileName) return
 
-    this.addOffense(
-      "File must end with trailing newline",
-      createEndOfFileLocation(source),
-      "error"
-    )
+    if (!source.endsWith('\n')) {
+      this.addOffense(
+        "File must end with trailing newline.",
+        createEndOfFileLocation(source),
+        "error"
+      )
+    } else if (source.endsWith('\n\n')) {
+      this.addOffense(
+        "File must end with exactly one trailing newline.",
+        createEndOfFileLocation(source),
+        "error"
+      )
+    }
   }
 }
 
 export class ERBRequiresTrailingNewlineRule extends SourceRule {
+  static autocorrectable = true
   name = "erb-requires-trailing-newline"
 
   check(source: string, context?: Partial<LintContext>): LintOffense[] {
@@ -26,4 +35,8 @@ export class ERBRequiresTrailingNewlineRule extends SourceRule {
 
     return visitor.offenses
   }
+
+  autofix(_offense: LintOffense, source: string, _context?: Partial<LintContext>): string | null {
+    return source.trimEnd() + "\n"
+  }
 }
diff --git a/javascript/packages/linter/src/rules/html-attribute-double-quotes.ts b/javascript/packages/linter/src/rules/html-attribute-double-quotes.ts
index c53743858..be2ee6f78 100644
--- a/javascript/packages/linter/src/rules/html-attribute-double-quotes.ts
+++ b/javascript/packages/linter/src/rules/html-attribute-double-quotes.ts
@@ -1,11 +1,16 @@
-import { ParserRule } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams, getAttributeValueQuoteType, hasAttributeValue } from "./rule-utils.js"
 import { filterLiteralNodes } from "@herb-tools/core"
 
 import type { LintOffense, LintContext } from "../types.js"
-import type { ParseResult } from "@herb-tools/core"
+import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
-class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
+interface AttributeDoubleQuotesAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLAttributeNode>
+  valueContent: string
+}
+
+class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin<AttributeDoubleQuotesAutofixContext> {
   protected checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }: StaticAttributeStaticValueParams) {
     if (!hasAttributeValue(attributeNode)) return
     if (getAttributeValueQuoteType(attributeNode) !== "single") return
@@ -14,7 +19,11 @@ class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
     this.addOffense(
       `Attribute \`${attributeName}\` uses single quotes. Prefer double quotes for HTML attribute values: \`${attributeName}="${attributeValue}"\`.`,
       attributeNode.value!.location,
-      "warning"
+      "warning",
+      {
+        node: attributeNode,
+        valueContent: attributeValue
+      }
     )
   }
 
@@ -26,19 +35,39 @@ class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
     this.addOffense(
       `Attribute \`${attributeName}\` uses single quotes. Prefer double quotes for HTML attribute values: \`${attributeName}="${combinedValue}"\`.`,
       attributeNode.value!.location,
-      "warning"
+      "warning",
+      {
+        node: attributeNode,
+        valueContent: combinedValue || ""
+      }
     )
   }
 }
 
-export class HTMLAttributeDoubleQuotesRule extends ParserRule {
+export class HTMLAttributeDoubleQuotesRule extends ParserRule<AttributeDoubleQuotesAutofixContext> {
+  static autocorrectable = true
   name = "html-attribute-double-quotes"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<AttributeDoubleQuotesAutofixContext>[] {
     const visitor = new AttributeDoubleQuotesVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<AttributeDoubleQuotesAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node: { value } } = offense.autofixContext
+
+    if (!value) return null
+    if (!value.open_quote) return  null
+    if (!value.close_quote) return  null
+
+    value.open_quote.value = '"'
+    value.close_quote.value = '"'
+
+    return result
+  }
 }
diff --git a/javascript/packages/linter/src/rules/html-attribute-equals-spacing.ts b/javascript/packages/linter/src/rules/html-attribute-equals-spacing.ts
index 223bf8c96..03bfc50c0 100644
--- a/javascript/packages/linter/src/rules/html-attribute-equals-spacing.ts
+++ b/javascript/packages/linter/src/rules/html-attribute-equals-spacing.ts
@@ -1,10 +1,14 @@
 import { BaseRuleVisitor } from "./rule-utils.js"
-import { ParserRule } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 
 import type { LintOffense, LintContext } from "../types.js"
 import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
-class HTMLAttributeEqualsSpacingVisitor extends BaseRuleVisitor {
+interface AttributeEqualsSpacingAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLAttributeNode>
+}
+
+class HTMLAttributeEqualsSpacingVisitor extends BaseRuleVisitor<AttributeEqualsSpacingAutofixContext> {
   visitHTMLAttributeNode(attribute: HTMLAttributeNode): void {
     if (!attribute.equals || !attribute.name || !attribute.value) {
       return
@@ -14,7 +18,8 @@ class HTMLAttributeEqualsSpacingVisitor extends BaseRuleVisitor {
       this.addOffense(
         "Remove whitespace before `=` in HTML attribute",
         attribute.equals.location,
-        "error"
+        "error",
+        { node: attribute }
       )
     }
 
@@ -22,20 +27,34 @@ class HTMLAttributeEqualsSpacingVisitor extends BaseRuleVisitor {
       this.addOffense(
         "Remove whitespace after `=` in HTML attribute",
         attribute.equals.location,
-        "error"
+        "error",
+        { node: attribute }
       )
     }
   }
 }
 
-export class HTMLAttributeEqualsSpacingRule extends ParserRule {
+export class HTMLAttributeEqualsSpacingRule extends ParserRule<AttributeEqualsSpacingAutofixContext> {
+  static autocorrectable = true
   name = "html-attribute-equals-spacing"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<AttributeEqualsSpacingAutofixContext>[] {
     const visitor = new HTMLAttributeEqualsSpacingVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<AttributeEqualsSpacingAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node: { equals } } = offense.autofixContext
+
+    if (!equals) return null
+
+    equals.value = "="
+
+    return result
+  }
 }
diff --git a/javascript/packages/linter/src/rules/html-attribute-values-require-quotes.ts b/javascript/packages/linter/src/rules/html-attribute-values-require-quotes.ts
index a0e6c069e..70024f056 100644
--- a/javascript/packages/linter/src/rules/html-attribute-values-require-quotes.ts
+++ b/javascript/packages/linter/src/rules/html-attribute-values-require-quotes.ts
@@ -1,10 +1,16 @@
-import { ParserRule } from "../types.js"
+import { Token, Location } from "@herb-tools/core"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams } from "./rule-utils.js"
 
 import type { LintOffense, LintContext } from "../types.js"
-import type { HTMLAttributeNode, HTMLAttributeValueNode, ParseResult } from "@herb-tools/core"
+import type { HTMLAttributeNode, ParseResult,  } from "@herb-tools/core"
 
-class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
+interface AttributeValuesRequireQuotesAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLAttributeNode>
+  unquotedValue: string
+}
+
+class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin<AttributeValuesRequireQuotesAutofixContext> {
   protected checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }: StaticAttributeStaticValueParams): void {
     if (this.hasAttributeValue(attributeNode)) return
     if (this.isQuoted(attributeNode)) return
@@ -12,7 +18,11 @@ class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
     this.addOffense(
       `Attribute value should be quoted: \`${attributeName}="${attributeValue}"\`. Always wrap attribute values in quotes.`,
       attributeNode.value!.location,
-      "error"
+      "error",
+      {
+        node: attributeNode,
+        unquotedValue: attributeValue
+      }
     )
   }
 
@@ -23,7 +33,11 @@ class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
     this.addOffense(
       `Attribute value should be quoted: \`${attributeName}="${combinedValue}"\`. Always wrap attribute values in quotes.`,
       attributeNode.value!.location,
-      "error"
+      "error",
+      {
+        node: attributeNode,
+        unquotedValue: combinedValue || ""
+      }
     )
   }
 
@@ -32,20 +46,47 @@ class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
   }
 
   private isQuoted(attributeNode: HTMLAttributeNode): boolean {
-    const valueNode = attributeNode.value as HTMLAttributeValueNode
+    const valueNode = attributeNode.value
 
-    return valueNode.quoted
+    return valueNode ? valueNode.quoted : false
   }
 }
 
-export class HTMLAttributeValuesRequireQuotesRule extends ParserRule {
+export class HTMLAttributeValuesRequireQuotesRule extends ParserRule<AttributeValuesRequireQuotesAutofixContext> {
+  static autocorrectable = true
   name = "html-attribute-values-require-quotes"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<AttributeValuesRequireQuotesAutofixContext>[] {
     const visitor = new AttributeValuesRequireQuotesVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<AttributeValuesRequireQuotesAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node: { value } } = offense.autofixContext
+
+    if (!value) return null
+
+    const quote = Token.from({ type: "TOKEN_QUOTE", value: '"', location: Location.zero, range: [0, 0] })
+
+    if (value.open_quote) {
+      value.open_quote.value = '"'
+    } else {
+      value.open_quote = quote
+    }
+
+    if (value.close_quote) {
+      value.close_quote.value = '"'
+    } else {
+      value.close_quote = quote
+    }
+
+    value.quoted = true
+
+    return result
+  }
 }
diff --git a/javascript/packages/linter/src/rules/html-boolean-attributes-no-value.ts b/javascript/packages/linter/src/rules/html-boolean-attributes-no-value.ts
index 370872ac8..29d5466eb 100644
--- a/javascript/packages/linter/src/rules/html-boolean-attributes-no-value.ts
+++ b/javascript/packages/linter/src/rules/html-boolean-attributes-no-value.ts
@@ -1,11 +1,15 @@
-import { ParserRule } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams, isBooleanAttribute, hasAttributeValue } from "./rule-utils.js"
 import { IdentityPrinter } from "@herb-tools/printer"
 
 import type { LintOffense, LintContext } from "../types.js"
 import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
-class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
+interface BooleanAttributeAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLAttributeNode>
+}
+
+class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin<BooleanAttributeAutofixContext> {
   protected checkStaticAttributeStaticValue({ originalAttributeName, attributeNode }: StaticAttributeStaticValueParams) {
     this.checkAttribute(originalAttributeName, attributeNode)
   }
@@ -21,19 +25,34 @@ class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
     this.addOffense(
       `Boolean attribute \`${IdentityPrinter.print(attributeNode.name)}\` should not have a value. Use \`${attributeName.toLowerCase()}\` instead of \`${IdentityPrinter.print(attributeNode)}\`.`,
       attributeNode.value!.location,
-      "error"
+      "error",
+      {
+        node: attributeNode
+      }
     )
   }
 }
 
-export class HTMLBooleanAttributesNoValueRule extends ParserRule {
+export class HTMLBooleanAttributesNoValueRule extends ParserRule<BooleanAttributeAutofixContext> {
+  static autocorrectable = true
   name = "html-boolean-attributes-no-value"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<BooleanAttributeAutofixContext>[] {
     const visitor = new BooleanAttributesNoValueVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<BooleanAttributeAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node } = offense.autofixContext
+
+    node.equals = null
+    node.value = null
+
+    return result
+  }
 }
diff --git a/javascript/packages/linter/src/rules/html-no-duplicate-ids.ts b/javascript/packages/linter/src/rules/html-no-duplicate-ids.ts
index 2741ec641..a56bafcfe 100644
--- a/javascript/packages/linter/src/rules/html-no-duplicate-ids.ts
+++ b/javascript/packages/linter/src/rules/html-no-duplicate-ids.ts
@@ -1,4 +1,4 @@
-import { ParserRule } from "../types"
+import { ParserRule, BaseAutofixContext } from "../types"
 import { ControlFlowTrackingVisitor, ControlFlowType } from "./rule-utils"
 import { LiteralNode } from "@herb-tools/core"
 import { Printer, IdentityPrinter } from "@herb-tools/printer"
@@ -29,7 +29,7 @@ class OutputPrinter extends Printer {
   }
 }
 
-class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor<ControlFlowState, BranchState> {
+class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor<BaseAutofixContext, ControlFlowState, BranchState> {
   private documentIds: Set<string> = new Set<string>()
   private currentBranchIds: Set<string> = new Set<string>()
   private controlFlowIds: Set<string> = new Set<string>()
diff --git a/javascript/packages/linter/src/rules/html-no-self-closing.ts b/javascript/packages/linter/src/rules/html-no-self-closing.ts
index 410f4d6d0..05168d901 100644
--- a/javascript/packages/linter/src/rules/html-no-self-closing.ts
+++ b/javascript/packages/linter/src/rules/html-no-self-closing.ts
@@ -1,11 +1,17 @@
-import { ParserRule } from "../types.js"
-import { BaseRuleVisitor, isVoidElement } from "./rule-utils.js"
-import { getTagName } from "@herb-tools/core"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
+import { isVoidElement, findParent, BaseRuleVisitor } from "./rule-utils.js"
+import { getTagName, isWhitespaceNode, Location, HTMLCloseTagNode } from "@herb-tools/core"
 
 import type { LintContext, LintOffense } from "../types.js"
-import type { HTMLOpenTagNode, HTMLElementNode, ParseResult } from "@herb-tools/core"
+import type { Node, HTMLOpenTagNode, HTMLElementNode, SerializedToken, ParseResult } from "@herb-tools/core"
 
-class NoSelfClosingVisitor extends BaseRuleVisitor {
+interface NoSelfClosingAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLOpenTagNode>
+  tagName: string
+  isVoid: boolean
+}
+
+class NoSelfClosingVisitor extends BaseRuleVisitor<NoSelfClosingAutofixContext> {
   visitHTMLElementNode(node: HTMLElementNode): void {
     if (getTagName(node) === "svg") {
       this.visit(node.open_tag)
@@ -22,20 +28,67 @@ class NoSelfClosingVisitor extends BaseRuleVisitor {
       this.addOffense(
         `Use \`${instead}\` instead of self-closing \`<${tagName} />\` for HTML compatibility.`,
         node.location,
-        "error"
+        "error",
+        {
+          node,
+          tagName,
+          isVoid: isVoidElement(tagName)
+        }
       )
     }
   }
 }
 
-export class HTMLNoSelfClosingRule extends ParserRule {
+export class HTMLNoSelfClosingRule extends ParserRule<NoSelfClosingAutofixContext> {
+  static autocorrectable = true
   name = "html-no-self-closing"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<NoSelfClosingAutofixContext>[] {
     const visitor = new NoSelfClosingVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<NoSelfClosingAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node, tagName, isVoid } = offense.autofixContext
+    const { tag_closing } = node
+
+    if (!tag_closing) return null
+
+    tag_closing.value = ">"
+
+    if (node.children && Array.isArray(node.children)) {
+      const children = node.children as Node[]
+
+      if (children.length > 0 && isWhitespaceNode(children[children.length - 1])) {
+        node.children = children.slice(0, -1)
+      }
+    }
+
+    if (!isVoid) {
+      const parent = findParent(result.value, node as any as Node) as Mutable<HTMLElementNode> | null
+
+      if (parent && parent.type === "AST_HTML_ELEMENT_NODE") {
+        const tag_opening: SerializedToken = { type: "TOKEN_HTML_TAG_START_CLOSE", value: "</", location: Location.zero, range: [0, 0] }
+        const tag_name: SerializedToken = { type: "TOKEN_IDENTIFIER", value: tagName, location: Location.zero, range: [0, 0] }
+        const tag_closing: SerializedToken = { type: "TOKEN_HTML_TAG_END", value: ">", location: Location.zero, range: [0, 0] }
+
+        parent.close_tag = HTMLCloseTagNode.from({
+          type: "AST_HTML_CLOSE_TAG_NODE",
+          tag_opening,
+          tag_name,
+          tag_closing,
+          children: [],
+          errors: [],
+          location: Location.zero,
+        })
+      }
+    }
+
+    return result
+  }
 }
diff --git a/javascript/packages/linter/src/rules/html-tag-name-lowercase.ts b/javascript/packages/linter/src/rules/html-tag-name-lowercase.ts
index a939967a7..29d0bc402 100644
--- a/javascript/packages/linter/src/rules/html-tag-name-lowercase.ts
+++ b/javascript/packages/linter/src/rules/html-tag-name-lowercase.ts
@@ -1,9 +1,15 @@
-import { ParserRule } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { BaseRuleVisitor } from "./rule-utils.js"
-
-import { isNode, getTagName, HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, ParseResult, XMLDeclarationNode, Node } from "@herb-tools/core"
+import { isNode, getTagName, HTMLOpenTagNode } from "@herb-tools/core"
 
 import type { LintOffense, LintContext } from "../types.js"
+import type { HTMLElementNode, HTMLCloseTagNode, ParseResult, XMLDeclarationNode, Node } from "@herb-tools/core"
+
+interface TagNameAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLOpenTagNode | HTMLCloseTagNode>
+  tagName: string
+  correctedTagName: string
+}
 
 class XMLDeclarationChecker extends BaseRuleVisitor {
   hasXMLDeclaration: boolean = false
@@ -18,7 +24,7 @@ class XMLDeclarationChecker extends BaseRuleVisitor {
   }
 }
 
-class TagNameLowercaseVisitor extends BaseRuleVisitor {
+class TagNameLowercaseVisitor extends BaseRuleVisitor<TagNameAutofixContext> {
   visitHTMLElementNode(node: HTMLElementNode): void {
     if (getTagName(node).toLowerCase() === "svg") {
       this.checkTagName(node.open_tag)
@@ -52,13 +58,19 @@ class TagNameLowercaseVisitor extends BaseRuleVisitor {
       this.addOffense(
         `${type} tag name \`${open}${tagName}>\` should be lowercase. Use \`${open}${lowercaseTagName}>\` instead.`,
         node.tag_name!.location,
-        "error"
+        "error",
+        {
+          node,
+          tagName,
+          correctedTagName: lowercaseTagName
+        }
       )
     }
   }
 }
 
-export class HTMLTagNameLowercaseRule extends ParserRule {
+export class HTMLTagNameLowercaseRule extends ParserRule<TagNameAutofixContext> {
+  static autocorrectable = true
   name = "html-tag-name-lowercase"
 
   isEnabled(result: ParseResult, context?: Partial<LintContext>): boolean {
@@ -71,9 +83,23 @@ export class HTMLTagNameLowercaseRule extends ParserRule {
     return !checker.hasXMLDeclaration
   }
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<TagNameAutofixContext>[] {
     const visitor = new TagNameLowercaseVisitor(this.name, context)
+
     visitor.visit(result.value)
+
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<TagNameAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node: { tag_name }, correctedTagName } = offense.autofixContext
+
+    if (!tag_name) return null
+
+    tag_name.value = correctedTagName
+
+    return result
+  }
 }
diff --git a/javascript/packages/linter/src/rules/rule-utils.ts b/javascript/packages/linter/src/rules/rule-utils.ts
index ae29bc634..c498b4206 100644
--- a/javascript/packages/linter/src/rules/rule-utils.ts
+++ b/javascript/packages/linter/src/rules/rule-utils.ts
@@ -27,7 +27,7 @@ import type {
 import { DEFAULT_LINT_CONTEXT } from "../types.js"
 
 import type * as Nodes from "@herb-tools/core"
-import type { LintOffense, LintSeverity, LintContext } from "../types.js"
+import type { LintOffense, LintSeverity, LintContext, BaseAutofixContext } from "../types.js"
 
 export enum ControlFlowType {
   CONDITIONAL,
@@ -37,8 +37,8 @@ export enum ControlFlowType {
 /**
  * Base visitor class that provides common functionality for rule visitors
  */
-export abstract class BaseRuleVisitor extends Visitor {
-  public readonly offenses: LintOffense[] = []
+export abstract class BaseRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> extends Visitor {
+  public readonly offenses: LintOffense<TAutofixContext>[] = []
   protected ruleName: string
   protected context: LintContext
 
@@ -52,7 +52,7 @@ export abstract class BaseRuleVisitor extends Visitor {
   /**
    * Helper method to create a lint offense
    */
-  protected createOffense(message: string, location: Location, severity: LintSeverity = "error"): LintOffense {
+  protected createOffense(message: string, location: Location, severity: LintSeverity = "error", autofixContext?: TAutofixContext): LintOffense<TAutofixContext> {
     return {
       rule: this.ruleName,
       code: this.ruleName,
@@ -60,14 +60,15 @@ export abstract class BaseRuleVisitor extends Visitor {
       message,
       location,
       severity,
+      autofixContext,
     }
   }
 
   /**
    * Helper method to add an offense to the offenses array
    */
-  protected addOffense(message: string, location: Location, severity: LintSeverity = "error"): void {
-    this.offenses.push(this.createOffense(message, location, severity))
+  protected addOffense(message: string, location: Location, severity: LintSeverity = "error", autofixContext?: TAutofixContext): void {
+    this.offenses.push(this.createOffense(message, location, severity, autofixContext))
   }
 }
 
@@ -76,10 +77,11 @@ export abstract class BaseRuleVisitor extends Visitor {
  * This allows rules to track state across different control flow structures
  * like if/else branches, loops, etc.
  *
+ * @template TAutofixContext - Type for autofix context (node + custom data)
  * @template TControlFlowState - Type for state passed between onEnterControlFlow and onExitControlFlow
  * @template TBranchState - Type for state passed between onEnterBranch and onExitBranch
  */
-export abstract class ControlFlowTrackingVisitor<TControlFlowState = any, TBranchState = any> extends BaseRuleVisitor {
+export abstract class ControlFlowTrackingVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext, TControlFlowState = any, TBranchState = any> extends BaseRuleVisitor<TAutofixContext> {
   protected isInControlFlow: boolean = false
   protected currentControlFlowType: ControlFlowType | null = null
 
@@ -621,7 +623,7 @@ export function isBooleanAttribute(attributeName: string): boolean {
  * - checkDynamicAttributeStaticValue()  - name="data-<%= key %>" value="foo"
  * - checkDynamicAttributeDynamicValue() - name="data-<%= key %>" value="<%= value %>"
  */
-export abstract class AttributeVisitorMixin extends BaseRuleVisitor {
+export abstract class AttributeVisitorMixin<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> extends BaseRuleVisitor<TAutofixContext> {
   constructor(ruleName: string, context?: Partial<LintContext>) {
     super(ruleName, context)
   }
@@ -735,8 +737,8 @@ export function forEachAttribute(
 /**
  * Base lexer visitor class that provides common functionality for lexer-based rule visitors
  */
-export abstract class BaseLexerRuleVisitor {
-  public readonly offenses: LintOffense[] = []
+export abstract class BaseLexerRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+  public readonly offenses: LintOffense<TAutofixContext>[] = []
   protected ruleName: string
   protected context: LintContext
 
@@ -748,7 +750,7 @@ export abstract class BaseLexerRuleVisitor {
   /**
    * Helper method to create a lint offense for lexer rules
    */
-  protected createOffense(message: string, location: Location, severity: LintSeverity = "error"): LintOffense {
+  protected createOffense(message: string, location: Location, severity: LintSeverity = "error", autofixContext?: TAutofixContext): LintOffense<TAutofixContext> {
     return {
       rule: this.ruleName,
       code: this.ruleName,
@@ -756,14 +758,15 @@ export abstract class BaseLexerRuleVisitor {
       message,
       location,
       severity,
+      autofixContext,
     }
   }
 
   /**
    * Helper method to add an offense to the offenses array
    */
-  protected addOffense(message: string, location: Location, severity: LintSeverity = "error"): void {
-    this.offenses.push(this.createOffense(message, location, severity))
+  protected addOffense(message: string, location: Location, severity: LintSeverity = "error", autofixContext?: TAutofixContext): void {
+    this.offenses.push(this.createOffense(message, location, severity, autofixContext))
   }
 
   /**
@@ -791,14 +794,13 @@ export abstract class BaseLexerRuleVisitor {
   protected visitToken(_token: Token): void {
     // Default implementation does nothing
   }
-
 }
 
 /**
  * Base source visitor class that provides common functionality for source-based rule visitors
  */
-export abstract class BaseSourceRuleVisitor {
-  public readonly offenses: LintOffense[] = []
+export abstract class BaseSourceRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+  public readonly offenses: LintOffense<TAutofixContext>[] = []
   protected ruleName: string
   protected context: LintContext
 
@@ -810,7 +812,7 @@ export abstract class BaseSourceRuleVisitor {
   /**
    * Helper method to create a lint offense for source rules
    */
-  protected createOffense(message: string, location: Location, severity: LintSeverity = "error"): LintOffense {
+  protected createOffense(message: string, location: Location, severity: LintSeverity = "error", autofixContext?: TAutofixContext): LintOffense<TAutofixContext> {
     return {
       rule: this.ruleName,
       code: this.ruleName,
@@ -818,14 +820,15 @@ export abstract class BaseSourceRuleVisitor {
       message,
       location,
       severity,
+      autofixContext,
     }
   }
 
   /**
    * Helper method to add an offense to the offenses array
    */
-  protected addOffense(message: string, location: Location, severity: LintSeverity = "error"): void {
-    this.offenses.push(this.createOffense(message, location, severity))
+  protected addOffense(message: string, location: Location, severity: LintSeverity = "error", autofixContext?: TAutofixContext): void {
+    this.offenses.push(this.createOffense(message, location, severity, autofixContext))
   }
 
   /**
@@ -841,19 +844,154 @@ export abstract class BaseSourceRuleVisitor {
    * Override this method to implement source-level checks
    */
   protected abstract visitSource(source: string): void
+}
 
-  /**
-   * Helper method to create a location for a specific position in the source
-   */
-  protected createLocationAt(source: string, position: number): Location {
-    const beforePosition = source.substring(0, position)
-    const lines = beforePosition.split('\n')
-    const line = lines.length
-    const column = lines[lines.length - 1].length + 1
+/**
+ * Autofix utilities for applying string replacements
+ */
+
+/**
+ * Checks if two locations are equal
+ * @param a - First location
+ * @param b - Second location
+ * @returns true if locations are equal
+ */
+export function locationsEqual(a: Location, b: Location): boolean {
+  return a.start.line === b.start.line &&
+         a.start.column === b.start.column &&
+         a.end.line === b.end.line &&
+         a.end.column === b.end.column
+}
+
+/**
+ * Finds a node in the AST that has a specific location
+ * Uses direct recursive traversal for reliability
+ * @param root - The root node to search from
+ * @param location - The location to match
+ * @param predicate - Optional predicate function to filter nodes (e.g., isERBNode)
+ * @returns The matching node or null if not found
+ */
+export function findNodeByLocation(root: Node, location: Location, predicate?: (node: Node) => boolean): any {
+  const visited = new Set<any>()
+
+  function search(node: any): any {
+    if (!node || visited.has(node)) return null
+    visited.add(node)
+
+    if (node.location && locationsEqual(node.location, location)) {
+      if (!predicate || predicate(node)) {
+        return node
+      }
+    }
 
-    const start = new Position(line, column)
-    const end = new Position(line, column)
+    const propsToCheck = ['tag_opening', 'tag_closing', 'tag_name', 'name', 'equals', 'value', 'content']
+    for (const prop of propsToCheck) {
+      if (node[prop]?.location && locationsEqual(node[prop].location, location)) {
+        if (!predicate || predicate(node)) {
+          return node
+        }
+      }
+    }
 
-    return new Location(start, end)
+    if (typeof node.compactChildNodes === 'function') {
+      for (const child of node.compactChildNodes()) {
+        const found = search(child)
+        if (found) return found
+      }
+    } else {
+      if (node.children && Array.isArray(node.children)) {
+        for (const child of node.children) {
+          const found = search(child)
+          if (found) return found
+        }
+      }
+
+      if (node.body && Array.isArray(node.body)) {
+        for (const child of node.body) {
+          const found = search(child)
+          if (found) return found
+        }
+      }
+    }
+
+    return null
   }
+
+  return search(root)
+}
+
+/**
+ * AST Navigation Utilities
+ * These utilities help navigate the AST tree for complex autofix operations
+ */
+
+/**
+ * Finds the parent node of a given child node in the AST
+ * @param root - The root node to search from (typically the document node)
+ * @param target - The child node to find the parent of
+ * @returns The parent node, or null if not found
+ *
+ * @example
+ * const parent = findParent(result.value, offense.autofixContext.node)
+ * if (parent?.type === "AST_HTML_ELEMENT_NODE") {
+ *   // Modify parent...
+ * }
+ */
+export function findParent(root: Node, target: Node): Node | null {
+  let parentNode: Node | null = null
+
+  const search = (node: Node, _parent: Node | null = null): void => {
+    if (parentNode) return
+
+    const nodeAny = node as any
+
+    if (nodeAny.children) {
+      for (const child of nodeAny.children) {
+        if (child === target) {
+          parentNode = node
+          return
+        }
+      }
+    }
+
+    const propsToCheck = ['open_tag', 'close_tag', 'body', 'name', 'value']
+
+    for (const prop of propsToCheck) {
+      const value = (node as any)[prop]
+      if (value === target) {
+        parentNode = node
+        return
+      }
+      if (Array.isArray(value) && value.includes(target)) {
+        parentNode = node
+        return
+      }
+    }
+
+    if (nodeAny.children) {
+      for (const child of nodeAny.children) {
+        search(child, node)
+        if (parentNode) return
+      }
+    }
+
+    for (const prop of propsToCheck) {
+      const value = (node as any)[prop]
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (item && typeof item === 'object' && 'type' in item) {
+            search(item, node)
+            if (parentNode) return
+          }
+        }
+      } else if (value && typeof value === 'object' && 'type' in value) {
+        search(value, node)
+        if (parentNode) return
+      }
+    }
+  }
+
+  search(root)
+
+  return parentNode
 }
diff --git a/javascript/packages/linter/src/rules/svg-tag-name-capitalization.ts b/javascript/packages/linter/src/rules/svg-tag-name-capitalization.ts
index 73d45c901..1581e00d0 100644
--- a/javascript/packages/linter/src/rules/svg-tag-name-capitalization.ts
+++ b/javascript/packages/linter/src/rules/svg-tag-name-capitalization.ts
@@ -1,10 +1,16 @@
+import { ParserRule } from "../types.js"
 import { BaseRuleVisitor, SVG_CAMEL_CASE_ELEMENTS, SVG_LOWERCASE_TO_CAMELCASE } from "./rule-utils.js"
 
-import { ParserRule } from "../types.js"
-import type { LintOffense, LintContext } from "../types.js"
+import type { LintOffense, LintContext, BaseAutofixContext, Mutable } from "../types.js"
 import type { HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, ParseResult } from "@herb-tools/core"
 
-class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
+interface SVGTagNameCapitalizationAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLOpenTagNode | HTMLCloseTagNode>
+  currentTagName: string
+  correctCamelCase: string
+}
+
+class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor<SVGTagNameCapitalizationAutofixContext> {
   private insideSVG = false
 
   visitHTMLElementNode(node: HTMLElementNode): void {
@@ -22,6 +28,7 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
       if (node.open_tag) {
         this.checkTagName(node.open_tag as HTMLOpenTagNode)
       }
+
       if (node.close_tag) {
         this.checkTagName(node.close_tag as HTMLCloseTagNode)
       }
@@ -50,18 +57,38 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
       this.addOffense(
         `${type} SVG tag name \`${tagName}\` should use proper capitalization. Use \`${correctCamelCase}\` instead.`,
         node.tag_name!.location,
-        "error"
+        "error",
+        {
+          node,
+          currentTagName: tagName,
+          correctCamelCase
+        }
       )
     }
   }
 }
 
-export class SVGTagNameCapitalizationRule extends ParserRule {
+export class SVGTagNameCapitalizationRule extends ParserRule<SVGTagNameCapitalizationAutofixContext> {
+  static autocorrectable = true
   name = "svg-tag-name-capitalization"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<SVGTagNameCapitalizationAutofixContext>[] {
     const visitor = new SVGTagNameCapitalizationVisitor(this.name, context)
+
     visitor.visit(result.value)
+
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<SVGTagNameCapitalizationAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node: { tag_name }, correctCamelCase } = offense.autofixContext
+
+    if (!tag_name) return null
+
+    tag_name.value = correctCamelCase
+
+    return result
+  }
 }
diff --git a/javascript/packages/linter/src/types.ts b/javascript/packages/linter/src/types.ts
index 7e377301a..cf32052ce 100644
--- a/javascript/packages/linter/src/types.ts
+++ b/javascript/packages/linter/src/types.ts
@@ -1,5 +1,7 @@
 import { Diagnostic, LexResult, ParseResult } from "@herb-tools/core"
+
 import type { defaultRules } from "./default-rules.js"
+import type { Node } from "@herb-tools/core"
 
 export type LintSeverity = "error" | "warning" | "info" | "hint"
 
@@ -9,22 +11,78 @@ export type LintSeverity = "error" | "warning" | "info" | "hint"
  */
 export type LinterRule = InstanceType<typeof defaultRules[number]>['name']
 
-export interface LintOffense extends Diagnostic {
+/**
+ * Recursively removes readonly modifiers from a type, making it mutable.
+ * Used internally during autofix to allow direct AST node mutation.
+ *
+ * @example
+ * const node: HTMLOpenTagNode = ...  // readonly properties
+ * const mutable = node as Mutable<HTMLOpenTagNode>  // can mutate
+ * mutable.tag_name!.value = 'div'  // ✓ allowed
+ */
+export type Mutable<T> = T extends ReadonlyArray<infer U>
+  ? Array<Mutable<U>>
+  : T extends object
+    ? { -readonly [K in keyof T]: Mutable<T[K]> }
+    : T
+
+/**
+ * Converts a readonly node or object to a mutable version.
+ * Use this in autofix methods to enable direct mutation of AST nodes.
+ * Follows the TypeScript pattern of 'as const' but for mutability.
+ *
+ * @example
+ * const mutable = asMutable(node)
+ * mutable.tag_name.value = 'div'
+ * mutable.content.value = 'updated'
+ */
+export function asMutable<T>(node: T): Mutable<T> {
+  return node as Mutable<T>
+}
+
+
+/**
+ * Base context for autofix operations. Contains the offending node.
+ * Rules can extend this interface to include rule-specific autofix data.
+ * Note: The node is typed as Mutable to allow direct mutation in autofix methods.
+ */
+export interface BaseAutofixContext {
+  /** The AST node, token, or data structure that caused the offense (mutable) */
+  node: Mutable<Node>
+}
+
+export interface LintOffense<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> extends Diagnostic {
   rule: LinterRule
   severity: LintSeverity
+  /** Context data for autofix, including the offending node and rule-specific data */
+  autofixContext?: TAutofixContext
 }
 
-export interface LintResult {
-  offenses: LintOffense[]
+export interface LintResult<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+  offenses: LintOffense<TAutofixContext>[]
   errors: number
   warnings: number
 }
 
-export abstract class ParserRule {
+/**
+ * Result of applying autofixes to source code
+ */
+export interface AutofixResult<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+  /** The corrected source code with all fixes applied */
+  source: string
+  /** Offenses that were successfully fixed */
+  fixed: LintOffense<TAutofixContext>[]
+  /** Offenses that could not be automatically fixed */
+  unfixed: LintOffense<TAutofixContext>[]
+}
+
+export abstract class ParserRule<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
   static type = "parser" as const
+  /** Indicates whether this rule supports autofix. Defaults to false. */
+  static autocorrectable = false
   abstract name: string
-  abstract check(result: ParseResult, context?: Partial<LintContext>): LintOffense[]
-  
+  abstract check(result: ParseResult, context?: Partial<LintContext>): LintOffense<TAutofixContext>[]
+
   /**
    * Optional method to determine if this rule should run.
    * If not implemented, rule is always enabled.
@@ -33,13 +91,25 @@ export abstract class ParserRule {
    * @returns true if rule should run, false to skip
    */
   isEnabled?(result: ParseResult, context?: Partial<LintContext>): boolean
+
+  /**
+   * Optional method to automatically fix an offense by mutating the AST.
+   * If not implemented, the rule does not support autofix.
+   * @param offense - The offense to fix (includes autofixContext with node and rule-specific data)
+   * @param result - The parse result containing the AST (mutate it directly and return it)
+   * @param context - Optional context for linting
+   * @returns The mutated ParseResult if fixed, or null if the offense could not be fixed
+   */
+  autofix?(offense: LintOffense<TAutofixContext>, result: ParseResult, context?: Partial<LintContext>): ParseResult | null
 }
 
-export abstract class LexerRule {
+export abstract class LexerRule<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
   static type = "lexer" as const
+  /** Indicates whether this rule supports autofix. Defaults to false. */
+  static autocorrectable = false
   abstract name: string
-  abstract check(lexResult: LexResult, context?: Partial<LintContext>): LintOffense[]
-  
+  abstract check(lexResult: LexResult, context?: Partial<LintContext>): LintOffense<TAutofixContext>[]
+
   /**
    * Optional method to determine if this rule should run.
    * If not implemented, rule is always enabled.
@@ -48,6 +118,16 @@ export abstract class LexerRule {
    * @returns true if rule should run, false to skip
    */
   isEnabled?(lexResult: LexResult, context?: Partial<LintContext>): boolean
+
+  /**
+   * Optional method to automatically fix an offense by mutating tokens.
+   * If not implemented, the rule does not support autofix.
+   * @param offense - The offense to fix (includes autofixContext with node and rule-specific data)
+   * @param lexResult - The lex result containing tokens (mutate them directly and return)
+   * @param context - Optional context for linting
+   * @returns The mutated LexResult if fixed, or null if the offense could not be fixed
+   */
+  autofix?(offense: LintOffense<TAutofixContext>, lexResult: LexResult, context?: Partial<LintContext>): LexResult | null
 }
 
 export interface LexerRuleConstructor {
@@ -70,11 +150,13 @@ export const DEFAULT_LINT_CONTEXT: LintContext = {
   fileName: undefined
 } as const
 
-export abstract class SourceRule {
+export abstract class SourceRule<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
   static type = "source" as const
+  /** Indicates whether this rule supports autofix. Defaults to false. */
+  static autocorrectable = false
   abstract name: string
-  abstract check(source: string, context?: Partial<LintContext>): LintOffense[]
-  
+  abstract check(source: string, context?: Partial<LintContext>): LintOffense<TAutofixContext>[]
+
   /**
    * Optional method to determine if this rule should run.
    * If not implemented, rule is always enabled.
@@ -83,6 +165,16 @@ export abstract class SourceRule {
    * @returns true if rule should run, false to skip
    */
   isEnabled?(source: string, context?: Partial<LintContext>): boolean
+
+  /**
+   * Optional method to automatically fix an offense.
+   * If not implemented, the rule does not support autofix.
+   * @param offense - The offense to fix (includes autofixContext with node and rule-specific data)
+   * @param source - The original source code
+   * @param context - Optional context for linting
+   * @returns The corrected source if the offense can be fixed, null otherwise
+   */
+  autofix?(offense: LintOffense<TAutofixContext>, source: string, context?: Partial<LintContext>): string | null
 }
 
 export interface SourceRuleConstructor {
diff --git a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
index 73e232c47..cbc5f81e9 100644
--- a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
+++ b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
@@ -21,7 +21,7 @@ test/fixtures/test-file-with-errors.html.erb:3:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/3] ⎯⎯⎯⎯
 
-[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
+[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-with-errors.html.erb:2:3
 
@@ -34,7 +34,7 @@ test/fixtures/test-file-with-errors.html.erb:2:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [2/3] ⎯⎯⎯⎯
 
-[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-with-errors.html.erb:2:22
 
@@ -51,13 +51,14 @@ test/fixtures/test-file-with-errors.html.erb:2:22
 
  Summary:
   Checked      1 file
-  Offenses     3 errors | 0 warnings (3 offenses across 1 file)"
+  Offenses     3 errors | 0 warnings (3 offenses across 1 file)
+  Fixable      3 offenses | 2 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > GitHub Actions format includes rule codes 1`] = `
-"::error file=test/fixtures/no-trailing-newline.html.erb,line=1,col=29,title=erb-requires-trailing-newline • @herb-tools/linter@0.7.5::File must end with trailing newline [erb-requires-trailing-newline]%0A%0A%0Atest/fixtures/no-trailing-newline.html.erb:1:29%0A%0A  →   1 │ <div>No trailing newline</div>%0A        │                              ~%0A
+"::error file=test/fixtures/no-trailing-newline.html.erb,line=1,col=29,title=erb-requires-trailing-newline • @herb-tools/linter@0.7.5::File must end with trailing newline. [erb-requires-trailing-newline]%0A%0A%0Atest/fixtures/no-trailing-newline.html.erb:1:29%0A%0A  →   1 │ <div>No trailing newline</div>%0A        │                              ~%0A
 
-[error] File must end with trailing newline (erb-requires-trailing-newline)
+[error] File must end with trailing newline. [Correctable] (erb-requires-trailing-newline)
 
 test/fixtures/no-trailing-newline.html.erb:1:29
 
@@ -70,7 +71,8 @@ test/fixtures/no-trailing-newline.html.erb:1:29
 
  Summary:
   Checked      1 file
-  Offenses     1 error | 0 warnings (1 offense across 1 file)"
+  Offenses     1 error | 0 warnings (1 offense across 1 file)
+  Fixable      1 offense | 1 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > diplays only parsers errors if one is present 1`] = `
@@ -90,7 +92,8 @@ test/fixtures/parser-errors.html.erb:2:16
 
  Summary:
   Checked      1 file
-  Offenses     1 error | 0 warnings (1 offense across 1 file)"
+  Offenses     1 error | 0 warnings (1 offense across 1 file)
+  Fixable      1 offense"
 `;
 
 exports[`CLI Output Formatting > displays most violated rules with multiple offenses 1`] = `
@@ -136,7 +139,7 @@ test/fixtures/multiple-rule-offenses.html.erb:10:4
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [3/14] ⎯⎯⎯⎯
 
-[warning] Attribute \`class\` uses single quotes. Prefer double quotes for HTML attribute values: \`class=""\`. (html-attribute-double-quotes)
+[warning] Attribute \`class\` uses single quotes. Prefer double quotes for HTML attribute values: \`class=""\`. [Correctable] (html-attribute-double-quotes)
 
 test/fixtures/multiple-rule-offenses.html.erb:3:20
 
@@ -150,7 +153,7 @@ test/fixtures/multiple-rule-offenses.html.erb:3:20
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [4/14] ⎯⎯⎯⎯
 
-[error] Attribute value should be quoted: \`id="test1"\`. Always wrap attribute values in quotes. (html-attribute-values-require-quotes)
+[error] Attribute value should be quoted: \`id="test1"\`. Always wrap attribute values in quotes. [Correctable] (html-attribute-values-require-quotes)
 
 test/fixtures/multiple-rule-offenses.html.erb:3:8
 
@@ -164,7 +167,7 @@ test/fixtures/multiple-rule-offenses.html.erb:3:8
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [5/14] ⎯⎯⎯⎯
 
-[error] Attribute value should be quoted: \`data-value="bar"\`. Always wrap attribute values in quotes. (html-attribute-values-require-quotes)
+[error] Attribute value should be quoted: \`data-value="bar"\`. Always wrap attribute values in quotes. [Correctable] (html-attribute-values-require-quotes)
 
 test/fixtures/multiple-rule-offenses.html.erb:3:34
 
@@ -276,7 +279,7 @@ test/fixtures/multiple-rule-offenses.html.erb:10:4
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [13/14] ⎯⎯⎯⎯
 
-[error] Use \`<img>\` instead of self-closing \`<img />\` for HTML compatibility. (html-no-self-closing)
+[error] Use \`<img>\` instead of self-closing \`<img />\` for HTML compatibility. [Correctable] (html-no-self-closing)
 
 test/fixtures/multiple-rule-offenses.html.erb:4:2
 
@@ -299,11 +302,12 @@ test/fixtures/multiple-rule-offenses.html.erb:4:2
 
  Summary:
   Checked      1 file
-  Offenses     10 errors | 4 warnings (14 offenses across 1 file)"
+  Offenses     10 errors | 4 warnings (14 offenses across 1 file)
+  Fixable      14 offenses | 4 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > displays rule offenses when showing all rules 1`] = `
-"[error] Attribute value should be quoted: \`id="test"\`. Always wrap attribute values in quotes. (html-attribute-values-require-quotes)
+"[error] Attribute value should be quoted: \`id="test"\`. Always wrap attribute values in quotes. [Correctable] (html-attribute-values-require-quotes)
 
 test/fixtures/few-rule-offenses.html.erb:2:8
 
@@ -316,7 +320,7 @@ test/fixtures/few-rule-offenses.html.erb:2:8
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/6] ⎯⎯⎯⎯
 
-[error] Attribute value should be quoted: \`class="foo"\`. Always wrap attribute values in quotes. (html-attribute-values-require-quotes)
+[error] Attribute value should be quoted: \`class="foo"\`. Always wrap attribute values in quotes. [Correctable] (html-attribute-values-require-quotes)
 
 test/fixtures/few-rule-offenses.html.erb:2:19
 
@@ -329,7 +333,7 @@ test/fixtures/few-rule-offenses.html.erb:2:19
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [2/6] ⎯⎯⎯⎯
 
-[error] Attribute value should be quoted: \`src="image"\`. Always wrap attribute values in quotes. (html-attribute-values-require-quotes)
+[error] Attribute value should be quoted: \`src="image"\`. Always wrap attribute values in quotes. [Correctable] (html-attribute-values-require-quotes)
 
 test/fixtures/few-rule-offenses.html.erb:3:11
 
@@ -390,7 +394,8 @@ test/fixtures/few-rule-offenses.html.erb:6:0
 
  Summary:
   Checked      1 file
-  Offenses     6 errors | 0 warnings (6 offenses across 1 file)"
+  Offenses     6 errors | 0 warnings (6 offenses across 1 file)
+  Fixable      6 offenses | 3 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > formats GitHub Actions output correctly for bad file 1`] = `
@@ -398,7 +403,7 @@ exports[`CLI Output Formatting > formats GitHub Actions output correctly for bad
 
 ::error file=test/fixtures/bad-file.html.erb,line=1,col=16,title=html-tag-name-lowercase • @herb-tools/linter@0.7.5::Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/bad-file.html.erb:1:16%0A%0A  →   1 │ <SPAN>Bad file</SPAN>%0A        │                 ~~~~%0A      2 │%0A
 
-[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
+[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/bad-file.html.erb:1:1
 
@@ -409,7 +414,7 @@ test/fixtures/bad-file.html.erb:1:1
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/2] ⎯⎯⎯⎯
 
-[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/bad-file.html.erb:1:16
 
@@ -423,7 +428,8 @@ test/fixtures/bad-file.html.erb:1:16
 
  Summary:
   Checked      1 file
-  Offenses     2 errors | 0 warnings (2 offenses across 1 file)"
+  Offenses     2 errors | 0 warnings (2 offenses across 1 file)
+  Fixable      2 offenses | 2 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > formats GitHub Actions output correctly for clean file 1`] = `
@@ -456,7 +462,7 @@ test/fixtures/test-file-with-errors.html.erb:3:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/3] ⎯⎯⎯⎯
 
-[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
+[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-with-errors.html.erb:2:3
 
@@ -469,7 +475,7 @@ test/fixtures/test-file-with-errors.html.erb:2:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [2/3] ⎯⎯⎯⎯
 
-[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-with-errors.html.erb:2:22
 
@@ -486,11 +492,12 @@ test/fixtures/test-file-with-errors.html.erb:2:22
 
  Summary:
   Checked      1 file
-  Offenses     3 errors | 0 warnings (3 offenses across 1 file)"
+  Offenses     3 errors | 0 warnings (3 offenses across 1 file)
+  Fixable      3 offenses | 2 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > formats GitHub Actions output with --format=github option 1`] = `
-"[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
+"[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-simple.html.erb:2:3
 
@@ -503,7 +510,7 @@ test/fixtures/test-file-simple.html.erb:2:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/2] ⎯⎯⎯⎯
 
-[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-simple.html.erb:2:22
 
@@ -519,7 +526,8 @@ test/fixtures/test-file-simple.html.erb:2:22
 
  Summary:
   Checked      1 file
-  Offenses     2 errors | 0 warnings (2 offenses across 1 file)"
+  Offenses     2 errors | 0 warnings (2 offenses across 1 file)
+  Fixable      2 offenses | 2 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > formats JSON output correctly for bad file 1`] = `
@@ -678,7 +686,7 @@ test/fixtures/test-file-with-errors.html.erb:3:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/3] ⎯⎯⎯⎯
 
-[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
+[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-with-errors.html.erb:2:3
 
@@ -691,7 +699,7 @@ test/fixtures/test-file-with-errors.html.erb:2:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [2/3] ⎯⎯⎯⎯
 
-[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-with-errors.html.erb:2:22
 
@@ -708,13 +716,14 @@ test/fixtures/test-file-with-errors.html.erb:2:22
 
  Summary:
   Checked      1 file
-  Offenses     3 errors | 0 warnings (3 offenses across 1 file)"
+  Offenses     3 errors | 0 warnings (3 offenses across 1 file)
+  Fixable      3 offenses | 2 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > formats simple output correctly 1`] = `
 "test/fixtures/test-file-simple.html.erb:
-  2:3  ✗ Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
-  2:22 ✗ Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+  2:3  ✗ Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase) [Correctable]
+  2:22 ✗ Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase) [Correctable]
 
  Rule offenses:
   html-tag-name-lowercase (2 offenses in 1 file)
@@ -722,13 +731,14 @@ exports[`CLI Output Formatting > formats simple output correctly 1`] = `
 
  Summary:
   Checked      1 file
-  Offenses     2 errors | 0 warnings (2 offenses across 1 file)"
+  Offenses     2 errors | 0 warnings (2 offenses across 1 file)
+  Fixable      2 offenses | 2 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > formats simple output for bad-file correctly 1`] = `
 "test/fixtures/bad-file.html.erb:
-  1:1  ✗ Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
-  1:16 ✗ Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+  1:1  ✗ Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase) [Correctable]
+  1:16 ✗ Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase) [Correctable]
 
  Rule offenses:
   html-tag-name-lowercase (2 offenses in 1 file)
@@ -736,7 +746,8 @@ exports[`CLI Output Formatting > formats simple output for bad-file correctly 1`
 
  Summary:
   Checked      1 file
-  Offenses     2 errors | 0 warnings (2 offenses across 1 file)"
+  Offenses     2 errors | 0 warnings (2 offenses across 1 file)
+  Fixable      2 offenses | 2 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > formats success output correctly 1`] = `
@@ -758,7 +769,7 @@ exports[`CLI Output Formatting > handles boolean attributes 1`] = `
 `;
 
 exports[`CLI Output Formatting > handles multiple errors correctly 1`] = `
-"[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
+"[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/bad-file.html.erb:1:1
 
@@ -769,7 +780,7 @@ test/fixtures/bad-file.html.erb:1:1
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/2] ⎯⎯⎯⎯
 
-[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/bad-file.html.erb:1:16
 
@@ -783,7 +794,8 @@ test/fixtures/bad-file.html.erb:1:16
 
  Summary:
   Checked      1 file
-  Offenses     2 errors | 0 warnings (2 offenses across 1 file)"
+  Offenses     2 errors | 0 warnings (2 offenses across 1 file)
+  Fixable      2 offenses | 2 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > uses GitHub Actions format by default when GITHUB_ACTIONS is true 1`] = `
@@ -807,7 +819,7 @@ test/fixtures/test-file-with-errors.html.erb:3:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/3] ⎯⎯⎯⎯
 
-[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
+[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-with-errors.html.erb:2:3
 
@@ -820,7 +832,7 @@ test/fixtures/test-file-with-errors.html.erb:2:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [2/3] ⎯⎯⎯⎯
 
-[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-with-errors.html.erb:2:22
 
@@ -837,5 +849,6 @@ test/fixtures/test-file-with-errors.html.erb:2:22
 
  Summary:
   Checked      1 file
-  Offenses     3 errors | 0 warnings (3 offenses across 1 file)"
+  Offenses     3 errors | 0 warnings (3 offenses across 1 file)
+  Fixable      3 offenses | 2 autocorrectable using \`--fix\`"
 `;
diff --git a/javascript/packages/linter/test/autofix/erb-require-whitespace-inside-tags.autofix.test.ts b/javascript/packages/linter/test/autofix/erb-require-whitespace-inside-tags.autofix.test.ts
new file mode 100644
index 000000000..c86abef80
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/erb-require-whitespace-inside-tags.autofix.test.ts
@@ -0,0 +1,142 @@
+import { describe, test, expect, beforeAll } from "vitest"
+import dedent from "dedent"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { ERBRequireWhitespaceRule } from "../../src/rules/erb-require-whitespace-inside-tags.js"
+
+describe("erb-require-whitespace-inside-tags autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("adds space after opening tag", () => {
+    const input = '<%if true %>\n<% end %>'
+    const expected = '<% if true %>\n<% end %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("adds space before closing tag", () => {
+    const input = '<% if admin%>\n<% end %>'
+    const expected = '<% if admin %>\n<% end %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("adds spaces after opening and before closing", () => {
+    const input = '<%if true%><% end %>'
+    const expected = '<% if true %><% end %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("fixes ERB output tags", () => {
+    const input = '<%=user.name%>'
+    const expected = '<%= user.name %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("fixes ERB comment tags", () => {
+    const input = '<%#This is a comment%>'
+    const expected = '<%# This is a comment %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("fixes multiple ERB tags", () => {
+    const input = dedent`
+      <%if admin%>
+        Hello, <%=user.name%>.
+      <%end%>
+    `
+
+    const expected = dedent`
+      <% if admin %>
+        Hello, <%= user.name %>.
+      <% end %>
+    `
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(6)
+  })
+
+  test("preserves already correct whitespace", () => {
+    const input = '<% if admin %>\n  Hello\n<% end %>'
+    const expected = '<% if admin %>\n  Hello\n<% end %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+  })
+
+  test("handles tags with newlines", () => {
+    const input = '<%\n  if admin\n%><% end %>'
+    const expected = '<%\n  if admin\n%><% end %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+  })
+
+  test("fixes only opening whitespace when needed", () => {
+    const input = '<%if user %><% end %>'
+    const expected = '<% if user %><% end %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("fixes only closing whitespace when needed", () => {
+    const input = '<% if admin%><% end %>'
+    const expected = '<% if admin %><% end %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles mixed correct and incorrect tags", () => {
+    const input = '<% if admin %>\n  <%=name%>\n<% end %>'
+    const expected = '<% if admin %>\n  <%= name %>\n<% end %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/erb-requires-trailing-newline.autofix.test.ts b/javascript/packages/linter/test/autofix/erb-requires-trailing-newline.autofix.test.ts
new file mode 100644
index 000000000..1bfc2661c
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/erb-requires-trailing-newline.autofix.test.ts
@@ -0,0 +1,99 @@
+import dedent from "dedent"
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { ERBRequiresTrailingNewlineRule } from "../../src/rules/erb-requires-trailing-newline.js"
+
+describe("erb-requires-trailing-newline autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("adds trailing newline to file without one", () => {
+    const input = '<div>Hello World</div>'
+    const expected = '<div>Hello World</div>\n'
+
+    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("does not add newline if already present", () => {
+    const input = '<div>Hello World</div>\n'
+    const expected = '<div>Hello World</div>\n'
+
+    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+  })
+
+  test("handles multi-line files", () => {
+    const input = dedent`
+      <div>
+        <span>Hello</span>
+      </div>`
+
+    const expected = dedent`
+      <div>
+        <span>Hello</span>
+      </div>
+    ` + '\n'
+
+    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles file with ERB tags", () => {
+    const input = '<div><%= content %></div>'
+    const expected = '<div><%= content %></div>\n'
+
+    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles empty file", () => {
+    const input = ''
+    const expected = ''
+
+    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+  })
+
+  test("removes redundant trailing newline", () => {
+    const input = '<div>Hello</div>\n\n'
+    const expected = '<div>Hello</div>\n'
+
+    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("removes redundant trailing newlines", () => {
+    const input = '<div>Hello</div>\n\n\n\n\n\n'
+    const expected = '<div>Hello</div>\n'
+
+    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/html-attribute-double-quotes.autofix.test.ts b/javascript/packages/linter/test/autofix/html-attribute-double-quotes.autofix.test.ts
new file mode 100644
index 000000000..b4f559960
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/html-attribute-double-quotes.autofix.test.ts
@@ -0,0 +1,76 @@
+import dedent from "dedent"
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { HTMLAttributeDoubleQuotesRule } from "../../src/rules/html-attribute-double-quotes.js"
+
+describe("html-attribute-double-quotes autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("converts single quotes to double quotes", () => {
+    const input = `<div class='container'>Content</div>`
+    const expected = `<div class="container">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("converts multiple attributes with single quotes", () => {
+    const input = `<div class='container' id='main' data-value='test'>Content</div>`
+    const expected = `<div class="container" id="main" data-value="test">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(3)
+  })
+
+  test("handles nested elements", () => {
+    const input = `<div class='outer'><span class='inner'>Text</span></div>`
+    const expected = `<div class="outer"><span class="inner">Text</span></div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("preserves content with special characters", () => {
+    const input = `<div data-text='Hello, World!'>Content</div>`
+    const expected = `<div data-text="Hello, World!">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles multiple lines", () => {
+    const input = dedent`
+      <div class='line1'>
+            <span id='line2'>Text</span>
+        </div>
+    `
+
+    const expected = dedent`
+      <div class="line1">
+            <span id="line2">Text</span>
+        </div>
+    `
+
+    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/html-attribute-equals-spacing.autofix.test.ts b/javascript/packages/linter/test/autofix/html-attribute-equals-spacing.autofix.test.ts
new file mode 100644
index 000000000..94dc0aa3b
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/html-attribute-equals-spacing.autofix.test.ts
@@ -0,0 +1,66 @@
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { HTMLAttributeEqualsSpacingRule } from "../../src/rules/html-attribute-equals-spacing.js"
+
+describe("html-attribute-equals-spacing autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("removes space before equals", () => {
+    const input = `<div class ="container">Content</div>`
+    const expected = `<div class="container">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("removes space after equals", () => {
+    const input = `<div class= "container">Content</div>`
+    const expected = `<div class="container">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("removes spaces on both sides of equals", () => {
+    const input = `<div class = "container">Content</div>`
+    const expected = `<div class="container">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("handles multiple attributes", () => {
+    const input = `<div class ="outer" id= "main">Content</div>`
+    const expected = `<div class="outer" id="main">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed.length).toBeGreaterThanOrEqual(2)
+  })
+
+  test("handles nested elements", () => {
+    const input = `<div class ="outer"><span id= "inner">Text</span></div>`
+    const expected = `<div class="outer"><span id="inner">Text</span></div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/html-attribute-values-require-quotes.autofix.test.ts b/javascript/packages/linter/test/autofix/html-attribute-values-require-quotes.autofix.test.ts
new file mode 100644
index 000000000..ff6c1b2e9
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/html-attribute-values-require-quotes.autofix.test.ts
@@ -0,0 +1,66 @@
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { HTMLAttributeValuesRequireQuotesRule } from "../../src/rules/html-attribute-values-require-quotes.js"
+
+describe("html-attribute-values-require-quotes autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("adds quotes to unquoted attribute value", () => {
+    const input = `<div class=container>Content</div>`
+    const expected = `<div class="container">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("adds quotes to multiple unquoted attributes", () => {
+    const input = `<div class=container id=main data-value=test>Content</div>`
+    const expected = `<div class="container" id="main" data-value="test">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(3)
+  })
+
+  test("handles nested elements", () => {
+    const input = `<div class=outer><span id=inner>Text</span></div>`
+    const expected = `<div class="outer"><span id="inner">Text</span></div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("preserves already quoted attributes", () => {
+    const input = `<div class="quoted" id=unquoted>Content</div>`
+    const expected = `<div class="quoted" id="unquoted">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles numeric values", () => {
+    const input = `<input type=text maxlength=100>`
+    const expected = `<input type="text" maxlength="100">`
+
+    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/html-boolean-attributes-no-value.autofix.test.ts b/javascript/packages/linter/test/autofix/html-boolean-attributes-no-value.autofix.test.ts
new file mode 100644
index 000000000..b1db8ad37
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/html-boolean-attributes-no-value.autofix.test.ts
@@ -0,0 +1,121 @@
+import dedent from "dedent"
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { HTMLBooleanAttributesNoValueRule } from "../../src/rules/html-boolean-attributes-no-value.js"
+
+describe("html-boolean-attributes-no-value autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("removes value from single boolean attribute", () => {
+    const input = '<input type="checkbox" checked="checked">'
+    const expected = '<input type="checkbox" checked>'
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("removes values from multiple boolean attributes", () => {
+    const input = '<input type="checkbox" checked="checked" disabled="disabled">'
+    const expected = '<input type="checkbox" checked disabled>'
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("removes value from boolean attribute with true/false", () => {
+    const input = '<button disabled="true">Submit</button>'
+    const expected = '<button disabled>Submit</button>'
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles self-closing tags", () => {
+    const input = '<input type="checkbox" checked="checked" required="true" />'
+    const expected = '<input type="checkbox" checked required />'
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("handles multiple elements with boolean attributes", () => {
+    const input = dedent`
+      <input checked="checked">
+      <button disabled="disabled">Click</button>
+      <video controls="controls" autoplay="autoplay"></video>
+    `
+
+    const expected = dedent`
+      <input checked>
+      <button disabled>Click</button>
+      <video controls autoplay></video>
+    `
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(4)
+  })
+
+  test("preserves non-boolean attributes", () => {
+    const input = '<input type="text" value="test" checked="checked">'
+    const expected = '<input type="text" value="test" checked>'
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles video element boolean attributes", () => {
+    const input = '<video controls="controls" autoplay="autoplay" loop="loop" muted="muted"></video>'
+    const expected = '<video controls autoplay loop muted></video>'
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(4)
+  })
+
+  test("handles select and option boolean attributes", () => {
+    const input = '<select multiple="multiple"><option selected="selected">Option</option></select>'
+    const expected = '<select multiple><option selected>Option</option></select>'
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("handles boolean attributes with different values", () => {
+    const input = '<video controls="something-else"></video>'
+    const expected = '<video controls></video>'
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/html-no-self-closing.autofix.test.ts b/javascript/packages/linter/test/autofix/html-no-self-closing.autofix.test.ts
new file mode 100644
index 000000000..bf239e188
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/html-no-self-closing.autofix.test.ts
@@ -0,0 +1,98 @@
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { HTMLNoSelfClosingRule } from "../../src/rules/html-no-self-closing.js"
+
+describe("html-no-self-closing autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("converts self-closing void element", () => {
+    const input = '<br />'
+    const expected = '<br>'
+
+    const linter = new Linter(Herb, [HTMLNoSelfClosingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("converts self-closing non-void element to open/close pair", () => {
+    const input = '<div />'
+    const expected = '<div></div>'
+
+    const linter = new Linter(Herb, [HTMLNoSelfClosingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles multiple void elements", () => {
+    const input = '<br /><hr /><img />'
+    const expected = '<br><hr><img>'
+
+    const linter = new Linter(Herb, [HTMLNoSelfClosingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(3)
+  })
+
+  test("handles self-closing div with attributes", () => {
+    const input = '<div class="test" id="main" />'
+    const expected = '<div class="test" id="main"></div>'
+
+    const linter = new Linter(Herb, [HTMLNoSelfClosingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles self-closing input element", () => {
+    const input = '<input type="text" />'
+    const expected = '<input type="text">'
+
+    const linter = new Linter(Herb, [HTMLNoSelfClosingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles mixed void and non-void elements", () => {
+    const input = '<div><br /><span /></div>'
+    const expected = '<div><br><span></span></div>'
+
+    const linter = new Linter(Herb, [HTMLNoSelfClosingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("preserves whitespace before slash", () => {
+    const input = '<input type="text" />'
+    const expected = '<input type="text">'
+
+    const linter = new Linter(Herb, [HTMLNoSelfClosingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("does not affect SVG elements", () => {
+    const input = '<svg><circle cx="50" cy="50" r="40" /></svg>'
+
+    const linter = new Linter(Herb, [HTMLNoSelfClosingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(input)
+    expect(result.fixed).toHaveLength(0)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/html-tag-name-lowercase.autofix.test.ts b/javascript/packages/linter/test/autofix/html-tag-name-lowercase.autofix.test.ts
new file mode 100644
index 000000000..ad46af233
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/html-tag-name-lowercase.autofix.test.ts
@@ -0,0 +1,109 @@
+import dedent from "dedent"
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { HTMLTagNameLowercaseRule } from "../../src/rules/html-tag-name-lowercase.js"
+
+describe("html-tag-name-lowercase autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("converts single uppercase tag to lowercase", () => {
+    const input = `<DIV>Hello</DIV>`
+    const expected = `<div>Hello</div>`
+
+    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("converts mixed case tags", () => {
+    const input = `<Div><Span>Text</Span></Div>`
+    const expected = `<div><span>Text</span></div>`
+
+    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(4)
+  })
+
+  test("handles self-closing tags", () => {
+    const input = `<BR />`
+    const expected = `<br />`
+
+    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles nested uppercase tags", () => {
+    const input = `<DIV><UL><LI>Item 1</LI><LI>Item 2</LI></UL></DIV>`
+    const expected = `<div><ul><li>Item 1</li><li>Item 2</li></ul></div>`
+
+    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(8)
+  })
+
+  test("preserves attributes when fixing tag names", () => {
+    const input = `<DIV class="container" id="main">Content</DIV>`
+    const expected = `<div class="container" id="main">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("handles multiple root elements", () => {
+    const input = dedent`
+      <DIV>First</DIV>
+      <SPAN>Second</SPAN>
+      <P>Third</P>
+    `
+
+    const expected = dedent`
+      <div>First</div>
+      <span>Second</span>
+      <p>Third</p>
+    `
+
+    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(6)
+  })
+
+  test("handles form elements", () => {
+    const input = `<FORM><INPUT type="text"><BUTTON>Submit</BUTTON></FORM>`
+    const expected = `<form><input type="text"><button>Submit</button></form>`
+
+    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(5)
+  })
+
+  test("does not affect already lowercase SVG tags", () => {
+    const input = `<svg><linearGradient></linearGradient></svg>`
+    const expected = `<svg><linearGradient></linearGradient></svg>`
+
+    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/svg-tag-name-capitalization.autofix.test.ts b/javascript/packages/linter/test/autofix/svg-tag-name-capitalization.autofix.test.ts
new file mode 100644
index 000000000..3990bdbdc
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/svg-tag-name-capitalization.autofix.test.ts
@@ -0,0 +1,88 @@
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { SVGTagNameCapitalizationRule } from "../../src/rules/svg-tag-name-capitalization.js"
+
+describe("svg-tag-name-capitalization autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("fixes lowercase SVG element to camelCase", () => {
+    const input = `<svg><lineargradient></lineargradient></svg>`
+    const expected = `<svg><linearGradient></linearGradient></svg>`
+
+    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("fixes multiple SVG elements", () => {
+    const input = `<svg><lineargradient></lineargradient><radialgradient></radialgradient></svg>`
+    const expected = `<svg><linearGradient></linearGradient><radialGradient></radialGradient></svg>`
+
+    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(4)
+  })
+
+  test("fixes clippath element", () => {
+    const input = `<svg><clippath></clippath></svg>`
+    const expected = `<svg><clipPath></clipPath></svg>`
+
+    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("fixes textpath element", () => {
+    const input = `<svg><textpath></textpath></svg>`
+    const expected = `<svg><textPath></textPath></svg>`
+
+    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("fixes nested SVG elements", () => {
+    const input = `<svg><defs><lineargradient id="grad"><stop /></lineargradient></defs></svg>`
+    const expected = `<svg><defs><linearGradient id="grad"><stop /></linearGradient></defs></svg>`
+
+    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("preserves already correct camelCase elements", () => {
+    const input = `<svg><linearGradient></linearGradient></svg>`
+    const expected = `<svg><linearGradient></linearGradient></svg>`
+
+    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+  })
+
+  test("fixes mixed case issues", () => {
+    const input = `<svg><LineArGrAdIeNt></LineArGrAdIeNt></svg>`
+    const expected = `<svg><linearGradient></linearGradient></svg>`
+
+    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+})
diff --git a/javascript/packages/linter/test/rules/erb-requires-trailing-newline.test.ts b/javascript/packages/linter/test/rules/erb-requires-trailing-newline.test.ts
index 63c149b01..823a68b5c 100644
--- a/javascript/packages/linter/test/rules/erb-requires-trailing-newline.test.ts
+++ b/javascript/packages/linter/test/rules/erb-requires-trailing-newline.test.ts
@@ -40,14 +40,14 @@ describe("ERBRequiresTrailingNewlineRule", () => {
       </h1>
     `
 
-    expectError("File must end with trailing newline")
+    expectError("File must end with trailing newline.")
     assertOffenses(html, { fileName: "test.html.erb" })
   })
 
   test("should report errors for single line files without newline", () => {
     const html = `<%= render partial: "header" %>`
 
-    expectError("File must end with trailing newline")
+    expectError("File must end with trailing newline.")
     assertOffenses(html, { fileName: "test.html.erb" })
   })
 
@@ -61,7 +61,7 @@ describe("ERBRequiresTrailingNewlineRule", () => {
       </div>
     `
 
-    expectError("File must end with trailing newline")
+    expectError("File must end with trailing newline.")
     assertOffenses(html, { fileName: "test.html.erb" })
   })
 
@@ -81,7 +81,7 @@ describe("ERBRequiresTrailingNewlineRule", () => {
   test("should handle ERB-only template without trailing newline", () => {
     const html = `<%= hello world %>`
 
-    expectError("File must end with trailing newline")
+    expectError("File must end with trailing newline.")
     assertOffenses(html, { fileName: "test.html.erb" })
   })
 
@@ -100,7 +100,7 @@ describe("ERBRequiresTrailingNewlineRule", () => {
   test("should flag empty file with whitespace", () => {
     const html = ` `
 
-    expectError("File must end with trailing newline")
+    expectError("File must end with trailing newline.")
     assertOffenses(html, { fileName: "test.html.erb" })
   })
 
@@ -139,7 +139,19 @@ describe("ERBRequiresTrailingNewlineRule", () => {
       </h1>
     `
 
-    expectError("File must end with trailing newline")
+    expectError("File must end with trailing newline.")
     assertOffenses(html, { fileName: "template.html.erb" })
   })
+
+  test("", () => {
+    expectError("File must end with exactly one trailing newline.")
+
+    assertOffenses(`<div>Hello</div>\n\n`, { fileName: "template.html.erb" })
+  })
+
+  test("", () => {
+    expectError("File must end with exactly one trailing newline.")
+
+    assertOffenses(`<div>Hello</div>\n\n\n\n\n\n`, { fileName: "template.html.erb" })
+  })
 })
diff --git a/javascript/packages/linter/unformatted.html.erb b/javascript/packages/linter/unformatted.html.erb
new file mode 100644
index 000000000..581b4a43e
--- /dev/null
+++ b/javascript/packages/linter/unformatted.html.erb
@@ -0,0 +1,3 @@
+<% if true %>
+<div></div>
+<% end %>

From dcc18cc4e0571ba92279354d930d60aad32bbc9d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Mon, 13 Oct 2025 10:12:12 +0200
Subject: [PATCH 50/97] C: Implement rudimentary arena allocator `hb_arena.c`
 (#623)

This pull request implements a rudimentary arena allocator.

It provides an initial interface for performing allocations using the
function `hb_arena_alloc(...)`.

## Implementation Details

All returned pointers **have an 8 byte alignment.** `malloc` on x64
machines returns 16 byte aligned memory
[ref](https://refspecs.linuxbase.org/elf/x86_64-abi-0.99.pdf), but from
everything I could find only 128bit integers and simd types really
require 16 bytes. Since we don't use SIMD right now, I think we can go
with 8 bytes.

We use [`mmap`](https://man7.org/linux/man-pages/man2/mmap.2.html) for
allocating the memory which only allocates the memory when the page is
actually written to on modern UNIX operating systems. This has the
advantage that we can reservce e.g. 512mb of memory and the OS only
really allocates the memory if we make our first write.

## `mmap` example

```c
#include <string.h>
#include <stdlib.h>
#include <stddef.h>
#include <unistd.h>
#include <sys/mman.h>

#define KB(kb) (1024 * kb)
#define MB(mb) (1024 * KB(mb))

int main() {
  size_t memory_size = MB(512);
  char *memory = mmap(NULL, memory_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

  memset(memory, 0, MB(400));

  sleep(100);
}
```

Compile and start program

```bash
$ ./a.out &
$ vmmap $PID_SHOWN_IN_TERMINAL
```

```
...
                                 VIRTUAL   RESIDENT      DIRTY    SWAPPED ALLOCATION      BYTES DIRTY+SWAP          REGION
MALLOC ZONE                         SIZE       SIZE       SIZE       SIZE      COUNT  ALLOCATED  FRAG SIZE  % FRAG   COUNT
===========                      =======  =========  =========  =========  =========  =========  =========  ======  ======
DefaultMallocZone_0x104a5c000     524.5M     400.1M     400.1M         0K        185     512.0M         0K      0%      10
```

### Activity Manager View

<img width="1611" height="137" alt="memory_usage"
src="https://github.com/user-attachments/assets/99f884e5-268d-4679-8e58-10fcf32ce92f"
/>
---
 javascript/packages/node/binding.gyp |  1 +
 src/hb_arena.c                       | 57 ++++++++++++++++++++++++++++
 src/include/hb_arena.h               | 20 ++++++++++
 test/c/main.c                        |  2 +
 test/c/test_hb_arena.c               | 57 ++++++++++++++++++++++++++++
 5 files changed, 137 insertions(+)
 create mode 100644 src/hb_arena.c
 create mode 100644 src/include/hb_arena.h
 create mode 100644 test/c/test_hb_arena.c

diff --git a/javascript/packages/node/binding.gyp b/javascript/packages/node/binding.gyp
index be7da9a78..ddd71d496 100644
--- a/javascript/packages/node/binding.gyp
+++ b/javascript/packages/node/binding.gyp
@@ -27,6 +27,7 @@
         "./extension/libherb/lexer_peek_helpers.c",
         "./extension/libherb/lexer.c",
         "./extension/libherb/location.c",
+        "./extension/libherb/hb_arena.c",
         "./extension/libherb/parser_helpers.c",
         "./extension/libherb/parser.c",
         "./extension/libherb/pretty_print.c",
diff --git a/src/hb_arena.c b/src/hb_arena.c
new file mode 100644
index 000000000..81d6dfee7
--- /dev/null
+++ b/src/hb_arena.c
@@ -0,0 +1,57 @@
+#ifdef __linux__
+#define _GNU_SOURCE
+#endif
+#include "include/hb_arena.h"
+#include <stdbool.h>
+#include <sys/mman.h>
+
+#define KB(kb) (1024 * kb)
+#define MB(mb) (1024 * KB(mb))
+
+bool hb_arena_init(hb_arena_T* allocator, size_t size) {
+  allocator->memory = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+
+  if (allocator->memory == MAP_FAILED) {
+    allocator->memory = NULL;
+    allocator->position = 0;
+    allocator->capacity = 0;
+    return false;
+  }
+
+  allocator->position = 0;
+  allocator->capacity = size;
+  return true;
+}
+
+void* hb_arena_alloc(hb_arena_T* allocator, size_t size) {
+  size_t required_size = ((size + 7) / 8) * 8; // rounds up to the next 8 bytes
+
+  if (allocator->position + required_size > allocator->capacity) { return NULL; }
+
+  size_t offset = allocator->position;
+  void* ptr = &allocator->memory[offset];
+  allocator->position += required_size;
+
+  return ptr;
+}
+
+size_t hb_arena_position(hb_arena_T* allocator) {
+  return allocator->position;
+}
+
+void hb_arena_reset(hb_arena_T* allocator) {
+  allocator->position = 0;
+}
+
+void hb_arena_reset_to(hb_arena_T* allocator, size_t new_position) {
+  if (new_position <= allocator->capacity) { allocator->position = new_position; }
+}
+
+void hb_arena_free(hb_arena_T* allocator) {
+  if (allocator->memory != NULL) {
+    munmap(allocator->memory, allocator->capacity);
+    allocator->memory = NULL;
+    allocator->position = 0;
+    allocator->capacity = 0;
+  }
+}
diff --git a/src/include/hb_arena.h b/src/include/hb_arena.h
new file mode 100644
index 000000000..f58df0a21
--- /dev/null
+++ b/src/include/hb_arena.h
@@ -0,0 +1,20 @@
+#ifndef HERB_ARENA_H
+#define HERB_ARENA_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef struct HB_ARENA_ALLOCATOR_STRUCT {
+  char* memory;
+  size_t capacity;
+  size_t position;
+} hb_arena_T;
+
+bool hb_arena_init(hb_arena_T* allocator, size_t size);
+void* hb_arena_alloc(hb_arena_T* allocator, size_t size);
+size_t hb_arena_position(hb_arena_T* allocator);
+void hb_arena_reset(hb_arena_T* allocator);
+void hb_arena_reset_to(hb_arena_T* allocator, size_t new_position);
+void hb_arena_free(hb_arena_T* allocator);
+
+#endif
diff --git a/test/c/main.c b/test/c/main.c
index c47f68534..b2f7f23aa 100644
--- a/test/c/main.c
+++ b/test/c/main.c
@@ -10,6 +10,7 @@ TCase *lex_tests(void);
 TCase *token_tests(void);
 TCase *util_tests(void);
 TCase *hb_string_tests(void);
+TCase *hb_arena_tests(void);
 
 Suite *herb_suite(void) {
   Suite *suite = suite_create("Herb Suite");
@@ -23,6 +24,7 @@ Suite *herb_suite(void) {
   suite_add_tcase(suite, token_tests());
   suite_add_tcase(suite, util_tests());
   suite_add_tcase(suite, hb_string_tests());
+  suite_add_tcase(suite, hb_arena_tests());
 
   return suite;
 }
diff --git a/test/c/test_hb_arena.c b/test/c/test_hb_arena.c
new file mode 100644
index 000000000..580c8103a
--- /dev/null
+++ b/test/c/test_hb_arena.c
@@ -0,0 +1,57 @@
+#include "include/test.h"
+#include "../../src/include/hb_arena.h"
+
+// Test appending text to buffer
+TEST(test_arena_alloc)
+  hb_arena_T allocator;
+
+  hb_arena_init(&allocator, 1024);
+  ck_assert_int_eq(allocator.position, 0);
+  ck_assert_int_eq(allocator.capacity, 1024);
+
+  {
+    // Ensure memory is writable
+    char *memory = hb_arena_alloc(&allocator, 1);
+    *memory = 'a';
+  }
+
+  ck_assert(allocator.position % 8 == 0);
+  ck_assert_int_eq(allocator.position, 8);
+
+  char *memory = hb_arena_alloc(&allocator, allocator.capacity - allocator.position);
+  ck_assert_ptr_nonnull(memory);
+  ck_assert(allocator.position % 8 == 0);
+END
+
+TEST(test_arena_free)
+  hb_arena_T allocator;
+
+  {
+    hb_arena_init(&allocator, 1024);
+    hb_arena_free(&allocator);
+
+    ck_assert_ptr_null(allocator.memory);
+    ck_assert_int_eq(allocator.capacity, 0);
+    ck_assert_int_eq(allocator.position, 0);
+  }
+
+  {
+    hb_arena_init(&allocator, 1024);
+    hb_arena_free(&allocator);
+    hb_arena_free(&allocator);
+
+    ck_assert_ptr_null(allocator.memory);
+    ck_assert_int_eq(allocator.capacity, 0);
+    ck_assert_int_eq(allocator.position, 0);
+  }
+END
+
+
+TCase *hb_arena_tests(void) {
+  TCase *tags = tcase_create("arena");
+
+  tcase_add_test(tags, test_arena_alloc);
+  tcase_add_test(tags, test_arena_free);
+
+  return tags;
+}

From 069e1f02d5b77f743925843eeebebf2a885622d6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Mon, 13 Oct 2025 10:17:02 +0200
Subject: [PATCH 51/97] C: Make parser options a normal struct member of the
 parser (#625)

This pull request changes the way we store the parser options in the parser
struct.

Instead of a heap allocation, we just use a local member.

In addition to less pointer chasing when checking the options, we also
get an explicit definition of the default parser options.

Public interfaces are unchanged by this refactoring.
---
 src/herb.c           |  7 ++++++-
 src/include/parser.h |  6 ++++--
 src/parser.c         | 19 +++++++------------
 3 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/src/herb.c b/src/herb.c
index c6a217347..2572539c5 100644
--- a/src/herb.c
+++ b/src/herb.c
@@ -32,7 +32,12 @@ AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options) {
   lexer_T lexer = { 0 };
   lexer_init(&lexer, source);
   parser_T parser = { 0 };
-  herb_parser_init(&parser, &lexer, options);
+
+  parser_options_T parser_options = HERB_DEFAULT_PARSER_OPTIONS;
+
+  if (options != NULL) { parser_options = *options; }
+
+  herb_parser_init(&parser, &lexer, parser_options);
 
   AST_DOCUMENT_NODE_T* document = herb_parser_parse(&parser);
 
diff --git a/src/include/parser.h b/src/include/parser.h
index fd5509ef7..eb9ef05d1 100644
--- a/src/include/parser.h
+++ b/src/include/parser.h
@@ -19,16 +19,18 @@ typedef struct PARSER_OPTIONS_STRUCT {
   bool track_whitespace;
 } parser_options_T;
 
+extern const parser_options_T HERB_DEFAULT_PARSER_OPTIONS;
+
 typedef struct PARSER_STRUCT {
   lexer_T* lexer;
   token_T* current_token;
   array_T* open_tags_stack;
   parser_state_T state;
   foreign_content_type_T foreign_content_type;
-  parser_options_T* options;
+  parser_options_T options;
 } parser_T;
 
-void herb_parser_init(parser_T* parser, lexer_T* lexer, parser_options_T* options);
+void herb_parser_init(parser_T* parser, lexer_T* lexer, parser_options_T options);
 
 AST_DOCUMENT_NODE_T* herb_parser_parse(parser_T* parser);
 
diff --git a/src/parser.c b/src/parser.c
index a45e1e941..d331c0cf7 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -27,23 +27,19 @@ static bool parser_lookahead_erb_is_attribute(lexer_T* lexer);
 static void parser_handle_erb_in_open_tag(parser_T* parser, array_T* children);
 static void parser_handle_whitespace_in_open_tag(parser_T* parser, array_T* children);
 
+const parser_options_T HERB_DEFAULT_PARSER_OPTIONS = { .track_whitespace = false };
+
 size_t parser_sizeof(void) {
   return sizeof(struct PARSER_STRUCT);
 }
 
-void herb_parser_init(parser_T* parser, lexer_T* lexer, parser_options_T* options) {
+void herb_parser_init(parser_T* parser, lexer_T* lexer, parser_options_T options) {
   parser->lexer = lexer;
   parser->current_token = lexer_next_token(lexer);
   parser->open_tags_stack = array_init(16);
   parser->state = PARSER_STATE_DATA;
   parser->foreign_content_type = FOREIGN_CONTENT_UNKNOWN;
-
-  if (options) {
-    parser->options = calloc(1, sizeof(parser_options_T));
-    parser->options->track_whitespace = options->track_whitespace;
-  } else {
-    parser->options = NULL;
-  }
+  parser->options = options;
 }
 
 static AST_CDATA_NODE_T* parser_parse_cdata(parser_T* parser) {
@@ -561,7 +557,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
 static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser) {
   AST_HTML_ATTRIBUTE_NAME_NODE_T* attribute_name = parser_parse_html_attribute_name(parser);
 
-  if (parser->options && parser->options->track_whitespace) {
+  if (parser->options.track_whitespace) {
     bool has_equals = (parser->current_token->type == TOKEN_EQUALS)
                    || lexer_peek_for_token_type_after_whitespace(parser->lexer, TOKEN_EQUALS);
 
@@ -1209,7 +1205,7 @@ AST_DOCUMENT_NODE_T* herb_parser_parse(parser_T* parser) {
 }
 
 static void parser_handle_whitespace(parser_T* parser, token_T* whitespace_token, array_T* children) {
-  if (parser->options && parser->options->track_whitespace) {
+  if (parser->options.track_whitespace) {
     array_T* errors = array_init(8);
     AST_WHITESPACE_NODE_T* whitespace_node = ast_whitespace_node_init(
       whitespace_token,
@@ -1227,7 +1223,7 @@ static void parser_consume_whitespace(parser_T* parser, array_T* children) {
   while (token_is_any_of(parser, TOKEN_WHITESPACE, TOKEN_NEWLINE)) {
     token_T* whitespace = parser_advance(parser);
 
-    if (parser->options && parser->options->track_whitespace && children != NULL) {
+    if (parser->options.track_whitespace && children != NULL) {
       parser_handle_whitespace(parser, whitespace, children);
     } else {
       token_free(whitespace);
@@ -1240,7 +1236,6 @@ void parser_free(parser_T* parser) {
 
   if (parser->current_token != NULL) { token_free(parser->current_token); }
   if (parser->open_tags_stack != NULL) { array_free(&parser->open_tags_stack); }
-  if (parser->options != NULL) { free(parser->options); }
 
   free(parser);
 }

From c1636c77e0271c6e22b8aa43a129e1efb7ff7be7 Mon Sep 17 00:00:00 2001
From: Domingo Edwards <dedwards@buk.cl>
Date: Mon, 13 Oct 2025 06:50:19 -0300
Subject: [PATCH 52/97] Linter: Implement `erb-no-extra-newline` linter rule
 (#557)

Implements the `ExtraNewLine` rule from
[ERBLint](https://github.com/Shopify/erb_lint).

This rules avoid having multiple extra consecutives new lines in one
file.

Resolves #541

---------

Co-authored-by: Marco Roth <marco.roth@intergga.ch>
---
 .../packages/linter/docs/rules/README.md      |   1 +
 .../linter/docs/rules/erb-no-extra-newline.md |  74 +++++
 .../packages/linter/src/default-rules.ts      |   2 +
 .../linter/src/rules/erb-no-extra-newline.ts  |  85 ++++++
 javascript/packages/linter/src/rules/index.ts |   3 +-
 .../test/__snapshots__/cli.test.ts.snap       |   6 +-
 .../erb-no-extra-newline.autofix.test.ts      | 283 ++++++++++++++++++
 .../test/rules/erb-no-extra-newline.test.ts   |  84 ++++++
 javascript/packages/vscode/package.json       |   1 +
 9 files changed, 535 insertions(+), 4 deletions(-)
 create mode 100644 javascript/packages/linter/docs/rules/erb-no-extra-newline.md
 create mode 100644 javascript/packages/linter/src/rules/erb-no-extra-newline.ts
 create mode 100644 javascript/packages/linter/test/autofix/erb-no-extra-newline.autofix.test.ts
 create mode 100644 javascript/packages/linter/test/rules/erb-no-extra-newline.test.ts

diff --git a/javascript/packages/linter/docs/rules/README.md b/javascript/packages/linter/docs/rules/README.md
index cdbec364c..b329bd748 100644
--- a/javascript/packages/linter/docs/rules/README.md
+++ b/javascript/packages/linter/docs/rules/README.md
@@ -7,6 +7,7 @@ This page contains documentation for all Herb Linter rules.
 - [`erb-comment-syntax`](./erb-comment-syntax.md) - Disallow Ruby comments immediately after ERB tags
 - [`erb-no-case-node-children`](./erb-no-case-node-children.md) - Don't use `children` for `case/when` and `case/in` nodes
 - [`erb-no-empty-tags`](./erb-no-empty-tags.md) - Disallow empty ERB tags
+- [`erb-no-extra-newline`](./erb-no-extra-newline.md) - Disallow extra newlines.
 - [`erb-no-output-control-flow`](./erb-no-output-control-flow.md) - Prevents outputting control flow blocks
 - [`erb-no-silent-tag-in-attribute-name`](./erb-no-silent-tag-in-attribute-name.md) - Disallow ERB silent tags in HTML attribute names
 - [`erb-prefer-image-tag-helper`](./erb-prefer-image-tag-helper.md) - Prefer `image_tag` helper over `<img>` with ERB expressions
diff --git a/javascript/packages/linter/docs/rules/erb-no-extra-newline.md b/javascript/packages/linter/docs/rules/erb-no-extra-newline.md
new file mode 100644
index 000000000..0a6cfa1a1
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/erb-no-extra-newline.md
@@ -0,0 +1,74 @@
+# Linter Rule: Disallow extra newlines
+
+**Rule:** `erb-no-extra-newline`
+
+## Description
+
+Disallow more than two consecutive blank lines in ERB templates. This rule enforces a maximum of two blank lines between content to maintain consistent vertical spacing throughout your templates.
+
+## Rationale
+
+Excessive blank lines can make templates harder to read and maintain. While some vertical spacing improves readability by visually separating logical sections, too many blank lines create unnecessary whitespace that:
+
+* Makes it harder to see related code on the same screen
+* Creates inconsistent visual rhythm in the codebase
+* Can accidentally accumulate through merge conflicts or refactoring
+* Provides no additional clarity beyond what 1-2 blank lines already achieve
+
+Limiting to two consecutive blank lines strikes a balance between allowing clear section separation while maintaining code density and readability.
+
+## Examples
+
+### ✅ Good
+
+```html
+line 1
+
+line 3
+
+<div>
+  <h1>Title</h1>
+</div>
+
+<div>
+  <h1>Section 1</h1>
+
+  <p>Content here</p>
+</div>
+
+<div>
+  <h1>Section 1</h1>
+
+
+  <h1>Section 2</h1>
+</div>
+```
+
+### 🚫 Bad
+
+```erb
+line 1
+
+
+
+line 3
+
+<div>
+  <h1>Title</h1>
+
+
+
+  <p>Content</p>
+</div>
+
+<%= user.name %>
+
+
+
+
+<%= user.email %>
+```
+
+## References
+
+- [Inspiration: ERB Lint `ExtraNewline` rule](https://github.com/Shopify/erb_lint/blob/main/README.md)
diff --git a/javascript/packages/linter/src/default-rules.ts b/javascript/packages/linter/src/default-rules.ts
index f26236dcd..322c69a36 100644
--- a/javascript/packages/linter/src/default-rules.ts
+++ b/javascript/packages/linter/src/default-rules.ts
@@ -3,6 +3,7 @@ import type { RuleClass } from "./types.js"
 import { ERBCommentSyntax } from "./rules/erb-comment-syntax.js";
 import { ERBNoCaseNodeChildrenRule } from "./rules/erb-no-case-node-children.js"
 import { ERBNoEmptyTagsRule } from "./rules/erb-no-empty-tags.js"
+import { ERBNoExtraNewLineRule } from "./rules/erb-no-extra-newline.js"
 import { ERBNoOutputControlFlowRule } from "./rules/erb-no-output-control-flow.js"
 import { ERBNoSilentTagInAttributeNameRule } from "./rules/erb-no-silent-tag-in-attribute-name.js"
 import { ERBPreferImageTagHelperRule } from "./rules/erb-prefer-image-tag-helper.js"
@@ -46,6 +47,7 @@ export const defaultRules: RuleClass[] = [
   ERBCommentSyntax,
   ERBNoCaseNodeChildrenRule,
   ERBNoEmptyTagsRule,
+  ERBNoExtraNewLineRule,
   ERBNoOutputControlFlowRule,
   ERBNoSilentTagInAttributeNameRule,
   ERBPreferImageTagHelperRule,
diff --git a/javascript/packages/linter/src/rules/erb-no-extra-newline.ts b/javascript/packages/linter/src/rules/erb-no-extra-newline.ts
new file mode 100644
index 000000000..a2bf96bae
--- /dev/null
+++ b/javascript/packages/linter/src/rules/erb-no-extra-newline.ts
@@ -0,0 +1,85 @@
+import { BaseSourceRuleVisitor } from "./rule-utils.js"
+import { SourceRule } from "../types.js"
+import { Location, Position } from "@herb-tools/core"
+
+import type { Node } from "@herb-tools/core"
+import type { LintOffense, LintContext, BaseAutofixContext } from "../types.js"
+
+interface ERBNoExtraNewLineAutofixContext extends BaseAutofixContext {
+  startOffset: number
+  endOffset: number
+}
+
+function positionFromOffset(source: string, offset: number): Position {
+  let line = 1
+  let column = 0
+  let currentOffset = 0
+
+  for (let i = 0; i < source.length && currentOffset < offset; i++) {
+    const char = source[i]
+    currentOffset++
+    if (char === "\n") {
+      line++
+      column = 0
+    } else {
+      column++
+    }
+  }
+
+  return new Position(line, column)
+}
+
+class ERBNoExtraNewLineVisitor extends BaseSourceRuleVisitor<ERBNoExtraNewLineAutofixContext> {
+  protected visitSource(source: string): void {
+    if (source.length === 0) return
+
+    const regex = /\n{4,}/g
+
+    let match: RegExpExecArray | null
+
+    while ((match = regex.exec(source)) !== null) {
+      const startOffset = match.index + 3
+      const endOffset = match.index + match[0].length
+      const start = positionFromOffset(source, startOffset)
+      const end = positionFromOffset(source, endOffset)
+      const location = new Location(start, end)
+
+      const extraLines = match[0].length - 3
+
+      this.addOffense(
+        `Extra blank line detected. Remove ${extraLines} blank ${extraLines === 1 ? "line" : "lines"} to maintain consistent spacing (max 2 allowed).`,
+        location,
+        "error",
+        {
+          node: null as any as Node,
+          startOffset,
+          endOffset
+        }
+      )
+    }
+  }
+}
+
+export class ERBNoExtraNewLineRule extends SourceRule {
+  static autocorrectable = true
+  name = "erb-no-extra-newline"
+
+  check(source: string, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ERBNoExtraNewLineVisitor(this.name, context)
+
+    visitor.visit(source)
+
+    return visitor.offenses
+  }
+
+  autofix(offense: LintOffense<ERBNoExtraNewLineAutofixContext>, source: string, _context?: Partial<LintContext>): string | null {
+    if (!offense.autofixContext) return null
+
+    const { startOffset, endOffset } = offense.autofixContext
+
+    const before = source.substring(0, startOffset)
+    const after = source.substring(endOffset)
+
+    return before + after
+  }
+}
diff --git a/javascript/packages/linter/src/rules/index.ts b/javascript/packages/linter/src/rules/index.ts
index 5add5e951..eb192e949 100644
--- a/javascript/packages/linter/src/rules/index.ts
+++ b/javascript/packages/linter/src/rules/index.ts
@@ -1,8 +1,9 @@
 export * from "./rule-utils.js"
 
 export * from "./erb-comment-syntax.js"
-export * from "./erb-no-empty-tags.js"
 export * from "./erb-no-case-node-children.js"
+export * from "./erb-no-empty-tags.js"
+export * from "./erb-no-extra-newline.js"
 export * from "./erb-no-output-control-flow.js"
 export * from "./erb-no-silent-tag-in-attribute-name.js"
 export * from "./erb-prefer-image-tag-helper.js"
diff --git a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
index cbc5f81e9..9629ab3c7 100644
--- a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
+++ b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
@@ -574,7 +574,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for bad file 1`]
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 35,
+    "ruleCount": 36,
     "totalErrors": 2,
     "totalOffenses": 2,
     "totalWarnings": 0,
@@ -592,7 +592,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for clean file 1`
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 0,
-    "ruleCount": 35,
+    "ruleCount": 36,
     "totalErrors": 0,
     "totalOffenses": 0,
     "totalWarnings": 0,
@@ -662,7 +662,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for file with err
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 35,
+    "ruleCount": 36,
     "totalErrors": 3,
     "totalOffenses": 3,
     "totalWarnings": 0,
diff --git a/javascript/packages/linter/test/autofix/erb-no-extra-newline.autofix.test.ts b/javascript/packages/linter/test/autofix/erb-no-extra-newline.autofix.test.ts
new file mode 100644
index 000000000..668e9827b
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/erb-no-extra-newline.autofix.test.ts
@@ -0,0 +1,283 @@
+import dedent from "dedent"
+
+import { describe, test, expect, beforeAll } from "vitest"
+
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+
+import { ERBNoExtraNewLineRule } from "../../src/rules/erb-no-extra-newline.js"
+
+describe("erb-no-extra-newline autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("removes extra blank lines in text content", () => {
+    const input = dedent`
+      line 1
+
+
+
+
+      line 2
+    `
+    const expected = dedent`
+      line 1
+
+
+      line 2
+    `
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("does not modify when only two blank lines present", () => {
+    const input = dedent`
+      line 1
+
+      line 2
+    `
+    const expected = dedent`
+      line 1
+
+      line 2
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("does not modify when only three blank lines present", () => {
+    const input = dedent`
+      line 1
+
+
+      line 2
+    `
+    const expected = dedent`
+      line 1
+
+
+      line 2
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("removes multiple occurrences of extra blank lines", () => {
+    const input = dedent`
+      line 1
+
+
+
+      line 2
+
+
+
+      line 3
+    `
+
+    const expected = dedent`
+      line 1
+
+
+      line 2
+
+
+      line 3
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("removes many consecutive blank lines", () => {
+    const input = dedent`
+      line 1
+
+
+
+
+      line 2
+    `
+
+    const expected = dedent`
+      line 1
+
+
+      line 2
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("handles HTML elements with extra blank lines", () => {
+    const input = dedent`
+      <div>Hello</div>
+
+
+
+      <div>World</div>
+    `
+
+    const expected = dedent`
+      <div>Hello</div>
+
+
+      <div>World</div>
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("handles ERB tags with extra blank lines", () => {
+    const input = dedent`
+      <%= content %>
+
+
+
+      <%= other_content %>
+    `
+
+    const expected = dedent`
+      <%= content %>
+
+
+      <%= other_content %>
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("does not modify file with no extra blank lines", () => {
+    const input = dedent`
+      line 1
+      line 2
+      line 3
+    `
+
+    const expected = dedent`
+      line 1
+      line 2
+      line 3
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("handles empty file", () => {
+    const input = ''
+    const expected = ''
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("handles file with only newlines", () => {
+    const input = '\n\n\n\n\n'
+    const expected = '\n\n\n'
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("preserves content before and after extra blank lines", () => {
+    const input = dedent`
+      <div>
+        <h1>Title</h1>
+
+
+
+        <p>Content</p>
+      </div>
+    `
+
+    const expected = dedent`
+      <div>
+        <h1>Title</h1>
+
+
+        <p>Content</p>
+      </div>
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("preserves content before and after extra blank lines", () => {
+    const input = dedent`
+      <div>
+        <h1>Title</h1>
+
+
+        <p>Content</p>
+      </div>
+    `
+
+    const expected = dedent`
+      <div>
+        <h1>Title</h1>
+
+
+        <p>Content</p>
+      </div>
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+})
diff --git a/javascript/packages/linter/test/rules/erb-no-extra-newline.test.ts b/javascript/packages/linter/test/rules/erb-no-extra-newline.test.ts
new file mode 100644
index 000000000..827cc8bc0
--- /dev/null
+++ b/javascript/packages/linter/test/rules/erb-no-extra-newline.test.ts
@@ -0,0 +1,84 @@
+import dedent from "dedent"
+
+import { describe, test } from "vitest"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
+
+import { ERBNoExtraNewLineRule } from "../../src/rules/erb-no-extra-newline.js"
+
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBNoExtraNewLineRule)
+
+describe("erb-no-extra-newline", () => {
+  describe("text content", () => {
+    test("when no new line is present", () => {
+      expectNoOffenses(dedent`
+        line 1
+      `)
+    })
+
+    test("when no blank lines are present", () => {
+      expectNoOffenses(dedent`
+        line 1
+        line 2
+        line 3
+      `)
+    })
+
+    test("when a single blank line is present", () => {
+      expectNoOffenses(dedent`
+        line 1
+
+        line 3
+      `)
+    })
+
+    test("when two blank lines follow each other", () => {
+      expectNoOffenses(dedent`
+        line 1
+
+
+        line 3
+      `)
+    })
+
+    test("when more than two newlines follow each other", () => {
+      expectError("Extra blank line detected. Remove 1 blank line to maintain consistent spacing (max 2 allowed).")
+
+      assertOffenses(dedent`
+        line 1
+
+
+
+        line 3
+      `)
+    })
+  })
+
+  describe("HTML elements", () => {
+    test("when no new line is present", () => {
+      expectNoOffenses(dedent`
+        <div>Hello</div>
+      `)
+    })
+
+    test("when two blank lines follow each other", () => {
+      expectNoOffenses(dedent`
+        <div>Hello</div>
+
+
+        <div>Hello</div>
+      `)
+    })
+
+    test("when more than two newlines follow each other", () => {
+      expectError("Extra blank line detected. Remove 1 blank line to maintain consistent spacing (max 2 allowed).")
+
+      assertOffenses(dedent`
+        <div>Hello</div>
+
+
+
+        <div>Hello</div>
+      `)
+    })
+  })
+})
diff --git a/javascript/packages/vscode/package.json b/javascript/packages/vscode/package.json
index 39ab8b60c..68b1d8b30 100644
--- a/javascript/packages/vscode/package.json
+++ b/javascript/packages/vscode/package.json
@@ -64,6 +64,7 @@
               "erb-comment-syntax",
               "erb-no-case-node-children",
               "erb-no-empty-tags",
+              "erb-no-extra-newline",
               "erb-no-output-control-flow",
               "erb-no-silent-tag-in-attribute-name",
               "erb-prefer-image-tag-helper",

From 3045b8908036bcc6018bc4919498234ff3290f86 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Mon, 13 Oct 2025 12:28:08 +0200
Subject: [PATCH 53/97] Playground: Add Herb Linter Autofix Button (#627)

<img width="3436" height="734" alt="CleanShot 2025-10-13 at 11 48 39@2x"
src="https://github.com/user-attachments/assets/5064fb08-0450-4b39-ab1b-6a0e9cb1145c"
/>


<img width="3436" height="734" alt="CleanShot 2025-10-13 at 11 48 06@2x"
src="https://github.com/user-attachments/assets/ccaaba13-6760-4b64-ac7d-8e2f424fbc8c"
/>
---
 playground/index.html                         |  23 +++
 .../src/controllers/playground_controller.js  | 141 ++++++++++++++++++
 2 files changed, 164 insertions(+)

diff --git a/playground/index.html b/playground/index.html
index 24e47c0f6..f976d6d6d 100644
--- a/playground/index.html
+++ b/playground/index.html
@@ -173,6 +173,29 @@
                   </div>
                 </div>
 
+                <div class="relative">
+                  <button
+                    data-action="click->playground#autofixEditor"
+                    data-playground-target="autofixButton"
+                    id="autofix-editor"
+                    class="text-gray-900 dark:text-gray-100 bg-gray-100 dark:bg-gray-800 hover:bg-gray-200 dark:hover:bg-gray-700 rounded-md px-3 py-1.5 text-sm font-medium"
+                  >
+                    <i class="fas fa-wand-magic-sparkles w-4"></i>
+                    <i
+                      class="fas fa-circle-check w-4 text-green-600 hidden ease-in duration-300"
+                    ></i>
+
+                    <span class="ml-1">Autofix</span>
+                  </button>
+                  <div
+                    data-playground-target="autofixTooltip"
+                    class="hidden absolute top-full left-1/2 transform -translate-x-1/2 mt-2 px-2 py-1 text-xs text-white bg-black rounded-md whitespace-nowrap z-50"
+                  >
+                    Autocorrect autocorrectable Herb Linter offenses
+                    <div class="absolute bottom-full left-1/2 transform -translate-x-1/2 w-0 h-0 border-l-4 border-r-4 border-b-4 border-transparent border-b-black"></div>
+                  </div>
+                </div>
+
                 <div class="relative">
                   <button
                     data-action="click->playground#formatEditor"
diff --git a/playground/src/controllers/playground_controller.js b/playground/src/controllers/playground_controller.js
index 2ebd2e7a5..bf50285a1 100644
--- a/playground/src/controllers/playground_controller.js
+++ b/playground/src/controllers/playground_controller.js
@@ -12,6 +12,7 @@ import { replaceTextareaWithMonaco } from "../monaco"
 import { findTreeLocationItemWithSmallestRangeFromPosition } from "../ranges"
 
 import { Herb } from "@herb-tools/browser"
+import { Linter } from "@herb-tools/linter"
 import { analyze } from "../analyze"
 
 window.Herb = Herb
@@ -61,6 +62,8 @@ export default class extends Controller {
     "formatVerification",
     "formatButton",
     "formatTooltip",
+    "autofixButton",
+    "autofixTooltip",
     "printerViewer",
     "printerOutput",
     "printerVerification",
@@ -156,6 +159,7 @@ export default class extends Controller {
 
     this.setupThemeListener()
     this.setupTooltip()
+    this.setupAutofixTooltip()
     this.setupShareTooltip()
     this.setupGitHubTooltip()
     this.setupCopyTooltip()
@@ -191,6 +195,7 @@ export default class extends Controller {
   disconnect() {
     window.removeEventListener("popstate", this.handlePopState)
     this.removeTooltip()
+    this.removeAutofixTooltip()
     this.removeShareTooltip()
     this.removeGitHubTooltip()
     this.removeCopyTooltip()
@@ -621,6 +626,58 @@ export default class extends Controller {
     }
   }
 
+  async autofixEditor(event) {
+    const button = this.getClosestButton(event.target)
+
+    if (button.disabled) {
+      return
+    }
+
+    const wandIcon = button.querySelector(".fa-wand-magic-sparkles")
+    const checkIcon = button.querySelector(".fa-circle-check")
+
+    try {
+      const value = this.editor ? this.editor.getValue() : this.inputTarget.value
+      const linter = new Linter(Herb)
+      const result = linter.autofix(value)
+
+      if (result && typeof result === "object" && "source" in result) {
+        const fixedCount = Array.isArray(result.fixed) ? result.fixed.length : 0
+
+        if (fixedCount > 0 && typeof result.source === "string") {
+          if (this.editor) {
+            this.editor.setValue(result.source)
+          } else {
+            this.inputTarget.value = result.source
+          }
+
+          if (wandIcon && checkIcon) {
+            wandIcon.classList.add("hidden")
+            checkIcon.classList.remove("hidden")
+            checkIcon.style.display = ""
+
+            setTimeout(() => {
+              this.resetAutofixButtonIcons()
+            }, 1000)
+          }
+
+          const offensesLabel = fixedCount === 1 ? "offense" : "offenses"
+          this.showTemporaryMessage(`Autofixed ${fixedCount} linter ${offensesLabel}`, "success")
+
+          await this.analyze()
+          this.resetAutofixButtonIcons()
+        } else {
+          this.showTemporaryMessage("No autocorrectable linter offenses found", "info")
+        }
+      } else {
+        this.showTemporaryMessage("Failed to autofix linter offenses", "error")
+      }
+    } catch (error) {
+      console.error("Autofix error:", error)
+      this.showTemporaryMessage("Failed to autofix linter offenses", "error")
+    }
+  }
+
   async analyze() {
     this.updateURL()
 
@@ -816,6 +873,24 @@ export default class extends Controller {
       }
     }
 
+    if (this.hasAutofixButtonTarget) {
+      const hasParserErrors = result.parseResult ? result.parseResult.recursiveErrors().length > 0 : false
+      const hasLintOffenses = !!(result.lintResult && Array.isArray(result.lintResult.offenses) && result.lintResult.offenses.length > 0)
+
+      if (hasParserErrors) {
+        this.disableAutofixButton()
+        this.setupAutofixTooltip()
+        this.updateAutofixTooltipText('Cannot autofix code due to parser errors. Fix parser errors in Diagnostics tab first.')
+      } else if (!hasLintOffenses) {
+        this.disableAutofixButton()
+        this.setupAutofixTooltip()
+        this.updateAutofixTooltipText('No Herb Linter offenses found to autofix.')
+      } else {
+        this.enableAutofixButton()
+        this.updateAutofixTooltipText('Autocorrect autocorrectable Herb Linter offenses')
+      }
+    }
+
     if (this.hasRubyViewerTarget) {
       this.rubyViewerTarget.classList.add("language-ruby")
       this.rubyViewerTarget.textContent = result.ruby
@@ -1236,6 +1311,72 @@ export default class extends Controller {
     }
   }
 
+  setupAutofixTooltip() {
+    if (this.hasAutofixTooltipTarget) {
+      this.autofixButtonTarget.addEventListener('mouseenter', this.showAutofixTooltip)
+      this.autofixButtonTarget.addEventListener('mouseleave', this.hideAutofixTooltip)
+    }
+  }
+
+  removeAutofixTooltip() {
+    if (this.hasAutofixTooltipTarget) {
+      this.autofixButtonTarget.removeEventListener('mouseenter', this.showAutofixTooltip)
+      this.autofixButtonTarget.removeEventListener('mouseleave', this.hideAutofixTooltip)
+
+      this.hideAutofixTooltip()
+    }
+  }
+
+  showAutofixTooltip = () => {
+    if (this.hasAutofixTooltipTarget) {
+      this.autofixTooltipTarget.classList.remove('hidden')
+    }
+  }
+
+  hideAutofixTooltip = () => {
+    if (this.hasAutofixTooltipTarget) {
+      this.autofixTooltipTarget.classList.add('hidden')
+    }
+  }
+
+  updateAutofixTooltipText(text) {
+    if (this.hasAutofixTooltipTarget) {
+      const textNode = this.autofixTooltipTarget.firstChild
+      if (textNode && textNode.nodeType === Node.TEXT_NODE) {
+        textNode.textContent = text
+      }
+    }
+  }
+
+  enableAutofixButton() {
+    this.autofixButtonTarget.disabled = false
+    this.autofixButtonTarget.classList.remove('opacity-50', 'cursor-not-allowed')
+    this.autofixButtonTarget.classList.add('hover:bg-gray-200', 'dark:hover:bg-gray-700')
+  }
+
+  disableAutofixButton() {
+    this.autofixButtonTarget.disabled = true
+    this.autofixButtonTarget.classList.add('opacity-50', 'cursor-not-allowed')
+    this.autofixButtonTarget.classList.remove('hover:bg-gray-200', 'dark:hover:bg-gray-700')
+    this.resetAutofixButtonIcons()
+  }
+
+  resetAutofixButtonIcons() {
+    if (!this.hasAutofixButtonTarget) return
+
+    const wandIcon = this.autofixButtonTarget.querySelector(".fa-wand-magic-sparkles")
+    const checkIcon = this.autofixButtonTarget.querySelector(".fa-circle-check")
+
+    if (wandIcon) {
+      wandIcon.classList.remove("hidden")
+    }
+
+    if (checkIcon) {
+      checkIcon.classList.add("hidden")
+      checkIcon.style.display = ""
+    }
+  }
+
   setupShareTooltip() {
     if (this.hasShareButtonTarget && this.hasShareTooltipTarget) {
       this.shareButtonTarget.addEventListener('mouseenter', this.showShareTooltip)

From 8bbaa2d08ea07939458602cde6b94f76dd1333ca Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Mon, 13 Oct 2025 15:26:45 +0200
Subject: [PATCH 54/97] Linter: Fix false positive in `erb-right-trim` when
 using `<%-` (#629)

This pull request resolves a false positive in the `erb-right-trim`
linter rule when using `<%-` opening tag with a `-%>` closing tag.

This is now valid:
```erb
<%- if true -%>
  Something
<%- end -%>
```

Closes https://github.com/marcoroth/herb/issues/628
---
 .../packages/linter/src/rules/erb-right-trim.ts    |  3 +++
 .../linter/test/rules/erb-right-trim.test.ts       | 14 ++++++++++++++
 2 files changed, 17 insertions(+)

diff --git a/javascript/packages/linter/src/rules/erb-right-trim.ts b/javascript/packages/linter/src/rules/erb-right-trim.ts
index 182db6857..0f8a4887b 100644
--- a/javascript/packages/linter/src/rules/erb-right-trim.ts
+++ b/javascript/packages/linter/src/rules/erb-right-trim.ts
@@ -7,10 +7,13 @@ import type { ERBNode, ParseResult } from "@herb-tools/core"
 
 class ERBRightTrimVisitor extends BaseRuleVisitor {
   visitERBNode(node: ERBNode): void {
+    if (!node.tag_opening) return
     if (!node.tag_closing) return
 
+    const trimOpening = node.tag_opening.value
     const trimClosing = node.tag_closing.value
 
+    if (trimOpening === "<%-") return
     if (trimClosing !== "=%>" && trimClosing !== "-%>") return
 
     if (!isERBOutputNode(node)) {
diff --git a/javascript/packages/linter/test/rules/erb-right-trim.test.ts b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
index 8de06caeb..6fa47cad7 100644
--- a/javascript/packages/linter/test/rules/erb-right-trim.test.ts
+++ b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
@@ -117,4 +117,18 @@ describe("ERBRightTrimRule", () => {
       <% end %>
     `)
   })
+
+  test("<%- with -%>", () => {
+    expectNoOffenses(dedent`
+      <%- something -%>
+    `)
+  })
+
+  test("<%- with -%> in if/end", () => {
+    expectNoOffenses(dedent`
+      <%- if true -%>
+        Something
+      <%- end -%>
+    `)
+  })
 })

From 1ac9e9c46b89fe99b12a6aa6febbaa28301bc69a Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Mon, 13 Oct 2025 16:14:59 +0200
Subject: [PATCH 55/97] Linter: Implement Autofix for `erb-right-trim` linter
 rule (#630)

This pull request implements the autofix for the `erb-right-trim` linter
rule, so the offenses can be autocorrect when running using the `--fix`
mode.
---
 .../linter/src/rules/erb-right-trim.ts        |  47 +++-
 .../autofix/erb-right-trim.autofix.test.ts    | 255 ++++++++++++++++++
 .../linter/test/rules/erb-right-trim.test.ts  |  34 +--
 3 files changed, 311 insertions(+), 25 deletions(-)
 create mode 100644 javascript/packages/linter/test/autofix/erb-right-trim.autofix.test.ts

diff --git a/javascript/packages/linter/src/rules/erb-right-trim.ts b/javascript/packages/linter/src/rules/erb-right-trim.ts
index 0f8a4887b..be8199125 100644
--- a/javascript/packages/linter/src/rules/erb-right-trim.ts
+++ b/javascript/packages/linter/src/rules/erb-right-trim.ts
@@ -1,11 +1,15 @@
 import { BaseRuleVisitor } from "./rule-utils.js"
-import { ParserRule } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { isERBOutputNode } from "@herb-tools/core"
 
 import type { LintOffense, LintContext } from "../types.js"
 import type { ERBNode, ParseResult } from "@herb-tools/core"
 
-class ERBRightTrimVisitor extends BaseRuleVisitor {
+interface ERBRightTrimAutofixContext extends BaseAutofixContext {
+  node: Mutable<ERBNode>
+}
+
+class ERBRightTrimVisitor extends BaseRuleVisitor<ERBRightTrimAutofixContext> {
   visitERBNode(node: ERBNode): void {
     if (!node.tag_opening) return
     if (!node.tag_closing) return
@@ -18,8 +22,10 @@ class ERBRightTrimVisitor extends BaseRuleVisitor {
 
     if (!isERBOutputNode(node)) {
       this.addOffense(
-        `Right-trimming with \`${trimClosing}\` has no effect on non-output ERB tags. Use \`%>\` instead`,
-        node.tag_closing.location
+        `Right-trimming with \`${trimClosing}\` has no effect on non-output ERB tags. Use \`%>\` instead.`,
+        node.tag_closing.location,
+        "error",
+        { node }
       )
 
       return
@@ -27,21 +33,46 @@ class ERBRightTrimVisitor extends BaseRuleVisitor {
 
     if (trimClosing === "=%>") {
       this.addOffense(
-        "Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines",
-        node.tag_closing.location
+        "Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.",
+        node.tag_closing.location,
+        "error",
+        { node }
       )
     }
   }
 }
 
-export class ERBRightTrimRule extends ParserRule {
+export class ERBRightTrimRule extends ParserRule<ERBRightTrimAutofixContext> {
+  static autocorrectable = true
   name = "erb-right-trim"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<ERBRightTrimAutofixContext>[] {
     const visitor = new ERBRightTrimVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<ERBRightTrimAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node } = offense.autofixContext
+
+    if (!node.tag_closing) return null
+
+    const closing = node.tag_closing
+
+    if (closing.value === "=%>") {
+      closing.value = "-%>"
+      return result
+    }
+
+    if (closing.value === "-%>") {
+      closing.value = "%>"
+      return result
+    }
+
+    return null
+  }
 }
diff --git a/javascript/packages/linter/test/autofix/erb-right-trim.autofix.test.ts b/javascript/packages/linter/test/autofix/erb-right-trim.autofix.test.ts
new file mode 100644
index 000000000..11a7a06e9
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/erb-right-trim.autofix.test.ts
@@ -0,0 +1,255 @@
+import dedent from "dedent"
+
+import { describe, test, expect, beforeAll } from "vitest"
+
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+
+import { ERBRightTrimRule } from "../../src/rules/erb-right-trim.js"
+
+describe("erb-right-trim autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("when the erb tag close with %>", () => {
+    const input = dedent`
+      <h1>
+        <%= title %>
+      </h1>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(input)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("when output erb tag closes with -%>", () => {
+    const input = dedent`
+      <h1>
+        <%= title -%>
+      </h1>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(input)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  // TODO: figure out if this is actually right
+  test("when non-output tag uses -%>", () => {
+    const input = dedent`
+      <% if condition -%>
+        <p>Content</p>
+      <% elsif other_condition -%>
+        <p>Content</p>
+      <% elsif yet_another_condition -%>
+        <p>Content</p>
+      <% else -%>
+        <p>Content</p>
+      <% end -%>
+    `
+
+    const expected = dedent`
+      <% if condition %>
+        <p>Content</p>
+      <% elsif other_condition %>
+        <p>Content</p>
+      <% elsif yet_another_condition %>
+        <p>Content</p>
+      <% else %>
+        <p>Content</p>
+      <% end %>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(5)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("when the erb tag close with =%>", () => {
+    const input = dedent`
+      <h1>
+        <%= title =%>
+      </h1>
+    `
+
+    const expected = dedent`
+      <h1>
+        <%= title -%>
+      </h1>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("when an if block uses =%>", () => {
+    const input = dedent`
+      <% if condition =%>
+        <p>Content</p>
+      <% end =%>
+    `
+
+    const expected = dedent`
+      <% if condition -%>
+        <p>Content</p>
+      <% end -%>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("when a loop uses =%>", () => {
+    const input = dedent`
+      <% items.each do |item| =%>
+        <li><%= item %></li>
+      <% end %>
+    `
+
+    const expected = dedent`
+      <% items.each do |item| -%>
+        <li><%= item %></li>
+      <% end %>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("when multiple lines use =%>", () => {
+    const input = dedent`
+      <%= first =%>
+      <%= second =%>
+      <%= third =%>
+    `
+
+    const expected = dedent`
+      <%= first -%>
+      <%= second -%>
+      <%= third -%>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(3)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("when mixed valid and invalid syntax is used", () => {
+    const input = dedent`
+      <%= valid %>
+      <%= invalid_trim =%>
+      <%= valid_trim -%>
+      <%= another_invalid =%>
+    `
+
+    const expected = dedent`
+      <%= valid %>
+      <%= invalid_trim -%>
+      <%= valid_trim -%>
+      <%= another_invalid -%>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("when silent ERB uses =%>", () => {
+    const input = dedent`
+      <% silent_operation =%>
+    `
+
+    const expected = dedent`
+      <% silent_operation -%>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("handles =%> in nested structures", () => {
+    const input = dedent`
+      <% if outer_condition =%>
+        <% if inner_condition =%>
+          <p>Nested content</p>
+        <% end %>
+      <% end %>
+    `
+
+    const expected = dedent`
+      <% if outer_condition -%>
+        <% if inner_condition -%>
+          <p>Nested content</p>
+        <% end %>
+      <% end %>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("<%- with -%>", () => {
+    const input = dedent`
+      <%- something -%>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(input)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("<%- with -%> in if/end", () => {
+    const input = dedent`
+      <%- if true -%>
+        Something
+      <%- end -%>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(input)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+})
diff --git a/javascript/packages/linter/test/rules/erb-right-trim.test.ts b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
index 6fa47cad7..363141219 100644
--- a/javascript/packages/linter/test/rules/erb-right-trim.test.ts
+++ b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
@@ -23,11 +23,11 @@ describe("ERBRightTrimRule", () => {
   })
 
   test("when non-output tag uses -%>", () => {
-    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
-    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
-    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
-    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
-    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead")
+    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead.")
+    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead.")
+    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead.")
+    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead.")
+    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead.")
 
     assertOffenses(dedent`
       <% if condition -%>
@@ -43,7 +43,7 @@ describe("ERBRightTrimRule", () => {
   })
 
   test("when the erb tag close with =%>", () => {
-    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
 
     assertOffenses(dedent`
       <h1>
@@ -53,8 +53,8 @@ describe("ERBRightTrimRule", () => {
   })
 
   test("when an if block uses =%>", () => {
-    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
-    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
+    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead.")
+    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead.")
 
     assertOffenses(dedent`
       <% if condition =%>
@@ -64,7 +64,7 @@ describe("ERBRightTrimRule", () => {
   })
 
   test("when a loop uses =%>", () => {
-    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
+    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead.")
 
     assertOffenses(dedent`
       <% items.each do |item| =%>
@@ -74,9 +74,9 @@ describe("ERBRightTrimRule", () => {
   })
 
   test("when multiple lines use =%>", () => {
-    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines")
-    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines")
-    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
 
     assertOffenses(dedent`
       <%= first =%>
@@ -86,8 +86,8 @@ describe("ERBRightTrimRule", () => {
   })
 
   test("when mixed valid and invalid syntax is used", () => {
-    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines")
-    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
 
     assertOffenses(dedent`
       <%= valid %>
@@ -98,7 +98,7 @@ describe("ERBRightTrimRule", () => {
   })
 
   test("when silent ERB uses =%>", () => {
-    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
+    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead.")
 
     assertOffenses(dedent`
       <% silent_operation =%>
@@ -106,8 +106,8 @@ describe("ERBRightTrimRule", () => {
   })
 
   test("handles =%> in nested structures", () => {
-    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
-    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead")
+    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead.")
+    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead.")
 
     assertOffenses(dedent`
       <% if outer_condition =%>

From cc340b51aebe1934c0ec94f13dc0104abbf8967d Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Mon, 13 Oct 2025 19:40:27 +0200
Subject: [PATCH 56/97] C: Namespace `hb_array` and `hb_buffer` and move to
 `src/util/` (#626)

This pull request namespaces the `array` and `buffer` structs into
`hb_array` and `hb_buffer` and moves them into the `src/util/`
directory, [following Prism's directory
structure](https://github.com/ruby/prism/tree/9cb560026d452c0abb497f6f07e3411f558507c6/src/util).

Additonally, it moves the new `hb_string` struct (introduced in #618) to
`src/util` too.
---
 ext/herb/extconf.rb                           |   1 +
 ext/herb/extension.c                          |  12 +-
 ext/herb/extension_helpers.c                  |   6 +-
 ext/herb/extension_helpers.h                  |   2 +-
 javascript/packages/node/binding.gyp          |   6 +-
 .../node/extension/extension_helpers.cpp      |  10 +-
 .../node/extension/extension_helpers.h        |   4 +-
 javascript/packages/node/extension/herb.cpp   |  16 +-
 lib/herb/libherb/array.rb                     |  12 +-
 lib/herb/libherb/buffer.rb                    |  28 +-
 src/analyze.c                                 | 242 ++++++++--------
 src/ast_node.c                                |  10 +-
 src/extract.c                                 |  66 ++---
 src/herb.c                                    |  36 +--
 src/html_util.c                               |  28 +-
 src/include/analyze.h                         |   4 +-
 src/include/analyzed_ruby.h                   |   2 +-
 src/include/array.h                           |  33 ---
 src/include/ast_node.h                        |   4 +-
 src/include/buffer.h                          |  39 ---
 src/include/extract.h                         |   8 +-
 src/include/herb.h                            |  12 +-
 src/include/parser.h                          |   4 +-
 src/include/parser_helpers.h                  |  29 +-
 src/include/pretty_print.h                    |  42 ++-
 src/include/util/hb_array.h                   |  33 +++
 src/include/util/hb_buffer.h                  |  39 +++
 src/include/{ => util}/hb_string.h            |   2 +-
 src/include/visitor.h                         |   2 +-
 src/io.c                                      |  10 +-
 src/lexer.c                                   |  20 +-
 src/main.c                                    |   6 +-
 src/parser.c                                  | 223 +++++++-------
 src/parser_helpers.c                          |  51 ++--
 src/pretty_print.c                            | 102 +++----
 src/util.c                                    |  26 +-
 src/{array.c => util/hb_array.c}              |  48 +--
 src/{buffer.c => util/hb_buffer.c}            |  85 +++---
 src/{ => util}/hb_string.c                    |   2 +-
 templates/ext/herb/error_helpers.c.erb        |   6 +-
 templates/ext/herb/error_helpers.h.erb        |   2 +-
 templates/ext/herb/nodes.c.erb                |   8 +-
 .../node/extension/error_helpers.cpp.erb      |  16 +-
 .../node/extension/error_helpers.h.erb        |   2 +-
 .../packages/node/extension/nodes.cpp.erb     |  14 +-
 .../packages/node/extension/nodes.h.erb       |   2 +-
 templates/src/ast_nodes.c.erb                 |  16 +-
 templates/src/ast_pretty_print.c.erb          |  24 +-
 templates/src/errors.c.erb                    |  44 +--
 templates/src/include/ast_nodes.h.erb         |  14 +-
 templates/src/include/ast_pretty_print.h.erb  |   4 +-
 templates/src/include/errors.h.erb            |  12 +-
 templates/src/visitor.c.erb                   |   8 +-
 templates/template.rb                         |   2 +-
 templates/wasm/error_helpers.cpp.erb          |  18 +-
 templates/wasm/error_helpers.h.erb            |   2 +-
 templates/wasm/nodes.cpp.erb                  |  14 +-
 templates/wasm/nodes.h.erb                    |   2 +-
 test/c/main.c                                 |  16 +-
 test/c/test_array.c                           | 105 -------
 test/c/test_buffer.c                          | 274 ------------------
 test/c/test_hb_array.c                        | 105 +++++++
 test/c/test_hb_buffer.c                       | 274 ++++++++++++++++++
 test/c/test_hb_string.c                       |   4 +-
 test/c/test_lex.c                             |   8 +-
 test/c/test_token.c                           |   4 +-
 test/lexer/text_content_test.rb               |  12 +-
 test/parser/text_content_test.rb              |  12 +-
 ..._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt} |   0
 ..._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt} |   0
 ..._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt} |   0
 ..._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt} |   0
 wasm/extension_helpers.cpp                    |  10 +-
 wasm/extension_helpers.h                      |   2 +-
 wasm/herb-wasm.cpp                            |  18 +-
 75 files changed, 1194 insertions(+), 1165 deletions(-)
 delete mode 100644 src/include/array.h
 delete mode 100644 src/include/buffer.h
 create mode 100644 src/include/util/hb_array.h
 create mode 100644 src/include/util/hb_buffer.h
 rename src/include/{ => util}/hb_string.h (96%)
 rename src/{array.c => util/hb_array.c} (64%)
 rename src/{buffer.c => util/hb_buffer.c} (65%)
 rename src/{ => util}/hb_string.c (97%)
 delete mode 100644 test/c/test_array.c
 delete mode 100644 test/c/test_buffer.c
 create mode 100644 test/c/test_hb_array.c
 create mode 100644 test/c/test_hb_buffer.c
 rename test/snapshots/lexer/text_content_test/{test_0003_text_content_that_exceeds_initial_buffer_T_size_and_needs_to_resize_once_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt => test_0003_text_content_that_exceeds_initial_hb_buffer_T_size_and_needs_to_resize_once_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt} (100%)
 rename test/snapshots/lexer/text_content_test/{test_0004_text_content_that_exceeds_initial_buffer_T_size_and_needs_to_resize_twice_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt => test_0004_text_content_that_exceeds_initial_hb_buffer_T_size_and_needs_to_resize_twice_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt} (100%)
 rename test/snapshots/parser/text_content_test/{test_0006_text_content_that_exceeds_initial_buffer_T_size_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt => test_0006_text_content_that_exceeds_initial_hb_buffer_T_size_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt} (100%)
 rename test/snapshots/parser/text_content_test/{test_0007_text_content_that_exceeds_initial_buffer_T_size_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt => test_0007_text_content_that_exceeds_initial_hb_buffer_T_size_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt} (100%)

diff --git a/ext/herb/extconf.rb b/ext/herb/extconf.rb
index 5dc44cfe4..cb215e568 100644
--- a/ext/herb/extconf.rb
+++ b/ext/herb/extconf.rb
@@ -15,6 +15,7 @@
 prism_include_path = "#{prism_path}/include"
 
 $VPATH << "$(srcdir)/../../src"
+$VPATH << "$(srcdir)/../../src/util"
 $VPATH << prism_src_path
 $VPATH << "#{prism_src_path}/util"
 
diff --git a/ext/herb/extension.c b/ext/herb/extension.c
index d50931f9e..155908ac3 100644
--- a/ext/herb/extension.c
+++ b/ext/herb/extension.c
@@ -19,7 +19,7 @@ VALUE cParseResult;
 static VALUE Herb_lex(VALUE self, VALUE source) {
   char* string = (char*) check_string(source);
 
-  array_T* tokens = herb_lex(string);
+  hb_array_T* tokens = herb_lex(string);
 
   VALUE result = create_lex_result(tokens, source);
 
@@ -30,7 +30,7 @@ static VALUE Herb_lex(VALUE self, VALUE source) {
 
 static VALUE Herb_lex_file(VALUE self, VALUE path) {
   char* file_path = (char*) check_string(path);
-  array_T* tokens = herb_lex_file(file_path);
+  hb_array_T* tokens = herb_lex_file(file_path);
 
   VALUE source_value = read_file_to_ruby_string(file_path);
   VALUE result = create_lex_result(tokens, source_value);
@@ -87,9 +87,9 @@ static VALUE Herb_parse_file(VALUE self, VALUE path) {
 
 static VALUE Herb_extract_ruby(VALUE self, VALUE source) {
   char* string = (char*) check_string(source);
-  buffer_T output;
+  hb_buffer_T output;
 
-  if (!buffer_init(&output, strlen(string))) { return Qnil; }
+  if (!hb_buffer_init(&output, strlen(string))) { return Qnil; }
 
   herb_extract_ruby_to_buffer(string, &output);
 
@@ -101,9 +101,9 @@ static VALUE Herb_extract_ruby(VALUE self, VALUE source) {
 
 static VALUE Herb_extract_html(VALUE self, VALUE source) {
   char* string = (char*) check_string(source);
-  buffer_T output;
+  hb_buffer_T output;
 
-  if (!buffer_init(&output, strlen(string))) { return Qnil; }
+  if (!hb_buffer_init(&output, strlen(string))) { return Qnil; }
 
   herb_extract_html_to_buffer(string, &output);
 
diff --git a/ext/herb/extension_helpers.c b/ext/herb/extension_helpers.c
index e9ab162b5..2cfc0602b 100644
--- a/ext/herb/extension_helpers.c
+++ b/ext/herb/extension_helpers.c
@@ -58,13 +58,13 @@ VALUE rb_token_from_c_struct(token_T* token) {
   return rb_class_new_instance(4, args, cToken);
 }
 
-VALUE create_lex_result(array_T* tokens, VALUE source) {
+VALUE create_lex_result(hb_array_T* tokens, VALUE source) {
   VALUE value = rb_ary_new();
   VALUE warnings = rb_ary_new();
   VALUE errors = rb_ary_new();
 
-  for (size_t i = 0; i < array_size(tokens); i++) {
-    token_T* token = array_get(tokens, i);
+  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+    token_T* token = hb_array_get(tokens, i);
     if (token != NULL) { rb_ary_push(value, rb_token_from_c_struct(token)); }
   }
 
diff --git a/ext/herb/extension_helpers.h b/ext/herb/extension_helpers.h
index d672da2b3..d4a853f07 100644
--- a/ext/herb/extension_helpers.h
+++ b/ext/herb/extension_helpers.h
@@ -18,7 +18,7 @@ VALUE rb_location_from_c_struct(location_T location);
 VALUE rb_token_from_c_struct(token_T* token);
 VALUE rb_range_from_c_struct(range_T range);
 
-VALUE create_lex_result(array_T* tokens, VALUE source);
+VALUE create_lex_result(hb_array_T* tokens, VALUE source);
 VALUE create_parse_result(AST_DOCUMENT_NODE_T* root, VALUE source);
 
 #endif
diff --git a/javascript/packages/node/binding.gyp b/javascript/packages/node/binding.gyp
index ddd71d496..8f4fffb2f 100644
--- a/javascript/packages/node/binding.gyp
+++ b/javascript/packages/node/binding.gyp
@@ -13,11 +13,9 @@
         "./extension/libherb/analyze_helpers.c",
         "./extension/libherb/analyze.c",
         "./extension/libherb/analyzed_ruby.c",
-        "./extension/libherb/array.c",
         "./extension/libherb/ast_node.c",
         "./extension/libherb/ast_nodes.c",
         "./extension/libherb/ast_pretty_print.c",
-        "./extension/libherb/buffer.c",
         "./extension/libherb/element_source.c",
         "./extension/libherb/errors.c",
         "./extension/libherb/extract.c",
@@ -33,11 +31,13 @@
         "./extension/libherb/pretty_print.c",
         "./extension/libherb/prism_helpers.c",
         "./extension/libherb/range.c",
-        "./extension/libherb/hb_string.c",
         "./extension/libherb/token_matchers.c",
         "./extension/libherb/token.c",
         "./extension/libherb/utf8.c",
         "./extension/libherb/util.c",
+        "./extension/libherb/util/hb_array.c",
+        "./extension/libherb/util/hb_buffer.c",
+        "./extension/libherb/util/hb_string.c",
         "./extension/libherb/visitor.c",
 
         # Prism main source files
diff --git a/javascript/packages/node/extension/extension_helpers.cpp b/javascript/packages/node/extension/extension_helpers.cpp
index d48b7556f..9ca985ef0 100644
--- a/javascript/packages/node/extension/extension_helpers.cpp
+++ b/javascript/packages/node/extension/extension_helpers.cpp
@@ -4,15 +4,15 @@
 #include <string.h>
 
 extern "C" {
-#include "../extension/libherb/include/array.h"
 #include "../extension/libherb/include/ast_nodes.h"
-#include "../extension/libherb/include/buffer.h"
 #include "../extension/libherb/include/herb.h"
 #include "../extension/libherb/include/io.h"
 #include "../extension/libherb/include/location.h"
 #include "../extension/libherb/include/position.h"
 #include "../extension/libherb/include/range.h"
 #include "../extension/libherb/include/token.h"
+#include "../extension/libherb/include/util/hb_array.h"
+#include "../extension/libherb/include/util/hb_buffer.h"
 }
 
 #include "error_helpers.h"
@@ -136,7 +136,7 @@ napi_value ReadFileToString(napi_env env, const char* file_path) {
   return result;
 }
 
-napi_value CreateLexResult(napi_env env, array_T* tokens, napi_value source) {
+napi_value CreateLexResult(napi_env env, hb_array_T* tokens, napi_value source) {
   napi_value result, tokens_array, errors_array, warnings_array;
 
   napi_create_object(env, &result);
@@ -146,8 +146,8 @@ napi_value CreateLexResult(napi_env env, array_T* tokens, napi_value source) {
 
   // Add tokens to array
   if (tokens) {
-    for (size_t i = 0; i < array_size(tokens); i++) {
-      token_T* token = (token_T*)array_get(tokens, i);
+    for (size_t i = 0; i < hb_array_size(tokens); i++) {
+      token_T* token = (token_T*)hb_array_get(tokens, i);
       if (token) {
         napi_value token_obj = CreateToken(env, token);
         napi_set_element(env, tokens_array, i, token_obj);
diff --git a/javascript/packages/node/extension/extension_helpers.h b/javascript/packages/node/extension/extension_helpers.h
index 6bfa4f1aa..2e3530b0c 100644
--- a/javascript/packages/node/extension/extension_helpers.h
+++ b/javascript/packages/node/extension/extension_helpers.h
@@ -4,14 +4,14 @@
 #include <node_api.h>
 
 extern "C" {
-#include "../extension/libherb/include/array.h"
 #include "../extension/libherb/include/ast_nodes.h"
+#include "../extension/libherb/include/util/hb_array.h"
 }
 
 char* CheckString(napi_env env, napi_value value);
 napi_value CreateString(napi_env env, const char* str);
 napi_value ReadFileToString(napi_env env, const char* file_path);
-napi_value CreateLexResult(napi_env env, array_T* tokens, napi_value source);
+napi_value CreateLexResult(napi_env env, hb_array_T* tokens, napi_value source);
 napi_value CreateParseResult(napi_env env, AST_DOCUMENT_NODE_T* root, napi_value source);
 
 napi_value CreateLocation(napi_env env, location_T location);
diff --git a/javascript/packages/node/extension/herb.cpp b/javascript/packages/node/extension/herb.cpp
index e470ab027..ec29d11c0 100644
--- a/javascript/packages/node/extension/herb.cpp
+++ b/javascript/packages/node/extension/herb.cpp
@@ -1,12 +1,12 @@
 extern "C" {
 #include "../extension/libherb/include/analyze.h"
-#include "../extension/libherb/include/array.h"
 #include "../extension/libherb/include/ast_nodes.h"
-#include "../extension/libherb/include/buffer.h"
 #include "../extension/libherb/include/herb.h"
 #include "../extension/libherb/include/location.h"
 #include "../extension/libherb/include/range.h"
 #include "../extension/libherb/include/token.h"
+#include "../extension/libherb/include/util/hb_array.h"
+#include "../extension/libherb/include/util/hb_buffer.h"
 }
 
 #include "error_helpers.h"
@@ -31,7 +31,7 @@ napi_value Herb_lex(napi_env env, napi_callback_info info) {
   char* string = CheckString(env, args[0]);
   if (!string) { return nullptr; }
 
-  array_T* tokens = herb_lex(string);
+  hb_array_T* tokens = herb_lex(string);
   napi_value result = CreateLexResult(env, tokens, args[0]);
 
   herb_free_tokens(&tokens);
@@ -53,7 +53,7 @@ napi_value Herb_lex_file(napi_env env, napi_callback_info info) {
   char* file_path = CheckString(env, args[0]);
   if (!file_path) { return nullptr; }
 
-  array_T* tokens = herb_lex_file(file_path);
+  hb_array_T* tokens = herb_lex_file(file_path);
   napi_value source_value = ReadFileToString(env, file_path);
   napi_value result = CreateLexResult(env, tokens, source_value);
 
@@ -155,8 +155,8 @@ napi_value Herb_extract_ruby(napi_env env, napi_callback_info info) {
   char* string = CheckString(env, args[0]);
   if (!string) { return nullptr; }
 
-  buffer_T output;
-  if (!buffer_init(&output, strlen(string))) {
+  hb_buffer_T output;
+  if (!hb_buffer_init(&output, strlen(string))) {
     free(string);
     napi_throw_error(env, nullptr, "Failed to initialize buffer");
     return nullptr;
@@ -185,8 +185,8 @@ napi_value Herb_extract_html(napi_env env, napi_callback_info info) {
   char* string = CheckString(env, args[0]);
   if (!string) { return nullptr; }
 
-  buffer_T output;
-  if (!buffer_init(&output, strlen(string))) {
+  hb_buffer_T output;
+  if (!hb_buffer_init(&output, strlen(string))) {
     free(string);
     napi_throw_error(env, nullptr, "Failed to initialize buffer");
     return nullptr;
diff --git a/lib/herb/libherb/array.rb b/lib/herb/libherb/array.rb
index 6ef705a1b..304252a43 100644
--- a/lib/herb/libherb/array.rb
+++ b/lib/herb/libherb/array.rb
@@ -7,9 +7,9 @@
 
 module Herb
   module LibHerb
-    attach_function :array_get, [:pointer, :int], :pointer
-    attach_function :array_capacity, [:pointer], :size_t
-    attach_function :array_size, [:pointer], :size_t
+    attach_function :hb_array_get, [:pointer, :int], :pointer
+    attach_function :hb_array_capacity, [:pointer], :size_t
+    attach_function :hb_array_size, [:pointer], :size_t
 
     class Array
       extend Forwardable
@@ -24,16 +24,16 @@ def initialize(pointer, item_class)
       end
 
       def capacity
-        LibHerb.array_capacity(pointer)
+        LibHerb.hb_array_capacity(pointer)
       end
 
       def size
-        LibHerb.array_size(pointer)
+        LibHerb.hb_array_size(pointer)
       end
 
       def item_pointers
         size.times.map { |item|
-          LibHerb.array_get(pointer, item)
+          LibHerb.hb_array_get(pointer, item)
         }
       end
 
diff --git a/lib/herb/libherb/buffer.rb b/lib/herb/libherb/buffer.rb
index d682df170..5db3858dc 100644
--- a/lib/herb/libherb/buffer.rb
+++ b/lib/herb/libherb/buffer.rb
@@ -5,16 +5,16 @@
 
 module Herb
   module LibHerb
-    attach_function :buffer_init, [:pointer], :bool
-    attach_function :buffer_free, [:pointer], :void
-    attach_function :buffer_value, [:pointer], :pointer
-    attach_function :buffer_length, [:pointer], :size_t
-    attach_function :buffer_capacity, [:pointer], :size_t
-    attach_function :buffer_sizeof, [], :size_t
-    attach_function :buffer_append, [:pointer, :pointer], :void
+    attach_function :hb_buffer_init, [:pointer], :bool
+    attach_function :hb_buffer_free, [:pointer], :void
+    attach_function :hb_buffer_value, [:pointer], :pointer
+    attach_function :hb_buffer_length, [:pointer], :size_t
+    attach_function :hb_buffer_capacity, [:pointer], :size_t
+    attach_function :hb_buffer_sizeof, [], :size_t
+    attach_function :hb_buffer_append, [:pointer, :pointer], :void
 
     class Buffer
-      SIZEOF = LibHerb.buffer_sizeof
+      SIZEOF = LibHerb.hb_buffer_sizeof
 
       attr_reader :pointer
 
@@ -23,19 +23,19 @@ def initialize(pointer)
       end
 
       def append(string)
-        LibHerb.buffer_append(pointer, string)
+        LibHerb.hb_buffer_append(pointer, string)
       end
 
       def value
-        LibHerb.buffer_value(pointer)
+        LibHerb.hb_buffer_value(pointer)
       end
 
       def length
-        LibHerb.buffer_length(pointer)
+        LibHerb.hb_buffer_length(pointer)
       end
 
       def capacity
-        LibHerb.buffer_capacity(pointer)
+        LibHerb.hb_buffer_capacity(pointer)
       end
 
       def read
@@ -44,11 +44,11 @@ def read
 
       def self.with
         FFI::MemoryPointer.new(SIZEOF) do |pointer|
-          raise "couldn't allocate Buffer" unless LibHerb.buffer_init(pointer)
+          raise "couldn't allocate Buffer" unless LibHerb.hb_buffer_init(pointer)
 
           return yield new(pointer)
         ensure
-          LibHerb.buffer_free(pointer)
+          LibHerb.hb_buffer_free(pointer)
         end
       end
     end
diff --git a/src/analyze.c b/src/analyze.c
index ca8ada004..5e4462bdf 100644
--- a/src/analyze.c
+++ b/src/analyze.c
@@ -1,7 +1,6 @@
 #include "include/analyze.h"
 #include "include/analyze_helpers.h"
 #include "include/analyzed_ruby.h"
-#include "include/array.h"
 #include "include/ast_nodes.h"
 #include "include/errors.h"
 #include "include/extract.h"
@@ -11,6 +10,7 @@
 #include "include/prism_helpers.h"
 #include "include/token_struct.h"
 #include "include/util.h"
+#include "include/util/hb_array.h"
 #include "include/visitor.h"
 
 #include <prism.h>
@@ -73,16 +73,16 @@ static bool analyze_erb_content(const AST_NODE_T* node, void* data) {
 
 static size_t process_block_children(
   AST_NODE_T* node,
-  array_T* array,
+  hb_array_T* array,
   size_t index,
-  array_T* children_array,
+  hb_array_T* children_array,
   analyze_ruby_context_T* context,
   control_type_t parent_type
 );
 
 static size_t process_subsequent_block(
   AST_NODE_T* node,
-  array_T* array,
+  hb_array_T* array,
   size_t index,
   AST_NODE_T** subsequent_out,
   analyze_ruby_context_T* context,
@@ -149,19 +149,19 @@ static bool is_terminator_type(control_type_t parent_type, control_type_t child_
 
 static AST_NODE_T* create_control_node(
   AST_ERB_CONTENT_NODE_T* erb_node,
-  array_T* children,
+  hb_array_T* children,
   AST_NODE_T* subsequent,
   AST_ERB_END_NODE_T* end_node,
   control_type_t control_type
 ) {
-  array_T* errors = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
   position_T start_position = erb_node->tag_opening->location.start;
   position_T end_position = erb_node->tag_closing->location.end;
 
   if (end_node) {
     end_position = end_node->base.location.end;
-  } else if (children && array_size(children) > 0) {
-    AST_NODE_T* last_child = array_get(children, array_size(children) - 1);
+  } else if (children && hb_array_size(children) > 0) {
+    AST_NODE_T* last_child = hb_array_get(children, hb_array_size(children) - 1);
     end_position = last_child->location.end;
   } else if (subsequent) {
     end_position = subsequent->location.end;
@@ -195,22 +195,22 @@ static AST_NODE_T* create_control_node(
       AST_ERB_ELSE_NODE_T* else_node = NULL;
       if (subsequent && subsequent->type == AST_ERB_ELSE_NODE) { else_node = (AST_ERB_ELSE_NODE_T*) subsequent; }
 
-      array_T* when_conditions = array_init(8);
-      array_T* in_conditions = array_init(8);
-      array_T* non_when_non_in_children = array_init(8);
+      hb_array_T* when_conditions = hb_array_init(8);
+      hb_array_T* in_conditions = hb_array_init(8);
+      hb_array_T* non_when_non_in_children = hb_array_init(8);
 
-      for (size_t i = 0; i < array_size(children); i++) {
-        AST_NODE_T* child = array_get(children, i);
+      for (size_t i = 0; i < hb_array_size(children); i++) {
+        AST_NODE_T* child = hb_array_get(children, i);
         if (child && child->type == AST_ERB_WHEN_NODE) {
-          array_append(when_conditions, child);
+          hb_array_append(when_conditions, child);
         } else if (child && child->type == AST_ERB_IN_NODE) {
-          array_append(in_conditions, child);
+          hb_array_append(in_conditions, child);
         } else {
-          array_append(non_when_non_in_children, child);
+          hb_array_append(non_when_non_in_children, child);
         }
       }
 
-      if (array_size(in_conditions) > 0) {
+      if (hb_array_size(in_conditions) > 0) {
         return (AST_NODE_T*) ast_erb_case_match_node_init(
           tag_opening,
           content,
@@ -376,30 +376,30 @@ static AST_NODE_T* create_control_node(
         ast_erb_yield_node_init(tag_opening, content, tag_closing, start_position, end_position, errors);
     }
 
-    default: array_free(&errors); return NULL;
+    default: hb_array_free(&errors); return NULL;
   }
 }
 
 static size_t process_control_structure(
   AST_NODE_T* node,
-  array_T* array,
+  hb_array_T* array,
   size_t index,
-  array_T* output_array,
+  hb_array_T* output_array,
   analyze_ruby_context_T* context,
   control_type_t initial_type
 ) {
-  AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) array_get(array, index);
-  array_T* children = array_init(8);
+  AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) hb_array_get(array, index);
+  hb_array_T* children = hb_array_init(8);
 
   index++;
 
   if (initial_type == CONTROL_TYPE_CASE || initial_type == CONTROL_TYPE_CASE_MATCH) {
-    array_T* when_conditions = array_init(8);
-    array_T* in_conditions = array_init(8);
-    array_T* non_when_non_in_children = array_init(8);
+    hb_array_T* when_conditions = hb_array_init(8);
+    hb_array_T* in_conditions = hb_array_init(8);
+    hb_array_T* non_when_non_in_children = hb_array_init(8);
 
-    while (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    while (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (!next_node) { break; }
 
@@ -410,17 +410,17 @@ static size_t process_control_structure(
         if (next_type == CONTROL_TYPE_WHEN || next_type == CONTROL_TYPE_IN) { break; }
       }
 
-      array_append(non_when_non_in_children, next_node);
+      hb_array_append(non_when_non_in_children, next_node);
       index++;
     }
 
-    while (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    while (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (!next_node) { break; }
 
       if (next_node->type != AST_ERB_CONTENT_NODE) {
-        array_append(non_when_non_in_children, next_node);
+        hb_array_append(non_when_non_in_children, next_node);
         index++;
         continue;
       }
@@ -429,7 +429,7 @@ static size_t process_control_structure(
       control_type_t next_type = detect_control_type(erb_content);
 
       if (next_type == CONTROL_TYPE_WHEN) {
-        array_T* when_statements = array_init(8);
+        hb_array_T* when_statements = hb_array_init(8);
         index++;
 
         index = process_block_children(node, array, index, when_statements, context, CONTROL_TYPE_WHEN);
@@ -441,14 +441,14 @@ static size_t process_control_structure(
           when_statements,
           erb_content->tag_opening->location.start,
           erb_content->tag_closing->location.end,
-          array_init(8)
+          hb_array_init(8)
         );
 
-        array_append(when_conditions, (AST_NODE_T*) when_node);
+        hb_array_append(when_conditions, (AST_NODE_T*) when_node);
 
         continue;
       } else if (next_type == CONTROL_TYPE_IN) {
-        array_T* in_statements = array_init(8);
+        hb_array_T* in_statements = hb_array_init(8);
         index++;
 
         index = process_block_children(node, array, index, in_statements, context, CONTROL_TYPE_IN);
@@ -460,36 +460,36 @@ static size_t process_control_structure(
           in_statements,
           erb_content->tag_opening->location.start,
           erb_content->tag_closing->location.end,
-          array_init(8)
+          hb_array_init(8)
         );
 
-        array_append(in_conditions, (AST_NODE_T*) in_node);
+        hb_array_append(in_conditions, (AST_NODE_T*) in_node);
 
         continue;
       } else if (next_type == CONTROL_TYPE_ELSE || next_type == CONTROL_TYPE_END) {
         break;
       } else {
-        array_append(non_when_non_in_children, next_node);
+        hb_array_append(non_when_non_in_children, next_node);
         index++;
       }
     }
 
     AST_ERB_ELSE_NODE_T* else_clause = NULL;
 
-    if (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
         control_type_t next_type = detect_control_type(next_erb);
 
         if (next_type == CONTROL_TYPE_ELSE) {
-          array_T* else_children = array_init(8);
+          hb_array_T* else_children = hb_array_init(8);
 
           index++;
 
-          while (index < array_size(array)) {
-            AST_NODE_T* child = array_get(array, index);
+          while (index < hb_array_size(array)) {
+            AST_NODE_T* child = hb_array_get(array, index);
 
             if (!child) { break; }
 
@@ -500,7 +500,7 @@ static size_t process_control_structure(
               if (child_type == CONTROL_TYPE_END) { break; }
             }
 
-            array_append(else_children, child);
+            hb_array_append(else_children, child);
             index++;
           }
 
@@ -511,7 +511,7 @@ static size_t process_control_structure(
             else_children,
             next_erb->tag_opening->location.start,
             next_erb->tag_closing->location.end,
-            array_init(8)
+            hb_array_init(8)
           );
         }
       }
@@ -519,8 +519,8 @@ static size_t process_control_structure(
 
     AST_ERB_END_NODE_T* end_node = NULL;
 
-    if (index < array_size(array)) {
-      AST_NODE_T* potential_end = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* potential_end = hb_array_get(array, index);
 
       if (potential_end && potential_end->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* end_erb = (AST_ERB_CONTENT_NODE_T*) potential_end;
@@ -547,15 +547,15 @@ static size_t process_control_structure(
       end_position = end_node->base.location.end;
     } else if (else_clause) {
       end_position = else_clause->base.location.end;
-    } else if (array_size(when_conditions) > 0) {
-      AST_NODE_T* last_when = array_get(when_conditions, array_size(when_conditions) - 1);
+    } else if (hb_array_size(when_conditions) > 0) {
+      AST_NODE_T* last_when = hb_array_get(when_conditions, hb_array_size(when_conditions) - 1);
       end_position = last_when->location.end;
-    } else if (array_size(in_conditions) > 0) {
-      AST_NODE_T* last_in = array_get(in_conditions, array_size(in_conditions) - 1);
+    } else if (hb_array_size(in_conditions) > 0) {
+      AST_NODE_T* last_in = hb_array_get(in_conditions, hb_array_size(in_conditions) - 1);
       end_position = last_in->location.end;
     }
 
-    if (array_size(in_conditions) > 0) {
+    if (hb_array_size(in_conditions) > 0) {
       AST_ERB_CASE_MATCH_NODE_T* case_match_node = ast_erb_case_match_node_init(
         erb_node->tag_opening,
         erb_node->content,
@@ -566,10 +566,10 @@ static size_t process_control_structure(
         end_node,
         start_position,
         end_position,
-        array_init(8)
+        hb_array_init(8)
       );
 
-      array_append(output_array, (AST_NODE_T*) case_match_node);
+      hb_array_append(output_array, (AST_NODE_T*) case_match_node);
       return index;
     }
 
@@ -583,10 +583,10 @@ static size_t process_control_structure(
       end_node,
       start_position,
       end_position,
-      array_init(8)
+      hb_array_init(8)
     );
 
-    array_append(output_array, (AST_NODE_T*) case_node);
+    hb_array_append(output_array, (AST_NODE_T*) case_node);
     return index;
   }
 
@@ -597,8 +597,8 @@ static size_t process_control_structure(
     AST_ERB_ELSE_NODE_T* else_clause = NULL;
     AST_ERB_ENSURE_NODE_T* ensure_clause = NULL;
 
-    if (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
@@ -612,20 +612,20 @@ static size_t process_control_structure(
       }
     }
 
-    if (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
         control_type_t next_type = detect_control_type(next_erb);
 
         if (next_type == CONTROL_TYPE_ELSE) {
-          array_T* else_children = array_init(8);
+          hb_array_T* else_children = hb_array_init(8);
 
           index++;
 
-          while (index < array_size(array)) {
-            AST_NODE_T* child = array_get(array, index);
+          while (index < hb_array_size(array)) {
+            AST_NODE_T* child = hb_array_get(array, index);
 
             if (!child) { break; }
 
@@ -636,7 +636,7 @@ static size_t process_control_structure(
               if (child_type == CONTROL_TYPE_ENSURE || child_type == CONTROL_TYPE_END) { break; }
             }
 
-            array_append(else_children, child);
+            hb_array_append(else_children, child);
             index++;
           }
 
@@ -647,26 +647,26 @@ static size_t process_control_structure(
             else_children,
             next_erb->tag_opening->location.start,
             next_erb->tag_closing->location.end,
-            array_init(8)
+            hb_array_init(8)
           );
         }
       }
     }
 
-    if (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
         control_type_t next_type = detect_control_type(next_erb);
 
         if (next_type == CONTROL_TYPE_ENSURE) {
-          array_T* ensure_children = array_init(8);
+          hb_array_T* ensure_children = hb_array_init(8);
 
           index++;
 
-          while (index < array_size(array)) {
-            AST_NODE_T* child = array_get(array, index);
+          while (index < hb_array_size(array)) {
+            AST_NODE_T* child = hb_array_get(array, index);
 
             if (!child) { break; }
 
@@ -677,7 +677,7 @@ static size_t process_control_structure(
               if (child_type == CONTROL_TYPE_END) { break; }
             }
 
-            array_append(ensure_children, child);
+            hb_array_append(ensure_children, child);
             index++;
           }
 
@@ -688,7 +688,7 @@ static size_t process_control_structure(
             ensure_children,
             next_erb->tag_opening->location.start,
             next_erb->tag_closing->location.end,
-            array_init(8)
+            hb_array_init(8)
           );
         }
       }
@@ -696,8 +696,8 @@ static size_t process_control_structure(
 
     AST_ERB_END_NODE_T* end_node = NULL;
 
-    if (index < array_size(array)) {
-      AST_NODE_T* potential_end = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* potential_end = hb_array_get(array, index);
 
       if (potential_end && potential_end->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* end_erb = (AST_ERB_CONTENT_NODE_T*) potential_end;
@@ -741,10 +741,10 @@ static size_t process_control_structure(
       end_node,
       start_position,
       end_position,
-      array_init(8)
+      hb_array_init(8)
     );
 
-    array_append(output_array, (AST_NODE_T*) begin_node);
+    hb_array_append(output_array, (AST_NODE_T*) begin_node);
     return index;
   }
 
@@ -753,8 +753,8 @@ static size_t process_control_structure(
 
     AST_ERB_END_NODE_T* end_node = NULL;
 
-    if (index < array_size(array)) {
-      AST_NODE_T* potential_close = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* potential_close = hb_array_get(array, index);
 
       if (potential_close && potential_close->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* close_erb = (AST_ERB_CONTENT_NODE_T*) potential_close;
@@ -780,8 +780,8 @@ static size_t process_control_structure(
 
     if (end_node) {
       end_position = end_node->base.location.end;
-    } else if (children && array_size(children) > 0) {
-      AST_NODE_T* last_child = array_get(children, array_size(children) - 1);
+    } else if (children && hb_array_size(children) > 0) {
+      AST_NODE_T* last_child = hb_array_get(children, hb_array_size(children) - 1);
       end_position = last_child->location.end;
     }
 
@@ -793,10 +793,10 @@ static size_t process_control_structure(
       end_node,
       start_position,
       end_position,
-      array_init(8)
+      hb_array_init(8)
     );
 
-    array_append(output_array, (AST_NODE_T*) block_node);
+    hb_array_append(output_array, (AST_NODE_T*) block_node);
     return index;
   }
 
@@ -805,8 +805,8 @@ static size_t process_control_structure(
   AST_NODE_T* subsequent = NULL;
   AST_ERB_END_NODE_T* end_node = NULL;
 
-  if (index < array_size(array)) {
-    AST_NODE_T* next_node = array_get(array, index);
+  if (index < hb_array_size(array)) {
+    AST_NODE_T* next_node = hb_array_get(array, index);
 
     if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
       AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
@@ -818,8 +818,8 @@ static size_t process_control_structure(
     }
   }
 
-  if (index < array_size(array)) {
-    AST_NODE_T* potential_end = array_get(array, index);
+  if (index < hb_array_size(array)) {
+    AST_NODE_T* potential_end = hb_array_get(array, index);
 
     if (potential_end && potential_end->type == AST_ERB_CONTENT_NODE) {
       AST_ERB_CONTENT_NODE_T* end_erb = (AST_ERB_CONTENT_NODE_T*) potential_end;
@@ -841,22 +841,22 @@ static size_t process_control_structure(
 
   AST_NODE_T* control_node = create_control_node(erb_node, children, subsequent, end_node, initial_type);
 
-  if (control_node) { array_append(output_array, control_node); }
+  if (control_node) { hb_array_append(output_array, control_node); }
 
   return index;
 }
 
 static size_t process_subsequent_block(
   AST_NODE_T* node,
-  array_T* array,
+  hb_array_T* array,
   size_t index,
   AST_NODE_T** subsequent_out,
   analyze_ruby_context_T* context,
   control_type_t parent_type
 ) {
-  AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) array_get(array, index);
+  AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) hb_array_get(array, index);
   control_type_t type = detect_control_type(erb_node);
-  array_T* children = array_init(8);
+  hb_array_T* children = hb_array_init(8);
 
   index++;
 
@@ -864,8 +864,8 @@ static size_t process_subsequent_block(
 
   AST_NODE_T* subsequent_node = create_control_node(erb_node, children, NULL, NULL, type);
 
-  if (index < array_size(array)) {
-    AST_NODE_T* next_node = array_get(array, index);
+  if (index < hb_array_size(array)) {
+    AST_NODE_T* next_node = hb_array_get(array, index);
 
     if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
       AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
@@ -916,19 +916,19 @@ static size_t process_subsequent_block(
 
 static size_t process_block_children(
   AST_NODE_T* node,
-  array_T* array,
+  hb_array_T* array,
   size_t index,
-  array_T* children_array,
+  hb_array_T* children_array,
   analyze_ruby_context_T* context,
   control_type_t parent_type
 ) {
-  while (index < array_size(array)) {
-    AST_NODE_T* child = array_get(array, index);
+  while (index < hb_array_size(array)) {
+    AST_NODE_T* child = hb_array_get(array, index);
 
     if (!child) { break; }
 
     if (child->type != AST_ERB_CONTENT_NODE) {
-      array_append(children_array, child);
+      hb_array_append(children_array, child);
       index++;
       continue;
     }
@@ -941,35 +941,35 @@ static size_t process_block_children(
     if (child_type == CONTROL_TYPE_IF || child_type == CONTROL_TYPE_CASE || child_type == CONTROL_TYPE_CASE_MATCH
         || child_type == CONTROL_TYPE_BEGIN || child_type == CONTROL_TYPE_UNLESS || child_type == CONTROL_TYPE_WHILE
         || child_type == CONTROL_TYPE_UNTIL || child_type == CONTROL_TYPE_FOR || child_type == CONTROL_TYPE_BLOCK) {
-      array_T* temp_array = array_init(1);
+      hb_array_T* temp_array = hb_array_init(1);
       size_t new_index = process_control_structure(node, array, index, temp_array, context, child_type);
 
-      if (array_size(temp_array) > 0) { array_append(children_array, array_get(temp_array, 0)); }
+      if (hb_array_size(temp_array) > 0) { hb_array_append(children_array, hb_array_get(temp_array, 0)); }
 
-      array_free(&temp_array);
+      hb_array_free(&temp_array);
 
       index = new_index;
       continue;
     }
 
-    array_append(children_array, child);
+    hb_array_append(children_array, child);
     index++;
   }
 
   return index;
 }
 
-static array_T* rewrite_node_array(AST_NODE_T* node, array_T* array, analyze_ruby_context_T* context) {
-  array_T* new_array = array_init(array_size(array));
+static hb_array_T* rewrite_node_array(AST_NODE_T* node, hb_array_T* array, analyze_ruby_context_T* context) {
+  hb_array_T* new_array = hb_array_init(hb_array_size(array));
   size_t index = 0;
 
-  while (index < array_size(array)) {
-    AST_NODE_T* item = array_get(array, index);
+  while (index < hb_array_size(array)) {
+    AST_NODE_T* item = hb_array_get(array, index);
 
     if (!item) { break; }
 
     if (item->type != AST_ERB_CONTENT_NODE) {
-      array_append(new_array, item);
+      hb_array_append(new_array, item);
       index++;
       continue;
     }
@@ -991,12 +991,12 @@ static array_T* rewrite_node_array(AST_NODE_T* node, array_T* array, analyze_rub
         continue;
 
       case CONTROL_TYPE_YIELD: {
-        AST_NODE_T* yield_node = create_control_node(erb_node, array_init(8), NULL, NULL, type);
+        AST_NODE_T* yield_node = create_control_node(erb_node, hb_array_init(8), NULL, NULL, type);
 
         if (yield_node) {
-          array_append(new_array, yield_node);
+          hb_array_append(new_array, yield_node);
         } else {
-          array_append(new_array, item);
+          hb_array_append(new_array, item);
         }
 
         index++;
@@ -1004,7 +1004,7 @@ static array_T* rewrite_node_array(AST_NODE_T* node, array_T* array, analyze_rub
       }
 
       default:
-        array_append(new_array, item);
+        hb_array_append(new_array, item);
         index++;
         break;
     }
@@ -1019,30 +1019,30 @@ static bool transform_erb_nodes(const AST_NODE_T* node, void* data) {
 
   if (node->type == AST_DOCUMENT_NODE) {
     AST_DOCUMENT_NODE_T* document_node = (AST_DOCUMENT_NODE_T*) node;
-    array_T* old_array = document_node->children;
+    hb_array_T* old_array = document_node->children;
     document_node->children = rewrite_node_array((AST_NODE_T*) node, document_node->children, context);
-    array_free(&old_array);
+    hb_array_free(&old_array);
   }
 
   if (node->type == AST_HTML_ELEMENT_NODE) {
     AST_HTML_ELEMENT_NODE_T* element_node = (AST_HTML_ELEMENT_NODE_T*) node;
-    array_T* old_array = element_node->body;
+    hb_array_T* old_array = element_node->body;
     element_node->body = rewrite_node_array((AST_NODE_T*) node, element_node->body, context);
-    array_free(&old_array);
+    hb_array_free(&old_array);
   }
 
   if (node->type == AST_HTML_OPEN_TAG_NODE) {
     AST_HTML_OPEN_TAG_NODE_T* open_tag = (AST_HTML_OPEN_TAG_NODE_T*) node;
-    array_T* old_array = open_tag->children;
+    hb_array_T* old_array = open_tag->children;
     open_tag->children = rewrite_node_array((AST_NODE_T*) node, open_tag->children, context);
-    array_free(&old_array);
+    hb_array_free(&old_array);
   }
 
   if (node->type == AST_HTML_ATTRIBUTE_VALUE_NODE) {
     AST_HTML_ATTRIBUTE_VALUE_NODE_T* value_node = (AST_HTML_ATTRIBUTE_VALUE_NODE_T*) node;
-    array_T* old_array = value_node->children;
+    hb_array_T* old_array = value_node->children;
     value_node->children = rewrite_node_array((AST_NODE_T*) node, value_node->children, context);
-    array_free(&old_array);
+    hb_array_free(&old_array);
   }
 
   herb_visit_child_nodes(node, transform_erb_nodes, data);
@@ -1056,13 +1056,13 @@ void herb_analyze_parse_tree(AST_DOCUMENT_NODE_T* document, const char* source)
   analyze_ruby_context_T* context = malloc(sizeof(analyze_ruby_context_T));
   context->document = document;
   context->parent = NULL;
-  context->ruby_context_stack = array_init(8);
+  context->ruby_context_stack = hb_array_init(8);
 
   herb_visit_node((AST_NODE_T*) document, transform_erb_nodes, context);
 
   herb_analyze_parse_errors(document, source);
 
-  array_free(&context->ruby_context_stack);
+  hb_array_free(&context->ruby_context_stack);
   free(context);
 }
 
@@ -1081,7 +1081,7 @@ void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source
        error = (const pm_diagnostic_t*) error->node.next) {
 
     RUBY_PARSE_ERROR_T* parse_error = ruby_parse_error_from_prism_error(error, (AST_NODE_T*) document, source, &parser);
-    array_append(document->base.errors, parse_error);
+    hb_array_append(document->base.errors, parse_error);
   }
 
   pm_node_destroy(&parser, root);
diff --git a/src/ast_node.c b/src/ast_node.c
index c70acb936..e66414249 100644
--- a/src/ast_node.c
+++ b/src/ast_node.c
@@ -12,7 +12,7 @@ size_t ast_node_sizeof(void) {
   return sizeof(struct AST_NODE_STRUCT);
 }
 
-void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T start, position_T end, array_T* errors) {
+void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T start, position_T end, hb_array_T* errors) {
   if (!node) { return; }
 
   node->type = type;
@@ -20,7 +20,7 @@ void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T star
   node->location.end = end;
 
   if (errors == NULL) {
-    node->errors = array_init(8);
+    node->errors = hb_array_init(8);
   } else {
     node->errors = errors;
   }
@@ -41,15 +41,15 @@ ast_node_type_T ast_node_type(const AST_NODE_T* node) {
 }
 
 size_t ast_node_errors_count(const AST_NODE_T* node) {
-  return array_size(node->errors);
+  return hb_array_size(node->errors);
 }
 
-array_T* ast_node_errors(const AST_NODE_T* node) {
+hb_array_T* ast_node_errors(const AST_NODE_T* node) {
   return node->errors;
 }
 
 void ast_node_append_error(const AST_NODE_T* node, ERROR_T* error) {
-  array_append(node->errors, error);
+  hb_array_append(node->errors, error);
 }
 
 void ast_node_set_start(AST_NODE_T* node, position_T position) {
diff --git a/src/extract.c b/src/extract.c
index ea3fdb93d..e927632a4 100644
--- a/src/extract.c
+++ b/src/extract.c
@@ -1,22 +1,22 @@
-#include "include/array.h"
-#include "include/buffer.h"
 #include "include/herb.h"
 #include "include/io.h"
 #include "include/lexer.h"
+#include "include/util/hb_array.h"
+#include "include/util/hb_buffer.h"
 
 #include <stdlib.h>
 #include <string.h>
 
-void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* output) {
-  array_T* tokens = herb_lex(source);
+void herb_extract_ruby_to_buffer_with_semicolons(const char* source, hb_buffer_T* output) {
+  hb_array_T* tokens = herb_lex(source);
   bool skip_erb_content = false;
 
-  for (size_t i = 0; i < array_size(tokens); i++) {
-    const token_T* token = array_get(tokens, i);
+  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+    const token_T* token = hb_array_get(tokens, i);
 
     switch (token->type) {
       case TOKEN_NEWLINE: {
-        buffer_append(output, token->value);
+        hb_buffer_append(output, token->value);
         break;
       }
 
@@ -25,15 +25,15 @@ void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* o
           skip_erb_content = true;
         }
 
-        buffer_append_whitespace(output, range_length(token->range));
+        hb_buffer_append_whitespace(output, range_length(token->range));
         break;
       }
 
       case TOKEN_ERB_CONTENT: {
         if (skip_erb_content == false) {
-          buffer_append(output, token->value);
+          hb_buffer_append(output, token->value);
         } else {
-          buffer_append_whitespace(output, range_length(token->range));
+          hb_buffer_append_whitespace(output, range_length(token->range));
         }
 
         break;
@@ -42,13 +42,13 @@ void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* o
       case TOKEN_ERB_END: {
         skip_erb_content = false;
 
-        buffer_append_char(output, ';');
-        buffer_append_whitespace(output, range_length(token->range) - 1);
+        hb_buffer_append_char(output, ';');
+        hb_buffer_append_whitespace(output, range_length(token->range) - 1);
         break;
       }
 
       default: {
-        buffer_append_whitespace(output, range_length(token->range));
+        hb_buffer_append_whitespace(output, range_length(token->range));
       }
     }
   }
@@ -56,16 +56,16 @@ void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* o
   herb_free_tokens(&tokens);
 }
 
-void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
-  array_T* tokens = herb_lex(source);
+void herb_extract_ruby_to_buffer(const char* source, hb_buffer_T* output) {
+  hb_array_T* tokens = herb_lex(source);
   bool skip_erb_content = false;
 
-  for (size_t i = 0; i < array_size(tokens); i++) {
-    const token_T* token = array_get(tokens, i);
+  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+    const token_T* token = hb_array_get(tokens, i);
 
     switch (token->type) {
       case TOKEN_NEWLINE: {
-        buffer_append(output, token->value);
+        hb_buffer_append(output, token->value);
         break;
       }
 
@@ -74,15 +74,15 @@ void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
           skip_erb_content = true;
         }
 
-        buffer_append_whitespace(output, range_length(token->range));
+        hb_buffer_append_whitespace(output, range_length(token->range));
         break;
       }
 
       case TOKEN_ERB_CONTENT: {
         if (skip_erb_content == false) {
-          buffer_append(output, token->value);
+          hb_buffer_append(output, token->value);
         } else {
-          buffer_append_whitespace(output, range_length(token->range));
+          hb_buffer_append_whitespace(output, range_length(token->range));
         }
 
         break;
@@ -91,12 +91,12 @@ void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
       case TOKEN_ERB_END: {
         skip_erb_content = false;
 
-        buffer_append_whitespace(output, range_length(token->range));
+        hb_buffer_append_whitespace(output, range_length(token->range));
         break;
       }
 
       default: {
-        buffer_append_whitespace(output, range_length(token->range));
+        hb_buffer_append_whitespace(output, range_length(token->range));
       }
     }
   }
@@ -104,17 +104,17 @@ void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
   herb_free_tokens(&tokens);
 }
 
-void herb_extract_html_to_buffer(const char* source, buffer_T* output) {
-  array_T* tokens = herb_lex(source);
+void herb_extract_html_to_buffer(const char* source, hb_buffer_T* output) {
+  hb_array_T* tokens = herb_lex(source);
 
-  for (size_t i = 0; i < array_size(tokens); i++) {
-    const token_T* token = array_get(tokens, i);
+  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+    const token_T* token = hb_array_get(tokens, i);
 
     switch (token->type) {
       case TOKEN_ERB_START:
       case TOKEN_ERB_CONTENT:
-      case TOKEN_ERB_END: buffer_append_whitespace(output, range_length(token->range)); break;
-      default: buffer_append(output, token->value);
+      case TOKEN_ERB_END: hb_buffer_append_whitespace(output, range_length(token->range)); break;
+      default: hb_buffer_append(output, token->value);
     }
   }
 
@@ -124,8 +124,8 @@ void herb_extract_html_to_buffer(const char* source, buffer_T* output) {
 char* herb_extract_ruby_with_semicolons(const char* source) {
   if (!source) { return NULL; }
 
-  buffer_T output;
-  buffer_init(&output, strlen(source));
+  hb_buffer_T output;
+  hb_buffer_init(&output, strlen(source));
 
   herb_extract_ruby_to_buffer_with_semicolons(source, &output);
 
@@ -135,8 +135,8 @@ char* herb_extract_ruby_with_semicolons(const char* source) {
 char* herb_extract(const char* source, const herb_extract_language_T language) {
   if (!source) { return NULL; }
 
-  buffer_T output;
-  buffer_init(&output, strlen(source));
+  hb_buffer_T output;
+  hb_buffer_init(&output, strlen(source));
 
   switch (language) {
     case HERB_EXTRACT_LANGUAGE_RUBY: herb_extract_ruby_to_buffer(source, &output); break;
diff --git a/src/herb.c b/src/herb.c
index 2572539c5..bd249e5ff 100644
--- a/src/herb.c
+++ b/src/herb.c
@@ -1,27 +1,27 @@
 #include "include/herb.h"
-#include "include/array.h"
-#include "include/buffer.h"
 #include "include/io.h"
 #include "include/lexer.h"
 #include "include/parser.h"
 #include "include/token.h"
+#include "include/util/hb_array.h"
+#include "include/util/hb_buffer.h"
 #include "include/version.h"
 
 #include <prism.h>
 #include <stdlib.h>
 
-array_T* herb_lex(const char* source) {
+hb_array_T* herb_lex(const char* source) {
   lexer_T lexer = { 0 };
   lexer_init(&lexer, source);
 
   token_T* token = NULL;
-  array_T* tokens = array_init(128);
+  hb_array_T* tokens = hb_array_init(128);
 
   while ((token = lexer_next_token(&lexer))->type != TOKEN_EOF) {
-    array_append(tokens, token);
+    hb_array_append(tokens, token);
   }
 
-  array_append(tokens, token);
+  hb_array_append(tokens, token);
 
   return tokens;
 }
@@ -44,40 +44,40 @@ AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options) {
   return document;
 }
 
-array_T* herb_lex_file(const char* path) {
+hb_array_T* herb_lex_file(const char* path) {
   char* source = herb_read_file(path);
-  array_T* tokens = herb_lex(source);
+  hb_array_T* tokens = herb_lex(source);
 
   free(source);
 
   return tokens;
 }
 
-void herb_lex_to_buffer(const char* source, buffer_T* output) {
-  array_T* tokens = herb_lex(source);
+void herb_lex_to_buffer(const char* source, hb_buffer_T* output) {
+  hb_array_T* tokens = herb_lex(source);
 
-  for (size_t i = 0; i < array_size(tokens); i++) {
-    token_T* token = array_get(tokens, i);
+  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+    token_T* token = hb_array_get(tokens, i);
 
     char* type = token_to_string(token);
-    buffer_append(output, type);
+    hb_buffer_append(output, type);
     free(type);
 
-    buffer_append(output, "\n");
+    hb_buffer_append(output, "\n");
   }
 
   herb_free_tokens(&tokens);
 }
 
-void herb_free_tokens(array_T** tokens) {
+void herb_free_tokens(hb_array_T** tokens) {
   if (!tokens || !*tokens) { return; }
 
-  for (size_t i = 0; i < array_size(*tokens); i++) {
-    token_T* token = array_get(*tokens, i);
+  for (size_t i = 0; i < hb_array_size(*tokens); i++) {
+    token_T* token = hb_array_get(*tokens, i);
     if (token) { token_free(token); }
   }
 
-  array_free(tokens);
+  hb_array_free(tokens);
 }
 
 const char* herb_version(void) {
diff --git a/src/html_util.c b/src/html_util.c
index 9c4132cd8..09cf4296f 100644
--- a/src/html_util.c
+++ b/src/html_util.c
@@ -1,6 +1,6 @@
 #include "include/html_util.h"
-#include "include/buffer.h"
 #include "include/util.h"
+#include "include/util/hb_buffer.h"
 
 #include <ctype.h>
 #include <stdbool.h>
@@ -43,13 +43,13 @@ bool is_void_element(const char* tag_name) {
 char* html_closing_tag_string(const char* tag_name) {
   if (tag_name == NULL) { return herb_strdup("</>"); }
 
-  buffer_T buffer;
-  buffer_init(&buffer, strlen(tag_name) + 3);
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, strlen(tag_name) + 3);
 
-  buffer_append_char(&buffer, '<');
-  buffer_append_char(&buffer, '/');
-  buffer_append(&buffer, tag_name);
-  buffer_append_char(&buffer, '>');
+  hb_buffer_append_char(&buffer, '<');
+  hb_buffer_append_char(&buffer, '/');
+  hb_buffer_append(&buffer, tag_name);
+  hb_buffer_append_char(&buffer, '>');
 
   return buffer.value;
 }
@@ -73,14 +73,14 @@ char* html_closing_tag_string(const char* tag_name) {
 char* html_self_closing_tag_string(const char* tag_name) {
   if (tag_name == NULL) { return herb_strdup("< />"); }
 
-  buffer_T buffer;
-  buffer_init(&buffer, strlen(tag_name) + 4);
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, strlen(tag_name) + 4);
 
-  buffer_append_char(&buffer, '<');
-  buffer_append(&buffer, tag_name);
-  buffer_append_char(&buffer, ' ');
-  buffer_append_char(&buffer, '/');
-  buffer_append_char(&buffer, '>');
+  hb_buffer_append_char(&buffer, '<');
+  hb_buffer_append(&buffer, tag_name);
+  hb_buffer_append_char(&buffer, ' ');
+  hb_buffer_append_char(&buffer, '/');
+  hb_buffer_append_char(&buffer, '>');
 
   return buffer.value;
 }
diff --git a/src/include/analyze.h b/src/include/analyze.h
index d423856d3..d6f5a1049 100644
--- a/src/include/analyze.h
+++ b/src/include/analyze.h
@@ -2,13 +2,13 @@
 #define HERB_ANALYZE_H
 
 #include "analyzed_ruby.h"
-#include "array.h"
 #include "ast_nodes.h"
+#include "util/hb_array.h"
 
 typedef struct ANALYZE_RUBY_CONTEXT_STRUCT {
   AST_DOCUMENT_NODE_T* document;
   AST_NODE_T* parent;
-  array_T* ruby_context_stack;
+  hb_array_T* ruby_context_stack;
 } analyze_ruby_context_T;
 
 typedef enum {
diff --git a/src/include/analyzed_ruby.h b/src/include/analyzed_ruby.h
index 67b2aa9a9..9d32c9715 100644
--- a/src/include/analyzed_ruby.h
+++ b/src/include/analyzed_ruby.h
@@ -1,7 +1,7 @@
 #ifndef HERB_ANALYZED_RUBY_H
 #define HERB_ANALYZED_RUBY_H
 
-#include "array.h"
+#include "util/hb_array.h"
 
 #include <prism.h>
 
diff --git a/src/include/array.h b/src/include/array.h
deleted file mode 100644
index f9715e83f..000000000
--- a/src/include/array.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef HERB_ARRAY_H
-#define HERB_ARRAY_H
-
-#include <stdlib.h>
-
-typedef struct ARRAY_STRUCT {
-  void** items;
-  size_t size;
-  size_t capacity;
-} array_T;
-
-array_T* array_init(size_t capacity);
-
-void* array_get(const array_T* array, size_t index);
-void* array_first(array_T* array);
-void* array_last(array_T* array);
-
-void array_append(array_T* array, void* item);
-void array_set(const array_T* array, size_t index, void* item);
-void array_free(array_T** array);
-void array_remove(array_T* array, size_t index);
-
-size_t array_index_of(array_T* array, void* item);
-void array_remove_item(array_T* array, void* item);
-
-void array_push(array_T* array, void* item);
-void* array_pop(array_T* array);
-
-size_t array_capacity(const array_T* array);
-size_t array_size(const array_T* array);
-size_t array_sizeof(void);
-
-#endif
diff --git a/src/include/ast_node.h b/src/include/ast_node.h
index 23af16d0c..144e35334 100644
--- a/src/include/ast_node.h
+++ b/src/include/ast_node.h
@@ -6,7 +6,7 @@
 #include "position.h"
 #include "token_struct.h"
 
-void ast_node_init(AST_NODE_T* node, ast_node_type_T type, position_T start, position_T end, array_T* errors);
+void ast_node_init(AST_NODE_T* node, ast_node_type_T type, position_T start, position_T end, hb_array_T* errors);
 void ast_node_free(AST_NODE_T* node);
 
 AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token);
@@ -22,7 +22,7 @@ void ast_node_set_start(AST_NODE_T* node, position_T position);
 void ast_node_set_end(AST_NODE_T* node, position_T position);
 
 size_t ast_node_errors_count(const AST_NODE_T* node);
-array_T* ast_node_errors(const AST_NODE_T* node);
+hb_array_T* ast_node_errors(const AST_NODE_T* node);
 void ast_node_append_error(const AST_NODE_T* node, ERROR_T* error);
 
 void ast_node_set_start_from_token(AST_NODE_T* node, const token_T* token);
diff --git a/src/include/buffer.h b/src/include/buffer.h
deleted file mode 100644
index 04c7fcb2b..000000000
--- a/src/include/buffer.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#ifndef HERB_BUFFER_H
-#define HERB_BUFFER_H
-
-#include <stdbool.h>
-#include <stdlib.h>
-
-typedef struct BUFFER_STRUCT {
-  char* value;
-  size_t length;
-  size_t capacity;
-} buffer_T;
-
-bool buffer_init(buffer_T* buffer, size_t capacity);
-buffer_T* buffer_new(size_t capacity);
-
-bool buffer_increase_capacity(buffer_T* buffer, size_t additional_capacity);
-bool buffer_has_capacity(buffer_T* buffer, size_t required_length);
-bool buffer_expand_capacity(buffer_T* buffer);
-bool buffer_expand_if_needed(buffer_T* buffer, size_t required_length);
-bool buffer_resize(buffer_T* buffer, size_t new_capacity);
-
-void buffer_append(buffer_T* buffer, const char* text);
-void buffer_append_with_length(buffer_T* buffer, const char* text, size_t length);
-void buffer_append_char(buffer_T* buffer, char character);
-void buffer_append_repeated(buffer_T* buffer, char character, size_t length);
-void buffer_append_whitespace(buffer_T* buffer, size_t length);
-void buffer_prepend(buffer_T* buffer, const char* text);
-void buffer_concat(buffer_T* destination, buffer_T* source);
-
-char* buffer_value(const buffer_T* buffer);
-
-size_t buffer_length(const buffer_T* buffer);
-size_t buffer_capacity(const buffer_T* buffer);
-size_t buffer_sizeof(void);
-
-void buffer_clear(buffer_T* buffer);
-void buffer_free(buffer_T** buffer);
-
-#endif
diff --git a/src/include/extract.h b/src/include/extract.h
index 668f821a3..2f1704dcc 100644
--- a/src/include/extract.h
+++ b/src/include/extract.h
@@ -1,18 +1,18 @@
 #ifndef HERB_EXTRACT_H
 #define HERB_EXTRACT_H
 
-#include "buffer.h"
+#include "util/hb_buffer.h"
 
 typedef enum {
   HERB_EXTRACT_LANGUAGE_RUBY,
   HERB_EXTRACT_LANGUAGE_HTML,
 } herb_extract_language_T;
 
-void herb_extract_ruby_to_buffer(const char* source, buffer_T* output);
-void herb_extract_html_to_buffer(const char* source, buffer_T* output);
+void herb_extract_ruby_to_buffer(const char* source, hb_buffer_T* output);
+void herb_extract_html_to_buffer(const char* source, hb_buffer_T* output);
 
 char* herb_extract_ruby_with_semicolons(const char* source);
-void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* output);
+void herb_extract_ruby_to_buffer_with_semicolons(const char* source, hb_buffer_T* output);
 
 char* herb_extract(const char* source, herb_extract_language_T language);
 char* herb_extract_from_file(const char* path, herb_extract_language_T language);
diff --git a/src/include/herb.h b/src/include/herb.h
index ef886a087..207053e45 100644
--- a/src/include/herb.h
+++ b/src/include/herb.h
@@ -1,11 +1,11 @@
 #ifndef HERB_H
 #define HERB_H
 
-#include "array.h"
 #include "ast_node.h"
-#include "buffer.h"
 #include "extract.h"
 #include "parser.h"
+#include "util/hb_array.h"
+#include "util/hb_buffer.h"
 
 #include <stdint.h>
 
@@ -13,17 +13,17 @@
 extern "C" {
 #endif
 
-void herb_lex_to_buffer(const char* source, buffer_T* output);
+void herb_lex_to_buffer(const char* source, hb_buffer_T* output);
 
-array_T* herb_lex(const char* source);
-array_T* herb_lex_file(const char* path);
+hb_array_T* herb_lex(const char* source);
+hb_array_T* herb_lex_file(const char* path);
 
 AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options);
 
 const char* herb_version(void);
 const char* herb_prism_version(void);
 
-void herb_free_tokens(array_T** tokens);
+void herb_free_tokens(hb_array_T** tokens);
 
 #ifdef __cplusplus
 }
diff --git a/src/include/parser.h b/src/include/parser.h
index eb9ef05d1..29a8c8b17 100644
--- a/src/include/parser.h
+++ b/src/include/parser.h
@@ -1,9 +1,9 @@
 #ifndef HERB_PARSER_H
 #define HERB_PARSER_H
 
-#include "array.h"
 #include "ast_node.h"
 #include "lexer.h"
+#include "util/hb_array.h"
 
 typedef enum {
   FOREIGN_CONTENT_UNKNOWN = 0,
@@ -24,7 +24,7 @@ extern const parser_options_T HERB_DEFAULT_PARSER_OPTIONS;
 typedef struct PARSER_STRUCT {
   lexer_T* lexer;
   token_T* current_token;
-  array_T* open_tags_stack;
+  hb_array_T* open_tags_stack;
   parser_state_T state;
   foreign_content_type_T foreign_content_type;
   parser_options_T options;
diff --git a/src/include/parser_helpers.h b/src/include/parser_helpers.h
index eba20f447..2eef59769 100644
--- a/src/include/parser_helpers.h
+++ b/src/include/parser_helpers.h
@@ -1,24 +1,29 @@
 #ifndef HERB_PARSER_HELPERS_H
 #define HERB_PARSER_HELPERS_H
 
-#include "array.h"
 #include "ast_nodes.h"
-#include "buffer.h"
 #include "errors.h"
 #include "parser.h"
 #include "token.h"
+#include "util/hb_array.h"
+#include "util/hb_buffer.h"
 
 void parser_push_open_tag(const parser_T* parser, token_T* tag_name);
 bool parser_check_matching_tag(const parser_T* parser, const char* tag_name);
 token_T* parser_pop_open_tag(const parser_T* parser);
 
-void parser_append_unexpected_error(parser_T* parser, const char* description, const char* expected, array_T* errors);
-void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, array_T* errors);
+void parser_append_unexpected_error(
+  parser_T* parser,
+  const char* description,
+  const char* expected,
+  hb_array_T* errors
+);
+void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, hb_array_T* errors);
 
 void parser_append_literal_node_from_buffer(
   const parser_T* parser,
-  buffer_T* buffer,
-  array_T* children,
+  hb_buffer_T* buffer,
+  hb_array_T* children,
   position_T start
 );
 
@@ -35,13 +40,17 @@ bool parser_is_expected_closing_tag_name(const char* tag_name, foreign_content_t
 
 token_T* parser_advance(parser_T* parser);
 token_T* parser_consume_if_present(parser_T* parser, token_type_T type);
-token_T* parser_consume_expected(parser_T* parser, token_type_T type, array_T* array);
+token_T* parser_consume_expected(parser_T* parser, token_type_T type, hb_array_T* array);
 
 AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
   AST_HTML_OPEN_TAG_NODE_T* open_tag,
-  array_T* body,
-  array_T* errors
+  hb_array_T* body,
+  hb_array_T* errors
+);
+void parser_handle_mismatched_tags(
+  const parser_T* parser,
+  const AST_HTML_CLOSE_TAG_NODE_T* close_tag,
+  hb_array_T* errors
 );
-void parser_handle_mismatched_tags(const parser_T* parser, const AST_HTML_CLOSE_TAG_NODE_T* close_tag, array_T* errors);
 
 #endif
diff --git a/src/include/pretty_print.h b/src/include/pretty_print.h
index 7cabef7af..12d33e8a0 100644
--- a/src/include/pretty_print.h
+++ b/src/include/pretty_print.h
@@ -3,14 +3,20 @@
 
 #include "analyzed_ruby.h"
 #include "ast_nodes.h"
-#include "buffer.h"
 #include "location.h"
+#include "util/hb_buffer.h"
 
 #include <stdbool.h>
 
-void pretty_print_indent(buffer_T* buffer, size_t indent);
-void pretty_print_newline(size_t indent, size_t relative_indent, buffer_T* buffer);
-void pretty_print_label(const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
+void pretty_print_indent(hb_buffer_T* buffer, size_t indent);
+void pretty_print_newline(size_t indent, size_t relative_indent, hb_buffer_T* buffer);
+void pretty_print_label(
+  const char* name,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  hb_buffer_T* buffer
+);
 
 void pretty_print_position_property(
   position_T* position,
@@ -18,10 +24,10 @@ void pretty_print_position_property(
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
-void pretty_print_location(location_T location, buffer_T* buffer);
+void pretty_print_location(location_T location, hb_buffer_T* buffer);
 
 void pretty_print_property(
   const char* name,
@@ -29,7 +35,7 @@ void pretty_print_property(
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_size_t_property(
@@ -38,7 +44,7 @@ void pretty_print_size_t_property(
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_string_property(
@@ -47,7 +53,7 @@ void pretty_print_string_property(
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_quoted_property(
@@ -56,7 +62,7 @@ void pretty_print_quoted_property(
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_boolean_property(
@@ -65,7 +71,7 @@ void pretty_print_boolean_property(
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_token_property(
@@ -74,19 +80,25 @@ void pretty_print_token_property(
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_array(
   const char* name,
-  array_T* array,
+  hb_array_T* array,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
-void pretty_print_errors(AST_NODE_T* node, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
+void pretty_print_errors(
+  AST_NODE_T* node,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  hb_buffer_T* buffer
+);
 
 void pretty_print_analyzed_ruby(analyzed_ruby_T* analyzed, const char* source);
 
diff --git a/src/include/util/hb_array.h b/src/include/util/hb_array.h
new file mode 100644
index 000000000..ccc3b043a
--- /dev/null
+++ b/src/include/util/hb_array.h
@@ -0,0 +1,33 @@
+#ifndef HERB_ARRAY_H
+#define HERB_ARRAY_H
+
+#include <stdlib.h>
+
+typedef struct HB_ARRAY_STRUCT {
+  void** items;
+  size_t size;
+  size_t capacity;
+} hb_array_T;
+
+hb_array_T* hb_array_init(size_t capacity);
+
+void* hb_array_get(const hb_array_T* array, size_t index);
+void* hb_array_first(hb_array_T* array);
+void* hb_array_last(hb_array_T* array);
+
+void hb_array_append(hb_array_T* array, void* item);
+void hb_array_set(const hb_array_T* array, size_t index, void* item);
+void hb_array_free(hb_array_T** array);
+void hb_array_remove(hb_array_T* array, size_t index);
+
+size_t hb_array_index_of(hb_array_T* array, void* item);
+void hb_array_remove_item(hb_array_T* array, void* item);
+
+void hb_array_push(hb_array_T* array, void* item);
+void* hb_array_pop(hb_array_T* array);
+
+size_t hb_array_capacity(const hb_array_T* array);
+size_t hb_array_size(const hb_array_T* array);
+size_t hb_array_sizeof(void);
+
+#endif
diff --git a/src/include/util/hb_buffer.h b/src/include/util/hb_buffer.h
new file mode 100644
index 000000000..d1aaf2351
--- /dev/null
+++ b/src/include/util/hb_buffer.h
@@ -0,0 +1,39 @@
+#ifndef HERB_BUFFER_H
+#define HERB_BUFFER_H
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+typedef struct HB_BUFFER_STRUCT {
+  char* value;
+  size_t length;
+  size_t capacity;
+} hb_buffer_T;
+
+bool hb_buffer_init(hb_buffer_T* buffer, size_t capacity);
+hb_buffer_T* hb_buffer_new(size_t capacity);
+
+bool hb_buffer_increase_capacity(hb_buffer_T* buffer, size_t additional_capacity);
+bool hb_buffer_has_capacity(hb_buffer_T* buffer, size_t required_length);
+bool hb_buffer_expand_capacity(hb_buffer_T* buffer);
+bool hb_buffer_expand_if_needed(hb_buffer_T* buffer, size_t required_length);
+bool hb_buffer_resize(hb_buffer_T* buffer, size_t new_capacity);
+
+void hb_buffer_append(hb_buffer_T* buffer, const char* text);
+void hb_buffer_append_with_length(hb_buffer_T* buffer, const char* text, size_t length);
+void hb_buffer_append_char(hb_buffer_T* buffer, char character);
+void hb_buffer_append_repeated(hb_buffer_T* buffer, char character, size_t length);
+void hb_buffer_append_whitespace(hb_buffer_T* buffer, size_t length);
+void hb_buffer_prepend(hb_buffer_T* buffer, const char* text);
+void hb_buffer_concat(hb_buffer_T* destination, hb_buffer_T* source);
+
+char* hb_buffer_value(const hb_buffer_T* buffer);
+
+size_t hb_buffer_length(const hb_buffer_T* buffer);
+size_t hb_buffer_capacity(const hb_buffer_T* buffer);
+size_t hb_buffer_sizeof(void);
+
+void hb_buffer_clear(hb_buffer_T* buffer);
+void hb_buffer_free(hb_buffer_T** buffer);
+
+#endif
diff --git a/src/include/hb_string.h b/src/include/util/hb_string.h
similarity index 96%
rename from src/include/hb_string.h
rename to src/include/util/hb_string.h
index 5f9f972c1..6fc93a814 100644
--- a/src/include/hb_string.h
+++ b/src/include/util/hb_string.h
@@ -4,7 +4,7 @@
 #include <stdbool.h>
 #include <stddef.h>
 
-typedef struct STRING_STRUCT {
+typedef struct HB_STRING_STRUCT {
   char* data;
   size_t length;
 } hb_string_T;
diff --git a/src/include/visitor.h b/src/include/visitor.h
index 01d5c9e44..bc6a6414f 100644
--- a/src/include/visitor.h
+++ b/src/include/visitor.h
@@ -1,9 +1,9 @@
 #ifndef HERB_VISITOR_H
 #define HERB_VISITOR_H
 
-#include "array.h"
 #include "ast_node.h"
 #include "ast_nodes.h"
+#include "util/hb_array.h"
 
 void herb_visit_node(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T*, void*), void* data);
 void herb_visit_child_nodes(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T* node, void* data), void* data);
diff --git a/src/io.c b/src/io.c
index 9ee5b9fe0..1c6e68f6d 100644
--- a/src/io.c
+++ b/src/io.c
@@ -1,5 +1,5 @@
 #include "include/io.h"
-#include "include/buffer.h"
+#include "include/util/hb_buffer.h"
 
 #include <errno.h>
 #include <stdio.h>
@@ -17,17 +17,17 @@ char* herb_read_file(const char* filename) {
     exit(1);
   }
 
-  buffer_T buffer;
-  buffer_init(&buffer, 4096);
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 4096);
 
   char chunk[FILE_READ_CHUNK];
   size_t bytes_read;
 
   while ((bytes_read = fread(chunk, 1, FILE_READ_CHUNK, fp)) > 0) {
-    buffer_append_with_length(&buffer, chunk, bytes_read);
+    hb_buffer_append_with_length(&buffer, chunk, bytes_read);
   }
 
   fclose(fp);
 
-  return buffer_value(&buffer);
+  return hb_buffer_value(&buffer);
 }
diff --git a/src/lexer.c b/src/lexer.c
index c069e269c..2847108a9 100644
--- a/src/lexer.c
+++ b/src/lexer.c
@@ -1,8 +1,8 @@
-#include "include/buffer.h"
 #include "include/lexer_peek_helpers.h"
 #include "include/token.h"
 #include "include/utf8.h"
 #include "include/util.h"
+#include "include/util/hb_buffer.h"
 
 #include <ctype.h>
 #include <string.h>
@@ -166,12 +166,12 @@ static token_T* lexer_match_and_advance(lexer_T* lexer, const char* value, const
 // ===== Specialized Parsers
 
 static token_T* lexer_parse_whitespace(lexer_T* lexer) {
-  buffer_T buffer;
-  buffer_init(&buffer, 128);
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 128);
 
   while (isspace(lexer->current_character) && lexer->current_character != '\n' && lexer->current_character != '\r'
          && !lexer_eof(lexer)) {
-    buffer_append_char(&buffer, lexer->current_character);
+    hb_buffer_append_char(&buffer, lexer->current_character);
     lexer_advance(lexer);
   }
 
@@ -183,14 +183,14 @@ static token_T* lexer_parse_whitespace(lexer_T* lexer) {
 }
 
 static token_T* lexer_parse_identifier(lexer_T* lexer) {
-  buffer_T buffer;
-  buffer_init(&buffer, 128);
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 128);
 
   while ((isalnum(lexer->current_character) || lexer->current_character == '-' || lexer->current_character == '_'
           || lexer->current_character == ':')
          && !lexer_peek_for_html_comment_end(lexer, 0) && !lexer_eof(lexer)) {
 
-    buffer_append_char(&buffer, lexer->current_character);
+    hb_buffer_append_char(&buffer, lexer->current_character);
     lexer_advance(lexer);
   }
 
@@ -217,15 +217,15 @@ static token_T* lexer_parse_erb_open(lexer_T* lexer) {
 }
 
 static token_T* lexer_parse_erb_content(lexer_T* lexer) {
-  buffer_T buffer;
-  buffer_init(&buffer, 1024);
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
 
   while (!lexer_peek_erb_end(lexer, 0)) {
     if (lexer_eof(lexer)) {
       return token_init(buffer.value, TOKEN_ERROR, lexer); // Handle unexpected EOF
     }
 
-    buffer_append_char(&buffer, lexer->current_character);
+    hb_buffer_append_char(&buffer, lexer->current_character);
 
     if (is_newline(lexer->current_character)) {
       lexer->current_line++;
diff --git a/src/main.c b/src/main.c
index e30b9e5f6..52b1f370c 100644
--- a/src/main.c
+++ b/src/main.c
@@ -4,11 +4,11 @@
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/ast_pretty_print.h"
-#include "include/buffer.h"
 #include "include/extract.h"
 #include "include/herb.h"
 #include "include/io.h"
 #include "include/ruby_parser.h"
+#include "include/util/hb_buffer.h"
 
 #include <stdio.h>
 #include <string.h>
@@ -52,9 +52,9 @@ int main(const int argc, char* argv[]) {
     return 1;
   }
 
-  buffer_T output;
+  hb_buffer_T output;
 
-  if (!buffer_init(&output, 4096)) { return 1; }
+  if (!hb_buffer_init(&output, 4096)) { return 1; }
 
   char* source = herb_read_file(argv[2]);
 
diff --git a/src/parser.c b/src/parser.c
index d331c0cf7..21402bbbc 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -1,8 +1,6 @@
 #include "include/parser.h"
-#include "include/array.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
-#include "include/buffer.h"
 #include "include/errors.h"
 #include "include/html_util.h"
 #include "include/lexer.h"
@@ -11,21 +9,23 @@
 #include "include/token.h"
 #include "include/token_matchers.h"
 #include "include/util.h"
+#include "include/util/hb_array.h"
+#include "include/util/hb_buffer.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <strings.h>
 
-static void parser_parse_in_data_state(parser_T* parser, array_T* children, array_T* errors);
-static void parser_parse_foreign_content(parser_T* parser, array_T* children, array_T* errors);
+static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, hb_array_T* errors);
+static void parser_parse_foreign_content(parser_T* parser, hb_array_T* children, hb_array_T* errors);
 static AST_ERB_CONTENT_NODE_T* parser_parse_erb_tag(parser_T* parser);
-static void parser_handle_whitespace(parser_T* parser, token_T* whitespace_token, array_T* children);
-static void parser_consume_whitespace(parser_T* parser, array_T* children);
+static void parser_handle_whitespace(parser_T* parser, token_T* whitespace_token, hb_array_T* children);
+static void parser_consume_whitespace(parser_T* parser, hb_array_T* children);
 static void parser_skip_erb_content(lexer_T* lexer);
 static bool parser_lookahead_erb_is_attribute(lexer_T* lexer);
-static void parser_handle_erb_in_open_tag(parser_T* parser, array_T* children);
-static void parser_handle_whitespace_in_open_tag(parser_T* parser, array_T* children);
+static void parser_handle_erb_in_open_tag(parser_T* parser, hb_array_T* children);
+static void parser_handle_whitespace_in_open_tag(parser_T* parser, hb_array_T* children);
 
 const parser_options_T HERB_DEFAULT_PARSER_OPTIONS = { .track_whitespace = false };
 
@@ -36,17 +36,17 @@ size_t parser_sizeof(void) {
 void herb_parser_init(parser_T* parser, lexer_T* lexer, parser_options_T options) {
   parser->lexer = lexer;
   parser->current_token = lexer_next_token(lexer);
-  parser->open_tags_stack = array_init(16);
+  parser->open_tags_stack = hb_array_init(16);
   parser->state = PARSER_STATE_DATA;
   parser->foreign_content_type = FOREIGN_CONTENT_UNKNOWN;
   parser->options = options;
 }
 
 static AST_CDATA_NODE_T* parser_parse_cdata(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
-  buffer_T content;
-  buffer_init(&content, 128);
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
+  hb_buffer_T content;
+  hb_buffer_init(&content, 128);
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_CDATA_START, errors);
   position_T start = parser->current_token->location.start;
@@ -55,13 +55,13 @@ static AST_CDATA_NODE_T* parser_parse_cdata(parser_T* parser) {
     if (token_is(parser, TOKEN_ERB_START)) {
       parser_append_literal_node_from_buffer(parser, &content, children, start);
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
+      hb_array_append(children, erb_node);
       start = parser->current_token->location.start;
       continue;
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&content, token->value);
+    hb_buffer_append(&content, token->value);
     token_free(token);
   }
 
@@ -85,20 +85,20 @@ static AST_CDATA_NODE_T* parser_parse_cdata(parser_T* parser) {
 }
 
 static AST_HTML_COMMENT_NODE_T* parser_parse_html_comment(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
   token_T* comment_start = parser_consume_expected(parser, TOKEN_HTML_COMMENT_START, errors);
   position_T start = parser->current_token->location.start;
 
-  buffer_T comment;
-  buffer_init(&comment, 512);
+  hb_buffer_T comment;
+  hb_buffer_init(&comment, 512);
 
   while (token_is_none_of(parser, TOKEN_HTML_COMMENT_END, TOKEN_EOF)) {
     if (token_is(parser, TOKEN_ERB_START)) {
       parser_append_literal_node_from_buffer(parser, &comment, children, start);
 
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
+      hb_array_append(children, erb_node);
 
       start = parser->current_token->location.start;
 
@@ -106,7 +106,7 @@ static AST_HTML_COMMENT_NODE_T* parser_parse_html_comment(parser_T* parser) {
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&comment, token->value);
+    hb_buffer_append(&comment, token->value);
     token_free(token);
   }
 
@@ -131,10 +131,10 @@ static AST_HTML_COMMENT_NODE_T* parser_parse_html_comment(parser_T* parser) {
 }
 
 static AST_HTML_DOCTYPE_NODE_T* parser_parse_html_doctype(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
-  buffer_T content;
-  buffer_init(&content, 64);
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
+  hb_buffer_T content;
+  hb_buffer_init(&content, 64);
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_HTML_DOCTYPE, errors);
 
@@ -145,13 +145,13 @@ static AST_HTML_DOCTYPE_NODE_T* parser_parse_html_doctype(parser_T* parser) {
       parser_append_literal_node_from_buffer(parser, &content, children, start);
 
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
+      hb_array_append(children, erb_node);
 
       continue;
     }
 
     token_T* token = parser_consume_expected(parser, parser->current_token->type, errors);
-    buffer_append(&content, token->value);
+    hb_buffer_append(&content, token->value);
     token_free(token);
   }
 
@@ -176,10 +176,10 @@ static AST_HTML_DOCTYPE_NODE_T* parser_parse_html_doctype(parser_T* parser) {
 }
 
 static AST_XML_DECLARATION_NODE_T* parser_parse_xml_declaration(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
-  buffer_T content;
-  buffer_init(&content, 64);
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
+  hb_buffer_T content;
+  hb_buffer_init(&content, 64);
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_XML_DECLARATION, errors);
 
@@ -190,7 +190,7 @@ static AST_XML_DECLARATION_NODE_T* parser_parse_xml_declaration(parser_T* parser
       parser_append_literal_node_from_buffer(parser, &content, children, start);
 
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
+      hb_array_append(children, erb_node);
 
       start = parser->current_token->location.start;
 
@@ -198,7 +198,7 @@ static AST_XML_DECLARATION_NODE_T* parser_parse_xml_declaration(parser_T* parser
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&content, token->value);
+    hb_buffer_append(&content, token->value);
     token_free(token);
   }
 
@@ -222,11 +222,11 @@ static AST_XML_DECLARATION_NODE_T* parser_parse_xml_declaration(parser_T* parser
   return xml_declaration;
 }
 
-static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, array_T* document_errors) {
+static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, hb_array_T* document_errors) {
   position_T start = parser->current_token->location.start;
 
-  buffer_T content;
-  buffer_init(&content, 2048);
+  hb_buffer_T content;
+  hb_buffer_init(&content, 2048);
 
   while (token_is_none_of(
     parser,
@@ -256,16 +256,17 @@ static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, array_T
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&content, token->value);
+    hb_buffer_append(&content, token->value);
     token_free(token);
   }
 
-  array_T* errors = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
 
   AST_HTML_TEXT_NODE_T* text_node = NULL;
 
-  if (buffer_length(&content) > 0) {
-    text_node = ast_html_text_node_init(buffer_value(&content), start, parser->current_token->location.start, errors);
+  if (hb_buffer_length(&content) > 0) {
+    text_node =
+      ast_html_text_node_init(hb_buffer_value(&content), start, parser->current_token->location.start, errors);
   } else {
     text_node = ast_html_text_node_init("", start, parser->current_token->location.start, errors);
   }
@@ -276,10 +277,10 @@ static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, array_T
 }
 
 static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
-  buffer_T buffer;
-  buffer_init(&buffer, 128);
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 128);
   position_T start = parser->current_token->location.start;
 
   while (token_is_none_of(
@@ -295,14 +296,14 @@ static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T
       parser_append_literal_node_from_buffer(parser, &buffer, children, start);
 
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
+      hb_array_append(children, erb_node);
 
       start = parser->current_token->location.start;
       continue;
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&buffer, token->value);
+    hb_buffer_append(&buffer, token->value);
     token_free(token);
   }
 
@@ -312,8 +313,8 @@ static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T
   position_T node_end = { 0 };
 
   if (children->size > 0) {
-    AST_NODE_T* first_child = array_get(children, 0);
-    AST_NODE_T* last_child = array_get(children, children->size - 1);
+    AST_NODE_T* first_child = hb_array_get(children, 0);
+    AST_NODE_T* last_child = hb_array_get(children, children->size - 1);
 
     node_start = first_child->location.start;
     node_end = last_child->location.end;
@@ -332,11 +333,11 @@ static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T
 
 static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value(
   parser_T* parser,
-  array_T* children,
-  array_T* errors
+  hb_array_T* children,
+  hb_array_T* errors
 ) {
-  buffer_T buffer;
-  buffer_init(&buffer, 512);
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 512);
   token_T* opening_quote = parser_consume_expected(parser, TOKEN_QUOTE, errors);
   position_T start = parser->current_token->location.start;
 
@@ -348,7 +349,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
     if (token_is(parser, TOKEN_ERB_START)) {
       parser_append_literal_node_from_buffer(parser, &buffer, children, start);
 
-      array_append(children, parser_parse_erb_tag(parser));
+      hb_array_append(children, parser_parse_erb_tag(parser));
 
       start = parser->current_token->location.start;
 
@@ -362,8 +363,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
 
       if (next_token && next_token->type == TOKEN_QUOTE && opening_quote != NULL
           && strcmp(next_token->value, opening_quote->value) == 0) {
-        buffer_append(&buffer, parser->current_token->value);
-        buffer_append(&buffer, next_token->value);
+        hb_buffer_append(&buffer, parser->current_token->value);
+        hb_buffer_append(&buffer, next_token->value);
 
         token_free(parser->current_token);
         token_free(next_token);
@@ -377,7 +378,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
       }
     }
 
-    buffer_append(&buffer, parser->current_token->value);
+    hb_buffer_append(&buffer, parser->current_token->value);
     token_free(parser->current_token);
 
     parser->current_token = lexer_next_token(parser->lexer);
@@ -405,7 +406,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
       token_free(parser->current_token);
       parser->current_token = potential_closing;
 
-      buffer_append(&buffer, parser->current_token->value);
+      hb_buffer_append(&buffer, parser->current_token->value);
       token_free(parser->current_token);
       parser->current_token = lexer_next_token(parser->lexer);
 
@@ -417,14 +418,14 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
         if (token_is(parser, TOKEN_ERB_START)) {
           parser_append_literal_node_from_buffer(parser, &buffer, children, start);
 
-          array_append(children, parser_parse_erb_tag(parser));
+          hb_array_append(children, parser_parse_erb_tag(parser));
 
           start = parser->current_token->location.start;
 
           continue;
         }
 
-        buffer_append(&buffer, parser->current_token->value);
+        hb_buffer_append(&buffer, parser->current_token->value);
         token_free(parser->current_token);
 
         parser->current_token = lexer_next_token(parser->lexer);
@@ -469,13 +470,13 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
 }
 
 static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser_T* parser) {
-  array_T* children = array_init(8);
-  array_T* errors = array_init(8);
+  hb_array_T* children = hb_array_init(8);
+  hb_array_T* errors = hb_array_init(8);
 
   // <div id=<%= "home" %>>
   if (token_is(parser, TOKEN_ERB_START)) {
     AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-    array_append(children, erb_node);
+    hb_array_append(children, erb_node);
 
     return ast_html_attribute_value_node_init(
       NULL,
@@ -494,7 +495,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
     AST_LITERAL_NODE_T* literal = ast_literal_node_init_from_token(identifier);
     token_free(identifier);
 
-    array_append(children, literal);
+    hb_array_append(children, literal);
 
     return ast_html_attribute_value_node_init(
       NULL,
@@ -562,8 +563,8 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
                    || lexer_peek_for_token_type_after_whitespace(parser->lexer, TOKEN_EQUALS);
 
     if (has_equals) {
-      buffer_T equals_buffer;
-      buffer_init(&equals_buffer, 256);
+      hb_buffer_T equals_buffer;
+      hb_buffer_init(&equals_buffer, 256);
       position_T equals_start = { 0 };
       position_T equals_end = { 0 };
       uint32_t range_start = 0;
@@ -579,7 +580,7 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
           range_start = whitespace->range.from;
         }
 
-        buffer_append(&equals_buffer, whitespace->value);
+        hb_buffer_append(&equals_buffer, whitespace->value);
         token_free(whitespace);
       }
 
@@ -591,14 +592,14 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
         range_start = equals->range.from;
       }
 
-      buffer_append(&equals_buffer, equals->value);
+      hb_buffer_append(&equals_buffer, equals->value);
       equals_end = equals->location.end;
       range_end = equals->range.to;
       token_free(equals);
 
       while (token_is_any_of(parser, TOKEN_WHITESPACE, TOKEN_NEWLINE)) {
         token_T* whitespace = parser_advance(parser);
-        buffer_append(&equals_buffer, whitespace->value);
+        hb_buffer_append(&equals_buffer, whitespace->value);
         equals_end = whitespace->location.end;
         range_end = whitespace->range.to;
         token_free(whitespace);
@@ -716,12 +717,12 @@ static bool parser_lookahead_erb_is_attribute(lexer_T* lexer) {
   } while (true);
 }
 
-static void parser_handle_erb_in_open_tag(parser_T* parser, array_T* children) {
+static void parser_handle_erb_in_open_tag(parser_T* parser, hb_array_T* children) {
   bool is_output_tag = parser->current_token->value && strlen(parser->current_token->value) >= 3
                     && strncmp(parser->current_token->value, "<%=", 3) == 0;
 
   if (!is_output_tag) {
-    array_append(children, parser_parse_erb_tag(parser));
+    hb_array_append(children, parser_parse_erb_tag(parser));
 
     return;
   }
@@ -735,13 +736,13 @@ static void parser_handle_erb_in_open_tag(parser_T* parser, array_T* children) {
   bool looks_like_attribute = parser_lookahead_erb_is_attribute(&lexer_copy);
 
   if (looks_like_attribute) {
-    array_append(children, parser_parse_html_attribute(parser));
+    hb_array_append(children, parser_parse_html_attribute(parser));
   } else {
-    array_append(children, parser_parse_erb_tag(parser));
+    hb_array_append(children, parser_parse_erb_tag(parser));
   }
 }
 
-static void parser_handle_whitespace_in_open_tag(parser_T* parser, array_T* children) {
+static void parser_handle_whitespace_in_open_tag(parser_T* parser, hb_array_T* children) {
   token_T* whitespace = parser_consume_if_present(parser, TOKEN_WHITESPACE);
 
   if (whitespace != NULL) {
@@ -755,8 +756,8 @@ static void parser_handle_whitespace_in_open_tag(parser_T* parser, array_T* chil
 }
 
 static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
 
   token_T* tag_start = parser_consume_expected(parser, TOKEN_HTML_TAG_START, errors);
   token_T* tag_name = parser_consume_expected(parser, TOKEN_IDENTIFIER, errors);
@@ -768,7 +769,7 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
     }
 
     if (parser->current_token->type == TOKEN_IDENTIFIER) {
-      array_append(children, parser_parse_html_attribute(parser));
+      hb_array_append(children, parser_parse_html_attribute(parser));
       continue;
     }
 
@@ -778,7 +779,7 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
     }
 
     if (parser->current_token->type == TOKEN_AT) {
-      array_append(children, parser_parse_html_attribute(parser));
+      hb_array_append(children, parser_parse_html_attribute(parser));
       continue;
     }
 
@@ -788,7 +789,7 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
 
       if (next_token && next_token->type == TOKEN_IDENTIFIER) {
         token_free(next_token);
-        array_append(children, parser_parse_html_attribute(parser));
+        hb_array_append(children, parser_parse_html_attribute(parser));
 
         continue;
       }
@@ -815,8 +816,8 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
       token_free(tag_start);
       token_free(tag_name);
 
-      array_free(&children);
-      array_free(&errors);
+      hb_array_free(&children);
+      hb_array_free(&errors);
 
       return NULL;
     }
@@ -843,8 +844,8 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
 }
 
 static AST_HTML_CLOSE_TAG_NODE_T* parser_parse_html_close_tag(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_HTML_TAG_START_CLOSE, errors);
 
@@ -912,8 +913,8 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_regular_element(
   parser_T* parser,
   AST_HTML_OPEN_TAG_NODE_T* open_tag
 ) {
-  array_T* errors = array_init(8);
-  array_T* body = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* body = hb_array_init(8);
 
   parser_push_open_tag(parser, open_tag->tag_name);
 
@@ -930,7 +931,7 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_regular_element(
   AST_HTML_CLOSE_TAG_NODE_T* close_tag = parser_parse_html_close_tag(parser);
 
   if (parser_in_svg_context(parser) == false && is_void_element(close_tag->tag_name->value)) {
-    array_push(body, close_tag);
+    hb_array_push(body, close_tag);
     parser_parse_in_data_state(parser, body, errors);
     close_tag = parser_parse_html_close_tag(parser);
   }
@@ -971,7 +972,7 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_element(parser_T* parser) {
   AST_HTML_ELEMENT_NODE_T* regular_element = parser_parse_html_regular_element(parser, open_tag);
   if (regular_element != NULL) { return regular_element; }
 
-  array_T* errors = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
 
   parser_append_unexpected_error(parser, "Unknown HTML open tag type", "HTMLOpenTag or HTMLSelfCloseTag", errors);
 
@@ -989,7 +990,7 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_element(parser_T* parser) {
 }
 
 static AST_ERB_CONTENT_NODE_T* parser_parse_erb_tag(parser_T* parser) {
-  array_T* errors = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
 
   token_T* opening_tag = parser_consume_expected(parser, TOKEN_ERB_START, errors);
   token_T* content = parser_consume_expected(parser, TOKEN_ERB_CONTENT, errors);
@@ -1014,9 +1015,9 @@ static AST_ERB_CONTENT_NODE_T* parser_parse_erb_tag(parser_T* parser) {
   return erb_node;
 }
 
-static void parser_parse_foreign_content(parser_T* parser, array_T* children, array_T* errors) {
-  buffer_T content;
-  buffer_init(&content, 1024);
+static void parser_parse_foreign_content(parser_T* parser, hb_array_T* children, hb_array_T* errors) {
+  hb_buffer_T content;
+  hb_buffer_init(&content, 1024);
   position_T start = parser->current_token->location.start;
   const char* expected_closing_tag = parser_get_foreign_content_closing_tag(parser->foreign_content_type);
 
@@ -1032,7 +1033,7 @@ static void parser_parse_foreign_content(parser_T* parser, array_T* children, ar
       parser_append_literal_node_from_buffer(parser, &content, children, start);
 
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
+      hb_array_append(children, erb_node);
 
       start = parser->current_token->location.start;
 
@@ -1064,7 +1065,7 @@ static void parser_parse_foreign_content(parser_T* parser, array_T* children, ar
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&content, token->value);
+    hb_buffer_append(&content, token->value);
     token_free(token);
   }
 
@@ -1073,35 +1074,35 @@ static void parser_parse_foreign_content(parser_T* parser, array_T* children, ar
   free(content.value);
 }
 
-static void parser_parse_in_data_state(parser_T* parser, array_T* children, array_T* errors) {
+static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, hb_array_T* errors) {
   while (token_is_none_of(parser, TOKEN_HTML_TAG_START_CLOSE, TOKEN_EOF)) {
     if (token_is(parser, TOKEN_ERB_START)) {
-      array_append(children, parser_parse_erb_tag(parser));
+      hb_array_append(children, parser_parse_erb_tag(parser));
       continue;
     }
 
     if (token_is(parser, TOKEN_HTML_DOCTYPE)) {
-      array_append(children, parser_parse_html_doctype(parser));
+      hb_array_append(children, parser_parse_html_doctype(parser));
       continue;
     }
 
     if (token_is(parser, TOKEN_XML_DECLARATION)) {
-      array_append(children, parser_parse_xml_declaration(parser));
+      hb_array_append(children, parser_parse_xml_declaration(parser));
       continue;
     }
 
     if (token_is(parser, TOKEN_CDATA_START)) {
-      array_append(children, parser_parse_cdata(parser));
+      hb_array_append(children, parser_parse_cdata(parser));
       continue;
     }
 
     if (token_is(parser, TOKEN_HTML_COMMENT_START)) {
-      array_append(children, parser_parse_html_comment(parser));
+      hb_array_append(children, parser_parse_html_comment(parser));
       continue;
     }
 
     if (token_is(parser, TOKEN_HTML_TAG_START)) {
-      array_append(children, parser_parse_html_element(parser));
+      hb_array_append(children, parser_parse_html_element(parser));
       continue;
     }
 
@@ -1125,7 +1126,7 @@ static void parser_parse_in_data_state(parser_T* parser, array_T* children, arra
           TOKEN_UNDERSCORE,
           TOKEN_WHITESPACE
         )) {
-      array_append(children, parser_parse_text_content(parser, errors));
+      hb_array_append(children, parser_parse_text_content(parser, errors));
       continue;
     }
 
@@ -1139,8 +1140,8 @@ static void parser_parse_in_data_state(parser_T* parser, array_T* children, arra
   }
 }
 
-static void parser_parse_unclosed_html_tags(const parser_T* parser, array_T* errors) {
-  while (array_size(parser->open_tags_stack) > 0) {
+static void parser_parse_unclosed_html_tags(const parser_T* parser, hb_array_T* errors) {
+  while (hb_array_size(parser->open_tags_stack) > 0) {
     token_T* unclosed_tag = parser_pop_open_tag(parser);
 
     append_unclosed_element_error(
@@ -1154,7 +1155,7 @@ static void parser_parse_unclosed_html_tags(const parser_T* parser, array_T* err
   }
 }
 
-static void parser_parse_stray_closing_tags(parser_T* parser, array_T* children, array_T* errors) {
+static void parser_parse_stray_closing_tags(parser_T* parser, hb_array_T* children, hb_array_T* errors) {
   while (token_is_not(parser, TOKEN_EOF)) {
     if (token_is_not(parser, TOKEN_HTML_TAG_START_CLOSE)) {
       parser_append_unexpected_token_error(parser, TOKEN_HTML_TAG_START_CLOSE, errors);
@@ -1176,15 +1177,15 @@ static void parser_parse_stray_closing_tags(parser_T* parser, array_T* children,
       );
     }
 
-    array_append(children, close_tag);
+    hb_array_append(children, close_tag);
 
     parser_parse_in_data_state(parser, children, errors);
   }
 }
 
 static AST_DOCUMENT_NODE_T* parser_parse_document(parser_T* parser) {
-  array_T* children = array_init(8);
-  array_T* errors = array_init(8);
+  hb_array_T* children = hb_array_init(8);
+  hb_array_T* errors = hb_array_init(8);
   position_T start = parser->current_token->location.start;
 
   parser_parse_in_data_state(parser, children, errors);
@@ -1204,22 +1205,22 @@ AST_DOCUMENT_NODE_T* herb_parser_parse(parser_T* parser) {
   return parser_parse_document(parser);
 }
 
-static void parser_handle_whitespace(parser_T* parser, token_T* whitespace_token, array_T* children) {
+static void parser_handle_whitespace(parser_T* parser, token_T* whitespace_token, hb_array_T* children) {
   if (parser->options.track_whitespace) {
-    array_T* errors = array_init(8);
+    hb_array_T* errors = hb_array_init(8);
     AST_WHITESPACE_NODE_T* whitespace_node = ast_whitespace_node_init(
       whitespace_token,
       whitespace_token->location.start,
       whitespace_token->location.end,
       errors
     );
-    array_append(children, whitespace_node);
+    hb_array_append(children, whitespace_node);
   }
 
   token_free(whitespace_token);
 }
 
-static void parser_consume_whitespace(parser_T* parser, array_T* children) {
+static void parser_consume_whitespace(parser_T* parser, hb_array_T* children) {
   while (token_is_any_of(parser, TOKEN_WHITESPACE, TOKEN_NEWLINE)) {
     token_T* whitespace = parser_advance(parser);
 
@@ -1235,7 +1236,7 @@ void parser_free(parser_T* parser) {
   if (parser == NULL) { return; }
 
   if (parser->current_token != NULL) { token_free(parser->current_token); }
-  if (parser->open_tags_stack != NULL) { array_free(&parser->open_tags_stack); }
+  if (parser->open_tags_stack != NULL) { hb_array_free(&parser->open_tags_stack); }
 
   free(parser);
 }
diff --git a/src/parser_helpers.c b/src/parser_helpers.c
index 0c848f9ec..9afb66e17 100644
--- a/src/parser_helpers.c
+++ b/src/parser_helpers.c
@@ -1,36 +1,36 @@
 #include "include/parser_helpers.h"
-#include "include/array.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
-#include "include/buffer.h"
 #include "include/errors.h"
 #include "include/html_util.h"
 #include "include/lexer.h"
 #include "include/parser.h"
 #include "include/token.h"
 #include "include/token_matchers.h"
+#include "include/util/hb_array.h"
+#include "include/util/hb_buffer.h"
 
 #include <stdio.h>
 #include <strings.h>
 
 void parser_push_open_tag(const parser_T* parser, token_T* tag_name) {
   token_T* copy = token_copy(tag_name);
-  array_push(parser->open_tags_stack, copy);
+  hb_array_push(parser->open_tags_stack, copy);
 }
 
 bool parser_check_matching_tag(const parser_T* parser, const char* tag_name) {
-  if (array_size(parser->open_tags_stack) == 0) { return false; }
+  if (hb_array_size(parser->open_tags_stack) == 0) { return false; }
 
-  token_T* top_token = array_last(parser->open_tags_stack);
+  token_T* top_token = hb_array_last(parser->open_tags_stack);
   if (top_token == NULL || top_token->value == NULL) { return false; };
 
   return (strcasecmp(top_token->value, tag_name) == 0);
 }
 
 token_T* parser_pop_open_tag(const parser_T* parser) {
-  if (array_size(parser->open_tags_stack) == 0) { return NULL; }
+  if (hb_array_size(parser->open_tags_stack) == 0) { return NULL; }
 
-  return array_pop(parser->open_tags_stack);
+  return hb_array_pop(parser->open_tags_stack);
 }
 
 /**
@@ -42,10 +42,10 @@ token_T* parser_pop_open_tag(const parser_T* parser) {
 bool parser_in_svg_context(const parser_T* parser) {
   if (!parser || !parser->open_tags_stack) { return false; }
 
-  size_t stack_size = array_size(parser->open_tags_stack);
+  size_t stack_size = hb_array_size(parser->open_tags_stack);
 
   for (size_t i = 0; i < stack_size; i++) {
-    token_T* tag = (token_T*) array_get(parser->open_tags_stack, i);
+    token_T* tag = (token_T*) hb_array_get(parser->open_tags_stack, i);
 
     if (tag && tag->value) {
       if (strcasecmp(tag->value, "svg") == 0) { return true; }
@@ -92,7 +92,12 @@ void parser_exit_foreign_content(parser_T* parser) {
   parser->foreign_content_type = FOREIGN_CONTENT_UNKNOWN;
 }
 
-void parser_append_unexpected_error(parser_T* parser, const char* description, const char* expected, array_T* errors) {
+void parser_append_unexpected_error(
+  parser_T* parser,
+  const char* description,
+  const char* expected,
+  hb_array_T* errors
+) {
   token_T* token = parser_advance(parser);
 
   append_unexpected_error(
@@ -107,7 +112,7 @@ void parser_append_unexpected_error(parser_T* parser, const char* description, c
   token_free(token);
 }
 
-void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, array_T* errors) {
+void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, hb_array_T* errors) {
   append_unexpected_token_error(
     expected_type,
     parser->current_token,
@@ -119,17 +124,17 @@ void parser_append_unexpected_token_error(parser_T* parser, token_type_T expecte
 
 void parser_append_literal_node_from_buffer(
   const parser_T* parser,
-  buffer_T* buffer,
-  array_T* children,
+  hb_buffer_T* buffer,
+  hb_array_T* children,
   position_T start
 ) {
-  if (buffer_length(buffer) == 0) { return; }
+  if (hb_buffer_length(buffer) == 0) { return; }
 
   AST_LITERAL_NODE_T* literal =
-    ast_literal_node_init(buffer_value(buffer), start, parser->current_token->location.start, NULL);
+    ast_literal_node_init(hb_buffer_value(buffer), start, parser->current_token->location.start, NULL);
 
-  if (children != NULL) { array_append(children, literal); }
-  buffer_clear(buffer);
+  if (children != NULL) { hb_array_append(children, literal); }
+  hb_buffer_clear(buffer);
 }
 
 token_T* parser_advance(parser_T* parser) {
@@ -143,7 +148,7 @@ token_T* parser_consume_if_present(parser_T* parser, const token_type_T type) {
   return parser_advance(parser);
 }
 
-token_T* parser_consume_expected(parser_T* parser, const token_type_T expected_type, array_T* array) {
+token_T* parser_consume_expected(parser_T* parser, const token_type_T expected_type, hb_array_T* array) {
   token_T* token = parser_consume_if_present(parser, expected_type);
 
   if (token == NULL) {
@@ -157,8 +162,8 @@ token_T* parser_consume_expected(parser_T* parser, const token_type_T expected_t
 
 AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
   AST_HTML_OPEN_TAG_NODE_T* open_tag,
-  array_T* body,
-  array_T* errors
+  hb_array_T* body,
+  hb_array_T* errors
 ) {
   append_missing_closing_tag_error(
     open_tag->tag_name,
@@ -183,10 +188,10 @@ AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
 void parser_handle_mismatched_tags(
   const parser_T* parser,
   const AST_HTML_CLOSE_TAG_NODE_T* close_tag,
-  array_T* errors
+  hb_array_T* errors
 ) {
-  if (array_size(parser->open_tags_stack) > 0) {
-    token_T* expected_tag = array_last(parser->open_tags_stack);
+  if (hb_array_size(parser->open_tags_stack) > 0) {
+    token_T* expected_tag = hb_array_last(parser->open_tags_stack);
     token_T* actual_tag = close_tag->tag_name;
 
     append_tag_names_mismatch_error(
diff --git a/src/pretty_print.c b/src/pretty_print.c
index 85b2f5894..b67ab9aec 100644
--- a/src/pretty_print.c
+++ b/src/pretty_print.c
@@ -3,25 +3,25 @@
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/ast_pretty_print.h"
-#include "include/buffer.h"
 #include "include/errors.h"
 #include "include/token_struct.h"
 #include "include/util.h"
+#include "include/util/hb_buffer.h"
 
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 
-void pretty_print_indent(buffer_T* buffer, const size_t indent) {
+void pretty_print_indent(hb_buffer_T* buffer, const size_t indent) {
   for (size_t i = 0; i < indent; i++) {
-    buffer_append(buffer, "    ");
+    hb_buffer_append(buffer, "    ");
   }
 }
 
-void pretty_print_newline(const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+void pretty_print_newline(const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   pretty_print_indent(buffer, indent);
   pretty_print_indent(buffer, relative_indent);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 }
 
 void pretty_print_label(
@@ -29,19 +29,19 @@ void pretty_print_label(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   pretty_print_indent(buffer, indent);
   pretty_print_indent(buffer, relative_indent);
 
   if (last_property) {
-    buffer_append(buffer, "└── ");
+    hb_buffer_append(buffer, "└── ");
   } else {
-    buffer_append(buffer, "├── ");
+    hb_buffer_append(buffer, "├── ");
   }
 
-  buffer_append(buffer, name);
-  buffer_append(buffer, ": ");
+  hb_buffer_append(buffer, name);
+  hb_buffer_append(buffer, ": ");
 }
 
 void pretty_print_quoted_property(
@@ -50,7 +50,7 @@ void pretty_print_quoted_property(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   char* quoted = quoted_string(value);
   pretty_print_property(name, quoted, indent, relative_indent, last_property, buffer);
@@ -63,7 +63,7 @@ void pretty_print_boolean_property(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   pretty_print_property(name, value ? "true" : "false", indent, relative_indent, last_property, buffer);
 }
@@ -74,11 +74,11 @@ void pretty_print_property(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
-  buffer_append(buffer, value);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, value);
+  hb_buffer_append(buffer, "\n");
 }
 
 void pretty_print_size_t_property(
@@ -87,22 +87,22 @@ void pretty_print_size_t_property(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
   char* string = size_t_to_string(value);
-  buffer_append(buffer, string);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, string);
+  hb_buffer_append(buffer, "\n");
   free(string);
 }
 
 void pretty_print_array(
   const char* name,
-  array_T* array,
+  hb_array_T* array,
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   if (array == NULL) {
     pretty_print_property(name, "∅", indent, relative_indent, last_property, buffer);
@@ -110,7 +110,7 @@ void pretty_print_array(
     return;
   }
 
-  if (array_size(array) == 0) {
+  if (hb_array_size(array) == 0) {
     pretty_print_property(name, "[]", indent, relative_indent, last_property, buffer);
 
     return;
@@ -118,31 +118,31 @@ void pretty_print_array(
 
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
 
-  buffer_append(buffer, "(");
+  hb_buffer_append(buffer, "(");
 
   char count[16];
-  sprintf(count, "%zu", array_size(array));
-  buffer_append(buffer, count);
-  buffer_append(buffer, ")\n");
+  sprintf(count, "%zu", hb_array_size(array));
+  hb_buffer_append(buffer, count);
+  hb_buffer_append(buffer, ")\n");
 
   if (indent < 20) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      AST_NODE_T* child = array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      AST_NODE_T* child = hb_array_get(array, i);
       pretty_print_indent(buffer, indent);
       pretty_print_indent(buffer, relative_indent + 1);
 
-      if (i == array_size(array) - 1) {
-        buffer_append(buffer, "└── ");
+      if (i == hb_array_size(array) - 1) {
+        hb_buffer_append(buffer, "└── ");
       } else {
-        buffer_append(buffer, "├── ");
+        hb_buffer_append(buffer, "├── ");
       }
 
       ast_pretty_print_node(child, indent + 1, relative_indent + 1, buffer);
 
-      if (i != array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
+      if (i != hb_array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
     }
   }
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 }
 
 void pretty_print_errors(
@@ -150,16 +150,16 @@ void pretty_print_errors(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
-  if (node->errors != NULL && array_size(node->errors) > 0) {
+  if (node->errors != NULL && hb_array_size(node->errors) > 0) {
     error_pretty_print_array("errors", node->errors, indent, relative_indent, last_property, buffer);
-    buffer_append(buffer, "\n");
+    hb_buffer_append(buffer, "\n");
   }
 }
 
-void pretty_print_location(location_T location, buffer_T* buffer) {
-  buffer_append(buffer, "(location: (");
+void pretty_print_location(location_T location, hb_buffer_T* buffer) {
+  hb_buffer_append(buffer, "(location: (");
   char location_string[128];
   sprintf(
     location_string,
@@ -169,8 +169,8 @@ void pretty_print_location(location_T location, buffer_T* buffer) {
     location.end.line,
     location.end.column
   );
-  buffer_append(buffer, location_string);
-  buffer_append(buffer, "))");
+  hb_buffer_append(buffer, location_string);
+  hb_buffer_append(buffer, "))");
 }
 
 void pretty_print_position_property(
@@ -179,24 +179,24 @@ void pretty_print_position_property(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
 
   if (position != NULL) {
-    buffer_append(buffer, "(");
+    hb_buffer_append(buffer, "(");
 
     char position_string[128];
 
     sprintf(position_string, "%u:%u", (position->line) ? position->line : 0, (position->column) ? position->column : 0);
 
-    buffer_append(buffer, position_string);
-    buffer_append(buffer, ")");
+    hb_buffer_append(buffer, position_string);
+    hb_buffer_append(buffer, ")");
   } else {
-    buffer_append(buffer, "∅");
+    hb_buffer_append(buffer, "∅");
   }
 
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 }
 
 void pretty_print_token_property(
@@ -205,22 +205,22 @@ void pretty_print_token_property(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
 
   if (token != NULL && token->value != NULL) {
     char* quoted = quoted_string(token->value);
-    buffer_append(buffer, quoted);
+    hb_buffer_append(buffer, quoted);
     free(quoted);
 
-    buffer_append(buffer, " ");
+    hb_buffer_append(buffer, " ");
     pretty_print_location(token->location, buffer);
   } else {
-    buffer_append(buffer, "∅");
+    hb_buffer_append(buffer, "∅");
   }
 
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 }
 
 void pretty_print_string_property(
@@ -229,7 +229,7 @@ void pretty_print_string_property(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   const char* value = "∅";
   char* escaped = NULL;
diff --git a/src/util.c b/src/util.c
index 483392abb..ccf6662d3 100644
--- a/src/util.c
+++ b/src/util.c
@@ -1,5 +1,5 @@
 #include "include/util.h"
-#include "include/buffer.h"
+#include "include/util/hb_buffer.h"
 
 #include <ctype.h>
 #include <stdio.h>
@@ -11,22 +11,22 @@ int is_newline(const int character) {
 }
 
 char* escape_newlines(const char* input) {
-  buffer_T buffer;
+  hb_buffer_T buffer;
 
-  buffer_init(&buffer, strlen(input));
+  hb_buffer_init(&buffer, strlen(input));
 
   for (size_t i = 0; i < strlen(input); ++i) {
     switch (input[i]) {
       case '\n': {
-        buffer_append_char(&buffer, '\\');
-        buffer_append_char(&buffer, 'n');
+        hb_buffer_append_char(&buffer, '\\');
+        hb_buffer_append_char(&buffer, 'n');
       } break;
       case '\r': {
-        buffer_append_char(&buffer, '\\');
-        buffer_append_char(&buffer, 'r');
+        hb_buffer_append_char(&buffer, '\\');
+        hb_buffer_append_char(&buffer, 'r');
       } break;
       default: {
-        buffer_append_char(&buffer, input[i]);
+        hb_buffer_append_char(&buffer, input[i]);
       }
     }
   }
@@ -37,13 +37,13 @@ char* escape_newlines(const char* input) {
 char* wrap_string(const char* input, const char character) {
   if (input == NULL) { return NULL; }
 
-  buffer_T buffer;
+  hb_buffer_T buffer;
 
-  buffer_init(&buffer, strlen(input) + 2);
+  hb_buffer_init(&buffer, strlen(input) + 2);
 
-  buffer_append_char(&buffer, character);
-  buffer_append(&buffer, input);
-  buffer_append_char(&buffer, character);
+  hb_buffer_append_char(&buffer, character);
+  hb_buffer_append(&buffer, input);
+  hb_buffer_append_char(&buffer, character);
 
   return buffer.value;
 }
diff --git a/src/array.c b/src/util/hb_array.c
similarity index 64%
rename from src/array.c
rename to src/util/hb_array.c
index fa882c0f1..4d3c26b24 100644
--- a/src/array.c
+++ b/src/util/hb_array.c
@@ -1,15 +1,15 @@
 #include <stdint.h>
 #include <stdio.h>
 
-#include "include/array.h"
-#include "include/macros.h"
+#include "../include/macros.h"
+#include "../include/util/hb_array.h"
 
-size_t array_sizeof(void) {
-  return sizeof(array_T);
+size_t hb_array_sizeof(void) {
+  return sizeof(hb_array_T);
 }
 
-array_T* array_init(const size_t capacity) {
-  array_T* array = malloc(array_sizeof());
+hb_array_T* hb_array_init(const size_t capacity) {
+  hb_array_T* array = malloc(hb_array_sizeof());
 
   array->size = 0;
   array->capacity = capacity;
@@ -23,7 +23,7 @@ array_T* array_init(const size_t capacity) {
   return array;
 }
 
-void array_append(array_T* array, void* item) {
+void hb_array_append(hb_array_T* array, void* item) {
   if (array->size >= array->capacity) {
     size_t new_capacity;
 
@@ -56,29 +56,29 @@ void array_append(array_T* array, void* item) {
   array->size++;
 }
 
-void* array_get(const array_T* array, const size_t index) {
+void* hb_array_get(const hb_array_T* array, const size_t index) {
   if (index >= array->size) { return NULL; }
 
   return array->items[index];
 }
 
-void* array_first(array_T* array) {
+void* hb_array_first(hb_array_T* array) {
   if (!array || array->size == 0) { return NULL; }
   return array->items[0];
 }
 
-void* array_last(array_T* array) {
+void* hb_array_last(hb_array_T* array) {
   if (!array || array->size == 0) { return NULL; }
   return array->items[array->size - 1];
 }
 
-void array_set(const array_T* array, const size_t index, void* item) {
+void hb_array_set(const hb_array_T* array, const size_t index, void* item) {
   if (index >= array->size) { return; }
 
   array->items[index] = item;
 }
 
-void array_remove(array_T* array, const size_t index) {
+void hb_array_remove(hb_array_T* array, const size_t index) {
   if (index >= array->size) { return; }
 
   for (size_t i = index; i < array->size - 1; i++) {
@@ -88,7 +88,7 @@ void array_remove(array_T* array, const size_t index) {
   array->size--;
 }
 
-size_t array_index_of(array_T* array, void* item) {
+size_t hb_array_index_of(hb_array_T* array, void* item) {
   for (size_t i = 0; i < array->size; i++) {
     if (array->items[i] == item) { return i; }
   }
@@ -96,37 +96,37 @@ size_t array_index_of(array_T* array, void* item) {
   return SIZE_MAX;
 }
 
-void array_remove_item(array_T* array, void* item) {
-  size_t index = array_index_of(array, item);
+void hb_array_remove_item(hb_array_T* array, void* item) {
+  size_t index = hb_array_index_of(array, item);
 
-  if (index != SIZE_MAX) { array_remove(array, index); }
+  if (index != SIZE_MAX) { hb_array_remove(array, index); }
 }
 
-// Alias for array_append
-void array_push(array_T* array, void* item) {
-  array_append(array, item);
+// Alias for hb_array_append
+void hb_array_push(hb_array_T* array, void* item) {
+  hb_array_append(array, item);
 }
 
-void* array_pop(array_T* array) {
+void* hb_array_pop(hb_array_T* array) {
   if (!array || array->size == 0) { return NULL; }
 
-  void* last_item = array_last(array);
+  void* last_item = hb_array_last(array);
   array->size--;
 
   return last_item;
 }
 
-size_t array_size(const array_T* array) {
+size_t hb_array_size(const hb_array_T* array) {
   if (array == NULL) { return 0; }
 
   return array->size;
 }
 
-size_t array_capacity(const array_T* array) {
+size_t hb_array_capacity(const hb_array_T* array) {
   return array->capacity;
 }
 
-void array_free(array_T** array) {
+void hb_array_free(hb_array_T** array) {
   if (!array || !*array) { return; }
 
   free((*array)->items);
diff --git a/src/buffer.c b/src/util/hb_buffer.c
similarity index 65%
rename from src/buffer.c
rename to src/util/hb_buffer.c
index d9de6506b..76f1d6584 100644
--- a/src/buffer.c
+++ b/src/util/hb_buffer.c
@@ -2,17 +2,18 @@
 #include <stdio.h>
 #include <string.h>
 
-#include "include/buffer.h"
-#include "include/macros.h"
-#include "include/util.h"
+#include "../include/macros.h"
+#include "../include/util.h"
+#include "../include/util/hb_buffer.h"
 
-bool buffer_init(buffer_T* buffer, const size_t capacity) {
+bool hb_buffer_init(hb_buffer_T* buffer, const size_t capacity) {
   buffer->capacity = capacity;
   buffer->length = 0;
   buffer->value = malloc(sizeof(char) * (buffer->capacity + 1));
 
   if (!buffer->value) {
     fprintf(stderr, "Error: Failed to initialize buffer with capacity of %zu.\n", buffer->capacity);
+
     return false;
   }
 
@@ -21,10 +22,10 @@ bool buffer_init(buffer_T* buffer, const size_t capacity) {
   return true;
 }
 
-buffer_T* buffer_new(const size_t capacity) {
-  buffer_T* buffer = malloc(sizeof(buffer_T));
+hb_buffer_T* hb_buffer_new(const size_t capacity) {
+  hb_buffer_T* buffer = malloc(sizeof(hb_buffer_T));
 
-  if (!buffer_init(buffer, capacity)) {
+  if (!hb_buffer_init(buffer, capacity)) {
     free(buffer);
     return NULL;
   }
@@ -32,20 +33,20 @@ buffer_T* buffer_new(const size_t capacity) {
   return buffer;
 }
 
-char* buffer_value(const buffer_T* buffer) {
+char* hb_buffer_value(const hb_buffer_T* buffer) {
   return buffer->value;
 }
 
-size_t buffer_length(const buffer_T* buffer) {
+size_t hb_buffer_length(const hb_buffer_T* buffer) {
   return buffer->length;
 }
 
-size_t buffer_capacity(const buffer_T* buffer) {
+size_t hb_buffer_capacity(const hb_buffer_T* buffer) {
   return buffer->capacity;
 }
 
-size_t buffer_sizeof(void) {
-  return sizeof(buffer_T);
+size_t hb_buffer_sizeof(void) {
+  return sizeof(hb_buffer_T);
 }
 
 /**
@@ -57,7 +58,7 @@ size_t buffer_sizeof(void) {
  * @param additional_capacity The additional length needed beyond current buffer capacity
  * @return true if capacity was increased, false if reallocation failed
  */
-bool buffer_increase_capacity(buffer_T* buffer, const size_t additional_capacity) {
+bool hb_buffer_increase_capacity(hb_buffer_T* buffer, const size_t additional_capacity) {
   if (additional_capacity + 1 >= SIZE_MAX) {
     fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
     exit(1);
@@ -65,7 +66,7 @@ bool buffer_increase_capacity(buffer_T* buffer, const size_t additional_capacity
 
   const size_t new_capacity = buffer->capacity + additional_capacity;
 
-  return buffer_resize(buffer, new_capacity);
+  return hb_buffer_resize(buffer, new_capacity);
 }
 
 /**
@@ -75,7 +76,7 @@ bool buffer_increase_capacity(buffer_T* buffer, const size_t additional_capacity
  * @param new_capacity The new capacity to resize the buffer to
  * @return true if capacity was resized, false if reallocation failed
  */
-bool buffer_resize(buffer_T* buffer, const size_t new_capacity) {
+bool hb_buffer_resize(hb_buffer_T* buffer, const size_t new_capacity) {
   if (new_capacity + 1 >= SIZE_MAX) {
     fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
     exit(1);
@@ -96,27 +97,27 @@ bool buffer_resize(buffer_T* buffer, const size_t new_capacity) {
 
 /**
  * Expands the capacity of the buffer by doubling its current capacity.
- * This function is a convenience function that calls buffer_increase_capacity
+ * This function is a convenience function that calls hb_buffer_increase_capacity
  * with a factor of 2.
  *
  * @param buffer The buffer to expand capacity for
  * @return true if capacity was increased, false if reallocation failed
  */
-bool buffer_expand_capacity(buffer_T* buffer) {
-  return buffer_resize(buffer, buffer->capacity * 2);
+bool hb_buffer_expand_capacity(hb_buffer_T* buffer) {
+  return hb_buffer_resize(buffer, buffer->capacity * 2);
 }
 
 /**
  * Expands the capacity of the buffer if needed to accommodate additional content.
- * This function is a convenience function that calls buffer_has_capacity and
- * buffer_expand_capacity.
+ * This function is a convenience function that calls hb_buffer_has_capacity and
+ * hb_buffer_expand_capacity.
  *
  * @param buffer The buffer to expand capacity for
  * @param required_length The additional length needed beyond current buffer capacity
  * @return true if capacity was increased, false if reallocation failed
  */
-bool buffer_expand_if_needed(buffer_T* buffer, const size_t required_length) {
-  if (buffer_has_capacity(buffer, required_length)) { return true; }
+bool hb_buffer_expand_if_needed(hb_buffer_T* buffer, const size_t required_length) {
+  if (hb_buffer_has_capacity(buffer, required_length)) { return true; }
 
   bool should_double_capacity = required_length < buffer->capacity;
   size_t new_capacity = 0;
@@ -127,26 +128,26 @@ bool buffer_expand_if_needed(buffer_T* buffer, const size_t required_length) {
     new_capacity = buffer->capacity + (required_length * 2);
   }
 
-  return buffer_resize(buffer, new_capacity);
+  return hb_buffer_resize(buffer, new_capacity);
 }
 
 /**
  * Appends a null-terminated string to the buffer.
  * @note This function requires that 'text' is a properly null-terminated string.
  * When reading data from files or other non-string sources, ensure the data is
- * null-terminated before calling this function, or use buffer_append_with_length instead.
+ * null-terminated before calling this function, or use hb_buffer_append_with_length instead.
  *
  * @param buffer The buffer to append to
  * @param text A null-terminated string to append
  * @return void
  */
-void buffer_append(buffer_T* buffer, const char* text) {
+void hb_buffer_append(hb_buffer_T* buffer, const char* text) {
   if (!buffer || !text) { return; }
   if (text[0] == '\0') { return; }
 
   size_t text_length = strlen(text);
 
-  if (!buffer_expand_if_needed(buffer, text_length)) { return; }
+  if (!hb_buffer_expand_if_needed(buffer, text_length)) { return; }
 
   memcpy(buffer->value + buffer->length, text, text_length);
   buffer->length += text_length;
@@ -155,7 +156,7 @@ void buffer_append(buffer_T* buffer, const char* text) {
 
 /**
  * Appends a string of specified length to the buffer.
- * Unlike buffer_append(), this function does not require the text to be
+ * Unlike hb_buffer_append(), this function does not require the text to be
  * null-terminated as it uses the provided length instead of strlen().
  * This is particularly useful when working with data from files, network
  * buffers, or other non-null-terminated sources.
@@ -165,9 +166,9 @@ void buffer_append(buffer_T* buffer, const char* text) {
  * @param length The number of bytes to append from text
  * @return void
  */
-void buffer_append_with_length(buffer_T* buffer, const char* text, const size_t length) {
+void hb_buffer_append_with_length(hb_buffer_T* buffer, const char* text, const size_t length) {
   if (!buffer || !text || length == 0) { return; }
-  if (!buffer_expand_if_needed(buffer, length)) { return; }
+  if (!hb_buffer_expand_if_needed(buffer, length)) { return; }
 
   memcpy(buffer->value + buffer->length, text, length);
 
@@ -175,18 +176,18 @@ void buffer_append_with_length(buffer_T* buffer, const char* text, const size_t
   buffer->value[buffer->length] = '\0';
 }
 
-void buffer_append_char(buffer_T* buffer, const char character) {
+void hb_buffer_append_char(hb_buffer_T* buffer, const char character) {
   static char string[2];
 
   string[0] = character;
   string[1] = '\0';
 
-  buffer_append(buffer, string);
+  hb_buffer_append(buffer, string);
 }
 
-void buffer_append_repeated(buffer_T* buffer, const char character, size_t length) {
+void hb_buffer_append_repeated(hb_buffer_T* buffer, const char character, size_t length) {
   if (!buffer || length == 0) { return; }
-  if (!buffer_expand_if_needed(buffer, length)) { return; }
+  if (!hb_buffer_expand_if_needed(buffer, length)) { return; }
 
   memset(buffer->value + buffer->length, character, length);
 
@@ -194,17 +195,17 @@ void buffer_append_repeated(buffer_T* buffer, const char character, size_t lengt
   buffer->value[buffer->length] = '\0';
 }
 
-void buffer_append_whitespace(buffer_T* buffer, const size_t length) {
-  buffer_append_repeated(buffer, ' ', length);
+void hb_buffer_append_whitespace(hb_buffer_T* buffer, const size_t length) {
+  hb_buffer_append_repeated(buffer, ' ', length);
 }
 
-void buffer_prepend(buffer_T* buffer, const char* text) {
+void hb_buffer_prepend(hb_buffer_T* buffer, const char* text) {
   if (!buffer || !text) { return; }
   if (text[0] == '\0') { return; }
 
   size_t text_length = strlen(text);
 
-  if (!buffer_expand_if_needed(buffer, text_length)) { return; }
+  if (!hb_buffer_expand_if_needed(buffer, text_length)) { return; }
 
   memmove(buffer->value + text_length, buffer->value, buffer->length + 1);
   memcpy(buffer->value, text, text_length);
@@ -212,9 +213,9 @@ void buffer_prepend(buffer_T* buffer, const char* text) {
   buffer->length += text_length;
 }
 
-void buffer_concat(buffer_T* destination, buffer_T* source) {
+void hb_buffer_concat(hb_buffer_T* destination, hb_buffer_T* source) {
   if (source->length == 0) { return; }
-  if (!buffer_expand_if_needed(destination, source->length)) { return; }
+  if (!hb_buffer_expand_if_needed(destination, source->length)) { return; }
 
   memcpy(destination->value + destination->length, source->value, source->length);
 
@@ -222,16 +223,16 @@ void buffer_concat(buffer_T* destination, buffer_T* source) {
   destination->value[destination->length] = '\0';
 }
 
-bool buffer_has_capacity(buffer_T* buffer, const size_t required_length) {
+bool hb_buffer_has_capacity(hb_buffer_T* buffer, const size_t required_length) {
   return (buffer->length + required_length <= buffer->capacity);
 }
 
-void buffer_clear(buffer_T* buffer) {
+void hb_buffer_clear(hb_buffer_T* buffer) {
   buffer->length = 0;
   buffer->value[0] = '\0';
 }
 
-void buffer_free(buffer_T** buffer) {
+void hb_buffer_free(hb_buffer_T** buffer) {
   if (!buffer || !*buffer) { return; }
 
   if ((*buffer)->value != NULL) { free((*buffer)->value); }
diff --git a/src/hb_string.c b/src/util/hb_string.c
similarity index 97%
rename from src/hb_string.c
rename to src/util/hb_string.c
index 93b5872c7..0a45af6e8 100644
--- a/src/hb_string.c
+++ b/src/util/hb_string.c
@@ -1,4 +1,4 @@
-#include "include/hb_string.h"
+#include "../include/util/hb_string.h"
 
 #include <stdlib.h>
 #include <string.h>
diff --git a/templates/ext/herb/error_helpers.c.erb b/templates/ext/herb/error_helpers.c.erb
index 5771a91eb..7ededea6d 100644
--- a/templates/ext/herb/error_helpers.c.erb
+++ b/templates/ext/herb/error_helpers.c.erb
@@ -67,12 +67,12 @@ VALUE rb_error_from_c_struct(ERROR_T* error) {
   return Qnil;
 }
 
-VALUE rb_errors_array_from_c_array(array_T* array) {
+VALUE rb_errors_array_from_c_array(hb_array_T* array) {
   VALUE rb_array = rb_ary_new();
 
   if (array) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      ERROR_T* child_node = (ERROR_T*) array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      ERROR_T* child_node = (ERROR_T*) hb_array_get(array, i);
 
       if (child_node) {
         VALUE rb_child = rb_error_from_c_struct(child_node);
diff --git a/templates/ext/herb/error_helpers.h.erb b/templates/ext/herb/error_helpers.h.erb
index d30be39ae..3a7a88c47 100644
--- a/templates/ext/herb/error_helpers.h.erb
+++ b/templates/ext/herb/error_helpers.h.erb
@@ -7,6 +7,6 @@
 #include <ruby.h>
 
 VALUE rb_error_from_c_struct(ERROR_T* error);
-VALUE rb_errors_array_from_c_array(array_T* array);
+VALUE rb_errors_array_from_c_array(hb_array_T* array);
 
 #endif
diff --git a/templates/ext/herb/nodes.c.erb b/templates/ext/herb/nodes.c.erb
index 5fd5d677f..a778196c1 100644
--- a/templates/ext/herb/nodes.c.erb
+++ b/templates/ext/herb/nodes.c.erb
@@ -9,7 +9,7 @@
 #include "../../src/include/token.h"
 
 VALUE rb_node_from_c_struct(AST_NODE_T* node);
-static VALUE rb_nodes_array_from_c_array(array_T* array);
+static VALUE rb_nodes_array_from_c_array(hb_array_T* array);
 
 <%- nodes.each do |node| -%>
 static VALUE rb_<%= node.human %>_from_c_struct(<%= node.struct_type %>* <%= node.human %>) {
@@ -72,12 +72,12 @@ VALUE rb_node_from_c_struct(AST_NODE_T* node) {
   return Qnil;
 }
 
-static VALUE rb_nodes_array_from_c_array(array_T* array) {
+static VALUE rb_nodes_array_from_c_array(hb_array_T* array) {
   VALUE rb_array = rb_ary_new();
 
   if (array) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      AST_NODE_T* child_node = (AST_NODE_T*) array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
 
       if (child_node) {
         VALUE rb_child = rb_node_from_c_struct(child_node);
diff --git a/templates/javascript/packages/node/extension/error_helpers.cpp.erb b/templates/javascript/packages/node/extension/error_helpers.cpp.erb
index 390848a22..712960efe 100644
--- a/templates/javascript/packages/node/extension/error_helpers.cpp.erb
+++ b/templates/javascript/packages/node/extension/error_helpers.cpp.erb
@@ -4,16 +4,16 @@
 #include "nodes.h"
 
 extern "C" {
-#include "../extension/libherb/include/herb.h"
-#include "../extension/libherb/include/token.h"
-#include "../extension/libherb/include/array.h"
-#include "../extension/libherb/include/errors.h"
 #include "../extension/libherb/include/ast_node.h"
 #include "../extension/libherb/include/ast_nodes.h"
+#include "../extension/libherb/include/errors.h"
+#include "../extension/libherb/include/herb.h"
+#include "../extension/libherb/include/token.h"
+#include "../extension/libherb/include/util/hb_array.h"
 }
 
 napi_value ErrorFromCStruct(napi_env env, ERROR_T* error);
-napi_value ErrorsArrayFromCArray(napi_env env, array_T* array);
+napi_value ErrorsArrayFromCArray(napi_env env, hb_array_T* array);
 
 <%- errors.each do |error| -%>
 napi_value <%= error.name %>FromCStruct(napi_env env, <%= error.struct_type %>* <%= error.human %>) {
@@ -75,13 +75,13 @@ napi_value <%= error.name %>FromCStruct(napi_env env, <%= error.struct_type %>*
 
 <%- end -%>
 
-napi_value ErrorsArrayFromCArray(napi_env env, array_T* array) {
+napi_value ErrorsArrayFromCArray(napi_env env, hb_array_T* array) {
   napi_value result;
   napi_create_array(env, &result);
 
   if (array) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      ERROR_T* error = (ERROR_T*) array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      ERROR_T* error = (ERROR_T*) hb_array_get(array, i);
       if (error) {
         napi_value js_error = ErrorFromCStruct(env, error);
         napi_set_element(env, result, i, js_error);
diff --git a/templates/javascript/packages/node/extension/error_helpers.h.erb b/templates/javascript/packages/node/extension/error_helpers.h.erb
index 003dd4a40..c10df4fec 100644
--- a/templates/javascript/packages/node/extension/error_helpers.h.erb
+++ b/templates/javascript/packages/node/extension/error_helpers.h.erb
@@ -8,7 +8,7 @@ extern "C" {
 }
 
 napi_value ErrorFromCStruct(napi_env env, ERROR_T* error);
-napi_value ErrorsArrayFromCArray(napi_env env, array_T* array);
+napi_value ErrorsArrayFromCArray(napi_env env, hb_array_T* array);
 
 <%- errors.each do |error| -%>
 napi_value <%= error.name %>FromCStruct(napi_env env, <%= error.struct_type %>* <%= error.human %>);
diff --git a/templates/javascript/packages/node/extension/nodes.cpp.erb b/templates/javascript/packages/node/extension/nodes.cpp.erb
index f5ecc95b7..a8de107df 100644
--- a/templates/javascript/packages/node/extension/nodes.cpp.erb
+++ b/templates/javascript/packages/node/extension/nodes.cpp.erb
@@ -4,15 +4,15 @@
 #include "nodes.h"
 
 extern "C" {
-#include "../extension/libherb/include/herb.h"
-#include "../extension/libherb/include/token.h"
-#include "../extension/libherb/include/array.h"
 #include "../extension/libherb/include/ast_node.h"
 #include "../extension/libherb/include/ast_nodes.h"
+#include "../extension/libherb/include/herb.h"
+#include "../extension/libherb/include/token.h"
+#include "../extension/libherb/include/util/hb_array.h"
 }
 
 napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node);
-napi_value NodesArrayFromCArray(napi_env env, array_T* array);
+napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array);
 
 <%- nodes.each do |node| -%>
 napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %>* <%= node.human %>) {
@@ -73,13 +73,13 @@ napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %
 }
 <%- end -%>
 
-napi_value NodesArrayFromCArray(napi_env env, array_T* array) {
+napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array) {
   napi_value result;
   napi_create_array(env, &result);
 
   if (array) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      AST_NODE_T* child_node = (AST_NODE_T*) array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
       if (child_node) {
         napi_value js_child = NodeFromCStruct(env, child_node);
         napi_set_element(env, result, i, js_child);
diff --git a/templates/javascript/packages/node/extension/nodes.h.erb b/templates/javascript/packages/node/extension/nodes.h.erb
index 1f83989df..78f97c849 100644
--- a/templates/javascript/packages/node/extension/nodes.h.erb
+++ b/templates/javascript/packages/node/extension/nodes.h.erb
@@ -8,7 +8,7 @@ extern "C" {
 }
 
 napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node);
-napi_value NodesArrayFromCArray(napi_env env, array_T* array);
+napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array);
 
 <%- nodes.each do |node| -%>
 napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %>* <%= node.human %>);
diff --git a/templates/src/ast_nodes.c.erb b/templates/src/ast_nodes.c.erb
index 3c6bcebcc..658bf5061 100644
--- a/templates/src/ast_nodes.c.erb
+++ b/templates/src/ast_nodes.c.erb
@@ -4,16 +4,16 @@
 #include <prism.h>
 
 #include "include/analyzed_ruby.h"
-#include "include/array.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/errors.h"
 #include "include/token.h"
 #include "include/util.h"
+#include "include/util/hb_array.h"
 
 <%- nodes.each do |node| -%>
 <%- node_arguments = node.fields.any? ? node.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
-<%- arguments = node_arguments + ["position_T start_position", "position_T end_position", "array_T* errors"] -%>
+<%- arguments = node_arguments + ["position_T start_position", "position_T end_position", "hb_array_T* errors"] -%>
 
 <%= node.struct_type %>* ast_<%= node.human %>_init(<%= arguments.join(", ") %>) {
   <%= node.struct_type %>* <%= node.human %> = malloc(sizeof(<%= node.struct_type %>));
@@ -73,12 +73,12 @@ void ast_free_base_node(AST_NODE_T* node) {
   if (node == NULL) { return; }
 
   if (node->errors) {
-    for (size_t i = 0; i < array_size(node->errors); i++) {
-      ERROR_T* child = array_get(node->errors, i);
+    for (size_t i = 0; i < hb_array_size(node->errors); i++) {
+      ERROR_T* child = hb_array_get(node->errors, i);
       if (child != NULL) { error_free(child); }
     }
 
-    array_free(&node->errors);
+    hb_array_free(&node->errors);
   }
 
   free(node);
@@ -99,12 +99,12 @@ static void ast_free_<%= node.human %>(<%= node.struct_type %>* <%= node.human %
   ast_node_free((AST_NODE_T*) <%= node.human %>-><%= field.name %>);
   <%- when Herb::Template::ArrayField -%>
   if (<%= node.human %>-><%= field.name %> != NULL) {
-    for (size_t i = 0; i < array_size(<%= node.human %>-><%= field.name %>); i++) {
-      AST_NODE_T* child = array_get(<%= node.human %>-><%= field.name %>, i);
+    for (size_t i = 0; i < hb_array_size(<%= node.human %>-><%= field.name %>); i++) {
+      AST_NODE_T* child = hb_array_get(<%= node.human %>-><%= field.name %>, i);
       if (child) { ast_node_free(child); }
     }
 
-    array_free(&<%= node.human %>-><%= field.name %>);
+    hb_array_free(&<%= node.human %>-><%= field.name %>);
   }
   <%- when Herb::Template::StringField -%>
   if (<%= node.human %>-><%= field.name %> != NULL) { free((char*) <%= node.human %>-><%= field.name %>); }
diff --git a/templates/src/ast_pretty_print.c.erb b/templates/src/ast_pretty_print.c.erb
index 845ab35bb..78e371937 100644
--- a/templates/src/ast_pretty_print.c.erb
+++ b/templates/src/ast_pretty_print.c.erb
@@ -1,27 +1,27 @@
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
-#include "include/buffer.h"
 #include "include/errors.h"
 #include "include/pretty_print.h"
 #include "include/token_struct.h"
 #include "include/util.h"
+#include "include/util/hb_buffer.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>
 
-void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!node) { return; }
 
   bool print_location = true;
 
-  buffer_append(buffer, "@ ");
-  buffer_append(buffer, ast_node_human_type(node));
-  buffer_append(buffer, " ");
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append(buffer, ast_node_human_type(node));
+  hb_buffer_append(buffer, " ");
 
   if (print_location) { pretty_print_location(node->location, buffer); }
 
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 
   switch (node->type) {
     <%- nodes.each do |node| -%>
@@ -49,16 +49,16 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       pretty_print_label("<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
 
       if (<%= node.human %>-><%= field.name %>) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) <%= node.human %>-><%= field.name %>, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
       <%- when Herb::Template::AnalyzedRubyField -%>
       if (<%= node.human %>-><%= field.name %>) {
@@ -79,12 +79,12 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
         pretty_print_boolean_property("unless_node", <%= node.human %>-><%= field.name %>->has_unless_node, indent, relative_indent,  <%= last %>, buffer);
       } else {
       pretty_print_label("<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
 
       <%- when Herb::Template::VoidPointerField -%>
       pretty_print_label("<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
-      buffer_append(buffer, " ?\n");
+      hb_buffer_append(buffer, " ?\n");
 
       <%- else -%>
       <%= field.inspect %>
diff --git a/templates/src/errors.c.erb b/templates/src/errors.c.erb
index edf63a9e2..1c8e1408c 100644
--- a/templates/src/errors.c.erb
+++ b/templates/src/errors.c.erb
@@ -1,10 +1,10 @@
-#include "include/array.h"
 #include "include/errors.h"
 #include "include/location.h"
 #include "include/position.h"
 #include "include/pretty_print.h"
 #include "include/token.h"
 #include "include/util.h"
+#include "include/util/hb_array.h"
 
 #include <stdio.h>
 #include <stdbool.h>
@@ -89,8 +89,8 @@ void error_init(ERROR_T* error, const error_type_T type, position_T start, posit
   return <%= error.human %>;
 }
 
-void append_<%= error.human %>(<%= (arguments + ["array_T* errors"]).join(", ") %>) {
-  array_append(errors, <%= error.human %>_init(<%= arguments.map { |argument| argument.split(" ").last.strip }.join(", ") %>));
+void append_<%= error.human %>(<%= (arguments + ["hb_array_T* errors"]).join(", ") %>) {
+  hb_array_append(errors, <%= error.human %>_init(<%= arguments.map { |argument| argument.split(" ").last.strip }.join(", ") %>));
 }
 <%- end -%>
 
@@ -158,8 +158,8 @@ void error_free(ERROR_T* error) {
 }
 
 void error_pretty_print_array(
-  const char* name, array_T* array, const size_t indent, const size_t relative_indent, const bool last_property,
-  buffer_T* buffer
+  const char* name, hb_array_T* array, const size_t indent, const size_t relative_indent, const bool last_property,
+  hb_buffer_T* buffer
 ) {
   if (array == NULL) {
     pretty_print_property(name, "∅", indent, relative_indent, last_property, buffer);
@@ -167,7 +167,7 @@ void error_pretty_print_array(
     return;
   }
 
-  if (array_size(array) == 0) {
+  if (hb_array_size(array) == 0) {
     pretty_print_property(name, "[]", indent, relative_indent, last_property, buffer);
 
     return;
@@ -175,42 +175,42 @@ void error_pretty_print_array(
 
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
 
-  buffer_append(buffer, "(");
+  hb_buffer_append(buffer, "(");
 
   char count[16];
-  sprintf(count, "%zu", array_size(array));
-  buffer_append(buffer, count);
-  buffer_append(buffer, ")\n");
+  sprintf(count, "%zu", hb_array_size(array));
+  hb_buffer_append(buffer, count);
+  hb_buffer_append(buffer, ")\n");
 
   if (indent < 20) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      ERROR_T* child = array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      ERROR_T* child = hb_array_get(array, i);
       pretty_print_indent(buffer, indent);
       pretty_print_indent(buffer, relative_indent + 1);
 
-      if (i == array_size(array) - 1) {
-        buffer_append(buffer, "└── ");
+      if (i == hb_array_size(array) - 1) {
+        hb_buffer_append(buffer, "└── ");
       } else {
-        buffer_append(buffer, "├── ");
+        hb_buffer_append(buffer, "├── ");
       }
 
       error_pretty_print(child, indent + 1, relative_indent + 1, buffer);
 
-      if (i != array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
+      if (i != hb_array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
     }
   }
 }
 
 <%- errors.each do |error| -%>
-static void error_pretty_print_<%= error.human %>(<%= error.struct_type %>* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+static void error_pretty_print_<%= error.human %>(<%= error.struct_type %>* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
-  buffer_append(buffer, "@ ");
-  buffer_append(buffer, error_human_type((ERROR_T*) error));
-  buffer_append(buffer, " ");
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
 
   pretty_print_location(error->base.location, buffer);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 
   pretty_print_quoted_property("message", error->base.message, indent, relative_indent, <%= error.fields.none? %>, buffer);
   <%- error.fields.each_with_index do |field, index| -%>
@@ -232,7 +232,7 @@ static void error_pretty_print_<%= error.human %>(<%= error.struct_type %>* erro
 }
 
 <%- end -%>
-void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
   switch (error->type) {
diff --git a/templates/src/include/ast_nodes.h.erb b/templates/src/include/ast_nodes.h.erb
index 89a7a4736..9aad4ad94 100644
--- a/templates/src/include/ast_nodes.h.erb
+++ b/templates/src/include/ast_nodes.h.erb
@@ -4,13 +4,13 @@
 #include <stdbool.h>
 #include <prism.h>
 
-#include "array.h"
-#include "buffer.h"
-#include "position.h"
-#include "location.h"
-#include "token_struct.h"
 #include "analyzed_ruby.h"
 #include "element_source.h"
+#include "location.h"
+#include "position.h"
+#include "token_struct.h"
+#include "util/hb_array.h"
+#include "util/hb_buffer.h"
 
 typedef enum {
 <%- nodes.each do |node| -%>
@@ -22,7 +22,7 @@ typedef struct AST_NODE_STRUCT {
   ast_node_type_T type;
   location_T location;
   // maybe a range too?
-  array_T* errors;
+  hb_array_T* errors;
 } AST_NODE_T;
 
 <%- nodes.each do |node| -%>
@@ -36,7 +36,7 @@ typedef struct <%= node.struct_name %> {
 
 <%- nodes.each do |node| -%>
 <%- node_arguments = node.fields.any? ? node.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
-<%- arguments = node_arguments + ["position_T start_position", "position_T end_position", "array_T* errors"] -%>
+<%- arguments = node_arguments + ["position_T start_position", "position_T end_position", "hb_array_T* errors"] -%>
 <%= node.struct_type %>* ast_<%= node.human %>_init(<%= arguments.join(", ") %>);
 <%- end -%>
 
diff --git a/templates/src/include/ast_pretty_print.h.erb b/templates/src/include/ast_pretty_print.h.erb
index e0dc4052b..47f91aa13 100644
--- a/templates/src/include/ast_pretty_print.h.erb
+++ b/templates/src/include/ast_pretty_print.h.erb
@@ -2,13 +2,13 @@
 #define HERB_AST_PRETTY_PRINT_H
 
 #include "ast_nodes.h"
-#include "buffer.h"
+#include "util/hb_buffer.h"
 
 void ast_pretty_print_node(
   AST_NODE_T* node,
   size_t indent,
   size_t relative_indent,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 #endif
diff --git a/templates/src/include/errors.h.erb b/templates/src/include/errors.h.erb
index 41a5ea068..4676c72d3 100644
--- a/templates/src/include/errors.h.erb
+++ b/templates/src/include/errors.h.erb
@@ -1,12 +1,12 @@
 #ifndef HERB_ERRORS_H
 #define HERB_ERRORS_H
 
-#include "array.h"
-#include "buffer.h"
 #include "errors.h"
 #include "location.h"
 #include "position.h"
 #include "token.h"
+#include "util/hb_array.h"
+#include "util/hb_buffer.h"
 
 typedef enum {
 <%- errors.each do |error| -%>
@@ -33,7 +33,7 @@ typedef struct {
 <%- error_arguments = error.fields.any? ? error.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
 <%- arguments = error_arguments + ["position_T start", "position_T end"] -%>
 <%= error.struct_type %>* <%= error.human %>_init(<%= arguments.join(", ") %>);
-void append_<%= error.human %>(<%= (arguments << "array_T* errors").join(", ") %>);
+void append_<%= error.human %>(<%= (arguments << "hb_array_T* errors").join(", ") %>);
 <%- end -%>
 
 void error_init(ERROR_T* error, error_type_T type, position_T start, position_T end);
@@ -48,11 +48,11 @@ const char* error_human_type(ERROR_T* error);
 
 void error_free(ERROR_T* error);
 
-void error_pretty_print(ERROR_T* error, size_t indent, size_t relative_indent, buffer_T* buffer);
+void error_pretty_print(ERROR_T* error, size_t indent, size_t relative_indent, hb_buffer_T* buffer);
 
 void error_pretty_print_array(
-  const char* name, array_T* array, size_t indent, size_t relative_indent, bool last_property,
-  buffer_T* buffer
+  const char* name, hb_array_T* array, size_t indent, size_t relative_indent, bool last_property,
+  hb_buffer_T* buffer
 );
 
 #endif
diff --git a/templates/src/visitor.c.erb b/templates/src/visitor.c.erb
index 41a5afd55..ab20a5bfa 100644
--- a/templates/src/visitor.c.erb
+++ b/templates/src/visitor.c.erb
@@ -1,9 +1,9 @@
 #include <stdio.h>
 
-#include "include/array.h"
-#include "include/visitor.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
+#include "include/util/hb_array.h"
+#include "include/visitor.h"
 
 void herb_visit_node(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T*, void*), void* data) {
   if (visitor(node, data) && node != NULL) {
@@ -31,8 +31,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
       <%- when Herb::Template::ArrayField -%>
       if (<%= node.human %>-><%= field.name %> != NULL) {
-        for (size_t index = 0; index < array_size(<%= node.human %>-><%= field.name %>); index++) {
-          herb_visit_node(array_get(<%= node.human %>-><%= field.name %>, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(<%= node.human %>-><%= field.name %>); index++) {
+          herb_visit_node(hb_array_get(<%= node.human %>-><%= field.name %>, index), visitor, data);
         }
       }
 
diff --git a/templates/template.rb b/templates/template.rb
index 4d5973703..64097371f 100755
--- a/templates/template.rb
+++ b/templates/template.rb
@@ -30,7 +30,7 @@ def ruby_type
       end
 
       def c_type
-        "array_T*"
+        "hb_array_T*"
       end
 
       def c_item_type
diff --git a/templates/wasm/error_helpers.cpp.erb b/templates/wasm/error_helpers.cpp.erb
index 427972a0f..7e0f43b7b 100644
--- a/templates/wasm/error_helpers.cpp.erb
+++ b/templates/wasm/error_helpers.cpp.erb
@@ -8,12 +8,12 @@
 #include "extension_helpers.h"
 
 extern "C" {
-#include "../src/include/herb.h"
-#include "../src/include/token.h"
-#include "../src/include/array.h"
-#include "../src/include/errors.h"
 #include "../src/include/ast_node.h"
 #include "../src/include/ast_nodes.h"
+#include "../src/include/errors.h"
+#include "../src/include/herb.h"
+#include "../src/include/token.h"
+#include "../src/include/util/hb_array.h"
 }
 
 using namespace emscripten;
@@ -21,9 +21,9 @@ using namespace emscripten;
 val CreateLocation(location_T* location);
 val CreateToken(token_T* token);
 val NodeFromCStruct(AST_NODE_T* node);
-val NodesArrayFromCArray(array_T* array);
+val NodesArrayFromCArray(hb_array_T* array);
 val ErrorFromCStruct(ERROR_T* error);
-val ErrorsArrayFromCArray(array_T* array);
+val ErrorsArrayFromCArray(hb_array_T* array);
 
 <%- errors.each do |error| -%>
 val <%= error.name %>FromCStruct(<%= error.struct_type %>* <%= error.human %>) {
@@ -61,13 +61,13 @@ val <%= error.name %>FromCStruct(<%= error.struct_type %>* <%= error.human %>) {
 
 <%- end -%>
 
-val ErrorsArrayFromCArray(array_T* array) {
+val ErrorsArrayFromCArray(hb_array_T* array) {
   val Array = val::global("Array");
   val result = Array.new_();
 
   if (array) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      ERROR_T* error = (ERROR_T*)array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      ERROR_T* error = (ERROR_T*)hb_array_get(array, i);
       if (error) {
         result.call<void>("push", ErrorFromCStruct(error));
       }
diff --git a/templates/wasm/error_helpers.h.erb b/templates/wasm/error_helpers.h.erb
index bfa8971d3..32f65cefb 100644
--- a/templates/wasm/error_helpers.h.erb
+++ b/templates/wasm/error_helpers.h.erb
@@ -6,7 +6,7 @@ extern "C" {
 }
 
 emscripten::val ErrorFromCStruct(ERROR_T* error);
-emscripten::val ErrorsArrayFromCArray(array_T* array);
+emscripten::val ErrorsArrayFromCArray(hb_array_T* array);
 
 <%- errors.each do |error| -%>
 emscripten::val <%= error.name %>FromCStruct(<%= error.struct_type %>* <%= error.human %>);
diff --git a/templates/wasm/nodes.cpp.erb b/templates/wasm/nodes.cpp.erb
index 1580f22d4..d804a37c8 100644
--- a/templates/wasm/nodes.cpp.erb
+++ b/templates/wasm/nodes.cpp.erb
@@ -4,17 +4,17 @@
 #include "error_helpers.h"
 #include "extension_helpers.h"
 
-#include "../src/include/herb.h"
-#include "../src/include/token.h"
-#include "../src/include/array.h"
 #include "../src/include/ast_node.h"
 #include "../src/include/ast_nodes.h"
+#include "../src/include/herb.h"
 #include "../src/include/location.h"
+#include "../src/include/token.h"
+#include "../src/include/util/hb_array.h"
 
 using namespace emscripten;
 
 val NodeFromCStruct(AST_NODE_T* node);
-val NodesArrayFromCArray(array_T* array);
+val NodesArrayFromCArray(hb_array_T* array);
 
 <%- nodes.each do |node| -%>
 val <%= node.name %>FromCStruct(<%= node.struct_type %>* <%= node.human %>) {
@@ -62,13 +62,13 @@ val NodeFromCStruct(AST_NODE_T* node) {
   }
 }
 
-val NodesArrayFromCArray(array_T* array) {
+val NodesArrayFromCArray(hb_array_T* array) {
   if (!array) return val::null();
 
   val jsArray = val::array();
 
-  for (size_t i = 0; i < array_size(array); i++) {
-    AST_NODE_T* child_node = (AST_NODE_T*) array_get(array, i);
+  for (size_t i = 0; i < hb_array_size(array); i++) {
+    AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
 
     if (child_node) {
       jsArray.set(i, NodeFromCStruct(child_node));
diff --git a/templates/wasm/nodes.h.erb b/templates/wasm/nodes.h.erb
index a32c551ae..eeefc1177 100644
--- a/templates/wasm/nodes.h.erb
+++ b/templates/wasm/nodes.h.erb
@@ -6,7 +6,7 @@ extern "C" {
 }
 
 emscripten::val NodeFromCStruct(AST_NODE_T* node);
-emscripten::val NodesArrayFromCArray(array_T* array);
+emscripten::val NodesArrayFromCArray(hb_array_T* array);
 
 <%- nodes.each do |node| -%>
 emscripten::val <%= node.human %>NodeFromCStruct(<%= node.struct_type %>* <%= node.human %>);
diff --git a/test/c/main.c b/test/c/main.c
index b2f7f23aa..ef4238806 100644
--- a/test/c/main.c
+++ b/test/c/main.c
@@ -1,30 +1,30 @@
 #include <check.h>
 #include <stdlib.h>
 
-TCase *array_tests(void);
-TCase *buffer_tests(void);
+TCase *hb_arena_tests(void);
+TCase *hb_array_tests(void);
+TCase *hb_buffer_tests(void);
+TCase *hb_string_tests(void);
 TCase *herb_tests(void);
 TCase *html_util_tests(void);
 TCase *io_tests(void);
 TCase *lex_tests(void);
 TCase *token_tests(void);
 TCase *util_tests(void);
-TCase *hb_string_tests(void);
-TCase *hb_arena_tests(void);
 
 Suite *herb_suite(void) {
   Suite *suite = suite_create("Herb Suite");
 
-  suite_add_tcase(suite, array_tests());
-  suite_add_tcase(suite, buffer_tests());
+  suite_add_tcase(suite, hb_arena_tests());
+  suite_add_tcase(suite, hb_array_tests());
+  suite_add_tcase(suite, hb_buffer_tests());
+  suite_add_tcase(suite, hb_string_tests());
   suite_add_tcase(suite, herb_tests());
   suite_add_tcase(suite, html_util_tests());
   suite_add_tcase(suite, io_tests());
   suite_add_tcase(suite, lex_tests());
   suite_add_tcase(suite, token_tests());
   suite_add_tcase(suite, util_tests());
-  suite_add_tcase(suite, hb_string_tests());
-  suite_add_tcase(suite, hb_arena_tests());
 
   return suite;
 }
diff --git a/test/c/test_array.c b/test/c/test_array.c
deleted file mode 100644
index 5473d76fc..000000000
--- a/test/c/test_array.c
+++ /dev/null
@@ -1,105 +0,0 @@
-#include "include/test.h"
-#include "../../src/include/array.h"
-
-// Test array initialization
-TEST(test_array_init)
-  array_T* array = array_init(10);
-
-  ck_assert_ptr_nonnull(array);
-  ck_assert_int_eq(array->size, 0);
-  ck_assert_int_eq(array->capacity, 10);
-  ck_assert_ptr_nonnull(array->items);
-
-  array_free(&array);
-END
-
-// Test array appending
-TEST(test_array_append)
-  array_T* array = array_init(2);
-
-  size_t item1 = 42, item2 = 99, item3 = 100;
-  array_append(array, &item1);
-  array_append(array, &item2);
-
-  ck_assert_int_eq(array->size, 2);
-  ck_assert_int_eq(array->capacity, 2);
-  ck_assert_ptr_eq(array->items[0], &item1);
-  ck_assert_ptr_eq(array->items[1], &item2);
-
-  // Trigger reallocation
-  array_append(array, &item3);
-  ck_assert_int_eq(array->size, 3);
-  ck_assert_int_eq(array->capacity, 4);
-
-  array_free(&array);
-END
-
-// Test getting elements
-TEST(test_array_get)
-  array_T* array = array_init(3);
-
-  size_t item1 = 42, item2 = 99;
-  array_append(array, &item1);
-  array_append(array, &item2);
-
-  ck_assert_ptr_eq(array_get(array, 0), &item1);
-  ck_assert_ptr_eq(array_get(array, 1), &item2);
-  ck_assert_ptr_null(array_get(array, 2)); // Out of bounds check
-
-  array_free(&array);
-END
-
-// Test setting elements
-TEST(test_array_set)
-  array_T* array = array_init(3);
-
-  size_t item1 = 42, item2 = 99;
-  array_append(array, &item1);
-  array_append(array, &item2);
-
-  size_t new_item = 77;
-  array_set(array, 1, &new_item);
-
-  ck_assert_ptr_eq(array_get(array, 1), &new_item);
-
-  array_free(&array);
-END
-
-// Test removing elements
-TEST(test_array_remove)
-  array_T* array = array_init(3);
-
-  size_t item1 = 42, item2 = 99, item3 = 100;
-  array_append(array, &item1);
-  array_append(array, &item2);
-  array_append(array, &item3);
-
-  array_remove(array, 1); // Remove item2
-  ck_assert_int_eq(array->size, 2);
-  ck_assert_ptr_eq(array_get(array, 0), &item1);
-  ck_assert_ptr_eq(array_get(array, 1), &item3); // Shifted left
-
-  array_free(&array);
-END
-
-// Test freeing the array
-TEST(test_array_free)
-  array_T* array = array_init(5);
-  array_free(&array);
-
-  ck_assert_ptr_null(array);
-END
-
-// Register test cases
-TCase *array_tests(void) {
-  TCase *array = tcase_create("Array");
-
-  tcase_add_test(array, test_array_init);
-  tcase_add_test(array, test_array_append);
-  tcase_add_test(array, test_array_get);
-  tcase_add_test(array, test_array_set);
-  tcase_add_test(array, test_array_remove);
-  tcase_add_test(array, test_array_free);
-
-  return array;
-}
diff --git a/test/c/test_buffer.c b/test/c/test_buffer.c
deleted file mode 100644
index 58bce8358..000000000
--- a/test/c/test_buffer.c
+++ /dev/null
@@ -1,274 +0,0 @@
-#include "include/test.h"
-#include "../../src/include/buffer.h"
-
-// Test buffer initialization
-TEST(test_buffer_init)
-  buffer_T buffer;
-
-  ck_assert(buffer_init(&buffer, 1024));
-  ck_assert_int_eq(buffer.capacity, 1024);
-  ck_assert_int_eq(buffer.length, 0);
-  ck_assert_ptr_nonnull(buffer.value);
-  ck_assert_str_eq(buffer.value, "");
-
-  free(buffer.value);
-END
-
-// Test appending text to buffer
-TEST(test_buffer_append)
-  buffer_T buffer;
-  buffer_init(&buffer, 1024);
-
-  ck_assert_str_eq(buffer.value, "");
-
-  buffer_append(&buffer, "Hello");
-  ck_assert_str_eq(buffer.value, "Hello");
-  ck_assert_int_eq(buffer.length, 5);
-
-  buffer_append(&buffer, " World");
-  ck_assert_str_eq(buffer.value, "Hello World");
-  ck_assert_int_eq(buffer.length, 11);
-
-  free(buffer.value);
-END
-
-// Test prepending text to buffer
-TEST(test_buffer_prepend)
-  buffer_T buffer;
-  buffer_init(&buffer, 1024);
-
-  buffer_append(&buffer, "World");
-  buffer_prepend(&buffer, "Hello ");
-  ck_assert_str_eq(buffer.value, "Hello World");
-  ck_assert_int_eq(buffer.length, 11);
-
-  free(buffer.value);
-END
-
-// Test concatenating two buffers
-TEST(test_buffer_concat)
-  buffer_T buffer1;
-  buffer_init(&buffer1, 1024);
-  buffer_T buffer2;
-  buffer_init(&buffer2, 1024);
-
-  buffer_append(&buffer1, "Hello");
-  buffer_append(&buffer2, " World");
-
-  buffer_concat(&buffer1, &buffer2);
-  ck_assert_str_eq(buffer1.value, "Hello World");
-  ck_assert_int_eq(buffer1.length, 11);
-
-  free(buffer1.value);
-  free(buffer2.value);
-END
-
-// Test increating
-TEST(test_buffer_increase_capacity)
-  buffer_T buffer;
-  buffer_init(&buffer, 1024);
-
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(buffer_increase_capacity(&buffer, 1));
-  ck_assert_int_eq(buffer.capacity, 1025);
-
-  ck_assert(buffer_increase_capacity(&buffer, 1024 + 1));
-  ck_assert_int_eq(buffer.capacity, 2050);
-
-  free(buffer.value);
-END
-
-// Test expanding capacity
-TEST(test_buffer_expand_capacity)
-  buffer_T buffer;
-  buffer_init(&buffer, 1024);
-
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(buffer_expand_capacity(&buffer));
-  ck_assert_int_eq(buffer.capacity, 2048);
-
-  ck_assert(buffer_expand_capacity(&buffer));
-  ck_assert_int_eq(buffer.capacity, 4096);
-
-  ck_assert(buffer_expand_capacity(&buffer));
-  ck_assert_int_eq(buffer.capacity, 8192);
-
-  free(buffer.value);
-END
-
-// Test expanding if needed
-TEST(test_buffer_expand_if_needed)
-  buffer_T buffer;
-  buffer_init(&buffer, 1024);
-
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(buffer_expand_if_needed(&buffer, 1));
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(buffer_expand_if_needed(&buffer, 1023));
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(buffer_expand_if_needed(&buffer, 1024));
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(buffer_expand_if_needed(&buffer, 1025));
-  ck_assert_int_eq(buffer.capacity, 3074); // initial capacity (1024) + (required (1025) * 2) = 3074
-
-  free(buffer.value);
-END
-
-TEST(test_buffer_expand_if_needed_with_nearly_full_buffer)
-  buffer_T buffer;
-  buffer_init(&buffer, 1024);
-
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  buffer_append_repeated(&buffer, ' ', 1023);
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(buffer_expand_if_needed(&buffer, 2));
-  ck_assert_int_eq(buffer.capacity, 2048);
-
-  free(buffer.value);
-END
-
-// Test resizing buffer
-TEST(test_buffer_resize)
-  buffer_T buffer;
-  buffer_init(&buffer, 1024);
-
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(buffer_resize(&buffer, 2048));
-  ck_assert_int_eq(buffer.capacity, 2048);
-
-  ck_assert(buffer_resize(&buffer, 4096));
-  ck_assert_int_eq(buffer.capacity, 4096);
-
-  ck_assert(buffer_resize(&buffer, 8192));
-  ck_assert_int_eq(buffer.capacity, 8192);
-
-  free(buffer.value);
-END
-
-// Test clearing buffer without freeing memory
-TEST(test_buffer_clear)
-  buffer_T buffer;
-  buffer_init(&buffer, 1024);
-
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  buffer_append(&buffer, "Hello");
-  ck_assert_str_eq(buffer.value, "Hello");
-  ck_assert_int_eq(buffer.length, 5);
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  buffer_clear(&buffer);
-
-  ck_assert_str_eq(buffer.value, "");
-  ck_assert_int_eq(buffer.length, 0);
-  ck_assert_int_eq(buffer.capacity, 1024); // Capacity should remain unchanged
-
-  free(buffer.value);
-END
-
-// Test freeing buffer
-TEST(test_buffer_free)
-  buffer_T buffer;
-  buffer_init(&buffer, 1024);
-
-  buffer_append(&buffer, "Test");
-  ck_assert_int_eq(buffer.length, 4);
-  ck_assert_int_eq(buffer.capacity, 1024);
-  free(buffer.value);
-  buffer.value = NULL;
-  buffer.length = 0;
-  buffer.capacity = 0;
-
-  ck_assert_ptr_null(buffer.value);
-  ck_assert_int_eq(buffer.length, 0);
-  ck_assert_int_eq(buffer.capacity, 0);
-END
-
-// Test buffer UTF-8 integrity
-TEST(test_buffer_utf8_integrity)
-  buffer_T buffer;
-  buffer_init(&buffer, 1024);
-
-  // UTF-8 String
-  const char *utf8_text = "こんにちは";
-  buffer_append(&buffer, utf8_text);
-
-  // Ensure length matches actual UTF-8 bytes
-  ck_assert_int_eq(buffer.length, strlen(utf8_text));
-  ck_assert_int_eq(buffer.length, 15);
-  ck_assert_str_eq(buffer.value, utf8_text);
-
-  free(buffer.value);
-END
-
-// Test: Buffer Appending UTF-8 Characters
-TEST(test_buffer_append_utf8)
-  buffer_T buffer;
-  buffer_init(&buffer, 1024);
-
-  // Append UTF-8 string
-  buffer_append(&buffer, "こんにちは"); // "Hello" in Japanese
-  ck_assert_int_eq(strlen("こんにちは"), 15); // UTF-8 multibyte characters
-  ck_assert_int_eq(buffer_length(&buffer), 15);
-  ck_assert_str_eq(buffer_value(&buffer), "こんにちは");
-
-  free(buffer.value);
-END
-
-// Test buffer length correctness
-TEST(test_buffer_length_correctness)
-  buffer_T buffer;
-  buffer_init(&buffer, 1024);
-
-  buffer_append(&buffer, "Short");
-  size_t length = buffer_length(&buffer);
-  ck_assert_int_eq(length, 5);
-
-  buffer_append(&buffer, "er test");
-  length = buffer_length(&buffer);
-  ck_assert_int_eq(length, 12);
-
-  free(buffer.value);
-END
-
-// Test: Buffer Null-Termination
-TEST(test_buffer_null_termination)
-  buffer_T buffer;
-  buffer_init(&buffer, 1024);
-
-  buffer_append(&buffer, "Test");
-  ck_assert(buffer_value(&buffer)[buffer_length(&buffer)] == '\0'); // Ensure null termination
-
-  free(buffer.value);
-END
-
-TCase *buffer_tests(void) {
-  TCase *buffer = tcase_create("Buffer");
-
-  tcase_add_test(buffer, test_buffer_init);
-  tcase_add_test(buffer, test_buffer_append);
-  tcase_add_test(buffer, test_buffer_prepend);
-  tcase_add_test(buffer, test_buffer_concat);
-  tcase_add_test(buffer, test_buffer_increase_capacity);
-  tcase_add_test(buffer, test_buffer_expand_capacity);
-  tcase_add_test(buffer, test_buffer_expand_if_needed);
-  tcase_add_test(buffer, test_buffer_expand_if_needed_with_nearly_full_buffer);
-  tcase_add_test(buffer, test_buffer_resize);
-  tcase_add_test(buffer, test_buffer_clear);
-  tcase_add_test(buffer, test_buffer_free);
-  tcase_add_test(buffer, test_buffer_utf8_integrity);
-  tcase_add_test(buffer, test_buffer_append_utf8);
-  tcase_add_test(buffer, test_buffer_length_correctness);
-  tcase_add_test(buffer, test_buffer_null_termination);
-
-  return buffer;
-}
diff --git a/test/c/test_hb_array.c b/test/c/test_hb_array.c
new file mode 100644
index 000000000..1abe357cc
--- /dev/null
+++ b/test/c/test_hb_array.c
@@ -0,0 +1,105 @@
+#include "include/test.h"
+#include "../../src/include/util/hb_array.h"
+
+// Test array initialization
+TEST(test_hb_array_init)
+  hb_array_T* array = hb_array_init(10);
+
+  ck_assert_ptr_nonnull(array);
+  ck_assert_int_eq(array->size, 0);
+  ck_assert_int_eq(array->capacity, 10);
+  ck_assert_ptr_nonnull(array->items);
+
+  hb_array_free(&array);
+END
+
+// Test array appending
+TEST(test_hb_array_append)
+  hb_array_T* array = hb_array_init(2);
+
+  size_t item1 = 42, item2 = 99, item3 = 100;
+  hb_array_append(array, &item1);
+  hb_array_append(array, &item2);
+
+  ck_assert_int_eq(array->size, 2);
+  ck_assert_int_eq(array->capacity, 2);
+  ck_assert_ptr_eq(array->items[0], &item1);
+  ck_assert_ptr_eq(array->items[1], &item2);
+
+  // Trigger reallocation
+  hb_array_append(array, &item3);
+  ck_assert_int_eq(array->size, 3);
+  ck_assert_int_eq(array->capacity, 4);
+
+  hb_array_free(&array);
+END
+
+// Test getting elements
+TEST(test_hb_array_get)
+  hb_array_T* array = hb_array_init(3);
+
+  size_t item1 = 42, item2 = 99;
+  hb_array_append(array, &item1);
+  hb_array_append(array, &item2);
+
+  ck_assert_ptr_eq(hb_array_get(array, 0), &item1);
+  ck_assert_ptr_eq(hb_array_get(array, 1), &item2);
+  ck_assert_ptr_null(hb_array_get(array, 2)); // Out of bounds check
+
+  hb_array_free(&array);
+END
+
+// Test setting elements
+TEST(test_hb_array_set)
+  hb_array_T* array = hb_array_init(3);
+
+  size_t item1 = 42, item2 = 99;
+  hb_array_append(array, &item1);
+  hb_array_append(array, &item2);
+
+  size_t new_item = 77;
+  hb_array_set(array, 1, &new_item);
+
+  ck_assert_ptr_eq(hb_array_get(array, 1), &new_item);
+
+  hb_array_free(&array);
+END
+
+// Test removing elements
+TEST(test_hb_array_remove)
+  hb_array_T* array = hb_array_init(3);
+
+  size_t item1 = 42, item2 = 99, item3 = 100;
+  hb_array_append(array, &item1);
+  hb_array_append(array, &item2);
+  hb_array_append(array, &item3);
+
+  hb_array_remove(array, 1); // Remove item2
+  ck_assert_int_eq(array->size, 2);
+  ck_assert_ptr_eq(hb_array_get(array, 0), &item1);
+  ck_assert_ptr_eq(hb_array_get(array, 1), &item3); // Shifted left
+
+  hb_array_free(&array);
+END
+
+// Test freeing the array
+TEST(test_hb_array_free)
+  hb_array_T* array = hb_array_init(5);
+  hb_array_free(&array);
+
+  ck_assert_ptr_null(array);
+END
+
+// Register test cases
+TCase *hb_array_tests(void) {
+  TCase *array = tcase_create("Herb Array");
+
+  tcase_add_test(array, test_hb_array_init);
+  tcase_add_test(array, test_hb_array_append);
+  tcase_add_test(array, test_hb_array_get);
+  tcase_add_test(array, test_hb_array_set);
+  tcase_add_test(array, test_hb_array_remove);
+  tcase_add_test(array, test_hb_array_free);
+
+  return array;
+}
diff --git a/test/c/test_hb_buffer.c b/test/c/test_hb_buffer.c
new file mode 100644
index 000000000..a239190e3
--- /dev/null
+++ b/test/c/test_hb_buffer.c
@@ -0,0 +1,274 @@
+#include "include/test.h"
+#include "../../src/include/util/hb_buffer.h"
+
+// Test buffer initialization
+TEST(test_hb_buffer_init)
+  hb_buffer_T buffer;
+
+  ck_assert(hb_buffer_init(&buffer, 1024));
+  ck_assert_int_eq(buffer.capacity, 1024);
+  ck_assert_int_eq(buffer.length, 0);
+  ck_assert_ptr_nonnull(buffer.value);
+  ck_assert_str_eq(buffer.value, "");
+
+  free(buffer.value);
+END
+
+// Test appending text to buffer
+TEST(test_hb_buffer_append)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  ck_assert_str_eq(buffer.value, "");
+
+  hb_buffer_append(&buffer, "Hello");
+  ck_assert_str_eq(buffer.value, "Hello");
+  ck_assert_int_eq(buffer.length, 5);
+
+  hb_buffer_append(&buffer, " World");
+  ck_assert_str_eq(buffer.value, "Hello World");
+  ck_assert_int_eq(buffer.length, 11);
+
+  free(buffer.value);
+END
+
+// Test prepending text to buffer
+TEST(test_hb_buffer_prepend)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  hb_buffer_append(&buffer, "World");
+  hb_buffer_prepend(&buffer, "Hello ");
+  ck_assert_str_eq(buffer.value, "Hello World");
+  ck_assert_int_eq(buffer.length, 11);
+
+  free(buffer.value);
+END
+
+// Test concatenating two buffers
+TEST(test_hb_buffer_concat)
+  hb_buffer_T buffer1;
+  hb_buffer_init(&buffer1, 1024);
+  hb_buffer_T buffer2;
+  hb_buffer_init(&buffer2, 1024);
+
+  hb_buffer_append(&buffer1, "Hello");
+  hb_buffer_append(&buffer2, " World");
+
+  hb_buffer_concat(&buffer1, &buffer2);
+  ck_assert_str_eq(buffer1.value, "Hello World");
+  ck_assert_int_eq(buffer1.length, 11);
+
+  free(buffer1.value);
+  free(buffer2.value);
+END
+
+// Test increating
+TEST(test_hb_buffer_increase_capacity)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  ck_assert_int_eq(buffer.capacity, 1024);
+
+  ck_assert(hb_buffer_increase_capacity(&buffer, 1));
+  ck_assert_int_eq(buffer.capacity, 1025);
+
+  ck_assert(hb_buffer_increase_capacity(&buffer, 1024 + 1));
+  ck_assert_int_eq(buffer.capacity, 2050);
+
+  free(buffer.value);
+END
+
+// Test expanding capacity
+TEST(test_hb_buffer_expand_capacity)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  ck_assert_int_eq(buffer.capacity, 1024);
+
+  ck_assert(hb_buffer_expand_capacity(&buffer));
+  ck_assert_int_eq(buffer.capacity, 2048);
+
+  ck_assert(hb_buffer_expand_capacity(&buffer));
+  ck_assert_int_eq(buffer.capacity, 4096);
+
+  ck_assert(hb_buffer_expand_capacity(&buffer));
+  ck_assert_int_eq(buffer.capacity, 8192);
+
+  free(buffer.value);
+END
+
+// Test expanding if needed
+TEST(test_hb_buffer_expand_if_needed)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  ck_assert_int_eq(buffer.capacity, 1024);
+
+  ck_assert(hb_buffer_expand_if_needed(&buffer, 1));
+  ck_assert_int_eq(buffer.capacity, 1024);
+
+  ck_assert(hb_buffer_expand_if_needed(&buffer, 1023));
+  ck_assert_int_eq(buffer.capacity, 1024);
+
+  ck_assert(hb_buffer_expand_if_needed(&buffer, 1024));
+  ck_assert_int_eq(buffer.capacity, 1024);
+
+  ck_assert(hb_buffer_expand_if_needed(&buffer, 1025));
+  ck_assert_int_eq(buffer.capacity, 3074); // initial capacity (1024) + (required (1025) * 2) = 3074
+
+  free(buffer.value);
+END
+
+TEST(test_hb_buffer_expand_if_needed_with_nearly_full_buffer)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  ck_assert_int_eq(buffer.capacity, 1024);
+
+  hb_buffer_append_repeated(&buffer, ' ', 1023);
+  ck_assert_int_eq(buffer.capacity, 1024);
+
+  ck_assert(hb_buffer_expand_if_needed(&buffer, 2));
+  ck_assert_int_eq(buffer.capacity, 2048);
+
+  free(buffer.value);
+END
+
+// Test resizing buffer
+TEST(test_hb_buffer_resize)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  ck_assert_int_eq(buffer.capacity, 1024);
+
+  ck_assert(hb_buffer_resize(&buffer, 2048));
+  ck_assert_int_eq(buffer.capacity, 2048);
+
+  ck_assert(hb_buffer_resize(&buffer, 4096));
+  ck_assert_int_eq(buffer.capacity, 4096);
+
+  ck_assert(hb_buffer_resize(&buffer, 8192));
+  ck_assert_int_eq(buffer.capacity, 8192);
+
+  free(buffer.value);
+END
+
+// Test clearing buffer without freeing memory
+TEST(test_hb_buffer_clear)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  ck_assert_int_eq(buffer.capacity, 1024);
+
+  hb_buffer_append(&buffer, "Hello");
+  ck_assert_str_eq(buffer.value, "Hello");
+  ck_assert_int_eq(buffer.length, 5);
+  ck_assert_int_eq(buffer.capacity, 1024);
+
+  hb_buffer_clear(&buffer);
+
+  ck_assert_str_eq(buffer.value, "");
+  ck_assert_int_eq(buffer.length, 0);
+  ck_assert_int_eq(buffer.capacity, 1024); // Capacity should remain unchanged
+
+  free(buffer.value);
+END
+
+// Test freeing buffer
+TEST(test_hb_buffer_free)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  hb_buffer_append(&buffer, "Test");
+  ck_assert_int_eq(buffer.length, 4);
+  ck_assert_int_eq(buffer.capacity, 1024);
+  free(buffer.value);
+  buffer.value = NULL;
+  buffer.length = 0;
+  buffer.capacity = 0;
+
+  ck_assert_ptr_null(buffer.value);
+  ck_assert_int_eq(buffer.length, 0);
+  ck_assert_int_eq(buffer.capacity, 0);
+END
+
+// Test buffer UTF-8 integrity
+TEST(test_buffer_utf8_integrity)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  // UTF-8 String
+  const char *utf8_text = "こんにちは";
+  hb_buffer_append(&buffer, utf8_text);
+
+  // Ensure length matches actual UTF-8 bytes
+  ck_assert_int_eq(buffer.length, strlen(utf8_text));
+  ck_assert_int_eq(buffer.length, 15);
+  ck_assert_str_eq(buffer.value, utf8_text);
+
+  free(buffer.value);
+END
+
+// Test: Buffer Appending UTF-8 Characters
+TEST(test_hb_buffer_append_utf8)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  // Append UTF-8 string
+  hb_buffer_append(&buffer, "こんにちは"); // "Hello" in Japanese
+  ck_assert_int_eq(strlen("こんにちは"), 15); // UTF-8 multibyte characters
+  ck_assert_int_eq(hb_buffer_length(&buffer), 15);
+  ck_assert_str_eq(hb_buffer_value(&buffer), "こんにちは");
+
+  free(buffer.value);
+END
+
+// Test buffer length correctness
+TEST(test_hb_buffer_length_correctness)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  hb_buffer_append(&buffer, "Short");
+  size_t length = hb_buffer_length(&buffer);
+  ck_assert_int_eq(length, 5);
+
+  hb_buffer_append(&buffer, "er test");
+  length = hb_buffer_length(&buffer);
+  ck_assert_int_eq(length, 12);
+
+  free(buffer.value);
+END
+
+// Test: Buffer Null-Termination
+TEST(test_buffer_null_termination)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  hb_buffer_append(&buffer, "Test");
+  ck_assert(hb_buffer_value(&buffer)[hb_buffer_length(&buffer)] == '\0'); // Ensure null termination
+
+  free(buffer.value);
+END
+
+TCase *hb_buffer_tests(void) {
+  TCase *buffer = tcase_create("Herb Buffer");
+
+  tcase_add_test(buffer, test_hb_buffer_init);
+  tcase_add_test(buffer, test_hb_buffer_append);
+  tcase_add_test(buffer, test_hb_buffer_prepend);
+  tcase_add_test(buffer, test_hb_buffer_concat);
+  tcase_add_test(buffer, test_hb_buffer_increase_capacity);
+  tcase_add_test(buffer, test_hb_buffer_expand_capacity);
+  tcase_add_test(buffer, test_hb_buffer_expand_if_needed);
+  tcase_add_test(buffer, test_hb_buffer_expand_if_needed_with_nearly_full_buffer);
+  tcase_add_test(buffer, test_hb_buffer_resize);
+  tcase_add_test(buffer, test_hb_buffer_clear);
+  tcase_add_test(buffer, test_hb_buffer_free);
+  tcase_add_test(buffer, test_buffer_utf8_integrity);
+  tcase_add_test(buffer, test_hb_buffer_append_utf8);
+  tcase_add_test(buffer, test_hb_buffer_length_correctness);
+  tcase_add_test(buffer, test_buffer_null_termination);
+
+  return buffer;
+}
diff --git a/test/c/test_hb_string.c b/test/c/test_hb_string.c
index 8d6098d29..49a9c366d 100644
--- a/test/c/test_hb_string.c
+++ b/test/c/test_hb_string.c
@@ -1,5 +1,5 @@
 #include "include/test.h"
-#include "../../src/include/hb_string.h"
+#include "../../src/include/util/hb_string.h"
 #include <string.h>
 
 TEST(hb_string_equals_tests)
@@ -122,7 +122,7 @@ TEST(hb_string_starts_with_tests)
 END
 
 TCase *hb_string_tests(void) {
-  TCase *tags = tcase_create("Str");
+  TCase *tags = tcase_create("Herb String");
 
   tcase_add_test(tags, hb_string_equals_tests);
   tcase_add_test(tags, hb_string_equals_case_insensitive_tests);
diff --git a/test/c/test_lex.c b/test/c/test_lex.c
index ee2418c9f..568615c94 100644
--- a/test/c/test_lex.c
+++ b/test/c/test_lex.c
@@ -3,8 +3,8 @@
 
 TEST(herb_lex_to_buffer_empty_file)
   char* html = "";
-  buffer_T output;
-  buffer_init(&output, 1024);
+  hb_buffer_T output;
+  hb_buffer_init(&output, 1024);
 
   herb_lex_to_buffer(html, &output);
 
@@ -15,8 +15,8 @@ END
 
 TEST(herb_lex_to_buffer_basic_tag)
   char* html = "<html></html>";
-  buffer_T output;
-  buffer_init(&output, 1024);
+  hb_buffer_T output;
+  hb_buffer_init(&output, 1024);
 
   herb_lex_to_buffer(html, &output);
 
diff --git a/test/c/test_token.c b/test/c/test_token.c
index 946e0649f..69335ad9c 100644
--- a/test/c/test_token.c
+++ b/test/c/test_token.c
@@ -8,8 +8,8 @@ TEST(test_token)
 END
 
 TEST(test_token_to_string)
-  buffer_T output;
-  buffer_init(&output, 1024);
+  hb_buffer_T output;
+  hb_buffer_init(&output, 1024);
   herb_lex_to_buffer("hello", &output);
 
   ck_assert_str_eq(
diff --git a/test/lexer/text_content_test.rb b/test/lexer/text_content_test.rb
index 2306336a5..03934d21f 100644
--- a/test/lexer/text_content_test.rb
+++ b/test/lexer/text_content_test.rb
@@ -14,18 +14,18 @@ class TextContentTest < Minitest::Spec
       assert_lexed_snapshot("<h1>Some. Text.</h1>")
     end
 
-    test "text content that exceeds initial buffer_T size and needs to resize once (ca. 4K)" do
-      initial_buffer_capacity = 1024 # bytes
-      content = cyclic_string((((initial_buffer_capacity * 2) + 1) * 2) + 1)
+    test "text content that exceeds initial hb_buffer_T size and needs to resize once (ca. 4K)" do
+      initial_hb_buffer_capacity = 1024 # bytes
+      content = cyclic_string((((initial_hb_buffer_capacity * 2) + 1) * 2) + 1)
       result = assert_lexed_snapshot(%(<div>#{content}</div>))
 
       identifier = result.value.find { |token| token.type == "TOKEN_IDENTIFIER" && token.value.length > 4000 }
       assert_equal content, identifier.value
     end
 
-    test "text content that exceeds initial buffer_T size and needs to resize twice (ca. 8K)" do
-      initial_buffer_capacity = 1024 # bytes
-      content = cyclic_string((((((initial_buffer_capacity * 2) + 1) * 2) + 1) * 2) + 1)
+    test "text content that exceeds initial hb_buffer_T size and needs to resize twice (ca. 8K)" do
+      initial_hb_buffer_capacity = 1024 # bytes
+      content = cyclic_string((((((initial_hb_buffer_capacity * 2) + 1) * 2) + 1) * 2) + 1)
       result = assert_lexed_snapshot(%(<div>#{content}</div>))
 
       identifier = result.value.find { |token| token.type == "TOKEN_IDENTIFIER" && token.value.length > 4000 }
diff --git a/test/parser/text_content_test.rb b/test/parser/text_content_test.rb
index 84e4e8d80..91736778a 100644
--- a/test/parser/text_content_test.rb
+++ b/test/parser/text_content_test.rb
@@ -26,17 +26,17 @@ class TextContentTest < Minitest::Spec
       assert_parsed_snapshot("Hello<span></span>World")
     end
 
-    test "text content that exceeds initial buffer_T size (ca. 4K)" do
-      initial_buffer_capacity = 1024 # bytes
-      content = cyclic_string((((initial_buffer_capacity * 2) + 1) * 2) + 1)
+    test "text content that exceeds initial hb_buffer_T size (ca. 4K)" do
+      initial_hb_buffer_capacity = 1024 # bytes
+      content = cyclic_string((((initial_hb_buffer_capacity * 2) + 1) * 2) + 1)
       result = assert_parsed_snapshot(%(<div>#{content}</div>))
 
       assert_equal content, result.value.children.first.body.first.content
     end
 
-    test "text content that exceeds initial buffer_T size (ca. 8K)" do
-      initial_buffer_capacity = 1024 # bytes
-      content = cyclic_string((((((initial_buffer_capacity * 2) + 1) * 2) + 1) * 2) + 1)
+    test "text content that exceeds initial hb_buffer_T size (ca. 8K)" do
+      initial_hb_buffer_capacity = 1024 # bytes
+      content = cyclic_string((((((initial_hb_buffer_capacity * 2) + 1) * 2) + 1) * 2) + 1)
       result = assert_parsed_snapshot(%(<div>#{content}</div>))
 
       assert_equal content, result.value.children.first.body.first.content
diff --git a/test/snapshots/lexer/text_content_test/test_0003_text_content_that_exceeds_initial_buffer_T_size_and_needs_to_resize_once_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt b/test/snapshots/lexer/text_content_test/test_0003_text_content_that_exceeds_initial_hb_buffer_T_size_and_needs_to_resize_once_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt
similarity index 100%
rename from test/snapshots/lexer/text_content_test/test_0003_text_content_that_exceeds_initial_buffer_T_size_and_needs_to_resize_once_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt
rename to test/snapshots/lexer/text_content_test/test_0003_text_content_that_exceeds_initial_hb_buffer_T_size_and_needs_to_resize_once_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt
diff --git a/test/snapshots/lexer/text_content_test/test_0004_text_content_that_exceeds_initial_buffer_T_size_and_needs_to_resize_twice_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt b/test/snapshots/lexer/text_content_test/test_0004_text_content_that_exceeds_initial_hb_buffer_T_size_and_needs_to_resize_twice_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt
similarity index 100%
rename from test/snapshots/lexer/text_content_test/test_0004_text_content_that_exceeds_initial_buffer_T_size_and_needs_to_resize_twice_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt
rename to test/snapshots/lexer/text_content_test/test_0004_text_content_that_exceeds_initial_hb_buffer_T_size_and_needs_to_resize_twice_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt
diff --git a/test/snapshots/parser/text_content_test/test_0006_text_content_that_exceeds_initial_buffer_T_size_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt b/test/snapshots/parser/text_content_test/test_0006_text_content_that_exceeds_initial_hb_buffer_T_size_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt
similarity index 100%
rename from test/snapshots/parser/text_content_test/test_0006_text_content_that_exceeds_initial_buffer_T_size_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt
rename to test/snapshots/parser/text_content_test/test_0006_text_content_that_exceeds_initial_hb_buffer_T_size_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt
diff --git a/test/snapshots/parser/text_content_test/test_0007_text_content_that_exceeds_initial_buffer_T_size_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt b/test/snapshots/parser/text_content_test/test_0007_text_content_that_exceeds_initial_hb_buffer_T_size_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt
similarity index 100%
rename from test/snapshots/parser/text_content_test/test_0007_text_content_that_exceeds_initial_buffer_T_size_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt
rename to test/snapshots/parser/text_content_test/test_0007_text_content_that_exceeds_initial_hb_buffer_T_size_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt
diff --git a/wasm/extension_helpers.cpp b/wasm/extension_helpers.cpp
index ecc59f2e0..3118cf13e 100644
--- a/wasm/extension_helpers.cpp
+++ b/wasm/extension_helpers.cpp
@@ -7,12 +7,12 @@
 #include "nodes.h"
 
 extern "C" {
-#include "../src/include/array.h"
+#include "../src/include/util/hb_array.h"
 #include "../src/include/ast_node.h"
 #include "../src/include/ast_nodes.h"
 #include "../src/include/pretty_print.h"
 #include "../src/include/ast_pretty_print.h"
-#include "../src/include/buffer.h"
+#include "../src/include/util/hb_buffer.h"
 #include "../src/include/herb.h"
 #include "../src/include/token.h"
 #include "../src/include/position.h"
@@ -78,7 +78,7 @@ val CreateToken(token_T* token) {
   return result;
 }
 
-val CreateLexResult(array_T* tokens, const std::string& source) {
+val CreateLexResult(hb_array_T* tokens, const std::string& source) {
   val Object = val::global("Object");
   val Array = val::global("Array");
 
@@ -88,8 +88,8 @@ val CreateLexResult(array_T* tokens, const std::string& source) {
   val warningsArray = Array.new_();
 
   if (tokens) {
-    for (size_t i = 0; i < array_size(tokens); i++) {
-      token_T* token = (token_T*)array_get(tokens, i);
+    for (size_t i = 0; i < hb_array_size(tokens); i++) {
+      token_T* token = (token_T*)hb_array_get(tokens, i);
       if (token) {
         tokensArray.call<void>("push", CreateToken(token));
       }
diff --git a/wasm/extension_helpers.h b/wasm/extension_helpers.h
index 86bf67100..e4d2332f4 100644
--- a/wasm/extension_helpers.h
+++ b/wasm/extension_helpers.h
@@ -18,7 +18,7 @@ emscripten::val CreatePosition(position_T position);
 emscripten::val CreateLocation(location_T location);
 emscripten::val CreateRange(range_T range);
 emscripten::val CreateToken(token_T* token);
-emscripten::val CreateLexResult(array_T* tokens, const std::string& source);
+emscripten::val CreateLexResult(hb_array_T* tokens, const std::string& source);
 emscripten::val CreateParseResult(AST_DOCUMENT_NODE_T *root, const std::string& source);
 
 #endif
diff --git a/wasm/herb-wasm.cpp b/wasm/herb-wasm.cpp
index 9d8624468..e1e5ce06e 100644
--- a/wasm/herb-wasm.cpp
+++ b/wasm/herb-wasm.cpp
@@ -8,11 +8,11 @@
 
 extern "C" {
 #include "../src/include/analyze.h"
-#include "../src/include/array.h"
+#include "../src/include/util/hb_array.h"
 #include "../src/include/ast_node.h"
 #include "../src/include/ast_nodes.h"
 #include "../src/include/ast_pretty_print.h"
-#include "../src/include/buffer.h"
+#include "../src/include/util/hb_buffer.h"
 #include "../src/include/extract.h"
 #include "../src/include/herb.h"
 #include "../src/include/location.h"
@@ -25,7 +25,7 @@ extern "C" {
 using namespace emscripten;
 
 val Herb_lex(const std::string& source) {
-  array_T* tokens = herb_lex(source.c_str());
+  hb_array_T* tokens = herb_lex(source.c_str());
 
   val result = CreateLexResult(tokens, source);
 
@@ -60,21 +60,21 @@ val Herb_parse(const std::string& source, val options) {
 }
 
 std::string Herb_extract_ruby(const std::string& source) {
-  buffer_T output;
-  buffer_init(&output, source.length());
+  hb_buffer_T output;
+  hb_buffer_init(&output, source.length());
 
   herb_extract_ruby_to_buffer(source.c_str(), &output);
-  std::string result(buffer_value(&output));
+  std::string result(hb_buffer_value(&output));
   free(output.value);
   return result;
 }
 
 std::string Herb_extract_html(const std::string& source) {
-  buffer_T output;
-  buffer_init(&output, source.length());
+  hb_buffer_T output;
+  hb_buffer_init(&output, source.length());
 
   herb_extract_html_to_buffer(source.c_str(), &output);
-  std::string result(buffer_value(&output));
+  std::string result(hb_buffer_value(&output));
   free(output.value);
   return result;
 }

From bd519ca9e2fbea822456e272a2e9ba27063f1568 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Mon, 13 Oct 2025 21:18:50 +0200
Subject: [PATCH 57/97] C: Remove unused functions from `hb_buffer.c` (#608)

This PR removes buffer functions that aren't used (anymore) and makes
functions required internally static.

## Removed functions

- buffer_new
- buffer_increase_capacity
- buffer_expand_capacity

## Made static

- buffer_resize
- buffer_has_capacity
- buffer_expand_if_needed
- buffer_append_repeated
---
 src/include/util/hb_buffer.h |   8 ---
 src/util/hb_buffer.c         | 117 +++++++++++------------------------
 test/c/test_hb_buffer.c      |  89 ++------------------------
 3 files changed, 43 insertions(+), 171 deletions(-)

diff --git a/src/include/util/hb_buffer.h b/src/include/util/hb_buffer.h
index d1aaf2351..e058b1f6d 100644
--- a/src/include/util/hb_buffer.h
+++ b/src/include/util/hb_buffer.h
@@ -11,18 +11,10 @@ typedef struct HB_BUFFER_STRUCT {
 } hb_buffer_T;
 
 bool hb_buffer_init(hb_buffer_T* buffer, size_t capacity);
-hb_buffer_T* hb_buffer_new(size_t capacity);
-
-bool hb_buffer_increase_capacity(hb_buffer_T* buffer, size_t additional_capacity);
-bool hb_buffer_has_capacity(hb_buffer_T* buffer, size_t required_length);
-bool hb_buffer_expand_capacity(hb_buffer_T* buffer);
-bool hb_buffer_expand_if_needed(hb_buffer_T* buffer, size_t required_length);
-bool hb_buffer_resize(hb_buffer_T* buffer, size_t new_capacity);
 
 void hb_buffer_append(hb_buffer_T* buffer, const char* text);
 void hb_buffer_append_with_length(hb_buffer_T* buffer, const char* text, size_t length);
 void hb_buffer_append_char(hb_buffer_T* buffer, char character);
-void hb_buffer_append_repeated(hb_buffer_T* buffer, char character, size_t length);
 void hb_buffer_append_whitespace(hb_buffer_T* buffer, size_t length);
 void hb_buffer_prepend(hb_buffer_T* buffer, const char* text);
 void hb_buffer_concat(hb_buffer_T* destination, hb_buffer_T* source);
diff --git a/src/util/hb_buffer.c b/src/util/hb_buffer.c
index 76f1d6584..68e5f2dab 100644
--- a/src/util/hb_buffer.c
+++ b/src/util/hb_buffer.c
@@ -6,67 +6,8 @@
 #include "../include/util.h"
 #include "../include/util/hb_buffer.h"
 
-bool hb_buffer_init(hb_buffer_T* buffer, const size_t capacity) {
-  buffer->capacity = capacity;
-  buffer->length = 0;
-  buffer->value = malloc(sizeof(char) * (buffer->capacity + 1));
-
-  if (!buffer->value) {
-    fprintf(stderr, "Error: Failed to initialize buffer with capacity of %zu.\n", buffer->capacity);
-
-    return false;
-  }
-
-  buffer->value[0] = '\0';
-
-  return true;
-}
-
-hb_buffer_T* hb_buffer_new(const size_t capacity) {
-  hb_buffer_T* buffer = malloc(sizeof(hb_buffer_T));
-
-  if (!hb_buffer_init(buffer, capacity)) {
-    free(buffer);
-    return NULL;
-  }
-
-  return buffer;
-}
-
-char* hb_buffer_value(const hb_buffer_T* buffer) {
-  return buffer->value;
-}
-
-size_t hb_buffer_length(const hb_buffer_T* buffer) {
-  return buffer->length;
-}
-
-size_t hb_buffer_capacity(const hb_buffer_T* buffer) {
-  return buffer->capacity;
-}
-
-size_t hb_buffer_sizeof(void) {
-  return sizeof(hb_buffer_T);
-}
-
-/**
- * Increases the capacity of the buffer if needed to accommodate additional content.
- * This function only handles memory allocation and does not modify the buffer content
- * or null termination.
- *
- * @param buffer The buffer to increase capacity for
- * @param additional_capacity The additional length needed beyond current buffer capacity
- * @return true if capacity was increased, false if reallocation failed
- */
-bool hb_buffer_increase_capacity(hb_buffer_T* buffer, const size_t additional_capacity) {
-  if (additional_capacity + 1 >= SIZE_MAX) {
-    fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
-    exit(1);
-  }
-
-  const size_t new_capacity = buffer->capacity + additional_capacity;
-
-  return hb_buffer_resize(buffer, new_capacity);
+static bool hb_buffer_has_capacity(hb_buffer_T* buffer, const size_t required_length) {
+  return (buffer->length + required_length <= buffer->capacity);
 }
 
 /**
@@ -76,7 +17,7 @@ bool hb_buffer_increase_capacity(hb_buffer_T* buffer, const size_t additional_ca
  * @param new_capacity The new capacity to resize the buffer to
  * @return true if capacity was resized, false if reallocation failed
  */
-bool hb_buffer_resize(hb_buffer_T* buffer, const size_t new_capacity) {
+static bool hb_buffer_resize(hb_buffer_T* buffer, const size_t new_capacity) {
   if (new_capacity + 1 >= SIZE_MAX) {
     fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
     exit(1);
@@ -95,18 +36,6 @@ bool hb_buffer_resize(hb_buffer_T* buffer, const size_t new_capacity) {
   return true;
 }
 
-/**
- * Expands the capacity of the buffer by doubling its current capacity.
- * This function is a convenience function that calls hb_buffer_increase_capacity
- * with a factor of 2.
- *
- * @param buffer The buffer to expand capacity for
- * @return true if capacity was increased, false if reallocation failed
- */
-bool hb_buffer_expand_capacity(hb_buffer_T* buffer) {
-  return hb_buffer_resize(buffer, buffer->capacity * 2);
-}
-
 /**
  * Expands the capacity of the buffer if needed to accommodate additional content.
  * This function is a convenience function that calls hb_buffer_has_capacity and
@@ -116,7 +45,7 @@ bool hb_buffer_expand_capacity(hb_buffer_T* buffer) {
  * @param required_length The additional length needed beyond current buffer capacity
  * @return true if capacity was increased, false if reallocation failed
  */
-bool hb_buffer_expand_if_needed(hb_buffer_T* buffer, const size_t required_length) {
+static bool hb_buffer_expand_if_needed(hb_buffer_T* buffer, const size_t required_length) {
   if (hb_buffer_has_capacity(buffer, required_length)) { return true; }
 
   bool should_double_capacity = required_length < buffer->capacity;
@@ -131,6 +60,38 @@ bool hb_buffer_expand_if_needed(hb_buffer_T* buffer, const size_t required_lengt
   return hb_buffer_resize(buffer, new_capacity);
 }
 
+bool hb_buffer_init(hb_buffer_T* buffer, const size_t capacity) {
+  buffer->capacity = capacity;
+  buffer->length = 0;
+  buffer->value = malloc(sizeof(char) * (buffer->capacity + 1));
+
+  if (!buffer->value) {
+    fprintf(stderr, "Error: Failed to initialize buffer with capacity of %zu.\n", buffer->capacity);
+
+    return false;
+  }
+
+  buffer->value[0] = '\0';
+
+  return true;
+}
+
+char* hb_buffer_value(const hb_buffer_T* buffer) {
+  return buffer->value;
+}
+
+size_t hb_buffer_length(const hb_buffer_T* buffer) {
+  return buffer->length;
+}
+
+size_t hb_buffer_capacity(const hb_buffer_T* buffer) {
+  return buffer->capacity;
+}
+
+size_t hb_buffer_sizeof(void) {
+  return sizeof(hb_buffer_T);
+}
+
 /**
  * Appends a null-terminated string to the buffer.
  * @note This function requires that 'text' is a properly null-terminated string.
@@ -185,7 +146,7 @@ void hb_buffer_append_char(hb_buffer_T* buffer, const char character) {
   hb_buffer_append(buffer, string);
 }
 
-void hb_buffer_append_repeated(hb_buffer_T* buffer, const char character, size_t length) {
+static void hb_buffer_append_repeated(hb_buffer_T* buffer, const char character, size_t length) {
   if (!buffer || length == 0) { return; }
   if (!hb_buffer_expand_if_needed(buffer, length)) { return; }
 
@@ -223,10 +184,6 @@ void hb_buffer_concat(hb_buffer_T* destination, hb_buffer_T* source) {
   destination->value[destination->length] = '\0';
 }
 
-bool hb_buffer_has_capacity(hb_buffer_T* buffer, const size_t required_length) {
-  return (buffer->length + required_length <= buffer->capacity);
-}
-
 void hb_buffer_clear(hb_buffer_T* buffer) {
   buffer->length = 0;
   buffer->value[0] = '\0';
diff --git a/test/c/test_hb_buffer.c b/test/c/test_hb_buffer.c
index a239190e3..d46e9e8e9 100644
--- a/test/c/test_hb_buffer.c
+++ b/test/c/test_hb_buffer.c
@@ -63,93 +63,20 @@ TEST(test_hb_buffer_concat)
   free(buffer2.value);
 END
 
-// Test increating
-TEST(test_hb_buffer_increase_capacity)
+TEST(test_hb_buffer_resizing_behavior)
   hb_buffer_T buffer;
   hb_buffer_init(&buffer, 1024);
 
   ck_assert_int_eq(buffer.capacity, 1024);
 
-  ck_assert(hb_buffer_increase_capacity(&buffer, 1));
-  ck_assert_int_eq(buffer.capacity, 1025);
-
-  ck_assert(hb_buffer_increase_capacity(&buffer, 1024 + 1));
-  ck_assert_int_eq(buffer.capacity, 2050);
-
-  free(buffer.value);
-END
-
-// Test expanding capacity
-TEST(test_hb_buffer_expand_capacity)
-  hb_buffer_T buffer;
-  hb_buffer_init(&buffer, 1024);
-
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(hb_buffer_expand_capacity(&buffer));
-  ck_assert_int_eq(buffer.capacity, 2048);
-
-  ck_assert(hb_buffer_expand_capacity(&buffer));
-  ck_assert_int_eq(buffer.capacity, 4096);
-
-  ck_assert(hb_buffer_expand_capacity(&buffer));
-  ck_assert_int_eq(buffer.capacity, 8192);
-
-  free(buffer.value);
-END
-
-// Test expanding if needed
-TEST(test_hb_buffer_expand_if_needed)
-  hb_buffer_T buffer;
-  hb_buffer_init(&buffer, 1024);
-
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(hb_buffer_expand_if_needed(&buffer, 1));
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(hb_buffer_expand_if_needed(&buffer, 1023));
+  hb_buffer_append_whitespace(&buffer, 1023);
   ck_assert_int_eq(buffer.capacity, 1024);
 
-  ck_assert(hb_buffer_expand_if_needed(&buffer, 1024));
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(hb_buffer_expand_if_needed(&buffer, 1025));
-  ck_assert_int_eq(buffer.capacity, 3074); // initial capacity (1024) + (required (1025) * 2) = 3074
-
-  free(buffer.value);
-END
-
-TEST(test_hb_buffer_expand_if_needed_with_nearly_full_buffer)
-  hb_buffer_T buffer;
-  hb_buffer_init(&buffer, 1024);
-
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  hb_buffer_append_repeated(&buffer, ' ', 1023);
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(hb_buffer_expand_if_needed(&buffer, 2));
-  ck_assert_int_eq(buffer.capacity, 2048);
-
-  free(buffer.value);
-END
-
-// Test resizing buffer
-TEST(test_hb_buffer_resize)
-  hb_buffer_T buffer;
-  hb_buffer_init(&buffer, 1024);
-
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(hb_buffer_resize(&buffer, 2048));
+  hb_buffer_append_whitespace(&buffer, 2);
   ck_assert_int_eq(buffer.capacity, 2048);
 
-  ck_assert(hb_buffer_resize(&buffer, 4096));
-  ck_assert_int_eq(buffer.capacity, 4096);
-
-  ck_assert(hb_buffer_resize(&buffer, 8192));
-  ck_assert_int_eq(buffer.capacity, 8192);
+  hb_buffer_append_whitespace(&buffer, 2048);
+  ck_assert_int_eq(buffer.capacity, 6144);
 
   free(buffer.value);
 END
@@ -258,11 +185,7 @@ TCase *hb_buffer_tests(void) {
   tcase_add_test(buffer, test_hb_buffer_append);
   tcase_add_test(buffer, test_hb_buffer_prepend);
   tcase_add_test(buffer, test_hb_buffer_concat);
-  tcase_add_test(buffer, test_hb_buffer_increase_capacity);
-  tcase_add_test(buffer, test_hb_buffer_expand_capacity);
-  tcase_add_test(buffer, test_hb_buffer_expand_if_needed);
-  tcase_add_test(buffer, test_hb_buffer_expand_if_needed_with_nearly_full_buffer);
-  tcase_add_test(buffer, test_hb_buffer_resize);
+  tcase_add_test(buffer, test_hb_buffer_resizing_behavior);
   tcase_add_test(buffer, test_hb_buffer_clear);
   tcase_add_test(buffer, test_hb_buffer_free);
   tcase_add_test(buffer, test_buffer_utf8_integrity);

From 53a9b16d1130f8e2b1434567b71904fedeae38be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Mon, 13 Oct 2025 22:14:45 +0200
Subject: [PATCH 58/97] C: Make lexer source an instance of `hb_string_T`
 (#632)

This PR makes the lexer source an instance of `hb_string_T` and adapts
all usages of the lexer source.

This is purely a refactoring and should not alter any interfaces, or
observable behavior for that matter.
---
 src/include/lexer_struct.h |  5 +++--
 src/lexer.c                | 32 +++++++++++++++++---------------
 src/lexer_peek_helpers.c   |  4 ++--
 3 files changed, 22 insertions(+), 19 deletions(-)

diff --git a/src/include/lexer_struct.h b/src/include/lexer_struct.h
index 0b305acf5..94b132559 100644
--- a/src/include/lexer_struct.h
+++ b/src/include/lexer_struct.h
@@ -1,6 +1,8 @@
 #ifndef HERB_LEXER_STRUCT_H
 #define HERB_LEXER_STRUCT_H
 
+#include "util/hb_string.h"
+
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -12,8 +14,7 @@ typedef enum {
 } lexer_state_T;
 
 typedef struct LEXER_STRUCT {
-  const char* source;
-  uint32_t source_length;
+  hb_string_T source;
 
   uint32_t current_line;
   uint32_t current_column;
diff --git a/src/lexer.c b/src/lexer.c
index 2847108a9..a00cd7551 100644
--- a/src/lexer.c
+++ b/src/lexer.c
@@ -3,6 +3,7 @@
 #include "include/utf8.h"
 #include "include/util.h"
 #include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
 
 #include <ctype.h>
 #include <string.h>
@@ -14,7 +15,7 @@ static bool lexer_eof(const lexer_T* lexer) {
 }
 
 static bool lexer_has_more_characters(const lexer_T* lexer) {
-  return lexer->current_position < lexer->source_length;
+  return lexer->current_position < lexer->source.length;
 }
 
 static bool lexer_stalled(lexer_T* lexer) {
@@ -31,14 +32,15 @@ static bool lexer_stalled(lexer_T* lexer) {
 }
 
 void lexer_init(lexer_T* lexer, const char* source) {
-  if (source == NULL) { source = ""; }
+  if (source != NULL) {
+    lexer->source = hb_string_from_c_string(source);
+  } else {
+    lexer->source = hb_string_from_c_string("");
+  }
 
+  lexer->current_character = lexer->source.data[0];
   lexer->state = STATE_DATA;
 
-  lexer->source = source;
-  lexer->source_length = (uint32_t) strlen(source);
-  lexer->current_character = source[0];
-
   lexer->current_line = 1;
   lexer->current_column = 0;
   lexer->current_position = 0;
@@ -73,7 +75,7 @@ static void lexer_advance(lexer_T* lexer) {
     if (!is_newline(lexer->current_character)) { lexer->current_column++; }
 
     lexer->current_position++;
-    lexer->current_character = lexer->source[lexer->current_position];
+    lexer->current_character = lexer->source.data[lexer->current_position];
   }
 }
 
@@ -85,11 +87,11 @@ static void lexer_advance_utf8_bytes(lexer_T* lexer, int byte_count) {
 
     lexer->current_position += byte_count;
 
-    if (lexer->current_position >= lexer->source_length) {
-      lexer->current_position = lexer->source_length;
+    if (lexer->current_position >= lexer->source.length) {
+      lexer->current_position = lexer->source.length;
       lexer->current_character = '\0';
     } else {
-      lexer->current_character = lexer->source[lexer->current_position];
+      lexer->current_character = lexer->source.data[lexer->current_position];
     }
   }
 }
@@ -127,7 +129,7 @@ static token_T* lexer_advance_current(lexer_T* lexer, const token_type_T type) {
 }
 
 static token_T* lexer_advance_utf8_character(lexer_T* lexer, const token_type_T type) {
-  int char_byte_length = utf8_sequence_length(lexer->source, lexer->current_position, lexer->source_length);
+  int char_byte_length = utf8_sequence_length(lexer->source.data, lexer->current_position, lexer->source.length);
 
   if (char_byte_length <= 1) { return lexer_advance_current(lexer, type); }
 
@@ -136,12 +138,12 @@ static token_T* lexer_advance_utf8_character(lexer_T* lexer, const token_type_T
   if (!utf8_char) { return lexer_advance_current(lexer, type); }
 
   for (int i = 0; i < char_byte_length; i++) {
-    if (lexer->current_position + i >= lexer->source_length) {
+    if (lexer->current_position + i >= lexer->source.length) {
       free(utf8_char);
       return lexer_advance_current(lexer, type);
     }
 
-    utf8_char[i] = lexer->source[lexer->current_position + i];
+    utf8_char[i] = lexer->source.data[lexer->current_position + i];
   }
 
   utf8_char[char_byte_length] = '\0';
@@ -156,7 +158,7 @@ static token_T* lexer_advance_utf8_character(lexer_T* lexer, const token_type_T
 }
 
 static token_T* lexer_match_and_advance(lexer_T* lexer, const char* value, const token_type_T type) {
-  if (strncmp(lexer->source + lexer->current_position, value, strlen(value)) == 0) {
+  if (strncmp(lexer->source.data + lexer->current_position, value, strlen(value)) == 0) {
     return lexer_advance_with(lexer, value, type);
   }
 
@@ -235,7 +237,7 @@ static token_T* lexer_parse_erb_content(lexer_T* lexer) {
     }
 
     lexer->current_position++;
-    lexer->current_character = lexer->source[lexer->current_position];
+    lexer->current_character = lexer->source.data[lexer->current_position];
   }
 
   lexer->state = STATE_ERB_CLOSE;
diff --git a/src/lexer_peek_helpers.c b/src/lexer_peek_helpers.c
index a1f96fa5e..828d2f5fd 100644
--- a/src/lexer_peek_helpers.c
+++ b/src/lexer_peek_helpers.c
@@ -8,11 +8,11 @@
 #include <stdbool.h>
 
 char lexer_backtrack(const lexer_T* lexer, const int offset) {
-  return lexer->source[MAX(lexer->current_position - offset, 0)];
+  return lexer->source.data[MAX(lexer->current_position - offset, 0)];
 }
 
 char lexer_peek(const lexer_T* lexer, const int offset) {
-  return lexer->source[MIN(lexer->current_position + offset, lexer->source_length)];
+  return lexer->source.data[MIN(lexer->current_position + offset, lexer->source.length)];
 }
 
 bool lexer_peek_for(const lexer_T* lexer, const int offset, const char* pattern, const bool case_insensitive) {

From 693f4918523b330b48761139495fc5d65654ecdc Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Tue, 14 Oct 2025 15:09:22 +0200
Subject: [PATCH 59/97] Parser: Allow `TOKEN_BACKSLASH` in HTML Text Content
 (#637)

This pull request updates the parser to allow backslashes in the HTML
Text Content. Previously, a document like this failed to parse:

```html
<p>\Asome-regexp\z</p>
```

With an error like:

```
Unexpected token. Expected: `TOKEN_ERB_START, TOKEN_HTML_DOCTYPE, TOKEN_HTML_COMMENT_START, TOKEN_IDENTIFIER, TOKEN_WHITESPACE, TOKEN_NBSP, TOKEN_AT, or TOKE`, found: `TOKEN_BACKSLASH`.
```

Resolves #633
Resolves #635
---
 src/parser.c                                  |  3 +-
 test/parser/text_content_test.rb              | 11 +++
 ...rings_3217a5ed01ac8ce6c44f9e106f9b4017.txt | 11 +--
 ...space_0ee4b96cac701f87a8b6cb0cf5ad48bc.txt |  4 +-
 ...e_635_816fd02d8670264d606d92812679f159.txt | 25 +++++++
 ...e_633_fd1ab6af93689cddc537bac4cbdaefde.txt | 72 +++++++++++++++++++
 6 files changed, 114 insertions(+), 12 deletions(-)
 create mode 100644 test/snapshots/parser/text_content_test/test_0034_backslash-prefixed_text_stays_literal_-_issue_635_816fd02d8670264d606d92812679f159.txt
 create mode 100644 test/snapshots/parser/text_content_test/test_0035_backslash-prefixed_text_-_issue_633_fd1ab6af93689cddc537bac4cbdaefde.txt

diff --git a/src/parser.c b/src/parser.c
index 21402bbbc..bcea9dbfb 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -1110,6 +1110,7 @@ static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, h
           parser,
           TOKEN_AMPERSAND,
           TOKEN_AT,
+          TOKEN_BACKSLASH,
           TOKEN_BACKTICK,
           TOKEN_CHARACTER,
           TOKEN_COLON,
@@ -1134,7 +1135,7 @@ static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, h
       parser,
       "Unexpected token",
       "TOKEN_ERB_START, TOKEN_HTML_DOCTYPE, TOKEN_HTML_COMMENT_START, TOKEN_IDENTIFIER, TOKEN_WHITESPACE, "
-      "TOKEN_NBSP, TOKEN_AT, or TOKEN_NEWLINE",
+      "TOKEN_NBSP, TOKEN_AT, TOKEN_BACKSLASH, or TOKEN_NEWLINE",
       errors
     );
   }
diff --git a/test/parser/text_content_test.rb b/test/parser/text_content_test.rb
index 91736778a..2f9686da7 100644
--- a/test/parser/text_content_test.rb
+++ b/test/parser/text_content_test.rb
@@ -145,5 +145,16 @@ class TextContentTest < Minitest::Spec
     test "backtick with HTML tags - issue 467" do
       assert_parsed_snapshot("a `<b></b>` c")
     end
+
+    test "backslash-prefixed text stays literal - issue 635" do
+      assert_parsed_snapshot("<p>\\Asome-regexp\\z</p>")
+    end
+
+    # https://github.com/lobsters/lobsters/blob/75f9a53077d5aeaeadbb8271def0479dd8fcd761/app/views/domains/edit.html.erb#L11
+    test "backslash-prefixed text - issue 633" do
+      assert_parsed_snapshot <<~HTML
+        <p class="help">Regexp with captures, must consume whole string like: <kbd>\\Ahttps?://github.com/+([^/]+).*\\z</kbd></p>
+      HTML
+    end
   end
 end
diff --git a/test/snapshots/parser/script_style_test/test_0035_script_tag_with_escaped_quotes_in_strings_3217a5ed01ac8ce6c44f9e106f9b4017.txt b/test/snapshots/parser/script_style_test/test_0035_script_tag_with_escaped_quotes_in_strings_3217a5ed01ac8ce6c44f9e106f9b4017.txt
index 43d5aa8af..48469075a 100644
--- a/test/snapshots/parser/script_style_test/test_0035_script_tag_with_escaped_quotes_in_strings_3217a5ed01ac8ce6c44f9e106f9b4017.txt
+++ b/test/snapshots/parser/script_style_test/test_0035_script_tag_with_escaped_quotes_in_strings_3217a5ed01ac8ce6c44f9e106f9b4017.txt
@@ -1,11 +1,4 @@
 @ DocumentNode (location: (1:0)-(1:59))
-├── errors: (1 error)
-│   └── @ UnexpectedError (location: (1:36)-(1:37))
-│       ├── message: "Unexpected token. Expected: `TOKEN_ERB_START, TOKEN_HTML_DOCTYPE, TOKEN_HTML_COMMENT_START, TOKEN_IDENTIFIER, TOKEN_WHITESPACE, TOKEN_NBSP, TOKEN_AT, or TOKE`, found: `TOKEN_BACKSLASH`."
-│       ├── description: "Unexpected token"
-│       ├── expected: "TOKEN_ERB_START, TOKEN_HTML_DOCTYPE, TOKEN_HTML_COMMENT_START, TOKEN_IDENTIFIER, TOKEN_WHITESPACE, TOKEN_NBSP, TOKEN_AT, or TOKEN_NEWLINE"
-│       └── found: "TOKEN_BACKSLASH"
-│
 └── children: (3 items)
     ├── @ HTMLElementNode (location: (1:0)-(1:36))
     │   ├── open_tag:
@@ -31,8 +24,8 @@
     │   ├── is_void: false
     │   └── source: "HTML"
     │
-    ├── @ HTMLTextNode (location: (1:37)-(1:50))
-    │   └── content: "\" yesterday\";"
+    ├── @ HTMLTextNode (location: (1:36)-(1:50))
+    │   └── content: "\\\" yesterday\";"
     │
     └── @ HTMLCloseTagNode (location: (1:50)-(1:59))
         ├── errors: (1 error)
diff --git a/test/snapshots/parser/tags_test/test_0027_stray_closing_tag_with_whitespace_0ee4b96cac701f87a8b6cb0cf5ad48bc.txt b/test/snapshots/parser/tags_test/test_0027_stray_closing_tag_with_whitespace_0ee4b96cac701f87a8b6cb0cf5ad48bc.txt
index 2a55af7ab..1bebae8b0 100644
--- a/test/snapshots/parser/tags_test/test_0027_stray_closing_tag_with_whitespace_0ee4b96cac701f87a8b6cb0cf5ad48bc.txt
+++ b/test/snapshots/parser/tags_test/test_0027_stray_closing_tag_with_whitespace_0ee4b96cac701f87a8b6cb0cf5ad48bc.txt
@@ -1,9 +1,9 @@
 @ DocumentNode (location: (1:0)-(1:24))
 ├── errors: (1 error)
 │   └── @ UnexpectedError (location: (1:16)-(1:17))
-│       ├── message: "Unexpected token. Expected: `TOKEN_ERB_START, TOKEN_HTML_DOCTYPE, TOKEN_HTML_COMMENT_START, TOKEN_IDENTIFIER, TOKEN_WHITESPACE, TOKEN_NBSP, TOKEN_AT, or TOKE`, found: `TOKEN_LT`."
+│       ├── message: "Unexpected token. Expected: `TOKEN_ERB_START, TOKEN_HTML_DOCTYPE, TOKEN_HTML_COMMENT_START, TOKEN_IDENTIFIER, TOKEN_WHITESPACE, TOKEN_NBSP, TOKEN_AT, TOKEN_B`, found: `TOKEN_LT`."
 │       ├── description: "Unexpected token"
-│       ├── expected: "TOKEN_ERB_START, TOKEN_HTML_DOCTYPE, TOKEN_HTML_COMMENT_START, TOKEN_IDENTIFIER, TOKEN_WHITESPACE, TOKEN_NBSP, TOKEN_AT, or TOKEN_NEWLINE"
+│       ├── expected: "TOKEN_ERB_START, TOKEN_HTML_DOCTYPE, TOKEN_HTML_COMMENT_START, TOKEN_IDENTIFIER, TOKEN_WHITESPACE, TOKEN_NBSP, TOKEN_AT, TOKEN_BACKSLASH, or TOKEN_NEWLINE"
 │       └── found: "TOKEN_LT"
 │
 └── children: (2 items)
diff --git a/test/snapshots/parser/text_content_test/test_0034_backslash-prefixed_text_stays_literal_-_issue_635_816fd02d8670264d606d92812679f159.txt b/test/snapshots/parser/text_content_test/test_0034_backslash-prefixed_text_stays_literal_-_issue_635_816fd02d8670264d606d92812679f159.txt
new file mode 100644
index 000000000..e75b2ccb2
--- /dev/null
+++ b/test/snapshots/parser/text_content_test/test_0034_backslash-prefixed_text_stays_literal_-_issue_635_816fd02d8670264d606d92812679f159.txt
@@ -0,0 +1,25 @@
+@ DocumentNode (location: (1:0)-(1:22))
+└── children: (1 item)
+    └── @ HTMLElementNode (location: (1:0)-(1:22))
+        ├── open_tag:
+        │   └── @ HTMLOpenTagNode (location: (1:0)-(1:3))
+        │       ├── tag_opening: "<" (location: (1:0)-(1:1))
+        │       ├── tag_name: "p" (location: (1:1)-(1:2))
+        │       ├── tag_closing: ">" (location: (1:2)-(1:3))
+        │       ├── children: []
+        │       └── is_void: false
+        │
+        ├── tag_name: "p" (location: (1:1)-(1:2))
+        ├── body: (1 item)
+        │   └── @ HTMLTextNode (location: (1:3)-(1:18))
+        │       └── content: "\\Asome-regexp\\z"
+        │
+        ├── close_tag:
+        │   └── @ HTMLCloseTagNode (location: (1:18)-(1:22))
+        │       ├── tag_opening: "</" (location: (1:18)-(1:20))
+        │       ├── tag_name: "p" (location: (1:20)-(1:21))
+        │       ├── children: []
+        │       └── tag_closing: ">" (location: (1:21)-(1:22))
+        │
+        ├── is_void: false
+        └── source: "HTML"
\ No newline at end of file
diff --git a/test/snapshots/parser/text_content_test/test_0035_backslash-prefixed_text_-_issue_633_fd1ab6af93689cddc537bac4cbdaefde.txt b/test/snapshots/parser/text_content_test/test_0035_backslash-prefixed_text_-_issue_633_fd1ab6af93689cddc537bac4cbdaefde.txt
new file mode 100644
index 000000000..e2d4e504d
--- /dev/null
+++ b/test/snapshots/parser/text_content_test/test_0035_backslash-prefixed_text_-_issue_633_fd1ab6af93689cddc537bac4cbdaefde.txt
@@ -0,0 +1,72 @@
+@ DocumentNode (location: (1:0)-(2:0))
+└── children: (2 items)
+    ├── @ HTMLElementNode (location: (1:0)-(1:119))
+    │   ├── open_tag:
+    │   │   └── @ HTMLOpenTagNode (location: (1:0)-(1:16))
+    │   │       ├── tag_opening: "<" (location: (1:0)-(1:1))
+    │   │       ├── tag_name: "p" (location: (1:1)-(1:2))
+    │   │       ├── tag_closing: ">" (location: (1:15)-(1:16))
+    │   │       ├── children: (1 item)
+    │   │       │   └── @ HTMLAttributeNode (location: (1:3)-(1:15))
+    │   │       │       ├── name:
+    │   │       │       │   └── @ HTMLAttributeNameNode (location: (1:3)-(1:8))
+    │   │       │       │       └── children: (1 item)
+    │   │       │       │           └── @ LiteralNode (location: (1:3)-(1:8))
+    │   │       │       │               └── content: "class"
+    │   │       │       │
+    │   │       │       │
+    │   │       │       ├── equals: "=" (location: (1:8)-(1:9))
+    │   │       │       └── value:
+    │   │       │           └── @ HTMLAttributeValueNode (location: (1:9)-(1:15))
+    │   │       │               ├── open_quote: """ (location: (1:9)-(1:10))
+    │   │       │               ├── children: (1 item)
+    │   │       │               │   └── @ LiteralNode (location: (1:10)-(1:14))
+    │   │       │               │       └── content: "help"
+    │   │       │               │
+    │   │       │               ├── close_quote: """ (location: (1:14)-(1:15))
+    │   │       │               └── quoted: true
+    │   │       │
+    │   │       │
+    │   │       └── is_void: false
+    │   │
+    │   ├── tag_name: "p" (location: (1:1)-(1:2))
+    │   ├── body: (2 items)
+    │   │   ├── @ HTMLTextNode (location: (1:16)-(1:70))
+    │   │   │   └── content: "Regexp with captures, must consume whole string like: "
+    │   │   │
+    │   │   └── @ HTMLElementNode (location: (1:70)-(1:115))
+    │   │       ├── open_tag:
+    │   │       │   └── @ HTMLOpenTagNode (location: (1:70)-(1:75))
+    │   │       │       ├── tag_opening: "<" (location: (1:70)-(1:71))
+    │   │       │       ├── tag_name: "kbd" (location: (1:71)-(1:74))
+    │   │       │       ├── tag_closing: ">" (location: (1:74)-(1:75))
+    │   │       │       ├── children: []
+    │   │       │       └── is_void: false
+    │   │       │
+    │   │       ├── tag_name: "kbd" (location: (1:71)-(1:74))
+    │   │       ├── body: (1 item)
+    │   │       │   └── @ HTMLTextNode (location: (1:75)-(1:109))
+    │   │       │       └── content: "\\Ahttps?://github.com/+([^/]+).*\\z"
+    │   │       │
+    │   │       ├── close_tag:
+    │   │       │   └── @ HTMLCloseTagNode (location: (1:109)-(1:115))
+    │   │       │       ├── tag_opening: "</" (location: (1:109)-(1:111))
+    │   │       │       ├── tag_name: "kbd" (location: (1:111)-(1:114))
+    │   │       │       ├── children: []
+    │   │       │       └── tag_closing: ">" (location: (1:114)-(1:115))
+    │   │       │
+    │   │       ├── is_void: false
+    │   │       └── source: "HTML"
+    │   │
+    │   ├── close_tag:
+    │   │   └── @ HTMLCloseTagNode (location: (1:115)-(1:119))
+    │   │       ├── tag_opening: "</" (location: (1:115)-(1:117))
+    │   │       ├── tag_name: "p" (location: (1:117)-(1:118))
+    │   │       ├── children: []
+    │   │       └── tag_closing: ">" (location: (1:118)-(1:119))
+    │   │
+    │   ├── is_void: false
+    │   └── source: "HTML"
+    │
+    └── @ HTMLTextNode (location: (1:119)-(2:0))
+        └── content: "\n"
\ No newline at end of file

From cd13bf7b95d120fe3177e26b2a626fac7b457815 Mon Sep 17 00:00:00 2001
From: Domingo Edwards <dedwards@buk.cl>
Date: Tue, 14 Oct 2025 11:27:30 -0300
Subject: [PATCH 60/97] Linter: Implement `html-input-require-autocomplete`
 linter rule (#565)

Resolves #552

---------

Co-authored-by: Marco Roth <marco.roth@intergga.ch>
---
 .../packages/linter/docs/rules/README.md      |  1 +
 .../rules/html-input-require-autocomplete.md  | 64 +++++++++++++++
 .../packages/linter/src/default-rules.ts      |  2 +
 .../rules/html-input-require-autocomplete.ts  | 78 +++++++++++++++++++
 javascript/packages/linter/src/rules/index.ts |  1 +
 .../test/__snapshots__/cli.test.ts.snap       |  6 +-
 .../html-input-require-autocomplete.test.ts   | 64 +++++++++++++++
 javascript/packages/vscode/package.json       |  1 +
 8 files changed, 214 insertions(+), 3 deletions(-)
 create mode 100644 javascript/packages/linter/docs/rules/html-input-require-autocomplete.md
 create mode 100644 javascript/packages/linter/src/rules/html-input-require-autocomplete.ts
 create mode 100644 javascript/packages/linter/test/rules/html-input-require-autocomplete.test.ts

diff --git a/javascript/packages/linter/docs/rules/README.md b/javascript/packages/linter/docs/rules/README.md
index b329bd748..40cf86d4b 100644
--- a/javascript/packages/linter/docs/rules/README.md
+++ b/javascript/packages/linter/docs/rules/README.md
@@ -26,6 +26,7 @@ This page contains documentation for all Herb Linter rules.
 - [`html-avoid-both-disabled-and-aria-disabled`](./html-avoid-both-disabled-and-aria-disabled.md) - Avoid using both `disabled` and `aria-disabled` attributes
 - [`html-boolean-attributes-no-value`](./html-boolean-attributes-no-value.md) - Prevents values on boolean attributes
 - [`html-iframe-has-title`](./html-iframe-has-title.md) - `iframe` elements must have a `title` attribute
+- [`html-input-require-autocomplete`](./html-input-require-autocomplete.md) - Require `autocomplete` attributes on `<input>` tags.
 - [`html-img-require-alt`](./html-img-require-alt.md) - Requires `alt` attributes on `<img>` tags
 - [`html-navigation-has-label`](./html-navigation-has-label.md) - Navigation landmarks must have accessible labels
 - [`html-no-aria-hidden-on-focusable`](./html-no-aria-hidden-on-focusable.md) - Focusable elements should not have `aria-hidden="true"`
diff --git a/javascript/packages/linter/docs/rules/html-input-require-autocomplete.md b/javascript/packages/linter/docs/rules/html-input-require-autocomplete.md
new file mode 100644
index 000000000..bb85e1f3c
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/html-input-require-autocomplete.md
@@ -0,0 +1,64 @@
+# Linter Rule: Require `autocomplete` attributes on `<input>` tags
+
+**Rule:** `html-input-require-autocomplete`
+
+## Description
+
+Require an `autocomplete` attribute on `<input>` elements with types that support autocomplete functionality. This rule ensures that developers explicitly declare autocomplete behavior for form inputs.
+
+
+## Rationale
+
+The HTML `autocomplete` attribute helps users complete forms by using data stored in the browser. This is particularly useful for people with motor disabilities or cognitive impairment who may have difficulties filling out forms online. Without an explicit `autocomplete` attribute, behavior varies across browsers and can lead to inconsistent user experiences.
+
+If you prefer not to specify a specific autocomplete value, use `autocomplete="on"` to enable browser defaults or `autocomplete="off"` to explicitly disable it.
+
+## Affected Input Types
+
+This rule applies to the following input types:
+
+- `color`
+- `date`
+- `datetime-local`
+- `email`
+- `month`
+- `number`
+- `password`
+- `range`
+- `search`
+- `tel`
+- `text`
+- `time`
+- `url`
+- `week`
+
+
+## Examples
+
+### ✅ Good
+
+```erb
+<input type="email" autocomplete="email">
+
+<input type="url" autocomplete="off">
+
+<input type="password" autocomplete="on">
+```
+
+
+### 🚫 Bad
+
+```erb
+<input type="email">
+
+<input type="url">
+
+<input type="password">
+```
+
+## References
+
+* [Inspiration: ERB Lint `RequireInputAutocomplete` rule](https://github.com/shopify/erb_lint?tab=readme-ov-file#requireinputautocomplete)
+* [HTML attribute: autocomplete](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete)
+* [WCAG: Using HTML autocomplete attributes](https://www.w3.org/WAI/WCAG21/Techniques/html/H98)
+* [HTML Specification: Autofill](https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill)
diff --git a/javascript/packages/linter/src/default-rules.ts b/javascript/packages/linter/src/default-rules.ts
index 322c69a36..f0e83d9c0 100644
--- a/javascript/packages/linter/src/default-rules.ts
+++ b/javascript/packages/linter/src/default-rules.ts
@@ -24,6 +24,7 @@ import { HTMLAvoidBothDisabledAndAriaDisabledRule } from "./rules/html-avoid-bot
 import { HTMLBooleanAttributesNoValueRule } from "./rules/html-boolean-attributes-no-value.js"
 import { HTMLIframeHasTitleRule } from "./rules/html-iframe-has-title.js"
 import { HTMLImgRequireAltRule } from "./rules/html-img-require-alt.js"
+import { HTMLInputRequireAutocompleteRule } from "./rules/html-input-require-autocomplete.js"
 // import { HTMLNavigationHasLabelRule } from "./rules/html-navigation-has-label.js"
 import { HTMLNoAriaHiddenOnFocusableRule } from "./rules/html-no-aria-hidden-on-focusable.js"
 // import { HTMLNoBlockInsideInlineRule } from "./rules/html-no-block-inside-inline.js"
@@ -68,6 +69,7 @@ export const defaultRules: RuleClass[] = [
   HTMLBooleanAttributesNoValueRule,
   HTMLIframeHasTitleRule,
   HTMLImgRequireAltRule,
+  HTMLInputRequireAutocompleteRule,
   // HTMLNavigationHasLabelRule,
   HTMLNoAriaHiddenOnFocusableRule,
   // HTMLNoBlockInsideInlineRule,
diff --git a/javascript/packages/linter/src/rules/html-input-require-autocomplete.ts b/javascript/packages/linter/src/rules/html-input-require-autocomplete.ts
new file mode 100644
index 000000000..ecb656f3b
--- /dev/null
+++ b/javascript/packages/linter/src/rules/html-input-require-autocomplete.ts
@@ -0,0 +1,78 @@
+import { getTagName } from "@herb-tools/core"
+import { BaseRuleVisitor, getAttribute, getAttributeValue, getStaticAttributeValueContent } from "./rule-utils.js"
+import { ParserRule } from "../types.js"
+
+import type { LintOffense, LintContext } from "../types.js"
+import type { ParseResult, HTMLOpenTagNode } from "@herb-tools/core"
+
+class HTMLInputRequireAutocompleteVisitor extends BaseRuleVisitor {
+  readonly HTML_INPUT_TYPES_REQUIRING_AUTOCOMPLETE = new Set([
+    "color",
+    "date",
+    "datetime-local",
+    "email",
+    "month",
+    "number",
+    "password",
+    "range",
+    "search",
+    "tel",
+    "text",
+    "time",
+    "url",
+    "week",
+  ])
+
+  visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
+    this.checkInputTag(node)
+  }
+
+  private checkInputTag(node: HTMLOpenTagNode): void {
+    if (!this.isInputTag(node) || this.hasAutocomplete(node)) return
+
+    const typeAttribute = getAttribute(node, "type");
+    if (!typeAttribute) return
+
+    const typeValue = getStaticAttributeValueContent(typeAttribute)
+    if (!typeValue) return
+
+    if (!this.HTML_INPUT_TYPES_REQUIRING_AUTOCOMPLETE.has(typeValue)) return
+
+    this.addOffense(
+      "Add an `autocomplete` attribute to improve form accessibility. Use a specific value (e.g., `autocomplete=\"email\"`), `autocomplete=\"on\"` for defaults, or `autocomplete=\"off\"` to disable.",
+      node.location
+    )
+  }
+
+  private hasAutocomplete(node: HTMLOpenTagNode) {
+    const autocompleteAttribute = getAttribute(node, "autocomplete");
+    if (!autocompleteAttribute) return false
+
+    const autocompleteValue = getAttributeValue(autocompleteAttribute)
+    if (!autocompleteValue) return false
+
+    return true
+  }
+
+  private isInputTag(node: HTMLOpenTagNode) {
+    const tagName = getTagName(node);
+
+    if (tagName === "input") {
+      return true
+    } else {
+      return false
+    }
+  }
+}
+
+export class HTMLInputRequireAutocompleteRule extends ParserRule {
+  name = "html-input-require-autocomplete"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new HTMLInputRequireAutocompleteVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}
diff --git a/javascript/packages/linter/src/rules/index.ts b/javascript/packages/linter/src/rules/index.ts
index eb192e949..e6ca65794 100644
--- a/javascript/packages/linter/src/rules/index.ts
+++ b/javascript/packages/linter/src/rules/index.ts
@@ -22,6 +22,7 @@ export * from "./html-avoid-both-disabled-and-aria-disabled.js"
 export * from "./html-boolean-attributes-no-value.js"
 export * from "./html-iframe-has-title.js"
 export * from "./html-img-require-alt.js"
+export * from "./html-input-require-autocomplete.js"
 export * from "./html-navigation-has-label.js"
 export * from "./html-no-aria-hidden-on-focusable.js"
 export * from "./html-no-block-inside-inline.js"
diff --git a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
index 9629ab3c7..1a1659a23 100644
--- a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
+++ b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
@@ -574,7 +574,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for bad file 1`]
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 36,
+    "ruleCount": 37,
     "totalErrors": 2,
     "totalOffenses": 2,
     "totalWarnings": 0,
@@ -592,7 +592,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for clean file 1`
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 0,
-    "ruleCount": 36,
+    "ruleCount": 37,
     "totalErrors": 0,
     "totalOffenses": 0,
     "totalWarnings": 0,
@@ -662,7 +662,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for file with err
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 36,
+    "ruleCount": 37,
     "totalErrors": 3,
     "totalOffenses": 3,
     "totalWarnings": 0,
diff --git a/javascript/packages/linter/test/rules/html-input-require-autocomplete.test.ts b/javascript/packages/linter/test/rules/html-input-require-autocomplete.test.ts
new file mode 100644
index 000000000..19bd35c4b
--- /dev/null
+++ b/javascript/packages/linter/test/rules/html-input-require-autocomplete.test.ts
@@ -0,0 +1,64 @@
+import dedent from "dedent"
+
+import { describe, test } from "vitest"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
+
+import { HTMLInputRequireAutocompleteRule } from "../../src/rules/html-input-require-autocomplete.js"
+
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLInputRequireAutocompleteRule)
+
+describe("HTMLInputRequireAutocompleteRule", () => {
+  test("when autocomplete is present on input types", () => {
+    expectNoOffenses(dedent`
+      <input type="email" autocomplete="foo">
+    `)
+  })
+
+  test("when input type does not require autocomplete attribute and it is not present", () => {
+    expectNoOffenses(dedent`
+      <input type="bar">
+    `)
+  })
+
+  test("when input type requires autocomplete attribute and it is not present", () => {
+    expectError("Add an `autocomplete` attribute to improve form accessibility. Use a specific value (e.g., `autocomplete=\"email\"`), `autocomplete=\"on\"` for defaults, or `autocomplete=\"off\"` to disable.")
+
+    assertOffenses(dedent`
+      <input type="email">
+    `)
+  })
+
+  describe.todo("Action View Helpers", () => {
+    const formHelpersRequiringAutocomplete = [
+      'date_field_tag',
+      'color_field_tag',
+      'email_field_tag',
+      'text_field_tag',
+      'utf8_enforcer_tag',
+      'month_field_tag',
+      'number_field_tag',
+      'password_field_tag',
+      'search_field_tag',
+      'telephone_field_tag',
+      'time_field_tag',
+      'url_field_tag',
+      'week_field_tag',
+    ]
+
+    formHelpersRequiringAutocomplete.forEach(formHelper => {
+      test(`usage of "${formHelper}" helper with autocomplete value`, () => {
+        expectNoOffenses(dedent`
+          <%= text_field_tag 'foo', autocomplete: 'foo' %>
+        `)
+      })
+
+      test(`usage of "${formHelper}" helper without autocomplete value`, () => {
+        expectError("Add an `autocomplete` attribute to improve form accessibility. Use a specific value (e.g., `autocomplete=\"email\"`), `autocomplete=\"on\"` for defaults, or `autocomplete=\"off\"` to disable.")
+
+        expectNoOffenses(dedent`
+          <%= ${formHelper} 'foo' autocomplete: 'foo' %>
+        `)
+      })
+    })
+  })
+})
diff --git a/javascript/packages/vscode/package.json b/javascript/packages/vscode/package.json
index 68b1d8b30..3b8a9c81b 100644
--- a/javascript/packages/vscode/package.json
+++ b/javascript/packages/vscode/package.json
@@ -84,6 +84,7 @@
               "html-boolean-attributes-no-value",
               "html-iframe-has-title",
               "html-img-require-alt",
+              "html-input-require-autocomplete",
               "html-navigation-has-label",
               "html-no-aria-hidden-on-focusable",
               "html-no-block-inside-inline",

From f2b3d787aa70c78871e4131ba8e48e289c3a928c Mon Sep 17 00:00:00 2001
From: Nico <nicolas.galdamez@unagisoftware.com>
Date: Tue, 14 Oct 2025 13:44:07 -0300
Subject: [PATCH 61/97] Linter: Implement `html-body-only-elements` linter rule
 (#470)

Add `html-body-only-elements` rule

This PR adds a new linter rule `html-body-only-elements` that enforces
certain HTML elements are only placed within the `<body>` tag.

## What does this rule do?

This rule prevents content-bearing and interactive HTML elements from
being placed in the `<head>` section or outside the HTML document
structure.

Closes #378

---------

Co-authored-by: Marco Roth <marco.roth@intergga.ch>
---
 .../packages/linter/docs/rules/README.md      |   1 +
 .../docs/rules/html-body-only-elements.md     |  99 ++++++++++++
 .../packages/linter/src/default-rules.ts      |   2 +
 .../src/rules/html-body-only-elements.ts      |  42 +++++
 javascript/packages/linter/src/rules/index.ts |   1 +
 .../packages/linter/src/rules/rule-utils.ts   |  72 ++++++++-
 .../test/__snapshots__/cli.test.ts.snap       |   6 +-
 .../rules/html-body-only-elements.test.ts     | 147 ++++++++++++++++++
 javascript/packages/vscode/package.json       |   1 +
 9 files changed, 367 insertions(+), 4 deletions(-)
 create mode 100644 javascript/packages/linter/docs/rules/html-body-only-elements.md
 create mode 100644 javascript/packages/linter/src/rules/html-body-only-elements.ts
 create mode 100644 javascript/packages/linter/test/rules/html-body-only-elements.test.ts

diff --git a/javascript/packages/linter/docs/rules/README.md b/javascript/packages/linter/docs/rules/README.md
index 40cf86d4b..08503a87a 100644
--- a/javascript/packages/linter/docs/rules/README.md
+++ b/javascript/packages/linter/docs/rules/README.md
@@ -24,6 +24,7 @@ This page contains documentation for all Herb Linter rules.
 - [`html-attribute-equals-spacing`](./html-attribute-equals-spacing.md) - No whitespace around `=` in HTML attributes
 - [`html-attribute-values-require-quotes`](./html-attribute-values-require-quotes.md) - Requires quotes around attribute values
 - [`html-avoid-both-disabled-and-aria-disabled`](./html-avoid-both-disabled-and-aria-disabled.md) - Avoid using both `disabled` and `aria-disabled` attributes
+- [`html-body-only-elements`](./html-body-only-elements.md) - Require content elements inside `<body>`.
 - [`html-boolean-attributes-no-value`](./html-boolean-attributes-no-value.md) - Prevents values on boolean attributes
 - [`html-iframe-has-title`](./html-iframe-has-title.md) - `iframe` elements must have a `title` attribute
 - [`html-input-require-autocomplete`](./html-input-require-autocomplete.md) - Require `autocomplete` attributes on `<input>` tags.
diff --git a/javascript/packages/linter/docs/rules/html-body-only-elements.md b/javascript/packages/linter/docs/rules/html-body-only-elements.md
new file mode 100644
index 000000000..a37754484
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/html-body-only-elements.md
@@ -0,0 +1,99 @@
+# Linter Rule: Require content elements inside `<body>`
+
+**Rule:** `html-body-only-elements`
+
+## Description
+
+Enforce that specific HTML elements are only placed within the `<body>` tag.
+
+## Rationale
+
+According to the HTML specification, certain elements are meant to contain content and should only appear within the `<body>` section of an HTML document. Placing content-bearing or interactive elements in the `<head>` section or outside the HTML structure can lead to:
+
+- Unpredictable browser rendering behavior
+- Accessibility issues for screen readers and assistive technologies
+- SEO problems as search engines may not properly index misplaced content
+- Validation errors and non-compliant HTML
+
+This rule enforces proper document structure by ensuring semantic and content elements are correctly placed within the `<body>` element.
+
+## Examples
+
+### ✅ Good
+
+```erb
+<html>
+  <head>
+    <title>Page Title</title>
+    <meta charset="utf-8">
+  </head>
+
+  <body>
+    <header>
+      <h1>Welcome</h1>
+      <nav>
+        <ul>
+          <li>Home</li>
+        </ul>
+      </nav>
+    </header>
+
+    <main>
+      <article>
+        <section>
+          <p>This is valid content.</p>
+          <table>
+            <tr><td>Data</td></tr>
+          </table>
+        </section>
+      </article>
+      <aside>
+        <form>
+          <input type="text" autocomplete="on">
+        </form>
+      </aside>
+    </main>
+
+    <footer>
+      <h2>Footer</h2>
+    </footer>
+  </body>
+</html>
+```
+
+### 🚫 Bad
+
+```erb
+<html>
+  <head>
+    <title>Page Title</title>
+    <h1>Welcome</h1>
+
+    <p>This should not be here.</p>
+
+  </head>
+
+  <body>
+    <main>Valid content</main>
+  </body>
+</html>
+```
+
+```erb
+<html>
+  <head>
+    <nav>Navigation</nav>
+
+    <form>Form</form>
+
+  </head>
+
+  <body>
+  </body>
+</html>
+```
+
+## References
+
+- [HTML Living Standard - The `body` element](https://html.spec.whatwg.org/multipage/sections.html#the-body-element)
+- [MDN: HTML `document` structure](https://developer.mozilla.org/en-US/docs/Learn/HTML/Introduction_to_HTML/Document_and_website_structure)
diff --git a/javascript/packages/linter/src/default-rules.ts b/javascript/packages/linter/src/default-rules.ts
index f0e83d9c0..2cbadb3f4 100644
--- a/javascript/packages/linter/src/default-rules.ts
+++ b/javascript/packages/linter/src/default-rules.ts
@@ -21,6 +21,7 @@ import { HTMLAttributeDoubleQuotesRule } from "./rules/html-attribute-double-quo
 import { HTMLAttributeEqualsSpacingRule } from "./rules/html-attribute-equals-spacing.js"
 import { HTMLAttributeValuesRequireQuotesRule } from "./rules/html-attribute-values-require-quotes.js"
 import { HTMLAvoidBothDisabledAndAriaDisabledRule } from "./rules/html-avoid-both-disabled-and-aria-disabled.js"
+import { HTMLBodyOnlyElementsRule } from "./rules/html-body-only-elements.js"
 import { HTMLBooleanAttributesNoValueRule } from "./rules/html-boolean-attributes-no-value.js"
 import { HTMLIframeHasTitleRule } from "./rules/html-iframe-has-title.js"
 import { HTMLImgRequireAltRule } from "./rules/html-img-require-alt.js"
@@ -66,6 +67,7 @@ export const defaultRules: RuleClass[] = [
   HTMLAttributeEqualsSpacingRule,
   HTMLAttributeValuesRequireQuotesRule,
   HTMLAvoidBothDisabledAndAriaDisabledRule,
+  HTMLBodyOnlyElementsRule,
   HTMLBooleanAttributesNoValueRule,
   HTMLIframeHasTitleRule,
   HTMLImgRequireAltRule,
diff --git a/javascript/packages/linter/src/rules/html-body-only-elements.ts b/javascript/packages/linter/src/rules/html-body-only-elements.ts
new file mode 100644
index 000000000..b1978ae50
--- /dev/null
+++ b/javascript/packages/linter/src/rules/html-body-only-elements.ts
@@ -0,0 +1,42 @@
+import { ParserRule } from "../types.js"
+import { BaseRuleVisitor, getTagName, isBodyOnlyTag } from "./rule-utils.js"
+
+import type { LintOffense, LintContext } from "../types.js"
+import type { HTMLElementNode, ParseResult } from "@herb-tools/core"
+
+class HTMLBodyOnlyElementsVisitor extends BaseRuleVisitor {
+  private isInHead = false
+
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    const tagName = getTagName(node.open_tag)
+    if (!tagName) return
+
+    const previousIsInHead = this.isInHead
+    if (tagName.toLowerCase() === "head") this.isInHead = true
+
+    if (this.isInHead && isBodyOnlyTag(tagName)) {
+      this.addOffense(
+        `Element \`<${tagName}>\` must be placed inside the \`<body>\` tag.`,
+        node.location,
+        "error"
+      )
+    }
+
+    this.visitChildNodes(node)
+
+    this.isInHead = previousIsInHead
+  }
+}
+
+export class HTMLBodyOnlyElementsRule extends ParserRule {
+  static autocorrectable = false
+  name = "html-body-only-elements"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new HTMLBodyOnlyElementsVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}
diff --git a/javascript/packages/linter/src/rules/index.ts b/javascript/packages/linter/src/rules/index.ts
index e6ca65794..f3f7490e1 100644
--- a/javascript/packages/linter/src/rules/index.ts
+++ b/javascript/packages/linter/src/rules/index.ts
@@ -19,6 +19,7 @@ export * from "./html-attribute-double-quotes.js"
 export * from "./html-attribute-equals-spacing.js"
 export * from "./html-attribute-values-require-quotes.js"
 export * from "./html-avoid-both-disabled-and-aria-disabled.js"
+export * from "./html-body-only-elements.js"
 export * from "./html-boolean-attributes-no-value.js"
 export * from "./html-iframe-has-title.js"
 export * from "./html-img-require-alt.js"
diff --git a/javascript/packages/linter/src/rules/rule-utils.ts b/javascript/packages/linter/src/rules/rule-utils.ts
index c498b4206..5d45f1f9a 100644
--- a/javascript/packages/linter/src/rules/rule-utils.ts
+++ b/javascript/packages/linter/src/rules/rule-utils.ts
@@ -172,7 +172,9 @@ export function getAttributes(node: HTMLOpenTagNode): HTMLAttributeNode[] {
 /**
  * Gets the tag name from an HTML tag node (lowercased)
  */
-export function getTagName(node: HTMLOpenTagNode): string | null {
+export function getTagName(node: HTMLOpenTagNode | null | undefined): string | null {
+  if (!node) return null
+
   return node.tag_name?.value.toLowerCase() || null
 }
 
@@ -995,3 +997,71 @@ export function findParent(root: Node, target: Node): Node | null {
 
   return parentNode
 }
+
+export const DOCUMENT_ONLY_TAG_NAMES = new Set<string>([
+  "html"
+])
+
+export const HTML_ONLY_TAG_NAMES = new Set<string>([
+  "head", "body"
+])
+
+export const HEAD_ONLY_TAG_NAMES = new Set<string>([
+  "base",
+  "title",
+  "style",
+  "meta",
+  "link",
+])
+
+export const HEAD_AND_BODY_TAG_NAMES = new Set<string>([
+  "script",
+  "noscript",
+  "template",
+])
+
+export function isDocumentOnlyTag(tagName: string): boolean {
+  return DOCUMENT_ONLY_TAG_NAMES.has(tagName.toLowerCase())
+}
+
+export function isHtmlOnlyTag(tagName: string): boolean {
+  return HTML_ONLY_TAG_NAMES.has(tagName.toLowerCase())
+}
+
+export function isHeadOnlyTag(tagName: string): boolean {
+  return HEAD_ONLY_TAG_NAMES.has(tagName.toLowerCase())
+}
+
+export function isHeadAndBodyTag(tagName: string): boolean {
+  return HEAD_AND_BODY_TAG_NAMES.has(tagName.toLowerCase())
+}
+
+export function isBodyOnlyTag(tagName: string): boolean {
+  const tag = tagName.toLowerCase()
+
+  return (
+    !isDocumentOnlyTag(tag) &&
+    !isHtmlOnlyTag(tag) &&
+    !isHeadOnlyTag(tag) &&
+    !isHeadAndBodyTag(tag)
+  )
+}
+
+export function isBodyTag(tagName: string): boolean {
+  const tag = tagName.toLowerCase()
+  return (
+    !isDocumentOnlyTag(tag) &&
+    !isHtmlOnlyTag(tag) &&
+    (isBodyOnlyTag(tag) || isHeadAndBodyTag(tag))
+  )
+}
+
+export function isHeadTag(tagName: string): boolean {
+  const tag = tagName.toLowerCase()
+
+  return (
+    !isDocumentOnlyTag(tag) &&
+    !isHtmlOnlyTag(tag) &&
+    (isHeadOnlyTag(tag) || isHeadAndBodyTag(tag))
+  )
+}
diff --git a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
index 1a1659a23..b0b58f9dd 100644
--- a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
+++ b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
@@ -574,7 +574,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for bad file 1`]
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 37,
+    "ruleCount": 38,
     "totalErrors": 2,
     "totalOffenses": 2,
     "totalWarnings": 0,
@@ -592,7 +592,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for clean file 1`
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 0,
-    "ruleCount": 37,
+    "ruleCount": 38,
     "totalErrors": 0,
     "totalOffenses": 0,
     "totalWarnings": 0,
@@ -662,7 +662,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for file with err
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 37,
+    "ruleCount": 38,
     "totalErrors": 3,
     "totalOffenses": 3,
     "totalWarnings": 0,
diff --git a/javascript/packages/linter/test/rules/html-body-only-elements.test.ts b/javascript/packages/linter/test/rules/html-body-only-elements.test.ts
new file mode 100644
index 000000000..23c4b6b41
--- /dev/null
+++ b/javascript/packages/linter/test/rules/html-body-only-elements.test.ts
@@ -0,0 +1,147 @@
+import dedent from "dedent"
+
+import { describe, test } from "vitest"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
+import { HTMLBodyOnlyElementsRule } from "../../src/rules/html-body-only-elements.js"
+
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLBodyOnlyElementsRule)
+
+describe("html-body-only-elements", () => {
+  test("passes when elements are inside body", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <title>Test</title>
+        </head>
+        <body>
+          <header>
+            <h1>Welcome</h1>
+            <nav>
+              <ul>
+                <li>Home</li>
+              </ul>
+            </nav>
+          </header>
+          <main>
+            <article>
+              <section>
+                <p>Content</p>
+                <table>
+                  <tr><td>Data</td></tr>
+                </table>
+              </section>
+            </article>
+            <aside>
+              <form>
+                <input type="text">
+              </form>
+            </aside>
+          </main>
+          <footer>
+            <h2>Footer</h2>
+          </footer>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when header is in head", () => {
+    expectError("Element `<header>` must be placed inside the `<body>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <header>This should not be here</header>
+        </head>
+        <body>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when heading is in head", () => {
+    expectError("Element `<h1>` must be placed inside the `<body>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <h1>Wrong place</h1>
+        </head>
+        <body>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when multiple elements are in head", () => {
+    expectError("Element `<nav>` must be placed inside the `<body>` tag.")
+    expectError("Element `<p>` must be placed inside the `<body>` tag.")
+    expectError("Element `<form>` must be placed inside the `<body>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <nav>Navigation</nav>
+          <p>Paragraph</p>
+          <form>Form</form>
+        </head>
+        <body>
+        </body>
+      </html>
+    `)
+  })
+
+  test("passes with valid ERB content in body", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <body>
+          <% if user_signed_in? %>
+            <header>
+              <h1><%= @title %></h1>
+            </header>
+          <% end %>
+        </body>
+      </html>
+    `)
+  })
+
+  describe("tests all body-only elements", () => {
+    const bodyOnlyElements = [
+      "header", "main", "nav", "section", "footer", "article", "aside", "form",
+      "h1", "h2", "h3", "h4", "h5", "h6", "p", "ul", "table"
+    ]
+
+    bodyOnlyElements.forEach(element => {
+      test(`tests ${element} body-only elements`, () => {
+        expectError(`Element \`<${element}>\` must be placed inside the \`<body>\` tag.`)
+
+        assertOffenses(dedent`
+          <html>
+            <head>
+              <${element}>Content</${element}>
+            </head>
+            <body>
+            </body>
+          </html>
+        `)
+      })
+    })
+  })
+
+  test("passes for allowed elements in head", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <title>Page Title</title>
+          <meta charset="utf-8">
+          <link rel="stylesheet" href="style.css">
+          <script src="script.js"></script>
+          <style>body { margin: 0; }</style>
+        </head>
+        <body>
+          <h1>Content</h1>
+        </body>
+      </html>
+    `)
+  })
+})
diff --git a/javascript/packages/vscode/package.json b/javascript/packages/vscode/package.json
index 3b8a9c81b..5b11c55d1 100644
--- a/javascript/packages/vscode/package.json
+++ b/javascript/packages/vscode/package.json
@@ -81,6 +81,7 @@
               "html-attribute-equals-spacing",
               "html-attribute-values-require-quotes",
               "html-avoid-both-disabled-and-aria-disabled",
+              "html-body-only-elements",
               "html-boolean-attributes-no-value",
               "html-iframe-has-title",
               "html-img-require-alt",

From 7034d389c1a8ffe70ad0851d2c076b1b7b7b1d9a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Tue, 14 Oct 2025 19:32:39 +0200
Subject: [PATCH 62/97] C: Use `uint32_t` for `length` member in `hb_string_T` 
 struct (#640)

In line with the lexer/parser we are going to limit the string length to
the range of `uint32_t` which is sufficient to hold 4 GB large strings.

Resolves #636
---
 src/include/util/hb_string.h | 3 ++-
 src/util/hb_string.c         | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/include/util/hb_string.h b/src/include/util/hb_string.h
index 6fc93a814..408908458 100644
--- a/src/include/util/hb_string.h
+++ b/src/include/util/hb_string.h
@@ -3,10 +3,11 @@
 
 #include <stdbool.h>
 #include <stddef.h>
+#include <stdint.h>
 
 typedef struct HB_STRING_STRUCT {
   char* data;
-  size_t length;
+  uint32_t length;
 } hb_string_T;
 
 hb_string_T hb_string_from_c_string(const char* null_terminated_c_string);
diff --git a/src/util/hb_string.c b/src/util/hb_string.c
index 0a45af6e8..8145ae575 100644
--- a/src/util/hb_string.c
+++ b/src/util/hb_string.c
@@ -8,7 +8,7 @@ hb_string_T hb_string_from_c_string(const char* null_terminated_c_string) {
   hb_string_T string;
 
   string.data = (char*) null_terminated_c_string;
-  string.length = strlen(null_terminated_c_string);
+  string.length = (uint32_t) strlen(null_terminated_c_string);
 
   return string;
 }

From cf691252e2822d1f3b262c2e78832649e8c6a584 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Tue, 14 Oct 2025 19:38:23 +0200
Subject: [PATCH 63/97] Linter: Implement `html-head-only-elements` linter rule
 (#382)

Resolves #167
---
 .../packages/linter/docs/rules/README.md      |   1 +
 .../docs/rules/html-head-only-elements.md     |  81 ++++++
 .../packages/linter/src/default-rules.ts      |   2 +
 .../src/rules/html-body-only-elements.ts      |  44 ++-
 .../src/rules/html-head-only-elements.ts      |  60 ++++
 javascript/packages/linter/src/rules/index.ts |   1 +
 .../packages/linter/src/rules/rule-utils.ts   |   3 +-
 .../test/__snapshots__/cli.test.ts.snap       |   6 +-
 .../rules/html-head-only-elements.test.ts     | 260 ++++++++++++++++++
 javascript/packages/vscode/package.json       |   1 +
 10 files changed, 442 insertions(+), 17 deletions(-)
 create mode 100644 javascript/packages/linter/docs/rules/html-head-only-elements.md
 create mode 100644 javascript/packages/linter/src/rules/html-head-only-elements.ts
 create mode 100644 javascript/packages/linter/test/rules/html-head-only-elements.test.ts

diff --git a/javascript/packages/linter/docs/rules/README.md b/javascript/packages/linter/docs/rules/README.md
index 08503a87a..f8d511966 100644
--- a/javascript/packages/linter/docs/rules/README.md
+++ b/javascript/packages/linter/docs/rules/README.md
@@ -26,6 +26,7 @@ This page contains documentation for all Herb Linter rules.
 - [`html-avoid-both-disabled-and-aria-disabled`](./html-avoid-both-disabled-and-aria-disabled.md) - Avoid using both `disabled` and `aria-disabled` attributes
 - [`html-body-only-elements`](./html-body-only-elements.md) - Require content elements inside `<body>`.
 - [`html-boolean-attributes-no-value`](./html-boolean-attributes-no-value.md) - Prevents values on boolean attributes
+- [`html-head-only-elements`](./html-head-only-elements.md) - Require head-scoped elements inside `<head>`.
 - [`html-iframe-has-title`](./html-iframe-has-title.md) - `iframe` elements must have a `title` attribute
 - [`html-input-require-autocomplete`](./html-input-require-autocomplete.md) - Require `autocomplete` attributes on `<input>` tags.
 - [`html-img-require-alt`](./html-img-require-alt.md) - Requires `alt` attributes on `<img>` tags
diff --git a/javascript/packages/linter/docs/rules/html-head-only-elements.md b/javascript/packages/linter/docs/rules/html-head-only-elements.md
new file mode 100644
index 000000000..8a12b47f8
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/html-head-only-elements.md
@@ -0,0 +1,81 @@
+# Linter Rule: Require head-scoped elements inside `<head>`
+
+**Rule:** `html-head-only-elements`
+
+## Description
+
+Enforce that certain elements only appear inside the `<head>` section of the document.
+
+Elements like `<title>`, `<meta>`, `<base>`, `<link>`, and `<style>` are permitted only inside the `<head>` element. They must not appear inside `<body>` or outside of `<html>`. Placing them elsewhere produces invalid HTML and relies on browser error correction.
+
+> [!NOTE] Exception
+> `<title>` elements are allowed inside `<svg>` elements for accessibility purposes.
+
+## Rationale
+
+The HTML specification requires certain elements to appear only in the `<head>` section because they affect document metadata, resource loading, or global behavior:
+
+Placing these elements outside `<head>` leads to invalid HTML and undefined behavior across browsers.
+
+
+## Examples
+
+### ✅ Good
+
+```erb
+<head>
+  <title>My Page</title>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <link rel="stylesheet" href="/styles.css">
+</head>
+
+<body>
+  <h1>Welcome</h1>
+</body>
+```
+
+```erb
+<head>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+  <%= favicon_link_tag 'favicon.ico' %>
+  <%= stylesheet_link_tag "application", "data-turbo-track": "reload" %>
+  <%= javascript_include_tag "application", "data-turbo-track": "reload", defer: true %>
+
+  <title><%= content_for?(:title) ? yield(:title) : "Default Title" %></title>
+</head>
+```
+
+```erb
+<body>
+  <svg>
+    <title>Chart Title</title>
+    <rect width="100" height="100" />
+  </svg>
+</body>
+```
+
+### 🚫 Bad
+
+```erb
+<body>
+  <title>My Page</title>
+
+  <meta charset="UTF-8">
+
+  <link rel="stylesheet" href="/styles.css">
+
+  <h1>Welcome</h1>
+</body>
+```
+
+```erb
+<body>
+  <title><%= content_for?(:title) ? yield(:title) : "Default Title" %></title>
+</body>
+```
+
+## References
+
+* [HTML Living Standard - The `head` element](https://html.spec.whatwg.org/multipage/semantics.html#the-head-element)
diff --git a/javascript/packages/linter/src/default-rules.ts b/javascript/packages/linter/src/default-rules.ts
index 2cbadb3f4..1b9866520 100644
--- a/javascript/packages/linter/src/default-rules.ts
+++ b/javascript/packages/linter/src/default-rules.ts
@@ -23,6 +23,7 @@ import { HTMLAttributeValuesRequireQuotesRule } from "./rules/html-attribute-val
 import { HTMLAvoidBothDisabledAndAriaDisabledRule } from "./rules/html-avoid-both-disabled-and-aria-disabled.js"
 import { HTMLBodyOnlyElementsRule } from "./rules/html-body-only-elements.js"
 import { HTMLBooleanAttributesNoValueRule } from "./rules/html-boolean-attributes-no-value.js"
+import { HTMLHeadOnlyElementsRule } from "./rules/html-head-only-elements.js"
 import { HTMLIframeHasTitleRule } from "./rules/html-iframe-has-title.js"
 import { HTMLImgRequireAltRule } from "./rules/html-img-require-alt.js"
 import { HTMLInputRequireAutocompleteRule } from "./rules/html-input-require-autocomplete.js"
@@ -69,6 +70,7 @@ export const defaultRules: RuleClass[] = [
   HTMLAvoidBothDisabledAndAriaDisabledRule,
   HTMLBodyOnlyElementsRule,
   HTMLBooleanAttributesNoValueRule,
+  HTMLHeadOnlyElementsRule,
   HTMLIframeHasTitleRule,
   HTMLImgRequireAltRule,
   HTMLInputRequireAutocompleteRule,
diff --git a/javascript/packages/linter/src/rules/html-body-only-elements.ts b/javascript/packages/linter/src/rules/html-body-only-elements.ts
index b1978ae50..302140bb7 100644
--- a/javascript/packages/linter/src/rules/html-body-only-elements.ts
+++ b/javascript/packages/linter/src/rules/html-body-only-elements.ts
@@ -5,26 +5,37 @@ import type { LintOffense, LintContext } from "../types.js"
 import type { HTMLElementNode, ParseResult } from "@herb-tools/core"
 
 class HTMLBodyOnlyElementsVisitor extends BaseRuleVisitor {
-  private isInHead = false
+  private elementStack: string[] = []
 
   visitHTMLElementNode(node: HTMLElementNode): void {
-    const tagName = getTagName(node.open_tag)
+    const tagName = getTagName(node.open_tag)?.toLowerCase()
     if (!tagName) return
 
-    const previousIsInHead = this.isInHead
-    if (tagName.toLowerCase() === "head") this.isInHead = true
-
-    if (this.isInHead && isBodyOnlyTag(tagName)) {
-      this.addOffense(
-        `Element \`<${tagName}>\` must be placed inside the \`<body>\` tag.`,
-        node.location,
-        "error"
-      )
-    }
+    this.checkBodyOnlyElement(node, tagName)
 
+    this.elementStack.push(tagName)
     this.visitChildNodes(node)
+    this.elementStack.pop()
+  }
+
+  private checkBodyOnlyElement(node: HTMLElementNode, tagName: string): void {
+    if (this.insideBody) return
+    if (!this.insideHead) return
+    if (!isBodyOnlyTag(tagName)) return
+
+    this.addOffense(
+      `Element \`<${tagName}>\` must be placed inside the \`<body>\` tag.`,
+      node.location,
+      "error"
+    )
+  }
 
-    this.isInHead = previousIsInHead
+  private get insideBody(): boolean {
+    return this.elementStack.includes("body")
+  }
+
+  private get insideHead(): boolean {
+    return this.elementStack.includes("head")
   }
 }
 
@@ -32,6 +43,13 @@ export class HTMLBodyOnlyElementsRule extends ParserRule {
   static autocorrectable = false
   name = "html-body-only-elements"
 
+  isEnabled(_result: ParseResult, context?: Partial<LintContext>): boolean {
+    if (context?.fileName?.endsWith(".xml")) return false
+    if (context?.fileName?.endsWith(".xml.erb")) return false
+
+    return true
+  }
+
   check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new HTMLBodyOnlyElementsVisitor(this.name, context)
 
diff --git a/javascript/packages/linter/src/rules/html-head-only-elements.ts b/javascript/packages/linter/src/rules/html-head-only-elements.ts
new file mode 100644
index 000000000..35ee2638f
--- /dev/null
+++ b/javascript/packages/linter/src/rules/html-head-only-elements.ts
@@ -0,0 +1,60 @@
+import { ParserRule } from "../types"
+import { BaseRuleVisitor, getTagName, isHeadOnlyTag } from "./rule-utils"
+
+import type { ParseResult, HTMLElementNode } from "@herb-tools/core"
+import type { LintOffense, LintContext } from "../types"
+
+class HeadOnlyElementsVisitor extends BaseRuleVisitor {
+  private elementStack: string[] = []
+
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    const tagName = getTagName(node)?.toLowerCase()
+    if (!tagName) return
+
+    this.checkHeadOnlyElement(node, tagName)
+
+    this.elementStack.push(tagName)
+    this.visitChildNodes(node)
+    this.elementStack.pop()
+  }
+
+  private checkHeadOnlyElement(node: HTMLElementNode, tagName: string): void {
+    if (this.insideHead) return
+    if (!isHeadOnlyTag(tagName)) return
+    if (tagName === "title" && this.insideSVG) return
+
+    this.addOffense(
+      `Element \`<${tagName}>\` must be placed inside the \`<head>\` tag.`,
+      node.location,
+      "error"
+    )
+  }
+
+  private get insideHead(): boolean {
+    return this.elementStack.includes("head")
+  }
+
+  private get insideSVG(): boolean {
+    return this.elementStack.includes("svg")
+  }
+}
+
+export class HTMLHeadOnlyElementsRule extends ParserRule {
+  static autocorrectable = false
+  name = "html-head-only-elements"
+
+  isEnabled(_result: ParseResult, context?: Partial<LintContext>): boolean {
+    if (context?.fileName?.endsWith(".xml")) return false
+    if (context?.fileName?.endsWith(".xml.erb")) return false
+
+    return true
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new HeadOnlyElementsVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}
diff --git a/javascript/packages/linter/src/rules/index.ts b/javascript/packages/linter/src/rules/index.ts
index f3f7490e1..2fc6f2208 100644
--- a/javascript/packages/linter/src/rules/index.ts
+++ b/javascript/packages/linter/src/rules/index.ts
@@ -21,6 +21,7 @@ export * from "./html-attribute-values-require-quotes.js"
 export * from "./html-avoid-both-disabled-and-aria-disabled.js"
 export * from "./html-body-only-elements.js"
 export * from "./html-boolean-attributes-no-value.js"
+export * from "./html-head-only-elements.js"
 export * from "./html-iframe-has-title.js"
 export * from "./html-img-require-alt.js"
 export * from "./html-input-require-autocomplete.js"
diff --git a/javascript/packages/linter/src/rules/rule-utils.ts b/javascript/packages/linter/src/rules/rule-utils.ts
index 5d45f1f9a..56cbdf1b2 100644
--- a/javascript/packages/linter/src/rules/rule-utils.ts
+++ b/javascript/packages/linter/src/rules/rule-utils.ts
@@ -17,6 +17,7 @@ import type {
   HTMLAttributeNameNode,
   HTMLAttributeNode,
   HTMLAttributeValueNode,
+  HTMLElementNode,
   HTMLOpenTagNode,
   LiteralNode,
   LexResult,
@@ -172,7 +173,7 @@ export function getAttributes(node: HTMLOpenTagNode): HTMLAttributeNode[] {
 /**
  * Gets the tag name from an HTML tag node (lowercased)
  */
-export function getTagName(node: HTMLOpenTagNode | null | undefined): string | null {
+export function getTagName(node: HTMLElementNode | HTMLOpenTagNode | null | undefined): string | null {
   if (!node) return null
 
   return node.tag_name?.value.toLowerCase() || null
diff --git a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
index b0b58f9dd..c75359a0c 100644
--- a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
+++ b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
@@ -574,7 +574,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for bad file 1`]
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 38,
+    "ruleCount": 39,
     "totalErrors": 2,
     "totalOffenses": 2,
     "totalWarnings": 0,
@@ -592,7 +592,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for clean file 1`
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 0,
-    "ruleCount": 38,
+    "ruleCount": 39,
     "totalErrors": 0,
     "totalOffenses": 0,
     "totalWarnings": 0,
@@ -662,7 +662,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for file with err
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 38,
+    "ruleCount": 39,
     "totalErrors": 3,
     "totalOffenses": 3,
     "totalWarnings": 0,
diff --git a/javascript/packages/linter/test/rules/html-head-only-elements.test.ts b/javascript/packages/linter/test/rules/html-head-only-elements.test.ts
new file mode 100644
index 000000000..36d1ea16d
--- /dev/null
+++ b/javascript/packages/linter/test/rules/html-head-only-elements.test.ts
@@ -0,0 +1,260 @@
+import dedent from "dedent"
+
+import { describe, test } from "vitest"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
+import { HTMLHeadOnlyElementsRule } from "../../src/rules/html-head-only-elements.js"
+
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLHeadOnlyElementsRule)
+
+describe("html-head-only-elements", () => {
+  test("passes when head-only elements are inside head", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <title>My Page</title>
+          <meta charset="UTF-8">
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          <link rel="stylesheet" href="/styles.css">
+          <style>body { color: red }</style>
+          <base href="/">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("passes when ERB helpers are inside head", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <%= csrf_meta_tags %>
+          <%= csp_meta_tag %>
+          <%= favicon_link_tag 'favicon.ico' %>
+          <%= stylesheet_link_tag "application", "data-turbo-track": "reload" %>
+          <title><%= content_for?(:title) ? yield(:title) : "Default Title" %></title>
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when title is in body", () => {
+    expectError("Element `<title>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+        </head>
+        <body>
+          <title>My Page</title>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when meta is in body", () => {
+    expectError("Element `<meta>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+        </head>
+        <body>
+          <meta charset="UTF-8">
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when link is in body", () => {
+    expectError("Element `<link>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+        </head>
+        <body>
+          <link rel="stylesheet" href="/styles.css">
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when style is in body", () => {
+    expectError("Element `<style>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+        </head>
+        <body>
+          <style>body { color: red }</style>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when base is in body", () => {
+    expectError("Element `<base>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+        </head>
+        <body>
+          <base href="/">
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails for multiple head-only elements in body", () => {
+    expectError("Element `<title>` must be placed inside the `<head>` tag.")
+    expectError("Element `<meta>` must be placed inside the `<head>` tag.")
+    expectError("Element `<link>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+        </head>
+        <body>
+          <title>My Page</title>
+          <meta charset="UTF-8">
+          <link rel="stylesheet" href="/styles.css">
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when elements are outside html structure", () => {
+    expectError("Element `<title>` must be placed inside the `<head>` tag.")
+    expectError("Element `<meta>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <title>My Page</title>
+      <meta charset="UTF-8">
+
+      <html>
+        <head>
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("works with ERB templates in body", () => {
+    expectError("Element `<title>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+        </head>
+        <body>
+          <%= csrf_meta_tags %>
+          <%= csp_meta_tag %>
+          <%= favicon_link_tag 'favicon.ico' %>
+          <%= stylesheet_link_tag "application", "data-turbo-track": "reload" %>
+          <title><%= content_for?(:title) ? yield(:title) : "Default Title" %></title>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("allows other elements in body", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <title>My Page</title>
+        </head>
+        <body>
+          <h1>Welcome</h1>
+          <p>This is content</p>
+          <div>
+            <span>Some text</span>
+          </div>
+        </body>
+      </html>
+    `)
+  })
+
+  test("allows title element inside SVG", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <title>My Page</title>
+        </head>
+        <body>
+          <svg>
+            <title>Chart Title</title>
+            <rect width="100" height="100"/>
+          </svg>
+        </body>
+      </html>
+    `)
+  })
+
+  test("allows nested title elements inside nested SVG", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <title>My Page</title>
+        </head>
+        <body>
+          <div>
+            <svg>
+              <g>
+                <title>Group Title</title>
+                <rect width="100" height="100"/>
+              </g>
+            </svg>
+          </div>
+        </body>
+      </html>
+    `)
+  })
+
+  test("still fails for other head-only elements inside SVG", () => {
+    expectError("Element `<meta>` must be placed inside the `<head>` tag.")
+    expectError("Element `<link>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <title>My Page</title>
+        </head>
+        <body>
+          <svg>
+            <meta charset="UTF-8" />
+            <link rel="stylesheet" href="/styles.css" />
+            <title>Chart Title</title>
+          </svg>
+        </body>
+      </html>
+    `)
+  })
+
+  test.todo("head in body", () => {
+    expectError("Element `<head>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <body>
+          <head></head>
+        </body>
+      </html>
+    `)
+  })
+})
diff --git a/javascript/packages/vscode/package.json b/javascript/packages/vscode/package.json
index 5b11c55d1..cb860960a 100644
--- a/javascript/packages/vscode/package.json
+++ b/javascript/packages/vscode/package.json
@@ -83,6 +83,7 @@
               "html-avoid-both-disabled-and-aria-disabled",
               "html-body-only-elements",
               "html-boolean-attributes-no-value",
+              "html-head-only-elements",
               "html-iframe-has-title",
               "html-img-require-alt",
               "html-input-require-autocomplete",

From 22242c9b6f163613f702bbf414cec95bb7896ea6 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Tue, 14 Oct 2025 20:55:34 +0200
Subject: [PATCH 64/97] Linter: Implement `html-no-duplicate-meta-names` linter
 rule (#383)

Resolves #381
---
 .../packages/linter/docs/rules/README.md      |   1 +
 .../rules/html-no-duplicate-meta-names.md     |  64 ++
 .../packages/linter/src/default-rules.ts      |   2 +
 .../src/rules/html-no-duplicate-meta-names.ts | 182 ++++++
 javascript/packages/linter/src/rules/index.ts |   1 +
 .../test/__snapshots__/cli.test.ts.snap       |   6 +-
 .../html-no-duplicate-meta-names.test.ts      | 552 ++++++++++++++++++
 javascript/packages/vscode/package.json       |   1 +
 .../packages/vscode/scripts/sync-defaults.js  |   2 +-
 9 files changed, 807 insertions(+), 4 deletions(-)
 create mode 100644 javascript/packages/linter/docs/rules/html-no-duplicate-meta-names.md
 create mode 100644 javascript/packages/linter/src/rules/html-no-duplicate-meta-names.ts
 create mode 100644 javascript/packages/linter/test/rules/html-no-duplicate-meta-names.test.ts

diff --git a/javascript/packages/linter/docs/rules/README.md b/javascript/packages/linter/docs/rules/README.md
index f8d511966..5a1361f2a 100644
--- a/javascript/packages/linter/docs/rules/README.md
+++ b/javascript/packages/linter/docs/rules/README.md
@@ -35,6 +35,7 @@ This page contains documentation for all Herb Linter rules.
 - [`html-no-block-inside-inline`](./html-no-block-inside-inline.md) - Prevents block-level elements inside inline elements
 - [`html-no-duplicate-attributes`](./html-no-duplicate-attributes.md) - Prevents duplicate attributes on HTML elements
 - [`html-no-duplicate-ids`](./html-no-duplicate-ids.md) - Prevents duplicate IDs within a document
+- [`html-no-duplicate-meta-names`](./html-no-duplicate-meta-names.md) - Duplicate `<meta>` name attributes are not allowed.
 - [`html-no-empty-attributes`](./html-no-empty-attributes.md) - Attributes must not have empty values
 - [`html-no-nested-links`](./html-no-nested-links.md) - Prevents nested anchor tags
 - [`html-no-positive-tab-index`](./html-no-positive-tab-index.md) - Avoid positive `tabindex` values
diff --git a/javascript/packages/linter/docs/rules/html-no-duplicate-meta-names.md b/javascript/packages/linter/docs/rules/html-no-duplicate-meta-names.md
new file mode 100644
index 000000000..bb38e1c62
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/html-no-duplicate-meta-names.md
@@ -0,0 +1,64 @@
+# Linter Rule: Duplicate `<meta>` name attributes are not allowed
+
+**Rule:** `html-no-duplicate-meta-names`
+
+## Description
+
+Warn when multiple `<meta>` tags share the same `name` or `http-equiv` attribute within the same `<head>` block, unless they are wrapped in conditional comments.
+
+## Rationale
+
+In HTML, duplicate `<meta>` tags with the same `name` or `http-equiv` can cause unexpected behavior. For example, search engines or social sharing tools may use the wrong value. These duplicates are often the result of copy-paste or partial rendering logic and should be avoided.
+
+## Examples
+
+### ✅ Good
+
+```erb
+<head>
+  <meta name="description" content="Welcome to our site">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+</head>
+```
+
+```erb
+<head>
+  <% if mobile? %>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <% else %>
+    <meta name="viewport" content="width=1024">
+  <% end %>
+</head>
+```
+
+### 🚫 Bad
+
+```erb
+<head>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta name="viewport" content="width=1024">
+</head>
+```
+
+```erb
+<head>
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta http-equiv="X-UA-Compatible" content="chrome=1">
+</head>
+```
+
+```erb
+<head>
+  <meta name="viewport" content="width=1024">
+
+  <% if mobile? %>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <% else %>
+    <meta http-equiv="refresh" content="30">  
+  <% end %>
+</head>
+```
+
+## References
+
+\-
diff --git a/javascript/packages/linter/src/default-rules.ts b/javascript/packages/linter/src/default-rules.ts
index 1b9866520..4655eaf85 100644
--- a/javascript/packages/linter/src/default-rules.ts
+++ b/javascript/packages/linter/src/default-rules.ts
@@ -32,6 +32,7 @@ import { HTMLNoAriaHiddenOnFocusableRule } from "./rules/html-no-aria-hidden-on-
 // import { HTMLNoBlockInsideInlineRule } from "./rules/html-no-block-inside-inline.js"
 import { HTMLNoDuplicateAttributesRule } from "./rules/html-no-duplicate-attributes.js"
 import { HTMLNoDuplicateIdsRule } from "./rules/html-no-duplicate-ids.js"
+import { HTMLNoDuplicateMetaNamesRule } from "./rules/html-no-duplicate-meta-names.js"
 import { HTMLNoEmptyAttributesRule } from "./rules/html-no-empty-attributes.js"
 import { HTMLNoEmptyHeadingsRule } from "./rules/html-no-empty-headings.js"
 import { HTMLNoNestedLinksRule } from "./rules/html-no-nested-links.js"
@@ -79,6 +80,7 @@ export const defaultRules: RuleClass[] = [
   // HTMLNoBlockInsideInlineRule,
   HTMLNoDuplicateAttributesRule,
   HTMLNoDuplicateIdsRule,
+  HTMLNoDuplicateMetaNamesRule,
   HTMLNoEmptyAttributesRule,
   HTMLNoEmptyHeadingsRule,
   HTMLNoNestedLinksRule,
diff --git a/javascript/packages/linter/src/rules/html-no-duplicate-meta-names.ts b/javascript/packages/linter/src/rules/html-no-duplicate-meta-names.ts
new file mode 100644
index 000000000..ebe45ff5e
--- /dev/null
+++ b/javascript/packages/linter/src/rules/html-no-duplicate-meta-names.ts
@@ -0,0 +1,182 @@
+import { isHTMLElementNode } from "@herb-tools/core"
+import { getTagName, getAttributeName, getAttributeValue, forEachAttribute } from "./rule-utils"
+
+import { ControlFlowTrackingVisitor, ControlFlowType } from "./rule-utils"
+import { ParserRule, BaseAutofixContext } from "../types"
+
+import type { ParseResult, HTMLElementNode, HTMLAttributeNode } from "@herb-tools/core"
+import type { LintOffense, LintContext } from "../types"
+
+interface MetaTag {
+  node: HTMLElementNode
+  nameValue?: string
+  httpEquivValue?: string
+}
+
+interface ControlFlowState {
+  previousBranchMetas: MetaTag[]
+  previousControlFlowMetas: MetaTag[]
+}
+
+interface BranchState {
+  previousBranchMetas: MetaTag[]
+}
+
+class HTMLNoDuplicateMetaNamesVisitor extends ControlFlowTrackingVisitor<BaseAutofixContext, ControlFlowState, BranchState> {
+  private elementStack: string[] = []
+  private documentMetas: MetaTag[] = []
+  private currentBranchMetas: MetaTag[] = []
+  private controlFlowMetas: MetaTag[] = []
+
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    const tagName = getTagName(node)?.toLowerCase()
+    if (!tagName) return
+
+    if (tagName === "head") {
+      this.documentMetas = []
+      this.currentBranchMetas = []
+      this.controlFlowMetas = []
+    } else if (tagName === "meta" && this.insideHead) {
+      this.collectAndCheckMetaTag(node)
+    }
+
+    this.elementStack.push(tagName)
+    this.visitChildNodes(node)
+    this.elementStack.pop()
+  }
+
+  protected onEnterControlFlow(_controlFlowType: ControlFlowType, wasAlreadyInControlFlow: boolean): ControlFlowState {
+    const stateToRestore: ControlFlowState = {
+      previousBranchMetas: this.currentBranchMetas,
+      previousControlFlowMetas: this.controlFlowMetas
+    }
+
+    this.currentBranchMetas = []
+
+    if (!wasAlreadyInControlFlow) {
+      this.controlFlowMetas = []
+    }
+
+    return stateToRestore
+  }
+
+  protected onExitControlFlow(controlFlowType: ControlFlowType, wasAlreadyInControlFlow: boolean, stateToRestore: ControlFlowState): void {
+    if (controlFlowType === ControlFlowType.CONDITIONAL && !wasAlreadyInControlFlow) {
+      this.controlFlowMetas.forEach(meta => this.documentMetas.push(meta))
+    }
+
+    this.currentBranchMetas = stateToRestore.previousBranchMetas
+    this.controlFlowMetas = stateToRestore.previousControlFlowMetas
+  }
+
+  protected onEnterBranch(): BranchState {
+    const stateToRestore: BranchState = {
+      previousBranchMetas: this.currentBranchMetas
+    }
+
+    if (this.isInControlFlow) {
+      this.currentBranchMetas = []
+    }
+
+    return stateToRestore
+  }
+
+  protected onExitBranch(_stateToRestore: BranchState): void {}
+
+  private get insideHead(): boolean {
+    return this.elementStack.includes("head")
+  }
+
+  private collectAndCheckMetaTag(node: HTMLElementNode): void {
+    const metaTag: MetaTag = { node }
+    this.extractAttributes(node, metaTag)
+
+    if (!metaTag.nameValue && !metaTag.httpEquivValue) return
+
+    if (this.isInControlFlow) {
+      this.handleControlFlowMeta(metaTag)
+    } else {
+      this.handleGlobalMeta(metaTag)
+    }
+
+    this.currentBranchMetas.push(metaTag)
+  }
+
+  private extractAttributes(node: HTMLElementNode, metaTag: MetaTag): void {
+    if (isHTMLElementNode(node) && node.open_tag) {
+      forEachAttribute(node.open_tag as any, (attributeNode: HTMLAttributeNode) => {
+        const name = getAttributeName(attributeNode)
+        const value = getAttributeValue(attributeNode)?.trim()
+
+        if (name === "name" && value) {
+          metaTag.nameValue = value
+        } else if (name === "http-equiv" && value) {
+          metaTag.httpEquivValue = value
+        }
+      })
+    }
+  }
+
+  private handleControlFlowMeta(metaTag: MetaTag): void {
+    if (this.currentControlFlowType === ControlFlowType.LOOP) {
+      this.checkAgainstMetaList(metaTag, this.currentBranchMetas, "within the same loop iteration")
+    } else {
+      this.checkAgainstMetaList(metaTag, this.currentBranchMetas, "within the same control flow branch")
+      this.checkAgainstMetaList(metaTag, this.documentMetas, "")
+
+      this.controlFlowMetas.push(metaTag)
+    }
+  }
+
+  private handleGlobalMeta(metaTag: MetaTag): void {
+    this.checkAgainstMetaList(metaTag, this.documentMetas, "")
+    this.documentMetas.push(metaTag)
+  }
+
+  private checkAgainstMetaList(metaTag: MetaTag, existingMetas: MetaTag[], context: string): void {
+    for (const existing of existingMetas) {
+      if (this.areMetaTagsDuplicate(metaTag, existing)) {
+        const attributeDescription = metaTag.nameValue
+          ? `\`name="${metaTag.nameValue}"\``
+          : `\`http-equiv="${metaTag.httpEquivValue}"\``
+
+        const attributeType = metaTag.nameValue ? "Meta names" : "`http-equiv` values"
+
+        const contextMsg = context ? ` ${context}` : ""
+
+        this.addOffense(
+          `Duplicate \`<meta>\` tag with ${attributeDescription}${contextMsg}. ${attributeType} should be unique within the \`<head>\` section.`,
+          metaTag.node.location,
+          "error"
+        )
+
+        return
+      }
+    }
+  }
+
+  private areMetaTagsDuplicate(meta1: MetaTag, meta2: MetaTag): boolean {
+    if (meta1.nameValue && meta2.nameValue) {
+      return meta1.nameValue.toLowerCase() === meta2.nameValue.toLowerCase()
+    }
+
+    if (meta1.httpEquivValue && meta2.httpEquivValue) {
+      return meta1.httpEquivValue.toLowerCase() === meta2.httpEquivValue.toLowerCase()
+    }
+
+    return false
+  }
+}
+
+export class HTMLNoDuplicateMetaNamesRule extends ParserRule {
+  static autocorrectable = false
+  name = "html-no-duplicate-meta-names"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new HTMLNoDuplicateMetaNamesVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}
diff --git a/javascript/packages/linter/src/rules/index.ts b/javascript/packages/linter/src/rules/index.ts
index 2fc6f2208..0c7eac722 100644
--- a/javascript/packages/linter/src/rules/index.ts
+++ b/javascript/packages/linter/src/rules/index.ts
@@ -30,6 +30,7 @@ export * from "./html-no-aria-hidden-on-focusable.js"
 export * from "./html-no-block-inside-inline.js"
 export * from "./html-no-duplicate-attributes.js"
 export * from "./html-no-duplicate-ids.js"
+export * from "./html-no-duplicate-meta-names.js"
 export * from "./html-no-empty-attributes.js"
 export * from "./html-no-empty-headings.js"
 export * from "./html-no-nested-links.js"
diff --git a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
index c75359a0c..1eb932445 100644
--- a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
+++ b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
@@ -574,7 +574,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for bad file 1`]
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 39,
+    "ruleCount": 40,
     "totalErrors": 2,
     "totalOffenses": 2,
     "totalWarnings": 0,
@@ -592,7 +592,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for clean file 1`
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 0,
-    "ruleCount": 39,
+    "ruleCount": 40,
     "totalErrors": 0,
     "totalOffenses": 0,
     "totalWarnings": 0,
@@ -662,7 +662,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for file with err
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 39,
+    "ruleCount": 40,
     "totalErrors": 3,
     "totalOffenses": 3,
     "totalWarnings": 0,
diff --git a/javascript/packages/linter/test/rules/html-no-duplicate-meta-names.test.ts b/javascript/packages/linter/test/rules/html-no-duplicate-meta-names.test.ts
new file mode 100644
index 000000000..14e5c2b41
--- /dev/null
+++ b/javascript/packages/linter/test/rules/html-no-duplicate-meta-names.test.ts
@@ -0,0 +1,552 @@
+import dedent from "dedent"
+
+import { describe, test } from "vitest"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
+
+import { HTMLNoDuplicateMetaNamesRule } from "../../src/rules/html-no-duplicate-meta-names.js"
+
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoDuplicateMetaNamesRule)
+
+describe("html-no-duplicate-meta-names", () => {
+  test("passes when meta names are unique", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <meta name="description" content="Welcome to our site">
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          <meta name="author" content="John Doe">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("passes when http-equiv values are unique", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+          <meta http-equiv="X-UA-Compatible" content="IE=edge">
+          <meta http-equiv="refresh" content="30">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("passes when mixing name and http-equiv attributes", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <meta name="description" content="Welcome to our site">
+          <meta http-equiv="X-UA-Compatible" content="IE=edge">
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when meta names are duplicated", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          <meta name="viewport" content="width=1024">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when http-equiv values are duplicated", () => {
+    expectError('Duplicate `<meta>` tag with `http-equiv="X-UA-Compatible"`. `http-equiv` values should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <meta http-equiv="X-UA-Compatible" content="IE=edge">
+          <meta http-equiv="X-UA-Compatible" content="chrome=1">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("handles case insensitive duplicates", () => {
+    expectError('Duplicate `<meta>` tag with `name="description"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <meta name="Description" content="Welcome to our site">
+          <meta name="description" content="Another description">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails with multiple duplicates", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+    expectError('Duplicate `<meta>` tag with `name="description"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          <meta name="viewport" content="width=1024">
+          <meta name="description" content="First description">
+          <meta name="description" content="Second description">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("ignores meta tags without name or http-equiv attributes", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <meta charset="UTF-8">
+          <meta charset="ISO-8859-1">
+          <meta property="og:title" content="Page Title">
+          <meta property="og:title" content="Another Title">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("only checks meta tags inside head", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        </head>
+        <body>
+          <meta name="viewport" content="width=1024">
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("works with ERB templates", () => {
+    expectError('Duplicate `<meta>` tag with `name="description"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <meta name="description" content="<%= @page_description %>">
+          <meta name="description" content="<%= @fallback_description %>">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("handles self-closing meta tags", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+          <meta name="viewport" content="width=1024" />
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("handles mixed name and http-equiv duplicates", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+    expectError('Duplicate `<meta>` tag with `http-equiv="refresh"`. `http-equiv` values should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          <meta name="viewport" content="width=1024">
+          <meta http-equiv="refresh" content="30">
+          <meta http-equiv="refresh" content="60">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("handles erb conditionals", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <% if mobile? %>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <% elsif hotwire_native_app? %>
+          <meta name="viewport" content="width=1024">
+        <% else %>
+          <meta name="viewport" content="width=1024">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("detects duplicates when meta tags are outside and inside erb conditionals", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <meta name="viewport" content="width=1024">
+
+        <% if mobile? %>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("detects duplicates between global meta tag and erb else branch", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <meta name="viewport" content="width=1024">
+
+        <% if mobile? %>
+          <meta http-equiv="refresh" content="30">
+        <% else %>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("detects duplicates when meta tag is outside erb conditional block", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <% if mobile? %>
+          <meta http-equiv="refresh" content="30">
+        <% else %>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <% end %>
+
+        <meta name="viewport" content="width=1024">
+      </head>
+    `)
+  })
+
+  test("handles nested erb conditionals", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <% if mobile? %>
+          <% if ios? %>
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          <% else %>
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          <% end %>
+        <% end %>
+      </head>
+    `)
+  })
+
+  test.todo("detects duplicates in nested conditionals within same execution path", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the same control flow branch.')
+
+    assertOffenses(dedent`
+      <head>
+        <% if mobile? %>
+          <meta name="viewport" content="width=device-width">
+          <% if ios? %>
+            <meta name="viewport" content="width=1024">
+          <% end %>
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("detects static duplicate meta tags in loops", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"` within the same control flow branch. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <% items.each do |item| %>
+          <meta name="viewport" content="width=device-width">
+          <meta name="viewport" content="width=1024">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("allows dynamic meta tags in loops", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <% keywords.each do |keyword| %>
+          <meta name="keyword" content="<%= keyword %>">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("detects duplicate in loop and outside loop", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <meta name="viewport" content="width=1024">
+        <% items.each do |item| %>
+          <meta name="viewport" content="width=device-width">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("resets checking for each head tag", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <meta name="viewport" content="width=device-width">
+        </head>
+        <body>
+          <h1>First document</h1>
+        </body>
+      </html>
+      <html>
+        <head>
+          <meta name="viewport" content="width=1024">
+        </head>
+        <body>
+          <h1>Second document</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("detects duplicates within each head tag separately", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+    expectError('Duplicate `<meta>` tag with `name="description"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <meta name="viewport" content="width=device-width">
+          <meta name="viewport" content="width=1024">
+        </head>
+      </html>
+      <html>
+        <head>
+          <meta name="description" content="First">
+          <meta name="description" content="Second">
+        </head>
+      </html>
+    `)
+  })
+
+  test("handles meta tags with whitespace in attribute values", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <meta name="  viewport  " content="width=device-width">
+        <meta name="viewport" content="width=1024">
+      </head>
+    `)
+  })
+
+  test("treats empty name attributes as different from missing", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <meta name="" content="value1">
+        <meta name="" content="value2">
+        <meta content="value3">
+        <meta content="value4">
+      </head>
+    `)
+  })
+
+  test("detects duplicates in elsif branches", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"` within the same control flow branch. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <% if mobile? %>
+          <meta name="description" content="Mobile">
+        <% elsif tablet? %>
+          <meta name="viewport" content="width=device-width">
+          <meta name="viewport" content="width=1024">
+        <% else %>
+          <meta name="description" content="Desktop">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("allows same meta across if and elsif branches", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <% if mobile? %>
+          <meta name="viewport" content="width=device-width">
+        <% elsif tablet? %>
+          <meta name="viewport" content="width=1024">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("handles conditional inside loop", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <% items.each do |item| %>
+          <% if item.mobile? %>
+            <meta name="viewport" content="<%= item.viewport %>">
+          <% end %>
+        <% end %>
+      </head>
+    `)
+  })
+
+  test.todo("detects static duplicate in conditional inside loop", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the same loop iteration.')
+
+    assertOffenses(dedent`
+      <head>
+        <% items.each do |item| %>
+          <% if item.mobile? %>
+            <meta name="viewport" content="mobile">
+          <% else %>
+            <meta name="viewport" content="desktop">
+          <% end %>
+          <meta name="viewport" content="always">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("handles http-equiv case insensitivity", () => {
+    expectError('Duplicate `<meta>` tag with `http-equiv="x-ua-compatible"`. `http-equiv` values should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <meta http-equiv="X-UA-Compatible" content="IE=edge">
+        <meta http-equiv="x-ua-compatible" content="chrome=1">
+      </head>
+    `)
+  })
+
+  test("detects all duplicate occurrences when there are three or more", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <meta name="viewport" content="first">
+        <meta name="viewport" content="second">
+        <meta name="viewport" content="third">
+      </head>
+    `)
+  })
+
+  test("handles ERB output in name attribute", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <meta name="<%= meta_name_1 %>" content="value1">
+        <meta name="<%= meta_name_2 %>" content="value2">
+      </head>
+    `)
+  })
+
+  test.todo("detects duplicates with partial ERB in name", () => {
+    expectError('Duplicate `<meta>` tag with `name="prefix-viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <meta name="prefix-viewport" content="value1">
+        <meta name="prefix-<%= 'viewport' %>" content="value2">
+      </head>
+    `)
+  })
+
+  test("handles unless conditionals", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <% unless mobile? %>
+          <meta name="viewport" content="width=1024">
+        <% else %>
+          <meta name="viewport" content="width=device-width">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("detects duplicates in unless branch", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"` within the same control flow branch. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <% unless mobile? %>
+          <meta name="viewport" content="width=1024">
+          <meta name="viewport" content="width=768">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("handles document without head tag", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <body>
+          <meta name="viewport" content="width=device-width">
+          <meta name="viewport" content="width=1024">
+        </body>
+      </html>
+    `)
+  })
+
+  test("detects duplicate when meta has both name and http-equiv (edge case)", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <meta name="viewport" http-equiv="refresh" content="value1">
+        <meta name="viewport" content="value2">
+      </head>
+    `)
+  })
+
+  test("allows same meta in different loop iterations with conditionals", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <% items.each do |item| %>
+          <% if item.active? %>
+            <meta name="status" content="<%= item.id %>">
+          <% end %>
+        <% end %>
+      </head>
+    `)
+  })
+})
diff --git a/javascript/packages/vscode/package.json b/javascript/packages/vscode/package.json
index cb860960a..149466ce1 100644
--- a/javascript/packages/vscode/package.json
+++ b/javascript/packages/vscode/package.json
@@ -92,6 +92,7 @@
               "html-no-block-inside-inline",
               "html-no-duplicate-attributes",
               "html-no-duplicate-ids",
+              "html-no-duplicate-meta-names",
               "html-no-empty-attributes",
               "html-no-empty-headings",
               "html-no-nested-links",
diff --git a/javascript/packages/vscode/scripts/sync-defaults.js b/javascript/packages/vscode/scripts/sync-defaults.js
index a177af031..892b0c702 100644
--- a/javascript/packages/vscode/scripts/sync-defaults.js
+++ b/javascript/packages/vscode/scripts/sync-defaults.js
@@ -18,7 +18,7 @@ function extractLinterRuleNames() {
     if (file.endsWith('.ts') && file !== 'index.ts' && file !== 'rule-utils.ts') {
       const filePath = path.join(rulesDir, file);
       const content = fs.readFileSync(filePath, 'utf8');
-      const match = content.match(/name\s*=\s*["']([^"']+)["']/);
+      const match = content.match(/  name\s*=\s*["']([^"']+)["']/);
 
       if (match) {
         ruleNames.push(match[1]);

From fc4de2bff04038e1084d900cb2e08ec0f44312ac Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Tue, 14 Oct 2025 21:15:14 +0200
Subject: [PATCH 65/97] Linter Rule: Allow head-only elements on top level
 (#641)

This pull request updates the `html-head-only-elements` linter rule to
allow head-only elements on the top-level, like:

```html
<meta>
<link>
<base>
<title></title>
<style></style>
```

This is useful, when the content of `<head>` element in the layout is
extracted to a partial, so that the partial itself doesn't contain the
`<head>` element directly. This is now allowed.
---
 .../src/rules/html-head-only-elements.ts      |  5 ++++
 .../rules/html-head-only-elements.test.ts     | 25 ++++++++++++++++++-
 2 files changed, 29 insertions(+), 1 deletion(-)

diff --git a/javascript/packages/linter/src/rules/html-head-only-elements.ts b/javascript/packages/linter/src/rules/html-head-only-elements.ts
index 35ee2638f..2cf9937b0 100644
--- a/javascript/packages/linter/src/rules/html-head-only-elements.ts
+++ b/javascript/packages/linter/src/rules/html-head-only-elements.ts
@@ -20,6 +20,7 @@ class HeadOnlyElementsVisitor extends BaseRuleVisitor {
 
   private checkHeadOnlyElement(node: HTMLElementNode, tagName: string): void {
     if (this.insideHead) return
+    if (!this.insideBody) return
     if (!isHeadOnlyTag(tagName)) return
     if (tagName === "title" && this.insideSVG) return
 
@@ -34,6 +35,10 @@ class HeadOnlyElementsVisitor extends BaseRuleVisitor {
     return this.elementStack.includes("head")
   }
 
+  private get insideBody(): boolean {
+    return this.elementStack.includes("body")
+  }
+
   private get insideSVG(): boolean {
     return this.elementStack.includes("svg")
   }
diff --git a/javascript/packages/linter/test/rules/html-head-only-elements.test.ts b/javascript/packages/linter/test/rules/html-head-only-elements.test.ts
index 36d1ea16d..97a3c28bd 100644
--- a/javascript/packages/linter/test/rules/html-head-only-elements.test.ts
+++ b/javascript/packages/linter/test/rules/html-head-only-elements.test.ts
@@ -57,6 +57,28 @@ describe("html-head-only-elements", () => {
     `)
   })
 
+  test("passes for head-only elements on the top-level", () => {
+    expectNoOffenses(dedent`
+      <meta>
+      <link>
+      <base>
+      <title></title>
+      <style></style>
+    `)
+  })
+
+  test.todo("fails for head-only elements on the top-level when other body-elements are present", () => {
+    expectNoOffenses(dedent`
+      <meta>
+      <link>
+      <base>
+      <title></title>
+      <style></style>
+
+      <div></div>
+    `)
+  })
+
   test("fails when meta is in body", () => {
     expectError("Element `<meta>` must be placed inside the `<head>` tag.")
 
@@ -136,7 +158,8 @@ describe("html-head-only-elements", () => {
     `)
   })
 
-  test("fails when elements are outside html structure", () => {
+  // TODO: this should be handled in https://github.com/marcoroth/herb/issues/638
+  test.fails("fails when elements are outside html structure", () => {
     expectError("Element `<title>` must be placed inside the `<head>` tag.")
     expectError("Element `<meta>` must be placed inside the `<head>` tag.")
 

From d1fc886e481a9a43459326be30ee9fd3727292ec Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Tue, 14 Oct 2025 22:34:36 +0200
Subject: [PATCH 66/97] Linter: Implement Autofix for `html-no-space-in-tag`
 linter rule (#642)

This pull request implements the autofix function for the
`html-no-space-in-tag` linter rule, so that this rule can be
autocorrected when running the Herb Linter CLI using `--fix`.
---
 javascript/packages/linter/src/linter.ts      |   5 +-
 .../linter/src/rules/html-no-space-in-tag.ts  |  93 +++-
 .../html-no-space-in-tag.autofix.test.ts      | 410 ++++++++++++++++++
 3 files changed, 493 insertions(+), 15 deletions(-)
 create mode 100644 javascript/packages/linter/test/autofix/html-no-space-in-tag.autofix.test.ts

diff --git a/javascript/packages/linter/src/linter.ts b/javascript/packages/linter/src/linter.ts
index 5b7926a19..1749e2290 100644
--- a/javascript/packages/linter/src/linter.ts
+++ b/javascript/packages/linter/src/linter.ts
@@ -1,4 +1,5 @@
 import { defaultRules } from "./default-rules.js"
+import { Location } from "@herb-tools/core"
 import { IdentityPrinter } from "@herb-tools/printer"
 import { findNodeByLocation } from "./rules/rule-utils.js"
 
@@ -175,12 +176,14 @@ export class Linter {
 
         if (offense.autofixContext) {
           const originalNodeType = offense.autofixContext.node.type
+          const location: Location = offense.autofixContext.node.location ? Location.from(offense.autofixContext.node.location) : offense.location
 
           const freshNode = findNodeByLocation(
             parseResult.value,
-            offense.location,
+            location,
             (node) => node.type === originalNodeType
           )
+
           if (freshNode) {
             offense.autofixContext.node = freshNode
           } else {
diff --git a/javascript/packages/linter/src/rules/html-no-space-in-tag.ts b/javascript/packages/linter/src/rules/html-no-space-in-tag.ts
index 53bacd8c6..384251c75 100644
--- a/javascript/packages/linter/src/rules/html-no-space-in-tag.ts
+++ b/javascript/packages/linter/src/rules/html-no-space-in-tag.ts
@@ -1,10 +1,11 @@
-import { ParserRule } from "../types.js"
-import { BaseRuleVisitor } from "./rule-utils.js"
+import { Token, Location, WhitespaceNode } from "@herb-tools/core"
+import { ParserRule, BaseAutofixContext } from "../types.js"
 
-import { filterWhitespaceNodes, isWhitespaceNode,  } from "@herb-tools/core"
+import { findParent, BaseRuleVisitor } from "./rule-utils.js"
+import { filterWhitespaceNodes, isWhitespaceNode, isHTMLOpenTagNode } from "@herb-tools/core"
 
-import type { LintOffense, LintContext } from "../types.js"
-import type { ParseResult, HTMLOpenTagNode, HTMLCloseTagNode, WhitespaceNode, Node, Token } from "@herb-tools/core"
+import type { ParseResult, Node, HTMLCloseTagNode, HTMLOpenTagNode } from "@herb-tools/core"
+import type { LintOffense, LintContext, Mutable } from "../types.js"
 
 const MESSAGES = {
   EXTRA_SPACE_NO_SPACE: "Extra space detected where there should be no space.",
@@ -13,7 +14,12 @@ const MESSAGES = {
   NO_SPACE_SINGLE_SPACE: "No space detected where there should be a single space.",
 } as const
 
-class HTMLNoSpaceInTagVisitor extends BaseRuleVisitor {
+interface HTMLNoSpaceInTagAutofixContext extends BaseAutofixContext {
+  node: WhitespaceNode | HTMLOpenTagNode
+  message: string
+}
+
+class HTMLNoSpaceInTagVisitor extends BaseRuleVisitor<HTMLNoSpaceInTagAutofixContext> {
   visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
     if (node.isSingleLine) {
       this.checkSingleLineTag(node)
@@ -48,7 +54,7 @@ class HTMLNoSpaceInTagVisitor extends BaseRuleVisitor {
       }
 
       if (content.length > 1) {
-        this.addOffense(MESSAGES.EXTRA_SPACE_SINGLE_SPACE, whitespace.location)
+        this.addOffense(MESSAGES.EXTRA_SPACE_SINGLE_SPACE, whitespace.location, "error", { node: whitespace, message: MESSAGES.EXTRA_SPACE_SINGLE_SPACE })
       }
     })
   }
@@ -56,7 +62,7 @@ class HTMLNoSpaceInTagVisitor extends BaseRuleVisitor {
   private checkTrailingWhitespace(whitespace: WhitespaceNode, content: string, isSelfClosing: boolean): void {
     if (isSelfClosing && content === ' ') return
 
-    this.addOffense(MESSAGES.EXTRA_SPACE_NO_SPACE, whitespace.location)
+    this.addOffense(MESSAGES.EXTRA_SPACE_NO_SPACE, whitespace.location, "error", { node: whitespace, message: MESSAGES.EXTRA_SPACE_NO_SPACE })
   }
 
   private checkMissingSpaceBeforeSelfClosing(node: HTMLOpenTagNode, children: Node[], isSelfClosing: boolean): void {
@@ -68,7 +74,7 @@ class HTMLNoSpaceInTagVisitor extends BaseRuleVisitor {
     const lastNonWhitespace = children.filter(child => !isWhitespaceNode(child)).pop()
     const locationToReport = lastNonWhitespace?.location ?? node.tag_name?.location ?? node.location
 
-    this.addOffense(MESSAGES.NO_SPACE_SINGLE_SPACE, locationToReport)
+    this.addOffense(MESSAGES.NO_SPACE_SINGLE_SPACE, locationToReport, "error", { node, message: MESSAGES.NO_SPACE_SINGLE_SPACE })
   }
 
   private checkMultilineTag(node: HTMLOpenTagNode): void {
@@ -80,7 +86,7 @@ class HTMLNoSpaceInTagVisitor extends BaseRuleVisitor {
       if (!content) return
 
       if (this.hasConsecutiveNewlines(content, previousWhitespace)) {
-        this.addOffense(MESSAGES.EXTRA_SPACE_SINGLE_BREAK, whitespace.location)
+        this.addOffense(MESSAGES.EXTRA_SPACE_SINGLE_BREAK, whitespace.location, "error", { node: whitespace, message: MESSAGES.EXTRA_SPACE_SINGLE_BREAK })
         previousWhitespace = whitespace
 
         return
@@ -113,7 +119,7 @@ class HTMLNoSpaceInTagVisitor extends BaseRuleVisitor {
 
     if (whitespace.location.end.column === expectedIndent) return
 
-    this.addOffense(MESSAGES.EXTRA_SPACE_NO_SPACE, whitespace.location)
+    this.addOffense(MESSAGES.EXTRA_SPACE_NO_SPACE, whitespace.location, "error", { node: whitespace, message: MESSAGES.EXTRA_SPACE_NO_SPACE })
   }
 
   private isSelfClosing(tag_closing: Token): boolean {
@@ -130,19 +136,78 @@ class HTMLNoSpaceInTagVisitor extends BaseRuleVisitor {
       : nodes as WhitespaceNode[]
 
     whitespaceNodes.forEach(whitespace => {
-      this.addOffense(message, whitespace.location)
+      this.addOffense(message, whitespace.location, "error", { node: whitespace, message })
     })
   }
 }
 
-export class HTMLNoSpaceInTagRule extends ParserRule {
+export class HTMLNoSpaceInTagRule extends ParserRule<HTMLNoSpaceInTagAutofixContext> {
+  static autocorrectable = true
   name = "html-no-space-in-tag"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<HTMLNoSpaceInTagAutofixContext>[] {
     const visitor = new HTMLNoSpaceInTagVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<HTMLNoSpaceInTagAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node, message } = offense.autofixContext
+    if (!node) return null
+
+    if (isHTMLOpenTagNode(node)) {
+      const token = Token.from({ type: "TOKEN_WHITESPACE", value: " ", range: [0, 0], location: Location.zero })
+      const whitespace = new WhitespaceNode({ type: "AST_WHITESPACE_NODE", value: token, location: Location.zero, errors: [] })
+
+      node.children.push(whitespace)
+
+      return result
+    }
+
+    if (!isWhitespaceNode(node)) return null
+
+    const whitespaceNode = node as Mutable<WhitespaceNode>
+    if (!whitespaceNode.value) return null
+
+    switch (message) {
+      case MESSAGES.EXTRA_SPACE_NO_SPACE: {
+        let selfClosing = false
+        let beginningOfLine = false
+
+        const parent = findParent(result.value, node)
+
+        if (parent && isHTMLOpenTagNode(parent)) {
+          selfClosing = parent.tag_closing?.value === "/>"
+          beginningOfLine = node.location.start.column === 0
+        }
+
+        whitespaceNode.value.value = selfClosing && !beginningOfLine ? " " : ""
+
+        return result
+      }
+
+      case MESSAGES.EXTRA_SPACE_SINGLE_BREAK: {
+        if (whitespaceNode.value.value.includes("\n")) {
+          whitespaceNode.value.value = ""
+        } else {
+          whitespaceNode.value.value = " "
+        }
+
+        return result
+      }
+
+      case MESSAGES.EXTRA_SPACE_SINGLE_SPACE:
+      case MESSAGES.NO_SPACE_SINGLE_SPACE: {
+        whitespaceNode.value.value = " "
+
+        return result
+      }
+
+      default: return null
+    }
+  }
 }
diff --git a/javascript/packages/linter/test/autofix/html-no-space-in-tag.autofix.test.ts b/javascript/packages/linter/test/autofix/html-no-space-in-tag.autofix.test.ts
new file mode 100644
index 000000000..8e69233f7
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/html-no-space-in-tag.autofix.test.ts
@@ -0,0 +1,410 @@
+import dedent from "dedent"
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+
+import { HTMLNoSpaceInTagRule } from "../../src/rules/html-no-space-in-tag.js"
+
+describe("html-no-space-in-tag autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  describe("when space is correct", () => {
+    test("void tag", () => {
+      const input = `<img />`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(input)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("plain tag with attribute", () => {
+      const input = `<div class="foo"></div>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(input)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("between attributes", () => {
+      const input = `<input class="foo" name="bar">`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(input)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("multi line tag", () => {
+      const input = dedent`
+        <input
+          type="password"
+          class="foo"
+        >
+      `
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(input)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("tag with erb", () => {
+      const input = dedent`<input <%= attributes %>>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(input)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("multi line tag with erb", () => {
+      const input = dedent`
+        <input
+          type="password"
+          <%= attributes %>
+          class="foo"
+        >
+      `
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+      expect(result.source).toBe(input)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("multi line tag with erb nested", () => {
+      const input = dedent`
+        <div>
+          <input
+            type="password"
+            <%= attributes %>
+            class="foo"
+          >
+        </div>
+      `
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(input)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+  })
+
+  describe("when no space should be present", () => {
+    test("after name", () => {
+      const input = dedent`<div   ></div>`
+      const expected = dedent`<div></div>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("before name", () => {
+      const input = dedent`<   div></div>`
+      const expected = dedent`<   div></div>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("before start solidus", () => {
+      const input = dedent`<div><   /div>`
+      const expected = dedent`<div><   /div>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("after start solidus", () => {
+      const input = dedent`<div></   div>`
+      const expected = dedent`<div></div>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("after end solidus", () => {
+      const input = dedent`<div><div /   >`
+      const expected = dedent`<div><div /   >`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+  })
+
+  describe("when space is missing", () => {
+    test("between attributes", () => {
+      const input = dedent`<div foo='foo'bar='bar'></div>`
+      const expected = dedent`<div foo='foo'bar='bar'></div>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("between last attribute and solidus", () => {
+      const input = dedent`<div foo='bar'/>`
+      const expected = dedent`<div foo='bar' />`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("between name and solidus", () => {
+      const input = `<div/>`
+      const expected = `<div />`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+  })
+
+  describe("when extra space is present", () => {
+    test("between name and end of tag", () => {
+      const input = dedent`<div  ></div>`
+      const expected = dedent`<div></div>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("between name and first attribute", () => {
+      const input = dedent`<img   class="hide">`
+      const expected = dedent`<img class="hide">`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("between name and end solidus", () => {
+      const input = dedent`<br   />`
+      const expected = dedent`<br />`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("between last attribute and solidus", () => {
+      const input = dedent`<br class="hide"   />`
+      const expected = dedent`<br class="hide" />`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("between last attribute and end of tag", () => {
+      const input = dedent`<img class="hide"    >`
+      const expected = dedent`<img class="hide">`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("between attributes", () => {
+      const input = dedent`<div foo='foo'      bar='bar'></div>`
+      const expected = dedent`<div foo='foo' bar='bar'></div>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("extra newline between name and first attribute", () => {
+      const input = dedent`
+        <input
+
+          type="password" />
+      `
+      const expected = dedent`
+        <input
+          type="password" />
+      `
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(2)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("extra newline between name and end of tag", () => {
+      const input = dedent`
+        <input
+
+          />
+      `
+      const expected = dedent`
+        <input
+        />
+      `
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(2)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("extra newline between attributes", () => {
+      const input = dedent`
+        <input
+          type="password"
+
+          class="foo" />
+      `
+      const expected = dedent`
+        <input
+          type="password"
+          class="foo" />
+      `
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(2)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("end solidus is on newline", () => {
+      const input = dedent`
+        <input
+          type="password"
+          class="foo"
+          />
+      `
+      const expected = dedent`
+        <input
+          type="password"
+          class="foo"
+        />
+      `
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("end of tag is on newline", () => {
+      const input = dedent`
+        <input
+          type="password"
+          class="foo"
+          >
+      `
+      const expected = dedent`
+        <input
+          type="password"
+          class="foo"
+        >
+      `
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("non-space detected between name and attribute", () => {
+      const input = `<input/class="hide" />`
+      const expected = `<input/class="hide" />`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("non-space detected between attributes", () => {
+      const input = `<input class="hide"/name="foo" />`
+      const expected = `<input class="hide"/name="foo" />`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+  })
+})

From ec4150078c012f221f40ba3e81c0732fa70c119a Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Wed, 15 Oct 2025 00:14:53 +0200
Subject: [PATCH 67/97] Linter Rule: Fix false positive for `yield` in
 `erb-right-trim` rule (#644)

This pull request updates the `isERBOutputNode` helper in
`@herb-tools/core` in order to detect a `<%= yield %>` node as an
`ERBOutputNode`.

This change fixes the `erb-right-trim` rule to not report the following
snippet as an offense:

```erb
<%= yield -%>
```

Resolves #643
---
 javascript/packages/core/src/ast-utils.ts          | 11 +++++++++--
 .../linter/test/rules/erb-right-trim.test.ts       | 14 ++++++++++++++
 2 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/javascript/packages/core/src/ast-utils.ts b/javascript/packages/core/src/ast-utils.ts
index c7f773ddb..6c844a4cd 100644
--- a/javascript/packages/core/src/ast-utils.ts
+++ b/javascript/packages/core/src/ast-utils.ts
@@ -1,6 +1,7 @@
 import {
   Node,
   LiteralNode,
+  ERBNode,
   ERBContentNode,
   ERBIfNode,
   ERBUnlessNode,
@@ -30,11 +31,17 @@ import {
 import type { Location } from "./location.js"
 import type { Position } from "./position.js"
 
+export type ERBOutputNode = ERBNode & {
+  tag_opening: {
+    value: "<%=" | "<%=="
+  }
+}
+
 /**
  * Checks if a node is an ERB output node (generates content: <%= %> or <%== %>)
  */
-export function isERBOutputNode(node: Node): node is ERBContentNode {
-  if (!isNode(node, ERBContentNode)) return false
+export function isERBOutputNode(node: Node): node is ERBOutputNode {
+  if (!isERBNode(node)) return false
   if (!node.tag_opening?.value) return false
 
   return ["<%=", "<%=="].includes(node.tag_opening?.value)
diff --git a/javascript/packages/linter/test/rules/erb-right-trim.test.ts b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
index 363141219..678ac1522 100644
--- a/javascript/packages/linter/test/rules/erb-right-trim.test.ts
+++ b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
@@ -131,4 +131,18 @@ describe("ERBRightTrimRule", () => {
       <%- end -%>
     `)
   })
+
+  test("passes for yield with -%>", () => {
+    expectNoOffenses(dedent`
+      <%= yield -%>
+    `)
+  })
+
+  test("passes for block with -%>", () => {
+    expectNoOffenses(dedent`
+      <%= content_for :content do -%>
+        Content
+      <%- end -%>
+    `)
+  })
 })

From 86efa79c810ef80740bc877679ee184629f9ee20 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Wed, 15 Oct 2025 12:02:55 +0200
Subject: [PATCH 68/97] Linter Rule: Remove `Trimming with -%> on non-output`
 offense (#645)

This pull request removes the following offense from the
`erb-right-trim` linter rule, as it's not right and does have an effect:

```
Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead.
```

It will have an effect on templates like this:

```erb
<% if true -%>
  <h1>Content</h1>
<% end -%>
```
---
 .../linter/docs/rules/erb-right-trim.md       | 15 ++++------
 .../linter/src/rules/erb-right-trim.ts        | 30 +++++--------------
 .../autofix/erb-right-trim.autofix.test.ts    | 17 ++---------
 .../linter/test/rules/erb-right-trim.test.ts  | 20 +++++--------
 4 files changed, 21 insertions(+), 61 deletions(-)

diff --git a/javascript/packages/linter/docs/rules/erb-right-trim.md b/javascript/packages/linter/docs/rules/erb-right-trim.md
index 74901eed9..54dd37c42 100644
--- a/javascript/packages/linter/docs/rules/erb-right-trim.md
+++ b/javascript/packages/linter/docs/rules/erb-right-trim.md
@@ -4,15 +4,13 @@
 
 ## Description
 
-This rule enforces the use of `-%>` for right-trimming ERB output tags (like `<%= %>`) instead of `=%>`. It also warns when right-trimming syntax (`-%>` or `=%>`) is used on non-output ERB tags (like `<% %>`, `<% if %>`, etc.) where it has no effect.
+This rule enforces the use of `-%>` for right-trimming ERB output tags (like `<%= %>`) instead of `=%>`.
 
 ## Rationale
 
-While `=%>` can be used for right-trimming whitespace in some ERB engines (like Erubi), it is an obscure and not well-defined syntax that lacks consistent support across most ERB implementations. The `-%>` syntax is the standard, well-documented approach for right-trimming that is universally supported and consistent with left-trimming syntax (`<%-`).
+While `=%>` can be used for right-trimming whitespace in some ERB engines (like Erubi), it is an obscure and not well-defined syntax that lacks consistent support across most ERB implementations.
 
-Additionally, right-trimming syntax only has an effect on ERB output tags (`<%=` and `<%==`). Using `-%>` or `=%>` on non-output ERB tags (control flow like `<% if %>`, `<% each %>`, etc.) has no effect and is misleading.
-
-Using `-%>` for output tags ensures compatibility across different ERB engines, improves code clarity, and aligns with established Rails and ERB conventions.
+The `-%>` syntax is the standard, well-documented approach for right-trimming that is universally supported and consistent with left-trimming syntax (`<%-`). Using `-%>` ensures compatibility across different ERB engines, improves code clarity, and aligns with established Rails and ERB conventions.
 
 ## Examples
 
@@ -21,7 +19,7 @@ Using `-%>` for output tags ensures compatibility across different ERB engines,
 ```erb
 <%= title -%>
 
-<% if true %>
+<% if condition? %>
   <h1>Content</h1>
 <% end %>
 
@@ -39,10 +37,7 @@ Using `-%>` for output tags ensures compatibility across different ERB engines,
 <% title =%>
 
 
-<% title -%>
-
-
-<% if true -%>
+<% if true =%>
   <h1>Content</h1>
 <% end %>
 
diff --git a/javascript/packages/linter/src/rules/erb-right-trim.ts b/javascript/packages/linter/src/rules/erb-right-trim.ts
index be8199125..f3cc083f2 100644
--- a/javascript/packages/linter/src/rules/erb-right-trim.ts
+++ b/javascript/packages/linter/src/rules/erb-right-trim.ts
@@ -11,34 +11,18 @@ interface ERBRightTrimAutofixContext extends BaseAutofixContext {
 
 class ERBRightTrimVisitor extends BaseRuleVisitor<ERBRightTrimAutofixContext> {
   visitERBNode(node: ERBNode): void {
-    if (!node.tag_opening) return
     if (!node.tag_closing) return
 
-    const trimOpening = node.tag_opening.value
     const trimClosing = node.tag_closing.value
 
-    if (trimOpening === "<%-") return
-    if (trimClosing !== "=%>" && trimClosing !== "-%>") return
+    if (trimClosing !== "=%>") return
 
-    if (!isERBOutputNode(node)) {
-      this.addOffense(
-        `Right-trimming with \`${trimClosing}\` has no effect on non-output ERB tags. Use \`%>\` instead.`,
-        node.tag_closing.location,
-        "error",
-        { node }
-      )
-
-      return
-    }
-
-    if (trimClosing === "=%>") {
-      this.addOffense(
-        "Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.",
-        node.tag_closing.location,
-        "error",
-        { node }
-      )
-    }
+    this.addOffense(
+      "Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.",
+      node.tag_closing.location,
+      "error",
+      { node }
+    )
   }
 }
 
diff --git a/javascript/packages/linter/test/autofix/erb-right-trim.autofix.test.ts b/javascript/packages/linter/test/autofix/erb-right-trim.autofix.test.ts
index 11a7a06e9..6a933c8e6 100644
--- a/javascript/packages/linter/test/autofix/erb-right-trim.autofix.test.ts
+++ b/javascript/packages/linter/test/autofix/erb-right-trim.autofix.test.ts
@@ -42,7 +42,6 @@ describe("erb-right-trim autofix", () => {
     expect(result.unfixed).toHaveLength(0)
   })
 
-  // TODO: figure out if this is actually right
   test("when non-output tag uses -%>", () => {
     const input = dedent`
       <% if condition -%>
@@ -56,23 +55,11 @@ describe("erb-right-trim autofix", () => {
       <% end -%>
     `
 
-    const expected = dedent`
-      <% if condition %>
-        <p>Content</p>
-      <% elsif other_condition %>
-        <p>Content</p>
-      <% elsif yet_another_condition %>
-        <p>Content</p>
-      <% else %>
-        <p>Content</p>
-      <% end %>
-    `
-
     const linter = new Linter(Herb, [ERBRightTrimRule])
     const result = linter.autofix(input, { fileName: 'test.html.erb' })
 
-    expect(result.source).toBe(expected)
-    expect(result.fixed).toHaveLength(5)
+    expect(result.source).toBe(input)
+    expect(result.fixed).toHaveLength(0)
     expect(result.unfixed).toHaveLength(0)
   })
 
diff --git a/javascript/packages/linter/test/rules/erb-right-trim.test.ts b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
index 678ac1522..d12923cca 100644
--- a/javascript/packages/linter/test/rules/erb-right-trim.test.ts
+++ b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
@@ -23,13 +23,7 @@ describe("ERBRightTrimRule", () => {
   })
 
   test("when non-output tag uses -%>", () => {
-    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead.")
-    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead.")
-    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead.")
-    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead.")
-    expectError("Right-trimming with `-%>` has no effect on non-output ERB tags. Use `%>` instead.")
-
-    assertOffenses(dedent`
+    expectNoOffenses(dedent`
       <% if condition -%>
         <p>Content</p>
       <% elsif other_condition -%>
@@ -53,8 +47,8 @@ describe("ERBRightTrimRule", () => {
   })
 
   test("when an if block uses =%>", () => {
-    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead.")
-    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead.")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
 
     assertOffenses(dedent`
       <% if condition =%>
@@ -64,7 +58,7 @@ describe("ERBRightTrimRule", () => {
   })
 
   test("when a loop uses =%>", () => {
-    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead.")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
 
     assertOffenses(dedent`
       <% items.each do |item| =%>
@@ -98,7 +92,7 @@ describe("ERBRightTrimRule", () => {
   })
 
   test("when silent ERB uses =%>", () => {
-    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead.")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
 
     assertOffenses(dedent`
       <% silent_operation =%>
@@ -106,8 +100,8 @@ describe("ERBRightTrimRule", () => {
   })
 
   test("handles =%> in nested structures", () => {
-    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead.")
-    expectError("Right-trimming with `=%>` has no effect on non-output ERB tags. Use `%>` instead.")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
 
     assertOffenses(dedent`
       <% if outer_condition =%>

From 8580949daaccf24e006cd2d550993dc3e9fd917a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Thu, 16 Oct 2025 11:51:17 +0200
Subject: [PATCH 69/97] C: Add `hb_buffer_append_string` function to
 `hb_buffer_T` (#657)

This PR adds a new function that allows adding `hb_string_T`s to our
buffer implementation
---
 src/include/util/hb_buffer.h |  3 +++
 src/util/hb_buffer.c         |  4 ++++
 test/c/test_hb_buffer.c      | 14 ++++++++++++++
 3 files changed, 21 insertions(+)

diff --git a/src/include/util/hb_buffer.h b/src/include/util/hb_buffer.h
index e058b1f6d..d9395009f 100644
--- a/src/include/util/hb_buffer.h
+++ b/src/include/util/hb_buffer.h
@@ -1,6 +1,8 @@
 #ifndef HERB_BUFFER_H
 #define HERB_BUFFER_H
 
+#include "hb_string.h"
+
 #include <stdbool.h>
 #include <stdlib.h>
 
@@ -14,6 +16,7 @@ bool hb_buffer_init(hb_buffer_T* buffer, size_t capacity);
 
 void hb_buffer_append(hb_buffer_T* buffer, const char* text);
 void hb_buffer_append_with_length(hb_buffer_T* buffer, const char* text, size_t length);
+void hb_buffer_append_string(hb_buffer_T* buffer, hb_string_T string);
 void hb_buffer_append_char(hb_buffer_T* buffer, char character);
 void hb_buffer_append_whitespace(hb_buffer_T* buffer, size_t length);
 void hb_buffer_prepend(hb_buffer_T* buffer, const char* text);
diff --git a/src/util/hb_buffer.c b/src/util/hb_buffer.c
index 68e5f2dab..34eae2c91 100644
--- a/src/util/hb_buffer.c
+++ b/src/util/hb_buffer.c
@@ -137,6 +137,10 @@ void hb_buffer_append_with_length(hb_buffer_T* buffer, const char* text, const s
   buffer->value[buffer->length] = '\0';
 }
 
+void hb_buffer_append_string(hb_buffer_T* buffer, hb_string_T string) {
+  if (!hb_string_is_empty(string)) { hb_buffer_append_with_length(buffer, string.data, string.length); }
+}
+
 void hb_buffer_append_char(hb_buffer_T* buffer, const char character) {
   static char string[2];
 
diff --git a/test/c/test_hb_buffer.c b/test/c/test_hb_buffer.c
index d46e9e8e9..47eee0c8b 100644
--- a/test/c/test_hb_buffer.c
+++ b/test/c/test_hb_buffer.c
@@ -63,6 +63,19 @@ TEST(test_hb_buffer_concat)
   free(buffer2.value);
 END
 
+// Test appending a string to the buffer
+TEST(test_hb_buffer_append_string)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1);
+
+  hb_buffer_append_string(&buffer, hb_string_from_c_string("Hello, world"));
+
+  ck_assert_str_eq(buffer.value, "Hello, world");
+  ck_assert_int_eq(buffer.length, 12);
+
+  free(buffer.value);
+END
+
 TEST(test_hb_buffer_resizing_behavior)
   hb_buffer_T buffer;
   hb_buffer_init(&buffer, 1024);
@@ -185,6 +198,7 @@ TCase *hb_buffer_tests(void) {
   tcase_add_test(buffer, test_hb_buffer_append);
   tcase_add_test(buffer, test_hb_buffer_prepend);
   tcase_add_test(buffer, test_hb_buffer_concat);
+  tcase_add_test(buffer, test_hb_buffer_append_string);
   tcase_add_test(buffer, test_hb_buffer_resizing_behavior);
   tcase_add_test(buffer, test_hb_buffer_clear);
   tcase_add_test(buffer, test_hb_buffer_free);

From d5afc84eef7f53282fc83f4bfb5af8baea7b64ac Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Thu, 16 Oct 2025 11:57:13 +0200
Subject: [PATCH 70/97] Linter: Rename `erb-require-trailing-newline` linter
 rule (#660)

This pull request renames the `erb-requires-trailing-newline` linter
rule to `erb-require-trailing-newline` to be more in line with the other
`erb-require-whitespace-inside-tags` linter rule name.
---
 .../transformers/herb-linter-transformer.mts   |  4 ++--
 javascript/packages/linter/README.md           |  2 +-
 .../packages/linter/docs/rules/README.md       |  2 +-
 ...line.md => erb-require-trailing-newline.md} |  2 +-
 .../packages/linter/src/default-rules.ts       |  4 ++--
 ...line.ts => erb-require-trailing-newline.ts} |  8 ++++----
 javascript/packages/linter/src/rules/index.ts  |  2 +-
 .../linter/test/__snapshots__/cli.test.ts.snap |  6 +++---
 ...b-require-trailing-newline.autofix.test.ts} | 18 +++++++++---------
 javascript/packages/linter/test/cli.test.ts    |  2 +-
 ...ts => erb-require-trailing-newline.test.ts} |  6 +++---
 javascript/packages/vscode/package.json        |  2 +-
 12 files changed, 29 insertions(+), 29 deletions(-)
 rename javascript/packages/linter/docs/rules/{erb-requires-trailing-newline.md => erb-require-trailing-newline.md} (96%)
 rename javascript/packages/linter/src/rules/{erb-requires-trailing-newline.ts => erb-require-trailing-newline.ts} (79%)
 rename javascript/packages/linter/test/autofix/{erb-requires-trailing-newline.autofix.test.ts => erb-require-trailing-newline.autofix.test.ts} (79%)
 rename javascript/packages/linter/test/rules/{erb-requires-trailing-newline.test.ts => erb-require-trailing-newline.test.ts} (95%)

diff --git a/docs/.vitepress/transformers/herb-linter-transformer.mts b/docs/.vitepress/transformers/herb-linter-transformer.mts
index 329189480..01cb4b02c 100644
--- a/docs/.vitepress/transformers/herb-linter-transformer.mts
+++ b/docs/.vitepress/transformers/herb-linter-transformer.mts
@@ -21,9 +21,9 @@ function createCustomTwoslashFunction(optionse) {
   return (code, lang, options) => {
     let fileName = undefined
 
-    // kinda of a hack to make sure we pass a `fileName` for the `erb-requires-trailing-newline` rule
+    // kind of a hack to make sure we pass a `fileName` for the `erb-require-trailing-newline` rule
     if (code.includes('▌')) {
-      fileName = "erb-requires-trailing-newline.html.erb"
+      fileName = "erb-require-trailing-newline.html.erb"
     }
 
     if (!lang || !['erb', 'html'].includes(lang)) {
diff --git a/javascript/packages/linter/README.md b/javascript/packages/linter/README.md
index 8604b4384..51706970f 100644
--- a/javascript/packages/linter/README.md
+++ b/javascript/packages/linter/README.md
@@ -250,7 +250,7 @@ npx @herb-tools/linter template.html.erb --json
         "end": { "line": 1, "column": 22 }
       },
       "severity": "error",
-      "code": "erb-requires-trailing-newline",
+      "code": "erb-require-trailing-newline",
       "source": "Herb Linter"
     }
   ],
diff --git a/javascript/packages/linter/docs/rules/README.md b/javascript/packages/linter/docs/rules/README.md
index 5a1361f2a..2d7bb6544 100644
--- a/javascript/packages/linter/docs/rules/README.md
+++ b/javascript/packages/linter/docs/rules/README.md
@@ -12,7 +12,7 @@ This page contains documentation for all Herb Linter rules.
 - [`erb-no-silent-tag-in-attribute-name`](./erb-no-silent-tag-in-attribute-name.md) - Disallow ERB silent tags in HTML attribute names
 - [`erb-prefer-image-tag-helper`](./erb-prefer-image-tag-helper.md) - Prefer `image_tag` helper over `<img>` with ERB expressions
 - [`erb-require-whitespace-inside-tags`](./erb-require-whitespace-inside-tags.md) - Requires whitespace around ERB tags
-- [`erb-requires-trailing-newline`](./erb-requires-trailing-newline.md) - Enforces that all HTML+ERB template files end with exactly one trailing newline character.
+- [`erb-require-trailing-newline`](./erb-require-trailing-newline.md) - Enforces that all HTML+ERB template files end with exactly one trailing newline character.
 - [`erb-right-trim`](./erb-right-trim.md) - Enforce consistent right-trimming syntax.
 - [`html-anchor-require-href`](./html-anchor-require-href.md) - Requires an href attribute on anchor tags
 - [`html-aria-attribute-must-be-valid`](./html-aria-attribute-must-be-valid.md) - Disallow invalid or unknown `aria-*` attributes.
diff --git a/javascript/packages/linter/docs/rules/erb-requires-trailing-newline.md b/javascript/packages/linter/docs/rules/erb-require-trailing-newline.md
similarity index 96%
rename from javascript/packages/linter/docs/rules/erb-requires-trailing-newline.md
rename to javascript/packages/linter/docs/rules/erb-require-trailing-newline.md
index d4bc11c91..d3bd7e9c6 100644
--- a/javascript/packages/linter/docs/rules/erb-requires-trailing-newline.md
+++ b/javascript/packages/linter/docs/rules/erb-require-trailing-newline.md
@@ -1,6 +1,6 @@
 # Linter Rule: Enforce trailing newline
 
-**Rule:** `erb-requires-trailing-newline`
+**Rule:** `erb-require-trailing-newline`
 
 ## Description
 
diff --git a/javascript/packages/linter/src/default-rules.ts b/javascript/packages/linter/src/default-rules.ts
index 4655eaf85..39188aa18 100644
--- a/javascript/packages/linter/src/default-rules.ts
+++ b/javascript/packages/linter/src/default-rules.ts
@@ -7,7 +7,7 @@ import { ERBNoExtraNewLineRule } from "./rules/erb-no-extra-newline.js"
 import { ERBNoOutputControlFlowRule } from "./rules/erb-no-output-control-flow.js"
 import { ERBNoSilentTagInAttributeNameRule } from "./rules/erb-no-silent-tag-in-attribute-name.js"
 import { ERBPreferImageTagHelperRule } from "./rules/erb-prefer-image-tag-helper.js"
-import { ERBRequiresTrailingNewlineRule } from "./rules/erb-requires-trailing-newline.js"
+import { ERBRequireTrailingNewlineRule } from "./rules/erb-require-trailing-newline.js"
 import { ERBRequireWhitespaceRule } from "./rules/erb-require-whitespace-inside-tags.js"
 import { ERBRightTrimRule } from "./rules/erb-right-trim.js"
 
@@ -55,7 +55,7 @@ export const defaultRules: RuleClass[] = [
   ERBNoOutputControlFlowRule,
   ERBNoSilentTagInAttributeNameRule,
   ERBPreferImageTagHelperRule,
-  ERBRequiresTrailingNewlineRule,
+  ERBRequireTrailingNewlineRule,
   ERBRequireWhitespaceRule,
   ERBRightTrimRule,
 
diff --git a/javascript/packages/linter/src/rules/erb-requires-trailing-newline.ts b/javascript/packages/linter/src/rules/erb-require-trailing-newline.ts
similarity index 79%
rename from javascript/packages/linter/src/rules/erb-requires-trailing-newline.ts
rename to javascript/packages/linter/src/rules/erb-require-trailing-newline.ts
index c13f8e9e7..52c7c4761 100644
--- a/javascript/packages/linter/src/rules/erb-requires-trailing-newline.ts
+++ b/javascript/packages/linter/src/rules/erb-require-trailing-newline.ts
@@ -3,7 +3,7 @@ import { BaseSourceRuleVisitor, createEndOfFileLocation } from "./rule-utils.js"
 
 import type { LintOffense, LintContext } from "../types.js"
 
-class ERBRequiresTrailingNewlineVisitor extends BaseSourceRuleVisitor {
+class ERBRequireTrailingNewlineVisitor extends BaseSourceRuleVisitor {
   protected visitSource(source: string): void {
     if (source.length === 0) return
     if (!this.context.fileName) return
@@ -24,12 +24,12 @@ class ERBRequiresTrailingNewlineVisitor extends BaseSourceRuleVisitor {
   }
 }
 
-export class ERBRequiresTrailingNewlineRule extends SourceRule {
+export class ERBRequireTrailingNewlineRule extends SourceRule {
   static autocorrectable = true
-  name = "erb-requires-trailing-newline"
+  name = "erb-require-trailing-newline"
 
   check(source: string, context?: Partial<LintContext>): LintOffense[] {
-    const visitor = new ERBRequiresTrailingNewlineVisitor(this.name, context)
+    const visitor = new ERBRequireTrailingNewlineVisitor(this.name, context)
 
     visitor.visit(source)
 
diff --git a/javascript/packages/linter/src/rules/index.ts b/javascript/packages/linter/src/rules/index.ts
index 0c7eac722..182c9bb0e 100644
--- a/javascript/packages/linter/src/rules/index.ts
+++ b/javascript/packages/linter/src/rules/index.ts
@@ -7,7 +7,7 @@ export * from "./erb-no-extra-newline.js"
 export * from "./erb-no-output-control-flow.js"
 export * from "./erb-no-silent-tag-in-attribute-name.js"
 export * from "./erb-prefer-image-tag-helper.js"
-export * from "./erb-requires-trailing-newline.js"
+export * from "./erb-require-trailing-newline.js"
 export * from "./erb-right-trim.js"
 
 export * from "./html-anchor-require-href.js"
diff --git a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
index 1eb932445..62e3df94e 100644
--- a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
+++ b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
@@ -56,9 +56,9 @@ test/fixtures/test-file-with-errors.html.erb:2:22
 `;
 
 exports[`CLI Output Formatting > GitHub Actions format includes rule codes 1`] = `
-"::error file=test/fixtures/no-trailing-newline.html.erb,line=1,col=29,title=erb-requires-trailing-newline • @herb-tools/linter@0.7.5::File must end with trailing newline. [erb-requires-trailing-newline]%0A%0A%0Atest/fixtures/no-trailing-newline.html.erb:1:29%0A%0A  →   1 │ <div>No trailing newline</div>%0A        │                              ~%0A
+"::error file=test/fixtures/no-trailing-newline.html.erb,line=1,col=29,title=erb-require-trailing-newline • @herb-tools/linter@0.7.5::File must end with trailing newline. [erb-require-trailing-newline]%0A%0A%0Atest/fixtures/no-trailing-newline.html.erb:1:29%0A%0A  →   1 │ <div>No trailing newline</div>%0A        │                              ~%0A
 
-[error] File must end with trailing newline. [Correctable] (erb-requires-trailing-newline)
+[error] File must end with trailing newline. [Correctable] (erb-require-trailing-newline)
 
 test/fixtures/no-trailing-newline.html.erb:1:29
 
@@ -66,7 +66,7 @@ test/fixtures/no-trailing-newline.html.erb:1:29
         │                              ~
 
  Rule offenses:
-  erb-requires-trailing-newline (1 offense in 1 file)
+  erb-require-trailing-newline (1 offense in 1 file)
 
 
  Summary:
diff --git a/javascript/packages/linter/test/autofix/erb-requires-trailing-newline.autofix.test.ts b/javascript/packages/linter/test/autofix/erb-require-trailing-newline.autofix.test.ts
similarity index 79%
rename from javascript/packages/linter/test/autofix/erb-requires-trailing-newline.autofix.test.ts
rename to javascript/packages/linter/test/autofix/erb-require-trailing-newline.autofix.test.ts
index 1bfc2661c..d598ea87b 100644
--- a/javascript/packages/linter/test/autofix/erb-requires-trailing-newline.autofix.test.ts
+++ b/javascript/packages/linter/test/autofix/erb-require-trailing-newline.autofix.test.ts
@@ -2,9 +2,9 @@ import dedent from "dedent"
 import { describe, test, expect, beforeAll } from "vitest"
 import { Herb } from "@herb-tools/node-wasm"
 import { Linter } from "../../src/linter.js"
-import { ERBRequiresTrailingNewlineRule } from "../../src/rules/erb-requires-trailing-newline.js"
+import { ERBRequireTrailingNewlineRule } from "../../src/rules/erb-require-trailing-newline.js"
 
-describe("erb-requires-trailing-newline autofix", () => {
+describe("erb-require-trailing-newline autofix", () => {
   beforeAll(async () => {
     await Herb.load()
   })
@@ -13,7 +13,7 @@ describe("erb-requires-trailing-newline autofix", () => {
     const input = '<div>Hello World</div>'
     const expected = '<div>Hello World</div>\n'
 
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
+    const linter = new Linter(Herb, [ERBRequireTrailingNewlineRule])
     const result = linter.autofix(input, { fileName: 'test.html.erb' })
 
     expect(result.source).toBe(expected)
@@ -25,7 +25,7 @@ describe("erb-requires-trailing-newline autofix", () => {
     const input = '<div>Hello World</div>\n'
     const expected = '<div>Hello World</div>\n'
 
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
+    const linter = new Linter(Herb, [ERBRequireTrailingNewlineRule])
     const result = linter.autofix(input, { fileName: 'test.html.erb' })
 
     expect(result.source).toBe(expected)
@@ -44,7 +44,7 @@ describe("erb-requires-trailing-newline autofix", () => {
       </div>
     ` + '\n'
 
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
+    const linter = new Linter(Herb, [ERBRequireTrailingNewlineRule])
     const result = linter.autofix(input, { fileName: 'test.html.erb' })
 
     expect(result.source).toBe(expected)
@@ -55,7 +55,7 @@ describe("erb-requires-trailing-newline autofix", () => {
     const input = '<div><%= content %></div>'
     const expected = '<div><%= content %></div>\n'
 
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
+    const linter = new Linter(Herb, [ERBRequireTrailingNewlineRule])
     const result = linter.autofix(input, { fileName: 'test.html.erb' })
 
     expect(result.source).toBe(expected)
@@ -66,7 +66,7 @@ describe("erb-requires-trailing-newline autofix", () => {
     const input = ''
     const expected = ''
 
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
+    const linter = new Linter(Herb, [ERBRequireTrailingNewlineRule])
     const result = linter.autofix(input, { fileName: 'test.html.erb' })
 
     expect(result.source).toBe(expected)
@@ -77,7 +77,7 @@ describe("erb-requires-trailing-newline autofix", () => {
     const input = '<div>Hello</div>\n\n'
     const expected = '<div>Hello</div>\n'
 
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
+    const linter = new Linter(Herb, [ERBRequireTrailingNewlineRule])
     const result = linter.autofix(input, { fileName: 'test.html.erb' })
 
     expect(result.source).toBe(expected)
@@ -89,7 +89,7 @@ describe("erb-requires-trailing-newline autofix", () => {
     const input = '<div>Hello</div>\n\n\n\n\n\n'
     const expected = '<div>Hello</div>\n'
 
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
+    const linter = new Linter(Herb, [ERBRequireTrailingNewlineRule])
     const result = linter.autofix(input, { fileName: 'test.html.erb' })
 
     expect(result.source).toBe(expected)
diff --git a/javascript/packages/linter/test/cli.test.ts b/javascript/packages/linter/test/cli.test.ts
index 0d3d1584f..26c049087 100644
--- a/javascript/packages/linter/test/cli.test.ts
+++ b/javascript/packages/linter/test/cli.test.ts
@@ -105,7 +105,7 @@ describe("CLI Output Formatting", () => {
   test("correctly passes filename context for file-specific rules", () => {
     const { output, exitCode } = runLinter("no-trailing-newline.html.erb", "--simple", "--no-wrap-lines")
 
-    expect(output).toContain("erb-requires-trailing-newline")
+    expect(output).toContain("erb-require-trailing-newline")
     expect(output).toContain("File must end with trailing newline")
     expect(exitCode).toBe(1)
   })
diff --git a/javascript/packages/linter/test/rules/erb-requires-trailing-newline.test.ts b/javascript/packages/linter/test/rules/erb-require-trailing-newline.test.ts
similarity index 95%
rename from javascript/packages/linter/test/rules/erb-requires-trailing-newline.test.ts
rename to javascript/packages/linter/test/rules/erb-require-trailing-newline.test.ts
index 823a68b5c..f2113b217 100644
--- a/javascript/packages/linter/test/rules/erb-requires-trailing-newline.test.ts
+++ b/javascript/packages/linter/test/rules/erb-require-trailing-newline.test.ts
@@ -2,12 +2,12 @@ import dedent from "dedent"
 
 import { describe, test } from "vitest"
 
-import { ERBRequiresTrailingNewlineRule } from "../../src/rules/erb-requires-trailing-newline.js"
+import { ERBRequireTrailingNewlineRule } from "../../src/rules/erb-require-trailing-newline.js"
 import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBRequiresTrailingNewlineRule)
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBRequireTrailingNewlineRule)
 
-describe("ERBRequiresTrailingNewlineRule", () => {
+describe("ERBRequireTrailingNewlineRule", () => {
   test("should not report errors for files ending with a trailing newline", () => {
     const html = dedent`
       <h1>
diff --git a/javascript/packages/vscode/package.json b/javascript/packages/vscode/package.json
index 149466ce1..f61824304 100644
--- a/javascript/packages/vscode/package.json
+++ b/javascript/packages/vscode/package.json
@@ -69,7 +69,7 @@
               "erb-no-silent-tag-in-attribute-name",
               "erb-prefer-image-tag-helper",
               "erb-require-whitespace-inside-tags",
-              "erb-requires-trailing-newline",
+              "erb-require-trailing-newline",
               "erb-right-trim",
               "html-anchor-require-href",
               "html-aria-attribute-must-be-valid",

From 9142a38dceaef032c75b75f4cce41cb38c3ad2ea Mon Sep 17 00:00:00 2001
From: Domingo Edwards <dedwards@buk.cl>
Date: Thu, 16 Oct 2025 08:27:12 -0300
Subject: [PATCH 71/97] Linter: Allow disabling offenses using `<%#
 herb:disable %>` (#531)

This PR makes possible to disable a rule in a erb line.

The implementation follows the [Standard
way](https://github.com/standardrb/standard?tab=readme-ov-file#ignoring-errors)
to disable rules, in the same way that [ERBLint allows to disable rules
inline](https://github.com/Shopify/erb_lint?tab=readme-ov-file#disable-rule-at-offense-level).

The implementation is very similar this [pull
request](https://github.com/Shopify/erb_lint/pull/249). The strategy
consist of

1. Use a regex to see which line skipped rules with the `<%#
herb:disable some-rule %>` syntax
2. Partition the offenses collected by the visitor based on the rules
that where disabled for each line.
3. Report in the reporters the number of offenses.

Here is a screenshot of how the implementation looks in the Linter CLI.

```erb
<div>
  <h1 class="<%= classes %>">
    <%= title %>
  </h1>

  <DIV>hello</DIV>
  <DIV>hello</DIV> <%# herb:disable html-tag-name-lowercase %>
  <% %> <%# herb:disable erb-no-empty-tags %>

</div>
```

<img width="790" height="620" alt="image"
src="https://github.com/user-attachments/assets/e38c35bd-f96c-455a-b4a1-5818c05c5c3a"
/>


Future work:
- Be able to skip the skipped lines (useful when we want to find where
are the rules skipped).
- Allow the LSP to make a code action with an autocorrect that adds the
line skipping.
- Allow disable multiple rules in one line (this should be pretty
straightforward in a follow up PR).
- Add another linter rule to avoid putting disable comments that not
disable anything (like erb_lint NoUnusedDisable).

Resolves #270
---
 .../packages/linter/src/cli/file-processor.ts |  5 ++-
 .../src/cli/formatters/json-formatter.ts      |  3 ++
 .../packages/linter/src/cli/output-manager.ts |  6 ++-
 .../linter/src/cli/summary-reporter.ts        |  7 +++-
 javascript/packages/linter/src/linter.ts      | 41 ++++++++++++++++++-
 javascript/packages/linter/src/types.ts       |  1 +
 .../test/__snapshots__/cli.test.ts.snap       | 39 ++++++++++++++++++
 javascript/packages/linter/test/cli.test.ts   |  7 ++++
 .../linter/test/fixtures/ignored.html.erb     |  9 ++++
 .../packages/linter/test/linter.test.ts       |  9 ++++
 10 files changed, 122 insertions(+), 5 deletions(-)
 create mode 100644 javascript/packages/linter/test/fixtures/ignored.html.erb

diff --git a/javascript/packages/linter/src/cli/file-processor.ts b/javascript/packages/linter/src/cli/file-processor.ts
index 9f39e0300..2e98cb798 100644
--- a/javascript/packages/linter/src/cli/file-processor.ts
+++ b/javascript/packages/linter/src/cli/file-processor.ts
@@ -24,6 +24,7 @@ export interface ProcessingContext {
 export interface ProcessingResult {
   totalErrors: number
   totalWarnings: number
+  totalIgnored: number
   filesWithOffenses: number
   filesFixed: number
   ruleCount: number
@@ -52,6 +53,7 @@ export class FileProcessor {
   async processFiles(files: string[], formatOption: FormatOption = 'detailed', context?: ProcessingContext): Promise<ProcessingResult> {
     let totalErrors = 0
     let totalWarnings = 0
+    let totalIgnored = 0
     let filesWithOffenses = 0
     let filesFixed = 0
     let ruleCount = 0
@@ -149,8 +151,9 @@ export class FileProcessor {
         totalWarnings += lintResult.warnings
         filesWithOffenses++
       }
+      totalIgnored += lintResult.ignored
     }
 
-    return { totalErrors, totalWarnings, filesWithOffenses, filesFixed, ruleCount, allOffenses, ruleOffenses, context }
+    return { totalErrors, totalWarnings, totalIgnored, filesWithOffenses, filesFixed, ruleCount, allOffenses, ruleOffenses, context }
   }
 }
diff --git a/javascript/packages/linter/src/cli/formatters/json-formatter.ts b/javascript/packages/linter/src/cli/formatters/json-formatter.ts
index abe23e0d3..4b2708d1d 100644
--- a/javascript/packages/linter/src/cli/formatters/json-formatter.ts
+++ b/javascript/packages/linter/src/cli/formatters/json-formatter.ts
@@ -12,6 +12,7 @@ interface JSONSummary {
   filesWithOffenses: number
   totalErrors: number
   totalWarnings: number
+  totalIgnored: number
   totalOffenses: number
   ruleCount: number
 }
@@ -34,6 +35,7 @@ interface JSONFormatOptions {
   files: string[]
   totalErrors: number
   totalWarnings: number
+  totalIgnored: number
   filesWithOffenses: number
   ruleCount: number
   startTime: number
@@ -79,6 +81,7 @@ export class JSONFormatter extends BaseFormatter {
       filesWithOffenses: options.filesWithOffenses,
       totalErrors: options.totalErrors,
       totalWarnings: options.totalWarnings,
+      totalIgnored: options.totalIgnored,
       totalOffenses: options.totalErrors + options.totalWarnings,
       ruleCount: options.ruleCount
     }
diff --git a/javascript/packages/linter/src/cli/output-manager.ts b/javascript/packages/linter/src/cli/output-manager.ts
index 2c5de40c7..cb75b70df 100644
--- a/javascript/packages/linter/src/cli/output-manager.ts
+++ b/javascript/packages/linter/src/cli/output-manager.ts
@@ -27,7 +27,7 @@ export class OutputManager {
    * Output successful lint results
    */
   async outputResults(results: LintResults, options: OutputOptions): Promise<void> {
-    const { allOffenses, files, totalErrors, totalWarnings, filesWithOffenses, ruleCount, ruleOffenses } = results
+    const { allOffenses, files, totalErrors, totalWarnings, totalIgnored, filesWithOffenses, ruleCount, ruleOffenses } = results
 
     const autofixableCount = allOffenses.filter(offense => offense.autocorrectable).length
 
@@ -47,6 +47,7 @@ export class OutputManager {
           files,
           totalErrors,
           totalWarnings,
+          totalIgnored,
           filesWithOffenses,
           ruleCount,
           startTime: options.startTime,
@@ -71,6 +72,7 @@ export class OutputManager {
           filesWithOffenses,
           totalErrors,
           totalWarnings,
+          totalIgnored,
           totalOffenses: totalErrors + totalWarnings,
           ruleCount
         },
@@ -99,6 +101,7 @@ export class OutputManager {
         files,
         totalErrors,
         totalWarnings,
+        totalIgnored,
         filesWithOffenses,
         ruleCount,
         startTime: options.startTime,
@@ -124,6 +127,7 @@ export class OutputManager {
           filesWithOffenses: 0,
           totalErrors: 0,
           totalWarnings: 0,
+          totalIgnored: 0,
           totalOffenses: 0,
           ruleCount: 0
         },
diff --git a/javascript/packages/linter/src/cli/summary-reporter.ts b/javascript/packages/linter/src/cli/summary-reporter.ts
index 17712b939..f429981f7 100644
--- a/javascript/packages/linter/src/cli/summary-reporter.ts
+++ b/javascript/packages/linter/src/cli/summary-reporter.ts
@@ -4,6 +4,7 @@ export interface SummaryData {
   files: string[]
   totalErrors: number
   totalWarnings: number
+  totalIgnored: number
   filesWithOffenses: number
   ruleCount: number
   startTime: number
@@ -19,7 +20,7 @@ export class SummaryReporter {
   }
 
   displaySummary(data: SummaryData): void {
-    const { files, totalErrors, totalWarnings, filesWithOffenses, ruleCount, startTime, startDate, showTiming, autofixableCount } = data
+    const { files, totalErrors, totalWarnings, totalIgnored, filesWithOffenses, ruleCount, startTime, startDate, showTiming, autofixableCount } = data
 
     console.log("\n")
     console.log(` ${colorize("Summary:", "bold")}`)
@@ -63,6 +64,10 @@ export class SummaryReporter {
       parts.push(colorize(colorize(`${totalWarnings} ${this.pluralize(totalWarnings, "warning")}`, "green"), "bold"))
     }
 
+    if (totalIgnored > 0) {
+      parts.push(colorize(colorize(`${totalIgnored} ignored`, "gray"), "bold"))
+    }
+
     if (parts.length === 0) {
       offensesSummary = colorize(colorize("0 offenses", "green"), "bold")
     } else {
diff --git a/javascript/packages/linter/src/linter.ts b/javascript/packages/linter/src/linter.ts
index 1749e2290..7c8630ef5 100644
--- a/javascript/packages/linter/src/linter.ts
+++ b/javascript/packages/linter/src/linter.ts
@@ -48,6 +48,37 @@ export class Linter {
     return (rule.constructor as any).type === "source"
   }
 
+  private filterOffenses(ruleOffenses: LintOffense[], sourceLines: string[], ruleName: string): { kept: LintOffense[], ignored: LintOffense[] } {
+    const kept: LintOffense[] = [];
+    const ignored: LintOffense[] = [];
+
+    for (const offense of ruleOffenses) {
+      const line = offense.location.start.line;
+      if (line > sourceLines.length) {
+        kept.push(offense);
+        continue;
+      }
+      const lineContent = sourceLines[line - 1];
+
+      const disableCommentRegex = /<%#\s+herb:disable\s+(.*)%>/;
+      const match = lineContent.match(disableCommentRegex);
+
+      if (match) {
+        const rulesRaw = (match && match[1]) || '';
+        const rules = rulesRaw.split(",").map((rule) => rule.trim());
+        if (rules.includes(ruleName) || rules.includes("all")) {
+          ignored.push(offense);
+        } else {
+          kept.push(offense);
+        }
+      } else {
+        kept.push(offense);
+      }
+    }
+
+    return { kept, ignored };
+  }
+
   /**
    * Lint source code using Parser/AST, Lexer, and Source rules.
    * @param source - The source code to lint
@@ -55,10 +86,12 @@ export class Linter {
    */
   lint(source: string, context?: Partial<LintContext>): LintResult {
     this.offenses = []
+    let ignoredCount = 0;
 
     const parseResult = this.herb.parse(source, { track_whitespace: true })
     const lexResult = this.herb.lex(source)
     const hasParserErrors = parseResult.recursiveErrors().length > 0
+    const sourceLines = source.split("\n");
 
     for (const RuleClass of this.rules) {
       const rule = new RuleClass()
@@ -105,7 +138,10 @@ export class Linter {
         }
       }
 
-      this.offenses.push(...ruleOffenses)
+      const { kept, ignored } = this.filterOffenses(ruleOffenses, sourceLines, rule.name);
+      ignoredCount += ignored.length;
+
+      this.offenses.push(...kept)
     }
 
     const errors = this.offenses.filter(offense => offense.severity === "error").length
@@ -114,7 +150,8 @@ export class Linter {
     return {
       offenses: this.offenses,
       errors,
-      warnings
+      warnings,
+      ignored: ignoredCount
     }
   }
 
diff --git a/javascript/packages/linter/src/types.ts b/javascript/packages/linter/src/types.ts
index cf32052ce..ab0d1d31a 100644
--- a/javascript/packages/linter/src/types.ts
+++ b/javascript/packages/linter/src/types.ts
@@ -62,6 +62,7 @@ export interface LintResult<TAutofixContext extends BaseAutofixContext = BaseAut
   offenses: LintOffense<TAutofixContext>[]
   errors: number
   warnings: number
+  ignored: number
 }
 
 /**
diff --git a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
index 62e3df94e..19680107a 100644
--- a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
+++ b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
@@ -75,6 +75,42 @@ test/fixtures/no-trailing-newline.html.erb:1:29
   Fixable      1 offense | 1 autocorrectable using \`--fix\`"
 `;
 
+exports[`CLI Output Formatting > Ignores disabled rules 1`] = `
+"[error] Opening tag name \`<DIV>\` should be lowercase. Use \`<div>\` instead. [Correctable] (html-tag-name-lowercase)
+
+test/fixtures/ignored.html.erb:6:3
+
+      4 │   </h1>
+      5 │ 
+  →   6 │   <DIV>hello</DIV>
+        │    ~~~
+      7 │   <DIV>hello</DIV> <%# herb:disable html-tag-name-lowercase %>
+      8 │   <% %> <%# herb:disable erb-no-empty-tags %>
+
+
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/2] ⎯⎯⎯⎯
+
+[error] Closing tag name \`</DIV>\` should be lowercase. Use \`</div>\` instead. [Correctable] (html-tag-name-lowercase)
+
+test/fixtures/ignored.html.erb:6:14
+
+      4 │   </h1>
+      5 │ 
+  →   6 │   <DIV>hello</DIV>
+        │               ~~~
+      7 │   <DIV>hello</DIV> <%# herb:disable html-tag-name-lowercase %>
+      8 │   <% %> <%# herb:disable erb-no-empty-tags %>
+
+ Rule offenses:
+  html-tag-name-lowercase (2 offenses in 1 file)
+
+
+ Summary:
+  Checked      1 file
+  Offenses     2 errors | 0 warnings | 3 ignored (2 offenses across 1 file)
+  Fixable      2 offenses | 2 autocorrectable using \`--fix\`"
+`;
+
 exports[`CLI Output Formatting > diplays only parsers errors if one is present 1`] = `
 "[error] Unexpected Token. Expected: \`TOKEN_IDENTIFIER, TOKEN_AT, TOKEN_ERB_START,TOKEN_WHITESPACE, or TOKEN_NEWLINE\`, found: \`TOKEN_CHARACTER\`. (\`UNEXPECTED_ERROR\`) (parser-no-errors)
 
@@ -576,6 +612,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for bad file 1`]
     "filesWithOffenses": 1,
     "ruleCount": 40,
     "totalErrors": 2,
+    "totalIgnored": 0,
     "totalOffenses": 2,
     "totalWarnings": 0,
   },
@@ -594,6 +631,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for clean file 1`
     "filesWithOffenses": 0,
     "ruleCount": 40,
     "totalErrors": 0,
+    "totalIgnored": 0,
     "totalOffenses": 0,
     "totalWarnings": 0,
   },
@@ -664,6 +702,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for file with err
     "filesWithOffenses": 1,
     "ruleCount": 40,
     "totalErrors": 3,
+    "totalIgnored": 0,
     "totalOffenses": 3,
     "totalWarnings": 0,
   },
diff --git a/javascript/packages/linter/test/cli.test.ts b/javascript/packages/linter/test/cli.test.ts
index 26c049087..07d576eb5 100644
--- a/javascript/packages/linter/test/cli.test.ts
+++ b/javascript/packages/linter/test/cli.test.ts
@@ -183,6 +183,13 @@ describe("CLI Output Formatting", () => {
     expect(exitCode).toBe(1)
   })
 
+  test("Ignores disabled rules", () => {
+    const { output, exitCode } = runLinter("ignored.html.erb")
+
+    expect(output).toMatchSnapshot()
+    expect(exitCode).toBe(1)
+  })
+
   test("rejects --github with --json format", () => {
     const { output, exitCode } = runLinter("test-file-with-errors.html.erb", "--json", "--github")
 
diff --git a/javascript/packages/linter/test/fixtures/ignored.html.erb b/javascript/packages/linter/test/fixtures/ignored.html.erb
new file mode 100644
index 000000000..45d0bfa4d
--- /dev/null
+++ b/javascript/packages/linter/test/fixtures/ignored.html.erb
@@ -0,0 +1,9 @@
+<div>
+  <h1 class="<%= classes %>">
+    <%= title %>
+  </h1>
+
+  <DIV>hello</DIV>
+  <DIV>hello</DIV> <%# herb:disable html-tag-name-lowercase %>
+  <% %> <%# herb:disable erb-no-empty-tags %>
+</div>
diff --git a/javascript/packages/linter/test/linter.test.ts b/javascript/packages/linter/test/linter.test.ts
index ff64a9784..bfcd750ff 100644
--- a/javascript/packages/linter/test/linter.test.ts
+++ b/javascript/packages/linter/test/linter.test.ts
@@ -193,5 +193,14 @@ describe("@herb-tools/linter", () => {
       expect(result2.offenses).toHaveLength(1)
       expect(result2.offenses[0].rule).toBe("content-based-rule")
     })
+
+    test("can disable a rule with a comment", () => {
+      const html = '<DIV>test</DIV> <%# herb:disable html-tag-name-lowercase %>'
+      const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+      const lintResult = linter.lint(html)
+
+      expect(lintResult.offenses).toHaveLength(0)
+      expect(lintResult.ignored).toBe(2)
+    })
   })
 })

From da1c31d672de3a1a33483a0f1fe61aeea8b13d42 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Thu, 16 Oct 2025 15:37:45 +0200
Subject: [PATCH 72/97] Bump Prism to `v1.6.0` (#669)

https://github.com/ruby/prism/releases/tag/v1.6.0
---
 CONTRIBUTING.md                                      | 2 +-
 Gemfile                                              | 2 +-
 Gemfile.lock                                         | 6 +++---
 javascript/packages/browser/test/browser.test.ts     | 2 +-
 javascript/packages/node-wasm/test/node-wasm.test.ts | 2 +-
 javascript/packages/node/test/node.test.ts           | 2 +-
 test/herb_test.rb                                    | 2 +-
 7 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 41d7ed395..659cab294 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -12,7 +12,7 @@ If you encounter any issues when following along with this file please dont hesi
 - [**Clang 19**](https://clang.llvm.org): The compiler used to build this project.
 - [**Clang Format 19**](https://clang.llvm.org/docs/ClangFormat.html): For formatting the project.
 - [**Clang Tidy 19**](https://clang.llvm.org/extra/clang-tidy/): For linting the project.
-- [**Prism Ruby Parser v1.5.2**](https://github.com/ruby/prism/releases/tag/v1.5.2): We use Prism for Parsing the Ruby Source Code in the HTML+ERB files.
+- [**Prism Ruby Parser v1.6.0**](https://github.com/ruby/prism/releases/tag/v1.6.0): We use Prism for Parsing the Ruby Source Code in the HTML+ERB files.
 - [**Ruby**](https://www.ruby-lang.org/en/): We need Ruby as a dependency for `bundler`.
 - [**Bundler**](https://bundler.io): We are using `bundler` to build [`prism`](https://github.com/ruby/prism) from source so we can build `herb` against it.
 - [**Emscripten**](https://emscripten.org): For the WebAssembly build of `libherb` so it can be used in the browser using the [`@herb-tools/browser`](https://github.com/marcoroth/herb/blob/main/javascript/packages/browser) package.
diff --git a/Gemfile b/Gemfile
index 426455797..fe40af78f 100644
--- a/Gemfile
+++ b/Gemfile
@@ -4,7 +4,7 @@ source "https://rubygems.org"
 
 gemspec
 
-gem "prism", github: "ruby/prism", tag: "v1.5.2"
+gem "prism", github: "ruby/prism", tag: "v1.6.0"
 
 gem "actionview", "~> 8.0"
 gem "lz_string"
diff --git a/Gemfile.lock b/Gemfile.lock
index 9f8672fca..5129d66c8 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -9,10 +9,10 @@ GIT
 
 GIT
   remote: https://github.com/ruby/prism.git
-  revision: 983ecaf4790a536ad26ff444ec962887ea2aa6ba
-  tag: v1.5.2
+  revision: 2924f8f8832d57def7895cd7e2cc199ee58b3a3b
+  tag: v1.6.0
   specs:
-    prism (1.5.2)
+    prism (1.6.0)
 
 PATH
   remote: .
diff --git a/javascript/packages/browser/test/browser.test.ts b/javascript/packages/browser/test/browser.test.ts
index dd0762474..701184766 100644
--- a/javascript/packages/browser/test/browser.test.ts
+++ b/javascript/packages/browser/test/browser.test.ts
@@ -17,7 +17,7 @@ describe("@herb-tools/browser", () => {
   test("version() returns a string", async () => {
     const version = Herb.version
     expect(typeof version).toBe("string")
-    expect(version).toBe("@herb-tools/browser@0.7.5, @herb-tools/core@0.7.5, libprism@1.5.2, libherb@0.7.5 (WebAssembly)")
+    expect(version).toBe("@herb-tools/browser@0.7.5, @herb-tools/core@0.7.5, libprism@1.6.0, libherb@0.7.5 (WebAssembly)")
   })
 
   test("parse() can process a simple template", async () => {
diff --git a/javascript/packages/node-wasm/test/node-wasm.test.ts b/javascript/packages/node-wasm/test/node-wasm.test.ts
index 271933f94..cb4d19bfd 100644
--- a/javascript/packages/node-wasm/test/node-wasm.test.ts
+++ b/javascript/packages/node-wasm/test/node-wasm.test.ts
@@ -17,7 +17,7 @@ describe("@herb-tools/node-wasm", () => {
   test("version() returns a string", async () => {
     const version = Herb.version
     expect(typeof version).toBe("string")
-    expect(version).toBe("@herb-tools/node-wasm@0.7.5, @herb-tools/core@0.7.5, libprism@1.5.2, libherb@0.7.5 (WebAssembly)")
+    expect(version).toBe("@herb-tools/node-wasm@0.7.5, @herb-tools/core@0.7.5, libprism@1.6.0, libherb@0.7.5 (WebAssembly)")
   })
 
   test("parse() can process a simple template", async () => {
diff --git a/javascript/packages/node/test/node.test.ts b/javascript/packages/node/test/node.test.ts
index 83e73788d..892167245 100644
--- a/javascript/packages/node/test/node.test.ts
+++ b/javascript/packages/node/test/node.test.ts
@@ -17,7 +17,7 @@ describe("@herb-tools/node", () => {
   test("version() returns a string", async () => {
     const version = Herb.version
     expect(typeof version).toBe("string")
-    expect(version).toBe("@herb-tools/node@0.7.5, @herb-tools/core@0.7.5, libprism@1.5.2, libherb@0.7.5 (Node.js C++ native extension)")
+    expect(version).toBe("@herb-tools/node@0.7.5, @herb-tools/core@0.7.5, libprism@1.6.0, libherb@0.7.5 (Node.js C++ native extension)")
   })
 
   test("parse() can process a simple template", async () => {
diff --git a/test/herb_test.rb b/test/herb_test.rb
index b74e7e34a..e6705036c 100644
--- a/test/herb_test.rb
+++ b/test/herb_test.rb
@@ -4,6 +4,6 @@
 
 class HerbTest < Minitest::Spec
   test "version" do
-    assert_equal "herb gem v0.7.5, libprism v1.5.2, libherb v0.7.5 (Ruby C native extension)", Herb.version
+    assert_equal "herb gem v0.7.5, libprism v1.6.0, libherb v0.7.5 (Ruby C native extension)", Herb.version
   end
 end

From a2117a47093df2325ffd7072b285fd7abfdc144a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Thu, 16 Oct 2025 20:23:02 +0200
Subject: [PATCH 73/97] C: Implement `hb_string_slice` function (#661)

This PR introduces a new function that allows to get a slice of a
string.

![slice](https://github.com/user-attachments/assets/448e8319-aeef-4cd5-8176-bd9794f45c0c)
---
 src/include/util/hb_string.h |  1 +
 src/util/hb_string.c         | 15 +++++++++++++++
 test/c/test_hb_string.c      | 36 ++++++++++++++++++++++++++++++++++++
 3 files changed, 52 insertions(+)

diff --git a/src/include/util/hb_string.h b/src/include/util/hb_string.h
index 408908458..547d73aa9 100644
--- a/src/include/util/hb_string.h
+++ b/src/include/util/hb_string.h
@@ -11,6 +11,7 @@ typedef struct HB_STRING_STRUCT {
 } hb_string_T;
 
 hb_string_T hb_string_from_c_string(const char* null_terminated_c_string);
+hb_string_T hb_string_slice(hb_string_T string, uint32_t offset);
 bool hb_string_equals(hb_string_T a, hb_string_T b);
 bool hb_string_equals_case_insensitive(hb_string_T a, hb_string_T b);
 bool hb_string_starts_with(hb_string_T string, hb_string_T expected_prefix);
diff --git a/src/util/hb_string.c b/src/util/hb_string.c
index 8145ae575..645d13fb2 100644
--- a/src/util/hb_string.c
+++ b/src/util/hb_string.c
@@ -13,6 +13,21 @@ hb_string_T hb_string_from_c_string(const char* null_terminated_c_string) {
   return string;
 }
 
+hb_string_T hb_string_slice(hb_string_T string, uint32_t offset) {
+  hb_string_T slice;
+  if (string.length < offset) {
+    slice.data = NULL;
+    slice.length = 0;
+
+    return slice;
+  }
+
+  slice.data = string.data + offset;
+  slice.length = string.length - offset;
+
+  return slice;
+}
+
 bool hb_string_equals(hb_string_T a, hb_string_T b) {
   if (a.length != b.length) { return false; }
 
diff --git a/test/c/test_hb_string.c b/test/c/test_hb_string.c
index 49a9c366d..67e3f3eee 100644
--- a/test/c/test_hb_string.c
+++ b/test/c/test_hb_string.c
@@ -25,6 +25,41 @@ TEST(hb_string_equals_tests)
   }
 END
 
+TEST(hb_string_offset_based_slice_tests)
+  {
+    hb_string_T source = hb_string_from_c_string("01234");
+    hb_string_T expected_slice = hb_string_from_c_string("234");
+
+    hb_string_T slice = hb_string_slice(source, 2);
+
+    ck_assert(hb_string_equals(slice, expected_slice));
+  }
+
+  {
+    hb_string_T source = hb_string_from_c_string("01234");
+    hb_string_T expected_slice = hb_string_from_c_string("4");
+
+    hb_string_T slice = hb_string_slice(source, 4);
+
+    ck_assert(hb_string_equals(slice, expected_slice));
+  }
+
+  {
+    hb_string_T source = hb_string_from_c_string("01234");
+    hb_string_T slice = hb_string_slice(source, 5);
+
+    ck_assert(hb_string_is_empty(slice));
+  }
+
+  {
+    hb_string_T source = hb_string_from_c_string("01234");
+    hb_string_T slice = hb_string_slice(source, 6);
+
+    ck_assert(hb_string_is_empty(slice));
+  }
+END
+
+
 TEST(hb_string_equals_case_insensitive_tests)
   {
     hb_string_T a = hb_string_from_c_string("Hello, world.");
@@ -125,6 +160,7 @@ TCase *hb_string_tests(void) {
   TCase *tags = tcase_create("Herb String");
 
   tcase_add_test(tags, hb_string_equals_tests);
+  tcase_add_test(tags, hb_string_offset_based_slice_tests);
   tcase_add_test(tags, hb_string_equals_case_insensitive_tests);
   tcase_add_test(tags, hb_string_is_empty_tests);
   tcase_add_test(tags, hb_string_starts_with_tests);

From a2de4319d80145b04b6ed26819315630066403fe Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Fri, 17 Oct 2025 18:40:07 +0200
Subject: [PATCH 74/97] Core: Introduce `HERB_FILES_GLOB` to share HTML+ERB
 glob (#672)

Resolves #646
Resolves #668
---
 javascript/packages/core/package.json         |  1 -
 javascript/packages/core/src/glob.ts          |  1 +
 javascript/packages/core/src/index.ts         |  3 +-
 javascript/packages/formatter/src/cli.ts      | 34 +++++++++++--------
 .../packages/formatter/test/cli.test.ts       |  6 ++--
 .../packages/language-server/src/server.ts    |  4 ++-
 javascript/packages/linter/README.md          |  8 +++--
 javascript/packages/linter/src/cli.ts         | 10 ++++--
 .../linter/src/cli/argument-parser.ts         |  9 ++---
 javascript/packages/printer/src/cli.ts        | 14 ++++----
 javascript/packages/vscode/src/client.ts      |  2 +-
 javascript/packages/vscode/src/extension.ts   | 13 +++----
 .../vscode/src/herb-analysis-provider.ts      |  4 ++-
 lib/herb/project.rb                           |  2 +-
 14 files changed, 65 insertions(+), 46 deletions(-)
 create mode 100644 javascript/packages/core/src/glob.ts

diff --git a/javascript/packages/core/package.json b/javascript/packages/core/package.json
index 6ae07a8a2..81b3c4a00 100644
--- a/javascript/packages/core/package.json
+++ b/javascript/packages/core/package.json
@@ -2,7 +2,6 @@
   "name": "@herb-tools/core",
   "version": "0.7.5",
   "description": "Core module exporting shared interfaces, AST node definitions, and common utilities for Herb",
-  "type": "module",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
   "bugs": "https://github.com/marcoroth/herb/issues/new?title=Package%20%60@herb-tools/core%60:%20",
diff --git a/javascript/packages/core/src/glob.ts b/javascript/packages/core/src/glob.ts
new file mode 100644
index 000000000..485042c74
--- /dev/null
+++ b/javascript/packages/core/src/glob.ts
@@ -0,0 +1 @@
+export const HERB_FILES_GLOB = "**/*.{html,rhtml,html.erb,html+*.erb,turbo_stream.erb}"
diff --git a/javascript/packages/core/src/index.ts b/javascript/packages/core/src/index.ts
index c0858ee4e..51f88b7e2 100644
--- a/javascript/packages/core/src/index.ts
+++ b/javascript/packages/core/src/index.ts
@@ -2,11 +2,12 @@ export * from "./ast-utils.js"
 export * from "./backend.js"
 export * from "./diagnostic.js"
 export * from "./errors.js"
+export * from "./glob.js"
 export * from "./herb-backend.js"
 export * from "./lex-result.js"
 export * from "./location.js"
-export * from "./nodes.js"
 export * from "./node-type-guards.js"
+export * from "./nodes.js"
 export * from "./parse-result.js"
 export * from "./parser-options.js"
 export * from "./position.js"
diff --git a/javascript/packages/formatter/src/cli.ts b/javascript/packages/formatter/src/cli.ts
index 13020443a..df73eb694 100644
--- a/javascript/packages/formatter/src/cli.ts
+++ b/javascript/packages/formatter/src/cli.ts
@@ -4,6 +4,8 @@ import { glob } from "glob"
 import { join, resolve } from "path"
 
 import { Herb } from "@herb-tools/node-wasm"
+import { HERB_FILES_GLOB } from "@herb-tools/core"
+
 import { Formatter } from "./formatter.js"
 import { parseArgs } from "util"
 import { resolveFormatOptions } from "./options.js"
@@ -19,8 +21,8 @@ export class CLI {
     Usage: herb-format [file|directory|glob-pattern] [options]
 
     Arguments:
-      file|directory|glob-pattern   File to format, directory to format all **/*.html{+*,}.erb files within,
-                                    glob pattern to match files, or '-' for stdin (omit to format all **/*.html{+*,}.erb files in current directory)
+      file|directory|glob-pattern   File to format, directory to format all \`${HERB_FILES_GLOB}\` files within,
+                                    glob pattern to match files, or '-' for stdin (omit to format all \`${HERB_FILES_GLOB}\` files in current directory)
 
     Options:
       -c, --check                     check if files are formatted without modifying them
@@ -30,18 +32,20 @@ export class CLI {
       --max-line-length <number>      maximum line length before wrapping (default: 80)
 
     Examples:
-      herb-format                                 # Format all **/*.html{+*,}.erb files in current directory
+      herb-format                                 # Format all \`${HERB_FILES_GLOB}\` files in current directory
       herb-format index.html.erb                  # Format and write single file
       herb-format templates/index.html.erb        # Format and write single file
-      herb-format templates/                      # Format and **/*.html{+*,}.erb within the given directory
-      herb-format "templates/**/*.html{+*,}.erb"  # Format all .html{+*,}.erb files in templates directory using glob pattern
-      herb-format "**/*.html{+*,}.erb"            # Format all .html{+*,}.erb files using glob pattern
-      herb-format "**/*.xml.erb"                  # Format all .xml.erb files using glob pattern
-      herb-format --check                         # Check if all **/*.html{+*,}.erb files are formatted
-      herb-format --check templates/              # Check if all **/*.html{+*,}.erb files in templates/ are formatted
-      herb-format --indent-width 4           # Format with 4-space indentation
-      herb-format --max-line-length 100      # Format with 100-character line limit
-      cat template.html.erb | herb-format    # Format from stdin to stdout
+      herb-format templates/                      # Format all \`${HERB_FILES_GLOB}\` within the given directory
+      herb-format "templates/**/*.html.erb"       # Format all \`**/*.html.erb\` files in the templates/ directory
+      herb-format "**/*.html.erb"                 # Format all \`*.html.erb\` files using glob pattern
+      herb-format "**/*.xml.erb"                  # Format all \`*.xml.erb\` files using glob pattern
+
+      herb-format --check                         # Check if all \`${HERB_FILES_GLOB}\` files are formatted
+      herb-format --check templates/              # Check if all \`${HERB_FILES_GLOB}\` files in templates/ are formatted
+
+      herb-format --indent-width 4                # Format with 4-space indentation
+      herb-format --max-line-length 100           # Format with 100-character line limit
+      cat template.html.erb | herb-format         # Format from stdin to stdout
   `
 
   private parseArguments() {
@@ -162,7 +166,7 @@ export class CLI {
         }
 
         if (isDirectory) {
-          pattern = join(file, "**/*.html{+*,}.erb")
+          pattern = join(file, HERB_FILES_GLOB)
         } else if (isFile) {
           const source = readFileSync(file, "utf-8")
           const result = formatter.format(source)
@@ -245,10 +249,10 @@ export class CLI {
           process.exit(1)
         }
       } else {
-        const files = await glob("**/*.html{+*,}.erb")
+        const files = await glob(HERB_FILES_GLOB)
 
         if (files.length === 0) {
-          console.log(`No files found matching pattern: ${resolve("**/*.html{+*,}.erb")}`)
+          console.log(`No files found matching pattern: ${resolve(HERB_FILES_GLOB)}`)
 
           process.exit(0)
         }
diff --git a/javascript/packages/formatter/test/cli.test.ts b/javascript/packages/formatter/test/cli.test.ts
index aa17e6c6b..bbb0b302d 100644
--- a/javascript/packages/formatter/test/cli.test.ts
+++ b/javascript/packages/formatter/test/cli.test.ts
@@ -201,7 +201,7 @@ describe("CLI Binary", () => {
       expectExitCode(result, 0)
       expect(result.stderr).toContain("⚠️  Experimental Preview")
       expect(result.stdout).toContain("No files found matching pattern:")
-      expect(result.stdout).toContain("test-empty-dir/**/*.html{+*,}.erb")
+      expect(result.stdout).toContain("test-empty-dir/**/*.{html,rhtml,html.erb,html+*.erb,turbo_stream.erb")
     } finally {
       await rm("test-empty-dir", { recursive: true }).catch(() => {})
     }
@@ -253,7 +253,7 @@ describe("CLI Binary", () => {
 
       expectExitCode(result, 0)
       expect(result.stdout).toContain("No files found matching pattern:")
-      expect(result.stdout).toContain("test-dir/**/*.html{+*,}.erb")
+      expect(result.stdout).toContain("test-dir/**/*.{html,rhtml,html.erb,html+*.erb,turbo_stream.erb")
     } finally {
       await rm("test-dir", { recursive: true }).catch(() => {})
     }
@@ -642,7 +642,7 @@ describe("CLI Binary", () => {
 
       expectExitCode(result, 0)
       expect(result.stdout).toContain("No files found matching pattern")
-      expect(result.stdout).toContain("test-advanced/**/*.html{+*,}.erb")
+      expect(result.stdout).toContain("test-advanced/**/*.{html,rhtml,html.erb,html+*.erb,turbo_stream.erb")
     })
 
     it("should handle mixed file arguments", async () => {
diff --git a/javascript/packages/language-server/src/server.ts b/javascript/packages/language-server/src/server.ts
index c946dfae5..09fa322e3 100644
--- a/javascript/packages/language-server/src/server.ts
+++ b/javascript/packages/language-server/src/server.ts
@@ -14,6 +14,8 @@ import {
 import { Service } from "./service"
 import { HerbSettings } from "./settings"
 
+import { HERB_FILES_GLOB } from "@herb-tools/core"
+
 export class Server {
   private service!: Service
   private connection: Connection
@@ -62,7 +64,7 @@ export class Server {
 
       this.connection.client.register(DidChangeWatchedFilesNotification.type, {
         watchers: [
-          { globPattern: `**/**/*.html{+*,}.erb` },
+          { globPattern: HERB_FILES_GLOB },
           { globPattern: `**/**/.herb-lsp/config.json` },
         ],
       })
diff --git a/javascript/packages/linter/README.md b/javascript/packages/linter/README.md
index 51706970f..77d6e4d74 100644
--- a/javascript/packages/linter/README.md
+++ b/javascript/packages/linter/README.md
@@ -67,7 +67,7 @@ After installing as a dev dependency, add a lint NPM script to your `package.jso
 ```json
 {
   "scripts": {
-    "herb:lint": "herb-lint '**/*.html{+*,}.erb'"
+    "herb:lint": "herb-lint"
   }
 }
 ```
@@ -100,9 +100,11 @@ bun run herb:lint
 
 Basic usage:
 ```bash
+npx @herb-tools/linter
+npx @herb-tools/linter app/views/
 npx @herb-tools/linter template.html.erb
-npx @herb-tools/linter "**/*.html{+*,}.erb"
-npx @herb-tools/linter app/
+npx @herb-tools/linter "**/*.rhtml"
+npx @herb-tools/linter "**/*.xml.erb"
 ```
 
 #### Options
diff --git a/javascript/packages/linter/src/cli.ts b/javascript/packages/linter/src/cli.ts
index 96f769332..d22ab76ba 100644
--- a/javascript/packages/linter/src/cli.ts
+++ b/javascript/packages/linter/src/cli.ts
@@ -1,12 +1,16 @@
 import { glob } from "glob"
 import { Herb } from "@herb-tools/node-wasm"
+import { HERB_FILES_GLOB } from "@herb-tools/core"
+
 import { existsSync, statSync } from "fs"
 import { dirname, resolve, relative } from "path"
 
-import { ArgumentParser, type FormatOption } from "./cli/argument-parser.js"
+import { ArgumentParser } from "./cli/argument-parser.js"
 import { FileProcessor } from "./cli/file-processor.js"
 import { OutputManager } from "./cli/output-manager.js"
 
+import type { FormatOption } from "./cli/argument-parser.js"
+
 export * from "./cli/index.js"
 
 export class CLI {
@@ -105,7 +109,7 @@ export class CLI {
 
   protected adjustPattern(pattern: string | undefined): string {
     if (!pattern) {
-      return '**/*.html{+*,}.erb'
+      return HERB_FILES_GLOB
     }
 
     const resolvedPattern = resolve(pattern)
@@ -114,7 +118,7 @@ export class CLI {
       const stats = statSync(resolvedPattern)
 
       if (stats.isDirectory()) {
-        return '**/*.html{+*,}.erb'
+        return HERB_FILES_GLOB
       } else if (stats.isFile()) {
         return relative(this.projectPath, resolvedPattern)
       }
diff --git a/javascript/packages/linter/src/cli/argument-parser.ts b/javascript/packages/linter/src/cli/argument-parser.ts
index 5f9f039a0..a4af407d6 100644
--- a/javascript/packages/linter/src/cli/argument-parser.ts
+++ b/javascript/packages/linter/src/cli/argument-parser.ts
@@ -5,6 +5,7 @@ import { statSync } from "fs"
 import { join } from "path"
 
 import { Herb } from "@herb-tools/node-wasm"
+import { HERB_FILES_GLOB } from "@herb-tools/core"
 
 import { THEME_NAMES, DEFAULT_THEME } from "@herb-tools/highlighter"
 import type { ThemeInput } from "@herb-tools/highlighter"
@@ -30,8 +31,8 @@ export class ArgumentParser {
 
     Arguments:
       file             Single file to lint
-      glob-pattern     Files to lint (defaults to **/*.html{+*,}.erb)
-      directory        Directory to lint (automatically appends **/*.html{+*,}.erb)
+      glob-pattern     Files to lint (defaults to \`${HERB_FILES_GLOB}\`)
+      directory        Directory to lint (automatically appends \`${HERB_FILES_GLOB}\`)
 
     Options:
       -h, --help       show help
@@ -132,12 +133,12 @@ export class ArgumentParser {
   }
 
   private getFilePattern(positionals: string[]): string {
-    let pattern = positionals.length > 0 ? positionals[0] : "**/*.html{+*,}.erb"
+    let pattern = positionals.length > 0 ? positionals[0] : HERB_FILES_GLOB
 
     try {
       const stat = statSync(pattern)
       if (stat.isDirectory()) {
-        pattern = join(pattern, "**/*.html{+*,}.erb")
+        pattern = join(pattern, HERB_FILES_GLOB)
       }
     } catch {
       // Not a file/directory, treat as glob pattern
diff --git a/javascript/packages/printer/src/cli.ts b/javascript/packages/printer/src/cli.ts
index 4d4e8b8a2..6cd8cde9d 100644
--- a/javascript/packages/printer/src/cli.ts
+++ b/javascript/packages/printer/src/cli.ts
@@ -7,6 +7,8 @@ import { resolve } from "path"
 import { glob } from "glob"
 
 import { Herb } from "@herb-tools/node-wasm"
+import { HERB_FILES_GLOB } from "@herb-tools/core"
+
 import { IdentityPrinter } from "./index.js"
 
 interface CLIOptions {
@@ -74,7 +76,7 @@ export class CLI {
         -o, --output <file>          Output file path (defaults to stdout)
         --verify                     Verify that output matches input exactly
         --stats                      Show parsing and printing statistics
-        --glob                       Treat input as glob pattern (default: **/*.html{+*,}.erb)
+        --glob                       Treat input as glob pattern (default: ${HERB_FILES_GLOB})
         -h, --help                   Show this help message
 
       Examples:
@@ -84,11 +86,11 @@ export class CLI {
         herb-print input.html.erb --stats
 
         # Glob patterns (batch verification)
-        herb-print --glob --verify                         # All .html{+*,}.erb files
-        herb-print "app/views/**/*.html{+*,}.erb" --glob --verify --stats
+        herb-print --glob --verify                         # All .html.erb files
+        herb-print "app/views/**/*.html.erb" --glob --verify --stats
         herb-print "*.erb" --glob --verify
-        herb-print "/path/to/templates" --glob --verify    # Directory (auto-appends /**/*.html{+*,}.erb)
-        herb-print "/path/to/templates/**/*.html{+*,}.erb" --glob --verify
+        herb-print "/path/to/templates" --glob --verify    # Directory (auto-appends /${HERB_FILES_GLOB})
+        herb-print "/path/to/templates/**/*.html.erb" --glob --verify
 
         # The --verify flag is useful to test parser fidelity:
         herb-print input.html.erb --verify
@@ -108,7 +110,7 @@ export class CLI {
       await Herb.load()
 
       if (options.glob) {
-        const pattern = options.input || "**/*.html{+*,}.erb"
+        const pattern = options.input || HERB_FILES_GLOB
         const files = await glob(pattern)
 
         if (files.length === 0) {
diff --git a/javascript/packages/vscode/src/client.ts b/javascript/packages/vscode/src/client.ts
index caccf60be..3679baf6a 100644
--- a/javascript/packages/vscode/src/client.ts
+++ b/javascript/packages/vscode/src/client.ts
@@ -7,7 +7,7 @@ export class Client {
   private client: LanguageClient
   private serverModule: string
   private languageClientId = "languageServerHerb"
-  private languageClientName = "Herb LSP "
+  private languageClientName = "Herb Language Server "
   private context: ExtensionContext
   private configurationListener?: Disposable
 
diff --git a/javascript/packages/vscode/src/extension.ts b/javascript/packages/vscode/src/extension.ts
index 5b873283f..fb4bb0e2b 100644
--- a/javascript/packages/vscode/src/extension.ts
+++ b/javascript/packages/vscode/src/extension.ts
@@ -1,5 +1,7 @@
 import * as vscode from "vscode"
 
+import { HERB_FILES_GLOB } from "@herb-tools/core"
+
 import { Client } from "./client"
 import { HerbAnalysisProvider } from "./herb-analysis-provider"
 import { HerbCodeActionProvider } from "./code-action-provider"
@@ -63,8 +65,7 @@ export async function activate(context: vscode.ExtensionContext) {
     })
   )
 
-  // Set up file watcher for HTML+ERB files
-  const fileWatcher = vscode.workspace.createFileSystemWatcher('**/*.html{+*,}.erb')
+  const fileWatcher = vscode.workspace.createFileSystemWatcher(HERB_FILES_GLOB)
 
   fileWatcher.onDidChange(async (uri) => {
     console.log(`File changed: ${uri.fsPath}`)
@@ -83,7 +84,6 @@ export async function activate(context: vscode.ExtensionContext) {
 
   context.subscriptions.push(fileWatcher)
 
-  // Auto-run analyze project if HTML+ERB files exist
   await runAutoAnalysis()
 
   console.log("Herb LSP is now active!")
@@ -94,12 +94,13 @@ async function runAutoAnalysis() {
     return
   }
 
-  const erbFiles = await vscode.workspace.findFiles('**/*.html{+*,}.erb')
-  if (erbFiles.length === 0) {
+  const files = await vscode.workspace.findFiles(HERB_FILES_GLOB)
+  if (files.length === 0) {
     return
   }
 
-  console.log(`Found ${erbFiles.length} HTML+ERB files. Running auto-analysis...`)
+  console.log(`Found ${files.length} HTML+ERB files. Running auto-analysis...`)
+
   await analysisProvider.analyzeProject()
 }
 
diff --git a/javascript/packages/vscode/src/herb-analysis-provider.ts b/javascript/packages/vscode/src/herb-analysis-provider.ts
index d578f5502..1121f4825 100644
--- a/javascript/packages/vscode/src/herb-analysis-provider.ts
+++ b/javascript/packages/vscode/src/herb-analysis-provider.ts
@@ -5,6 +5,8 @@ import { VersionService } from './version-service'
 
 import { workspace, window, EventEmitter, ProgressLocation } from 'vscode'
 
+import { HERB_FILES_GLOB } from "@herb-tools/core"
+
 import type { FileStatus, TreeNode } from './types'
 import type { TreeDataProvider, Event, ExtensionContext, TreeItem, Uri } from 'vscode'
 
@@ -46,7 +48,7 @@ export class HerbAnalysisProvider implements TreeDataProvider<TreeNode> {
   }
 
   async analyzeProject(): Promise<void> {
-    const uris = await workspace.findFiles('**/*.html{+*,}.erb')
+    const uris = await workspace.findFiles(HERB_FILES_GLOB)
 
     this.lastAnalysisTime = new Date()
 
diff --git a/lib/herb/project.rb b/lib/herb/project.rb
index 1d9332f96..bd44dc327 100644
--- a/lib/herb/project.rb
+++ b/lib/herb/project.rb
@@ -30,7 +30,7 @@ def initialize(project_path, output_file: nil)
     end
 
     def glob
-      "**/*.html{+*,}.erb"
+      "**/*.{html,rhtml,html.erb,html+*.erb,turbo_stream.erb}"
     end
 
     def full_path_glob

From e74424dfaf936bccf0a54ea05802fa10dfa8c1c3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Fri, 17 Oct 2025 18:42:39 +0200
Subject: [PATCH 75/97] C: Use Arena Allocator in `hb_string_to_c_string`
 function (#674)

This PR adds the new arena allocator to the `hb_string_to_c_string` that
is the only `hb_string` function that needs to allocate memory.
---
 src/include/util/hb_string.h | 19 +++----------------
 src/util/hb_string.c         |  4 ++--
 2 files changed, 5 insertions(+), 18 deletions(-)

diff --git a/src/include/util/hb_string.h b/src/include/util/hb_string.h
index 547d73aa9..fee5ba2c7 100644
--- a/src/include/util/hb_string.h
+++ b/src/include/util/hb_string.h
@@ -5,6 +5,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include "../hb_arena.h"
+
 typedef struct HB_STRING_STRUCT {
   char* data;
   uint32_t length;
@@ -17,21 +19,6 @@ bool hb_string_equals_case_insensitive(hb_string_T a, hb_string_T b);
 bool hb_string_starts_with(hb_string_T string, hb_string_T expected_prefix);
 bool hb_string_is_empty(hb_string_T string);
 
-/**
- * @brief Creates a null terminated c string version of the passed string
- *
- * @param string The string for which a c string version is to be created
- * @return A heap allocated null terminated c string
- *
- * Example:
- * @code
- *
- * hb_string_T string = hb_string_from_c_string("Hello, world");
- * char* cstring = hb_string_to_c_string(string);
- *
- * free(cstring);
- * @endcode
- */
-char* hb_string_to_c_string(hb_string_T string);
+char* hb_string_to_c_string(hb_arena_T* allocator, hb_string_T string);
 
 #endif
diff --git a/src/util/hb_string.c b/src/util/hb_string.c
index 645d13fb2..cf3b4e864 100644
--- a/src/util/hb_string.c
+++ b/src/util/hb_string.c
@@ -51,9 +51,9 @@ bool hb_string_is_empty(hb_string_T string) {
   return string.length == 0;
 }
 
-char* hb_string_to_c_string(hb_string_T string) {
+char* hb_string_to_c_string(hb_arena_T* allocator, hb_string_T string) {
   size_t string_length_in_bytes = sizeof(char) * (string.length);
-  char* buffer = malloc(string_length_in_bytes + sizeof(char) * 1);
+  char* buffer = hb_arena_alloc(allocator, string_length_in_bytes + sizeof(char) * 1);
 
   if (!hb_string_is_empty(string)) { memcpy(buffer, string.data, string_length_in_bytes); }
 

From 256c74627a6307b130dee8b5c8b63755f17fd49a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Fri, 17 Oct 2025 18:57:26 +0200
Subject: [PATCH 76/97] C: Use `hb_string_T` in `lexer_peek_helpers.c` (#656)

This PR migrates the lexer peek helper interfaces to use `hb_string_T`
instead of null terminated strings.
---
 src/include/lexer_peek_helpers.h | 28 +++++++-------
 src/lexer_peek_helpers.c         | 66 ++++++++++++++++----------------
 2 files changed, 46 insertions(+), 48 deletions(-)

diff --git a/src/include/lexer_peek_helpers.h b/src/include/lexer_peek_helpers.h
index c89ca2e08..9cc7e94c9 100644
--- a/src/include/lexer_peek_helpers.h
+++ b/src/include/lexer_peek_helpers.h
@@ -20,25 +20,25 @@ typedef struct {
   lexer_state_T state;
 } lexer_state_snapshot_T;
 
-char lexer_peek(const lexer_T* lexer, int offset);
-bool lexer_peek_for_doctype(const lexer_T* lexer, int offset);
-bool lexer_peek_for_xml_declaration(const lexer_T* lexer, int offset);
-bool lexer_peek_for_cdata_start(const lexer_T* lexer, int offset);
-bool lexer_peek_for_cdata_end(const lexer_T* lexer, int offset);
+char lexer_peek(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_for_doctype(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_for_xml_declaration(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_for_cdata_start(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_for_cdata_end(const lexer_T* lexer, uint32_t offset);
 
-bool lexer_peek_for_html_comment_start(const lexer_T* lexer, int offset);
-bool lexer_peek_for_html_comment_end(const lexer_T* lexer, int offset);
+bool lexer_peek_for_html_comment_start(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_for_html_comment_end(const lexer_T* lexer, uint32_t offset);
 
-bool lexer_peek_erb_close_tag(const lexer_T* lexer, int offset);
-bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, int offset);
-bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, int offset);
-bool lexer_peek_erb_equals_close_tag(const lexer_T* lexer, int offset);
-bool lexer_peek_erb_end(const lexer_T* lexer, int offset);
+bool lexer_peek_erb_close_tag(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_erb_equals_close_tag(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_erb_end(const lexer_T* lexer, uint32_t offset);
 
-char lexer_backtrack(const lexer_T* lexer, int offset);
+char lexer_backtrack(const lexer_T* lexer, uint32_t offset);
 
 bool lexer_peek_for_token_type_after_whitespace(lexer_T* lexer, token_type_T token_type);
-bool lexer_peek_for_close_tag_start(const lexer_T* lexer, int offset);
+bool lexer_peek_for_close_tag_start(const lexer_T* lexer, uint32_t offset);
 
 lexer_state_snapshot_T lexer_save_state(lexer_T* lexer);
 void lexer_restore_state(lexer_T* lexer, lexer_state_snapshot_T snapshot);
diff --git a/src/lexer_peek_helpers.c b/src/lexer_peek_helpers.c
index 828d2f5fd..e5decf1d9 100644
--- a/src/lexer_peek_helpers.c
+++ b/src/lexer_peek_helpers.c
@@ -3,73 +3,71 @@
 #include "include/lexer_struct.h"
 #include "include/macros.h"
 #include "include/token.h"
+#include "include/util/hb_string.h"
 
 #include <ctype.h>
 #include <stdbool.h>
 
-char lexer_backtrack(const lexer_T* lexer, const int offset) {
+char lexer_backtrack(const lexer_T* lexer, uint32_t offset) {
   return lexer->source.data[MAX(lexer->current_position - offset, 0)];
 }
 
-char lexer_peek(const lexer_T* lexer, const int offset) {
+char lexer_peek(const lexer_T* lexer, uint32_t offset) {
   return lexer->source.data[MIN(lexer->current_position + offset, lexer->source.length)];
 }
 
-bool lexer_peek_for(const lexer_T* lexer, const int offset, const char* pattern, const bool case_insensitive) {
-  for (int index = 0; pattern[index]; index++) {
-    const char character = lexer_peek(lexer, offset + index);
+bool lexer_peek_for(const lexer_T* lexer, uint32_t offset, hb_string_T pattern, const bool case_insensitive) {
+  hb_string_T remaining_source = hb_string_slice(lexer->source, lexer->current_position + offset);
+  remaining_source.length = MIN(pattern.length, remaining_source.length);
 
-    if (case_insensitive) {
-      if (tolower(character) != tolower(pattern[index])) { return false; }
-    } else {
-      if (character != pattern[index]) { return false; }
-    }
+  if (case_insensitive) {
+    return hb_string_equals_case_insensitive(remaining_source, pattern);
+  } else {
+    return hb_string_equals(remaining_source, pattern);
   }
-
-  return true;
 }
 
-bool lexer_peek_for_doctype(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "<!DOCTYPE", true);
+bool lexer_peek_for_doctype(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string_from_c_string("<!DOCTYPE"), true);
 }
 
-bool lexer_peek_for_xml_declaration(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "<?xml", true);
+bool lexer_peek_for_xml_declaration(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string_from_c_string("<?xml"), true);
 }
 
-bool lexer_peek_for_cdata_start(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "<![CDATA[", false);
+bool lexer_peek_for_cdata_start(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string_from_c_string("<![CDATA["), false);
 }
 
-bool lexer_peek_for_cdata_end(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "]]>", false);
+bool lexer_peek_for_cdata_end(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string_from_c_string("]]>"), false);
 }
 
-bool lexer_peek_for_html_comment_start(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "<!--", false);
+bool lexer_peek_for_html_comment_start(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string_from_c_string("<!--"), false);
 }
 
-bool lexer_peek_for_html_comment_end(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "-->", false);
+bool lexer_peek_for_html_comment_end(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string_from_c_string("-->"), false);
 }
 
-bool lexer_peek_erb_close_tag(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "%>", false);
+bool lexer_peek_erb_close_tag(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string_from_c_string("%>"), false);
 }
 
-bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "-%>", false);
+bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string_from_c_string("-%>"), false);
 }
 
-bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "%%>", false);
+bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string_from_c_string("%%>"), false);
 }
 
-bool lexer_peek_erb_equals_close_tag(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "=%>", false);
+bool lexer_peek_erb_equals_close_tag(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string_from_c_string("=%>"), false);
 }
 
-bool lexer_peek_erb_end(const lexer_T* lexer, const int offset) {
+bool lexer_peek_erb_end(const lexer_T* lexer, uint32_t offset) {
   return (
     lexer_peek_erb_close_tag(lexer, offset) || lexer_peek_erb_dash_close_tag(lexer, offset)
     || lexer_peek_erb_percent_close_tag(lexer, offset) || lexer_peek_erb_equals_close_tag(lexer, offset)
@@ -103,7 +101,7 @@ bool lexer_peek_for_token_type_after_whitespace(lexer_T* lexer, token_type_T tok
   return result;
 }
 
-bool lexer_peek_for_close_tag_start(const lexer_T* lexer, const int offset) {
+bool lexer_peek_for_close_tag_start(const lexer_T* lexer, uint32_t offset) {
   if (lexer_peek(lexer, offset) != '<' || lexer_peek(lexer, offset + 1) != '/') { return false; }
 
   int pos = offset + 2;

From a7f5b7546349a23282df0854d2f3b493a33c68f4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Sat, 18 Oct 2025 12:44:04 +0200
Subject: [PATCH 77/97] C: Inline `size_t_to_string` function (#676)

This PR removes the `size_t_to_string` function and replaces its only
usages the function body.

## Reasoning

- `size_t_to_string` is only used in one place
- it is rather trivial
- if we would migrate it to use the arena allocator we would need to
pass an explicit arena allocator to the pretty print function
- Using a stack allocated char array has better cache locality
---
 src/include/util.h | 2 --
 src/pretty_print.c | 8 +++++---
 src/util.c         | 7 -------
 3 files changed, 5 insertions(+), 12 deletions(-)

diff --git a/src/include/util.h b/src/include/util.h
index 61b371605..54ad790b7 100644
--- a/src/include/util.h
+++ b/src/include/util.h
@@ -11,6 +11,4 @@ char* quoted_string(const char* input);
 char* wrap_string(const char* input, char character);
 char* herb_strdup(const char* s);
 
-char* size_t_to_string(size_t value);
-
 #endif
diff --git a/src/pretty_print.c b/src/pretty_print.c
index b67ab9aec..a32e15c68 100644
--- a/src/pretty_print.c
+++ b/src/pretty_print.c
@@ -90,10 +90,12 @@ void pretty_print_size_t_property(
   hb_buffer_T* buffer
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
-  char* string = size_t_to_string(value);
-  hb_buffer_append(buffer, string);
+
+  char size_string[21];
+  snprintf(size_string, 21, "%zu", value);
+
+  hb_buffer_append(buffer, size_string);
   hb_buffer_append(buffer, "\n");
-  free(string);
 }
 
 void pretty_print_array(
diff --git a/src/util.c b/src/util.c
index ccf6662d3..4572a056f 100644
--- a/src/util.c
+++ b/src/util.c
@@ -60,10 +60,3 @@ char* herb_strdup(const char* s) {
 
   return copy;
 }
-
-char* size_t_to_string(const size_t value) {
-  char* buffer = malloc(21);
-  snprintf(buffer, 21, "%zu", value);
-
-  return buffer;
-}

From bdf595b3b15525d3ec4da2a49780ed703269c4bc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Sat, 18 Oct 2025 17:03:57 +0200
Subject: [PATCH 78/97] C: Use `hb_string_T` in `herb_analyze` function (#678)

This PR starts using the `hb_string_T` in the interface of
`herb_analyze`.

This is a side effect free refactor, that makes the switch to
`hb_string_T` based token values easier later on.
---
 src/analyze.c               | 5 +++--
 src/analyzed_ruby.c         | 5 +++--
 src/include/analyzed_ruby.h | 3 ++-
 3 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/analyze.c b/src/analyze.c
index 5e4462bdf..fb1dab545 100644
--- a/src/analyze.c
+++ b/src/analyze.c
@@ -11,6 +11,7 @@
 #include "include/token_struct.h"
 #include "include/util.h"
 #include "include/util/hb_array.h"
+#include "include/util/hb_string.h"
 #include "include/visitor.h"
 
 #include <prism.h>
@@ -19,7 +20,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-static analyzed_ruby_T* herb_analyze_ruby(char* source) {
+static analyzed_ruby_T* herb_analyze_ruby(hb_string_T source) {
   analyzed_ruby_T* analyzed = init_analyzed_ruby(source);
 
   pm_visit_node(analyzed->root, search_if_nodes, analyzed);
@@ -52,7 +53,7 @@ static bool analyze_erb_content(const AST_NODE_T* node, void* data) {
     const char* opening = erb_content_node->tag_opening->value;
 
     if (strcmp(opening, "<%%") != 0 && strcmp(opening, "<%%=") != 0 && strcmp(opening, "<%#") != 0) {
-      analyzed_ruby_T* analyzed = herb_analyze_ruby(erb_content_node->content->value);
+      analyzed_ruby_T* analyzed = herb_analyze_ruby(hb_string_from_c_string(erb_content_node->content->value));
 
       if (false) { pretty_print_analyzed_ruby(analyzed, erb_content_node->content->value); }
 
diff --git a/src/analyzed_ruby.c b/src/analyzed_ruby.c
index a2cd0947b..10e5f585f 100644
--- a/src/analyzed_ruby.c
+++ b/src/analyzed_ruby.c
@@ -1,12 +1,13 @@
 #include "include/analyzed_ruby.h"
+#include "include/util/hb_string.h"
 
 #include <prism.h>
 #include <string.h>
 
-analyzed_ruby_T* init_analyzed_ruby(char* source) {
+analyzed_ruby_T* init_analyzed_ruby(hb_string_T source) {
   analyzed_ruby_T* analyzed = malloc(sizeof(analyzed_ruby_T));
 
-  pm_parser_init(&analyzed->parser, (const uint8_t*) source, strlen(source), NULL);
+  pm_parser_init(&analyzed->parser, (const uint8_t*) source.data, source.length, NULL);
 
   analyzed->root = pm_parse(&analyzed->parser);
   analyzed->valid = (analyzed->parser.error_list.size == 0);
diff --git a/src/include/analyzed_ruby.h b/src/include/analyzed_ruby.h
index 9d32c9715..fc31037af 100644
--- a/src/include/analyzed_ruby.h
+++ b/src/include/analyzed_ruby.h
@@ -2,6 +2,7 @@
 #define HERB_ANALYZED_RUBY_H
 
 #include "util/hb_array.h"
+#include "util/hb_string.h"
 
 #include <prism.h>
 
@@ -30,7 +31,7 @@ typedef struct ANALYZED_RUBY_STRUCT {
   bool has_yield_node;
 } analyzed_ruby_T;
 
-analyzed_ruby_T* init_analyzed_ruby(char* source);
+analyzed_ruby_T* init_analyzed_ruby(hb_string_T source);
 void free_analyzed_ruby(analyzed_ruby_T* analyzed);
 
 #endif

From 1075f63ad31d6f8e757e5ea05bfdb287734277b1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Sat, 18 Oct 2025 17:42:32 +0200
Subject: [PATCH 79/97] C: Remove unused `pretty_print_analyzed_ruby` (#679)

This PR removes the unused `pretty_print_analyzed_ruby` function
---
 src/analyze.c              |  2 --
 src/include/pretty_print.h |  2 --
 src/pretty_print.c         | 27 ---------------------------
 3 files changed, 31 deletions(-)

diff --git a/src/analyze.c b/src/analyze.c
index fb1dab545..fe0b95455 100644
--- a/src/analyze.c
+++ b/src/analyze.c
@@ -55,8 +55,6 @@ static bool analyze_erb_content(const AST_NODE_T* node, void* data) {
     if (strcmp(opening, "<%%") != 0 && strcmp(opening, "<%%=") != 0 && strcmp(opening, "<%#") != 0) {
       analyzed_ruby_T* analyzed = herb_analyze_ruby(hb_string_from_c_string(erb_content_node->content->value));
 
-      if (false) { pretty_print_analyzed_ruby(analyzed, erb_content_node->content->value); }
-
       erb_content_node->parsed = true;
       erb_content_node->valid = analyzed->valid;
       erb_content_node->analyzed_ruby = analyzed;
diff --git a/src/include/pretty_print.h b/src/include/pretty_print.h
index 12d33e8a0..d7921a8c0 100644
--- a/src/include/pretty_print.h
+++ b/src/include/pretty_print.h
@@ -100,6 +100,4 @@ void pretty_print_errors(
   hb_buffer_T* buffer
 );
 
-void pretty_print_analyzed_ruby(analyzed_ruby_T* analyzed, const char* source);
-
 #endif
diff --git a/src/pretty_print.c b/src/pretty_print.c
index a32e15c68..079bf9489 100644
--- a/src/pretty_print.c
+++ b/src/pretty_print.c
@@ -250,30 +250,3 @@ void pretty_print_string_property(
     if (quoted != NULL) { free(quoted); }
   }
 }
-
-void pretty_print_analyzed_ruby(analyzed_ruby_T* analyzed, const char* source) {
-  printf(
-    "------------------------\nanalyzed (%p)\n------------------------\n%s\n------------------------\n  if:     %i\n "
-    " elsif:  %i\n  else:   %i\n  end:    %i\n  block:  %i\n  block_closing: %i\n  case:   %i\n  when:   %i\n  for:    "
-    "%i\n  while:  %i\n "
-    " until:  %i\n  begin:  %i\n  "
-    "rescue: %i\n  ensure: %i\n  unless: %i\n==================\n\n",
-    (void*) analyzed,
-    source,
-    analyzed->has_if_node,
-    analyzed->has_elsif_node,
-    analyzed->has_else_node,
-    analyzed->has_end,
-    analyzed->has_block_node,
-    analyzed->has_block_closing,
-    analyzed->has_case_node,
-    analyzed->has_when_node,
-    analyzed->has_for_node,
-    analyzed->has_while_node,
-    analyzed->has_until_node,
-    analyzed->has_begin_node,
-    analyzed->has_rescue_node,
-    analyzed->has_ensure_node,
-    analyzed->has_unless_node
-  );
-}

From dac2595a32694b62b9ff6e9d49e8b75efeb01eb2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Sun, 19 Oct 2025 13:33:08 +0200
Subject: [PATCH 80/97] C: Make `is_newline` function legible (#682)

This PR is just a minor fix for a nitpick of mine. Instead of using the
ascii codes in the `is_newline` function, we use the characters
directly, making the function way more readable.
---
 src/util.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/util.c b/src/util.c
index 4572a056f..9d6af3dc8 100644
--- a/src/util.c
+++ b/src/util.c
@@ -6,8 +6,8 @@
 #include <stdlib.h>
 #include <string.h>
 
-int is_newline(const int character) {
-  return character == 13 || character == 10;
+int is_newline(int character) {
+  return character == '\n' || character == '\r';
 }
 
 char* escape_newlines(const char* input) {

From e3b7291393269a927169dfd84ef94e16b354dcc5 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Sun, 19 Oct 2025 13:54:31 +0200
Subject: [PATCH 81/97] Lexer: Handle Memory Leak in `lexer_parse_erb_content`
 (#690)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

As discovered by @timkaechele, this pull request fixes a memory leak in
the `lexer_parse_erb_content` function when returning early in the
`lexer_eof` case.

Co-authored-by: Tim Kächele <3810945+timkaechele@users.noreply.github.com>
---
 src/lexer.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/lexer.c b/src/lexer.c
index a00cd7551..0822caedb 100644
--- a/src/lexer.c
+++ b/src/lexer.c
@@ -224,7 +224,11 @@ static token_T* lexer_parse_erb_content(lexer_T* lexer) {
 
   while (!lexer_peek_erb_end(lexer, 0)) {
     if (lexer_eof(lexer)) {
-      return token_init(buffer.value, TOKEN_ERROR, lexer); // Handle unexpected EOF
+      token_T* token = token_init(buffer.value, TOKEN_ERROR, lexer); // Handle unexpected EOF
+
+      free(buffer.value);
+
+      return token;
     }
 
     hb_buffer_append_char(&buffer, lexer->current_character);

From 788e8284e0a7fba78ecc44eddb645e1355bea898 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Sun, 19 Oct 2025 14:01:13 +0200
Subject: [PATCH 82/97] Parser: Handle memory leak in `herb_parse` (#691)

Follow up on #690

**`bin/leaks_parse examples/incomplete_erb.invalid.html.erb`**

```
leaks Report Version: 4.0, multi-line stacks
Process 1007: 189 nodes malloced for 11 KB
Process 1007: 4 leaks for 240 total leaked bytes.

STACK OF 1 INSTANCE OF 'ROOT LEAK: <malloc in hb_array_init>':
5   dyld                                  0x1820aab98 start + 6076
4   herb                                  0x10282b800 main + 576  main.c:96
3   herb                                  0x102829250 herb_parse + 168  herb.c:40
2   herb                                  0x10282c29c herb_parser_init + 64  parser.c:39
1   herb                                  0x102831774 hb_array_init + 24  hb_array.c:12
0   libsystem_malloc.dylib                0x18227d080 _malloc_zone_malloc_instrumented_or_legacy + 152
====
    2 (176 bytes) ROOT LEAK: <malloc in hb_array_init 0x14c704130> [32]
       1 (144 bytes) <malloc in hb_array_init 0x14c704150> [144]

STACK OF 1 INSTANCE OF 'ROOT LEAK: <calloc in token_init>':
10  dyld                                  0x1820aab98 start + 6076
9   herb                                  0x10282b800 main + 576  main.c:96
8   herb                                  0x102829258 herb_parse + 176  herb.c:42
7   herb                                  0x10282c2e4 herb_parser_parse + 24  parser.c:1206
6   herb                                  0x10282c36c parser_parse_document + 124  parser.c:1196
5   herb                                  0x10282c054 parser_consume_expected + 36  parser_helpers.c:152
4   herb                                  0x10282c018 parser_consume_if_present + 64  parser_helpers.c:148
3   herb                                  0x10282bee8 parser_advance + 40  parser_helpers.c:142
2   herb                                  0x10282a3a4 lexer_next_token + 52  lexer.c:269
1   herb                                  0x10282fc5c token_init + 40  token.c:17
0   libsystem_malloc.dylib                0x18227d270 _malloc_zone_calloc_instrumented_or_legacy + 132
====
    2 (64 bytes) ROOT LEAK: <calloc in token_init 0x14c704370> [48]
       1 (16 bytes) <malloc in herb_strdup 0x14c7043a0> [16]

```
---
 examples/complete_erb.html.erb                                | 1 +
 examples/incomplete_erb.invalid.html.erb                      | 1 +
 src/herb.c                                                    | 2 ++
 src/parser.c                                                  | 2 --
 test/engine/examples_compilation_test.rb                      | 2 ++
 ...plete_erb_compilation_a33dd3e79d24b4f31f6d4e92611f3f63.txt | 4 ++++
 ..._doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt} | 0
 ...0011_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt} | 0
 ...0012_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt} | 0
 ..._if_else_compilation_1437d0425640509570342c24b30de571.txt} | 0
 ...ine_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt} | 0
 ...th_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt} | 0
 ...d_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt} | 0
 ...le_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt} | 0
 ...mple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt} | 0
 ...019_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt} | 0
 ...20_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt} | 0
 ...021_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt} | 0
 ...22_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt} | 0
 19 files changed, 10 insertions(+), 2 deletions(-)
 create mode 100644 examples/complete_erb.html.erb
 create mode 100644 examples/incomplete_erb.invalid.html.erb
 create mode 100644 test/snapshots/engine/examples_compilation_test/test_0009_complete_erb_compilation_a33dd3e79d24b4f31f6d4e92611f3f63.txt
 rename test/snapshots/engine/examples_compilation_test/{test_0009_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt => test_0010_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0010_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt => test_0011_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0011_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt => test_0012_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0012_if_else_compilation_1437d0425640509570342c24b30de571.txt => test_0013_if_else_compilation_1437d0425640509570342c24b30de571.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0013_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt => test_0014_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0014_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt => test_0015_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0015_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt => test_0016_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0016_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt => test_0017_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0017_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt => test_0018_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0018_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt => test_0019_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0019_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt => test_0020_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0020_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt => test_0021_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt} (100%)
 rename test/snapshots/engine/examples_compilation_test/{test_0021_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt => test_0022_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt} (100%)

diff --git a/examples/complete_erb.html.erb b/examples/complete_erb.html.erb
new file mode 100644
index 000000000..7b1b244a8
--- /dev/null
+++ b/examples/complete_erb.html.erb
@@ -0,0 +1 @@
+<%= hello %>
diff --git a/examples/incomplete_erb.invalid.html.erb b/examples/incomplete_erb.invalid.html.erb
new file mode 100644
index 000000000..56157a8bb
--- /dev/null
+++ b/examples/incomplete_erb.invalid.html.erb
@@ -0,0 +1 @@
+<%= hello
diff --git a/src/herb.c b/src/herb.c
index bd249e5ff..e81d1acb9 100644
--- a/src/herb.c
+++ b/src/herb.c
@@ -41,6 +41,8 @@ AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options) {
 
   AST_DOCUMENT_NODE_T* document = herb_parser_parse(&parser);
 
+  parser_free(&parser);
+
   return document;
 }
 
diff --git a/src/parser.c b/src/parser.c
index bcea9dbfb..d7de418cc 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -1238,6 +1238,4 @@ void parser_free(parser_T* parser) {
 
   if (parser->current_token != NULL) { token_free(parser->current_token); }
   if (parser->open_tags_stack != NULL) { hb_array_free(&parser->open_tags_stack); }
-
-  free(parser);
 }
diff --git a/test/engine/examples_compilation_test.rb b/test/engine/examples_compilation_test.rb
index 2b3f16da9..91e6b0315 100644
--- a/test/engine/examples_compilation_test.rb
+++ b/test/engine/examples_compilation_test.rb
@@ -11,6 +11,8 @@ class ExamplesCompilationTest < Minitest::Spec
     example_files = Dir.glob(File.join(examples_dir, "*.html.erb"))
 
     example_files.each do |file_path|
+      next if file_path.end_with?(".invalid.html.erb")
+
       basename = File.basename(file_path, ".html.erb")
       test_name = "#{basename.tr("-_", " ")} compilation"
 
diff --git a/test/snapshots/engine/examples_compilation_test/test_0009_complete_erb_compilation_a33dd3e79d24b4f31f6d4e92611f3f63.txt b/test/snapshots/engine/examples_compilation_test/test_0009_complete_erb_compilation_a33dd3e79d24b4f31f6d4e92611f3f63.txt
new file mode 100644
index 000000000..f48818019
--- /dev/null
+++ b/test/snapshots/engine/examples_compilation_test/test_0009_complete_erb_compilation_a33dd3e79d24b4f31f6d4e92611f3f63.txt
@@ -0,0 +1,4 @@
+_buf = ::String.new;
+ _buf << (hello).to_s; _buf << '
+'.freeze;
+_buf.to_s
diff --git a/test/snapshots/engine/examples_compilation_test/test_0009_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt b/test/snapshots/engine/examples_compilation_test/test_0010_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0009_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt
rename to test/snapshots/engine/examples_compilation_test/test_0010_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0010_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt b/test/snapshots/engine/examples_compilation_test/test_0011_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0010_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt
rename to test/snapshots/engine/examples_compilation_test/test_0011_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0011_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt b/test/snapshots/engine/examples_compilation_test/test_0012_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0011_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt
rename to test/snapshots/engine/examples_compilation_test/test_0012_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0012_if_else_compilation_1437d0425640509570342c24b30de571.txt b/test/snapshots/engine/examples_compilation_test/test_0013_if_else_compilation_1437d0425640509570342c24b30de571.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0012_if_else_compilation_1437d0425640509570342c24b30de571.txt
rename to test/snapshots/engine/examples_compilation_test/test_0013_if_else_compilation_1437d0425640509570342c24b30de571.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0013_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt b/test/snapshots/engine/examples_compilation_test/test_0014_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0013_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt
rename to test/snapshots/engine/examples_compilation_test/test_0014_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0014_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt b/test/snapshots/engine/examples_compilation_test/test_0015_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0014_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt
rename to test/snapshots/engine/examples_compilation_test/test_0015_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0015_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt b/test/snapshots/engine/examples_compilation_test/test_0016_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0015_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt
rename to test/snapshots/engine/examples_compilation_test/test_0016_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0016_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt b/test/snapshots/engine/examples_compilation_test/test_0017_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0016_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt
rename to test/snapshots/engine/examples_compilation_test/test_0017_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0017_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt b/test/snapshots/engine/examples_compilation_test/test_0018_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0017_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt
rename to test/snapshots/engine/examples_compilation_test/test_0018_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0018_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt b/test/snapshots/engine/examples_compilation_test/test_0019_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0018_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt
rename to test/snapshots/engine/examples_compilation_test/test_0019_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0019_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt b/test/snapshots/engine/examples_compilation_test/test_0020_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0019_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt
rename to test/snapshots/engine/examples_compilation_test/test_0020_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0020_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt b/test/snapshots/engine/examples_compilation_test/test_0021_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0020_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt
rename to test/snapshots/engine/examples_compilation_test/test_0021_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0021_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt b/test/snapshots/engine/examples_compilation_test/test_0022_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0021_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt
rename to test/snapshots/engine/examples_compilation_test/test_0022_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt

From 4f131720bb9dc82875780493c457e502434129a3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Sun, 19 Oct 2025 14:41:34 +0200
Subject: [PATCH 83/97] C: Use `hb_string_T` in `parser_check_matching_tag`
 function (#689)

This PR changes the interface and implementation of
`parser_check_matching_tag` to make use of the new `hb_string_T` struct
and accompanying functions.
---
 src/include/parser_helpers.h | 2 +-
 src/parser.c                 | 2 +-
 src/parser_helpers.c         | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/include/parser_helpers.h b/src/include/parser_helpers.h
index 2eef59769..78367d465 100644
--- a/src/include/parser_helpers.h
+++ b/src/include/parser_helpers.h
@@ -9,7 +9,7 @@
 #include "util/hb_buffer.h"
 
 void parser_push_open_tag(const parser_T* parser, token_T* tag_name);
-bool parser_check_matching_tag(const parser_T* parser, const char* tag_name);
+bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name);
 token_T* parser_pop_open_tag(const parser_T* parser);
 
 void parser_append_unexpected_error(
diff --git a/src/parser.c b/src/parser.c
index d7de418cc..bb8b8e304 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -936,7 +936,7 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_regular_element(
     close_tag = parser_parse_html_close_tag(parser);
   }
 
-  bool matches_stack = parser_check_matching_tag(parser, close_tag->tag_name->value);
+  bool matches_stack = parser_check_matching_tag(parser, hb_string_from_c_string(close_tag->tag_name->value));
 
   if (matches_stack) {
     token_T* popped_token = parser_pop_open_tag(parser);
diff --git a/src/parser_helpers.c b/src/parser_helpers.c
index 9afb66e17..b9b2ccfa3 100644
--- a/src/parser_helpers.c
+++ b/src/parser_helpers.c
@@ -18,13 +18,13 @@ void parser_push_open_tag(const parser_T* parser, token_T* tag_name) {
   hb_array_push(parser->open_tags_stack, copy);
 }
 
-bool parser_check_matching_tag(const parser_T* parser, const char* tag_name) {
+bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name) {
   if (hb_array_size(parser->open_tags_stack) == 0) { return false; }
 
   token_T* top_token = hb_array_last(parser->open_tags_stack);
   if (top_token == NULL || top_token->value == NULL) { return false; };
 
-  return (strcasecmp(top_token->value, tag_name) == 0);
+  return hb_string_equals(hb_string_from_c_string(top_token->value), tag_name);
 }
 
 token_T* parser_pop_open_tag(const parser_T* parser) {

From e02945831f1bd37036463394d8aaf226d6c62e9f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Sun, 19 Oct 2025 14:43:15 +0200
Subject: [PATCH 84/97] C: Rename `parser_free` to `herb_parser_deinit` (#692)

This PR namespaces the `parser_free` function and renames it to
`parser_deinit`.

Follow up on #691
---
 src/herb.c           | 2 +-
 src/include/parser.h | 2 +-
 src/parser.c         | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/herb.c b/src/herb.c
index e81d1acb9..a48a56f3a 100644
--- a/src/herb.c
+++ b/src/herb.c
@@ -41,7 +41,7 @@ AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options) {
 
   AST_DOCUMENT_NODE_T* document = herb_parser_parse(&parser);
 
-  parser_free(&parser);
+  herb_parser_deinit(&parser);
 
   return document;
 }
diff --git a/src/include/parser.h b/src/include/parser.h
index 29a8c8b17..4eb92f3fb 100644
--- a/src/include/parser.h
+++ b/src/include/parser.h
@@ -36,6 +36,6 @@ AST_DOCUMENT_NODE_T* herb_parser_parse(parser_T* parser);
 
 size_t parser_sizeof(void);
 
-void parser_free(parser_T* parser);
+void herb_parser_deinit(parser_T* parser);
 
 #endif
diff --git a/src/parser.c b/src/parser.c
index bb8b8e304..785d7ae97 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -1233,7 +1233,7 @@ static void parser_consume_whitespace(parser_T* parser, hb_array_T* children) {
   }
 }
 
-void parser_free(parser_T* parser) {
+void herb_parser_deinit(parser_T* parser) {
   if (parser == NULL) { return; }
 
   if (parser->current_token != NULL) { token_free(parser->current_token); }

From 4443caf00aad218756bc85f94f498de431bca3d1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Sun, 19 Oct 2025 15:58:19 +0200
Subject: [PATCH 85/97] C: Use `hb_string_T` in `quoted_string` function (#681)

This PR refactors the `quoted_string` utility to use `hb_string_T` as an
argument and fixes all call sites.
---
 src/include/util.h |  4 ++--
 src/pretty_print.c | 21 +++++++++++----------
 src/util.c         | 13 ++++++-------
 3 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/src/include/util.h b/src/include/util.h
index 54ad790b7..978abeb92 100644
--- a/src/include/util.h
+++ b/src/include/util.h
@@ -1,14 +1,14 @@
 #ifndef HERB_UTIL_H
 #define HERB_UTIL_H
 
+#include "util/hb_string.h"
 #include <stdbool.h>
 #include <stdlib.h>
 
 int is_newline(int character);
 
 char* escape_newlines(const char* input);
-char* quoted_string(const char* input);
-char* wrap_string(const char* input, char character);
+hb_string_T quoted_string(hb_string_T input);
 char* herb_strdup(const char* s);
 
 #endif
diff --git a/src/pretty_print.c b/src/pretty_print.c
index 079bf9489..1dbf60247 100644
--- a/src/pretty_print.c
+++ b/src/pretty_print.c
@@ -7,6 +7,7 @@
 #include "include/token_struct.h"
 #include "include/util.h"
 #include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
 
 #include <stdbool.h>
 #include <stdio.h>
@@ -52,9 +53,9 @@ void pretty_print_quoted_property(
   const bool last_property,
   hb_buffer_T* buffer
 ) {
-  char* quoted = quoted_string(value);
-  pretty_print_property(name, quoted, indent, relative_indent, last_property, buffer);
-  free(quoted);
+  hb_string_T quoted = quoted_string(hb_string_from_c_string(value));
+  pretty_print_property(name, quoted.data, indent, relative_indent, last_property, buffer);
+  free(quoted.data);
 }
 
 void pretty_print_boolean_property(
@@ -212,9 +213,9 @@ void pretty_print_token_property(
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
 
   if (token != NULL && token->value != NULL) {
-    char* quoted = quoted_string(token->value);
-    hb_buffer_append(buffer, quoted);
-    free(quoted);
+    hb_string_T quoted = quoted_string(hb_string_from_c_string(token->value));
+    hb_buffer_append_string(buffer, quoted);
+    free(quoted.data);
 
     hb_buffer_append(buffer, " ");
     pretty_print_location(token->location, buffer);
@@ -235,18 +236,18 @@ void pretty_print_string_property(
 ) {
   const char* value = "∅";
   char* escaped = NULL;
-  char* quoted = NULL;
+  hb_string_T quoted;
 
   if (string != NULL) {
     escaped = escape_newlines(string);
-    quoted = quoted_string(escaped);
-    value = quoted;
+    quoted = quoted_string(hb_string_from_c_string(escaped));
+    value = quoted.data;
   }
 
   pretty_print_property(name, value, indent, relative_indent, last_property, buffer);
 
   if (string != NULL) {
     if (escaped != NULL) { free(escaped); }
-    if (quoted != NULL) { free(quoted); }
+    if (!hb_string_is_empty(quoted)) { free(quoted.data); }
   }
 }
diff --git a/src/util.c b/src/util.c
index 9d6af3dc8..21f19e484 100644
--- a/src/util.c
+++ b/src/util.c
@@ -1,5 +1,6 @@
 #include "include/util.h"
 #include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
 
 #include <ctype.h>
 #include <stdio.h>
@@ -34,21 +35,19 @@ char* escape_newlines(const char* input) {
   return buffer.value;
 }
 
-char* wrap_string(const char* input, const char character) {
-  if (input == NULL) { return NULL; }
-
+static hb_string_T wrap_string(hb_string_T input, char character) {
   hb_buffer_T buffer;
 
-  hb_buffer_init(&buffer, strlen(input) + 2);
+  hb_buffer_init(&buffer, input.length + 2);
 
   hb_buffer_append_char(&buffer, character);
-  hb_buffer_append(&buffer, input);
+  hb_buffer_append_string(&buffer, input);
   hb_buffer_append_char(&buffer, character);
 
-  return buffer.value;
+  return hb_string_from_c_string(buffer.value);
 }
 
-char* quoted_string(const char* input) {
+hb_string_T quoted_string(hb_string_T input) {
   return wrap_string(input, '"');
 }
 

From a95487e001da0723d36a62885e889949179b179c Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Sun, 19 Oct 2025 16:06:18 +0200
Subject: [PATCH 86/97] CI: Update trigger to run `build.yml` on pull requests

Signed-off-by: Marco Roth <marco.roth@intergga.ch>
---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index cd5820660..a9dd7bd96 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,6 +1,6 @@
 name: Build
 
-on: [push]
+on: [push, pull_request]
 
 permissions:
   contents: read

From de7a5efeae1d6b59fae2f13e6691031b7614c196 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Sun, 19 Oct 2025 17:02:04 +0200
Subject: [PATCH 87/97] C: Use `hb_string_T` in `parser_is_foreign_content_tag`
 function (#688)

This PR adapts the interfaces of the `parser_is_foreign_content_tag` and
`parser_get_foreign_content_type` to use `hb_string_T` instead of a
`const char*`.
---
 src/include/parser_helpers.h |  5 +++--
 src/parser.c                 |  5 +++--
 src/parser_helpers.c         | 11 ++++++-----
 3 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/src/include/parser_helpers.h b/src/include/parser_helpers.h
index 78367d465..f9ddbbb7d 100644
--- a/src/include/parser_helpers.h
+++ b/src/include/parser_helpers.h
@@ -7,6 +7,7 @@
 #include "token.h"
 #include "util/hb_array.h"
 #include "util/hb_buffer.h"
+#include "util/hb_string.h"
 
 void parser_push_open_tag(const parser_T* parser, token_T* tag_name);
 bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name);
@@ -29,8 +30,8 @@ void parser_append_literal_node_from_buffer(
 
 bool parser_in_svg_context(const parser_T* parser);
 
-foreign_content_type_T parser_get_foreign_content_type(const char* tag_name);
-bool parser_is_foreign_content_tag(const char* tag_name);
+foreign_content_type_T parser_get_foreign_content_type(hb_string_T tag_name);
+bool parser_is_foreign_content_tag(hb_string_T tag_name);
 const char* parser_get_foreign_content_closing_tag(foreign_content_type_T type);
 
 void parser_enter_foreign_content(parser_T* parser, foreign_content_type_T type);
diff --git a/src/parser.c b/src/parser.c
index 785d7ae97..61c700288 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -918,8 +918,9 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_regular_element(
 
   parser_push_open_tag(parser, open_tag->tag_name);
 
-  if (open_tag->tag_name->value && parser_is_foreign_content_tag(open_tag->tag_name->value)) {
-    foreign_content_type_T content_type = parser_get_foreign_content_type(open_tag->tag_name->value);
+  if (open_tag->tag_name->value && parser_is_foreign_content_tag(hb_string_from_c_string(open_tag->tag_name->value))) {
+    foreign_content_type_T content_type =
+      parser_get_foreign_content_type(hb_string_from_c_string(open_tag->tag_name->value));
     parser_enter_foreign_content(parser, content_type);
     parser_parse_foreign_content(parser, body, errors);
   } else {
diff --git a/src/parser_helpers.c b/src/parser_helpers.c
index b9b2ccfa3..0bf792bf1 100644
--- a/src/parser_helpers.c
+++ b/src/parser_helpers.c
@@ -9,6 +9,7 @@
 #include "include/token_matchers.h"
 #include "include/util/hb_array.h"
 #include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
 
 #include <stdio.h>
 #include <strings.h>
@@ -57,16 +58,16 @@ bool parser_in_svg_context(const parser_T* parser) {
 
 // ===== Foreign Content Handling =====
 
-foreign_content_type_T parser_get_foreign_content_type(const char* tag_name) {
-  if (tag_name == NULL) { return FOREIGN_CONTENT_UNKNOWN; }
+foreign_content_type_T parser_get_foreign_content_type(hb_string_T tag_name) {
+  if (hb_string_is_empty(tag_name)) { return FOREIGN_CONTENT_UNKNOWN; }
 
-  if (strcasecmp(tag_name, "script") == 0) { return FOREIGN_CONTENT_SCRIPT; }
-  if (strcasecmp(tag_name, "style") == 0) { return FOREIGN_CONTENT_STYLE; }
+  if (hb_string_equals(tag_name, hb_string_from_c_string("script"))) { return FOREIGN_CONTENT_SCRIPT; }
+  if (hb_string_equals(tag_name, hb_string_from_c_string("style"))) { return FOREIGN_CONTENT_STYLE; }
 
   return FOREIGN_CONTENT_UNKNOWN;
 }
 
-bool parser_is_foreign_content_tag(const char* tag_name) {
+bool parser_is_foreign_content_tag(hb_string_T tag_name) {
   return parser_get_foreign_content_type(tag_name) != FOREIGN_CONTENT_UNKNOWN;
 }
 

From f33e0ba05e54caeb042ebf870851e192a630d797 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Sun, 19 Oct 2025 21:07:59 +0200
Subject: [PATCH 88/97] Herb: Upgrade to LLVM 21 and Clang 21 (#694)

This pull request upgrades the `llvm` and the related `clang`,
`clang-format` and `clang-tidy` versions from 19 to 21.
---
 .github/workflows/build-gems.yml |  2 +-
 .github/workflows/build.yml      |  6 +++---
 .github/workflows/deploy.yml     |  2 +-
 .github/workflows/javascript.yml |  2 +-
 Aptfile                          |  6 +++---
 Brewfile                         |  2 +-
 CONTRIBUTING.md                  | 12 ++++++------
 Makefile                         |  8 ++++----
 src/analyze.c                    | 25 +++++++++++++++----------
 9 files changed, 35 insertions(+), 30 deletions(-)

diff --git a/.github/workflows/build-gems.yml b/.github/workflows/build-gems.yml
index 8fa627fd9..2082d4f02 100644
--- a/.github/workflows/build-gems.yml
+++ b/.github/workflows/build-gems.yml
@@ -65,7 +65,7 @@ jobs:
       - name: Add LLVM apt Repo
         run: |-
           wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-          sudo add-apt-repository "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-19 main"
+          sudo add-apt-repository "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-21 main"
           sudo apt update
 
       - name: Install APT dependencies
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index a9dd7bd96..283fa105d 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -18,7 +18,7 @@ jobs:
       - name: Add LLVM apt Repo
         run: |-
           wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-          sudo add-apt-repository "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-19 main"
+          sudo add-apt-repository "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-21 main"
           sudo apt update
 
       - name: Install APT dependencies
@@ -57,13 +57,13 @@ jobs:
         run: ./run_herb_tests
 
       - name: clang-format version
-        run: clang-format-19 --version
+        run: clang-format-21 --version
 
       - name: Lint
         run: bin/lint
 
       - name: clang-tidy version
-        run: clang-tidy-19 --version
+        run: clang-tidy-21 --version
 
       - name: Tidy
         run: bin/tidy
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 038be7d83..84d94d085 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -43,7 +43,7 @@ jobs:
       - name: Add LLVM apt Repo
         run: |-
           wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-          sudo add-apt-repository "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-19 main"
+          sudo add-apt-repository "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-21 main"
           sudo apt update
 
       - name: Install APT dependencies
diff --git a/.github/workflows/javascript.yml b/.github/workflows/javascript.yml
index 25e0de88a..35b873fc1 100644
--- a/.github/workflows/javascript.yml
+++ b/.github/workflows/javascript.yml
@@ -30,7 +30,7 @@ jobs:
       - name: Add LLVM apt Repo
         run: |-
           wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-          sudo add-apt-repository "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-19 main"
+          sudo add-apt-repository "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-21 main"
           sudo apt update
 
       - name: Install APT dependencies
diff --git a/Aptfile b/Aptfile
index df7a373cf..d52b811d7 100644
--- a/Aptfile
+++ b/Aptfile
@@ -1,7 +1,7 @@
 check
-clang-19
-clang-format-19
-clang-tidy-19
+clang-21
+clang-format-21
+clang-tidy-21
 emscripten
 doxygen
 xvfb
diff --git a/Brewfile b/Brewfile
index b127e58ba..c568821f3 100644
--- a/Brewfile
+++ b/Brewfile
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 brew "check"
-brew "llvm@19" # for clang, clang-format and clang-tidy
+brew "llvm@21" # for clang, clang-format and clang-tidy
 brew "emscripten"
 brew "doxygen"
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 659cab294..04f6f9ad0 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,16 +2,16 @@
 
 Pull request, bug reports, and any other forms of contribution are welcomed and highly encouraged.
 
-If you encounter any issues when following along with this file please dont hesitate to reach out and file an issue!
+If you encounter any issues when following along with this file please don't hesitate to reach out and file an issue!
 
 ## Running Locally
 
 ### Requirements
 
 - [**Check**](https://libcheck.github.io/check/): For unit testing.
-- [**Clang 19**](https://clang.llvm.org): The compiler used to build this project.
-- [**Clang Format 19**](https://clang.llvm.org/docs/ClangFormat.html): For formatting the project.
-- [**Clang Tidy 19**](https://clang.llvm.org/extra/clang-tidy/): For linting the project.
+- [**Clang 21**](https://clang.llvm.org): The compiler used to build this project.
+- [**Clang Format 21**](https://clang.llvm.org/docs/ClangFormat.html): For formatting the project.
+- [**Clang Tidy 21**](https://clang.llvm.org/extra/clang-tidy/): For linting the project.
 - [**Prism Ruby Parser v1.6.0**](https://github.com/ruby/prism/releases/tag/v1.6.0): We use Prism for Parsing the Ruby Source Code in the HTML+ERB files.
 - [**Ruby**](https://www.ruby-lang.org/en/): We need Ruby as a dependency for `bundler`.
 - [**Bundler**](https://bundler.io): We are using `bundler` to build [`prism`](https://github.com/ruby/prism) from source so we can build `herb` against it.
@@ -27,7 +27,7 @@ xargs sudo apt-get install < Aptfile
 or:
 
 ```bash
-sudo apt-get install check clang-19 clang-tidy-19 clang-format-19 emscripten doxygen
+sudo apt-get install check clang-21 clang-tidy-21 clang-format-21 emscripten doxygen
 ```
 
 ##### For macOS (using Homebrew)
@@ -38,7 +38,7 @@ brew bundle
 or:
 
 ```bash
-brew install check llvm@19 emscripten doxygen
+brew install check llvm@21 emscripten doxygen
 ```
 
 ### Building
diff --git a/Makefile b/Makefile
index 8b09e67f9..137f736d9 100644
--- a/Makefile
+++ b/Makefile
@@ -61,16 +61,16 @@ shared_flags = $(production_flags) $(shared_library_flags) $(prism_flags)
 ifeq ($(os),Linux)
   test_cflags = $(test_flags) -I/usr/include/check
   test_ldflags = -L/usr/lib/x86_64-linux-gnu -lcheck -lm -lsubunit $(prism_ldflags)
-  cc = clang-19
-  clang_format = clang-format-19
-  clang_tidy = clang-tidy-19
+  cc = clang-21
+  clang_format = clang-format-21
+  clang_tidy = clang-tidy-21
 endif
 
 ifeq ($(os),Darwin)
   brew_prefix := $(shell brew --prefix check)
   test_cflags = $(test_flags) -I$(brew_prefix)/include
   test_ldflags = -L$(brew_prefix)/lib -lcheck -lm $(prism_ldflags)
-  llvm_path = $(shell brew --prefix llvm@19)
+  llvm_path = $(shell brew --prefix llvm@21)
   cc = $(llvm_path)/bin/clang
   clang_format = $(llvm_path)/bin/clang-format
   clang_tidy = $(llvm_path)/bin/clang-tidy
diff --git a/src/analyze.c b/src/analyze.c
index fe0b95455..97e684ec1 100644
--- a/src/analyze.c
+++ b/src/analyze.c
@@ -186,8 +186,9 @@ static AST_NODE_T* create_control_node(
       );
 
     case CONTROL_TYPE_ELSE:
-      return (AST_NODE_T*)
-        ast_erb_else_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
+      return (
+        AST_NODE_T*
+      ) ast_erb_else_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
 
     case CONTROL_TYPE_CASE:
     case CONTROL_TYPE_CASE_MATCH: {
@@ -239,13 +240,15 @@ static AST_NODE_T* create_control_node(
     }
 
     case CONTROL_TYPE_WHEN: {
-      return (AST_NODE_T*)
-        ast_erb_when_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
+      return (
+        AST_NODE_T*
+      ) ast_erb_when_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
     }
 
     case CONTROL_TYPE_IN: {
-      return (AST_NODE_T*)
-        ast_erb_in_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
+      return (
+        AST_NODE_T*
+      ) ast_erb_in_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
     }
 
     case CONTROL_TYPE_BEGIN: {
@@ -296,8 +299,9 @@ static AST_NODE_T* create_control_node(
     }
 
     case CONTROL_TYPE_ENSURE: {
-      return (AST_NODE_T*)
-        ast_erb_ensure_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
+      return (
+        AST_NODE_T*
+      ) ast_erb_ensure_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
     }
 
     case CONTROL_TYPE_UNLESS: {
@@ -371,8 +375,9 @@ static AST_NODE_T* create_control_node(
     }
 
     case CONTROL_TYPE_YIELD: {
-      return (AST_NODE_T*)
-        ast_erb_yield_node_init(tag_opening, content, tag_closing, start_position, end_position, errors);
+      return (
+        AST_NODE_T*
+      ) ast_erb_yield_node_init(tag_opening, content, tag_closing, start_position, end_position, errors);
     }
 
     default: hb_array_free(&errors); return NULL;

From e3a4e86a7dad81c03037d9c1346973746c6b41f7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Sun, 19 Oct 2025 21:12:06 +0200
Subject: [PATCH 89/97] C: Migrate `is_void_element` to `hb_string_T` (#686)

This PR changes the interface to the `is_void_element` function to use
`hb_string_T` and adapts all call sites.

This makes the switch to `hb_string_T` based token values easier later
on.
---
 src/html_util.c         | 18 +++++++++++-------
 src/include/html_util.h |  3 ++-
 src/parser.c            | 10 ++++++----
 3 files changed, 19 insertions(+), 12 deletions(-)

diff --git a/src/html_util.c b/src/html_util.c
index 09cf4296f..16432484d 100644
--- a/src/html_util.c
+++ b/src/html_util.c
@@ -1,24 +1,28 @@
 #include "include/html_util.h"
 #include "include/util.h"
 #include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
 
 #include <ctype.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
-#include <strings.h>
 
 // https://developer.mozilla.org/en-US/docs/Glossary/Void_element
-bool is_void_element(const char* tag_name) {
-  if (tag_name == NULL) { return false; }
+bool is_void_element(hb_string_T tag_name) {
+  if (hb_string_is_empty(tag_name)) { return false; }
 
-  const char* void_tags[] = {
-    "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr",
+  hb_string_T void_tags[14] = {
+    hb_string_from_c_string("area"),  hb_string_from_c_string("base"),  hb_string_from_c_string("br"),
+    hb_string_from_c_string("col"),   hb_string_from_c_string("embed"), hb_string_from_c_string("hr"),
+    hb_string_from_c_string("img"),   hb_string_from_c_string("input"), hb_string_from_c_string("link"),
+    hb_string_from_c_string("meta"),  hb_string_from_c_string("param"), hb_string_from_c_string("source"),
+    hb_string_from_c_string("track"), hb_string_from_c_string("wbr"),
   };
 
-  for (size_t i = 0; i < sizeof(void_tags) / sizeof(char*); i++) {
-    if (strcasecmp(tag_name, void_tags[i]) == 0) { return true; }
+  for (size_t i = 0; i < 14; i++) {
+    if (hb_string_equals_case_insensitive(tag_name, void_tags[i])) { return true; }
   }
 
   return false;
diff --git a/src/include/html_util.h b/src/include/html_util.h
index 768660861..254c24074 100644
--- a/src/include/html_util.h
+++ b/src/include/html_util.h
@@ -1,9 +1,10 @@
 #ifndef HERB_HTML_UTIL_H
 #define HERB_HTML_UTIL_H
 
+#include "util/hb_string.h"
 #include <stdbool.h>
 
-bool is_void_element(const char* tag_name);
+bool is_void_element(hb_string_T tag_name);
 
 char* html_closing_tag_string(const char* tag_name);
 char* html_self_closing_tag_string(const char* tag_name);
diff --git a/src/parser.c b/src/parser.c
index 61c700288..e72fc194d 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -857,7 +857,8 @@ static AST_HTML_CLOSE_TAG_NODE_T* parser_parse_html_close_tag(parser_T* parser)
 
   token_T* tag_closing = parser_consume_expected(parser, TOKEN_HTML_TAG_END, errors);
 
-  if (tag_name != NULL && is_void_element(tag_name->value) && parser_in_svg_context(parser) == false) {
+  if (tag_name != NULL && is_void_element(hb_string_from_c_string(tag_name->value))
+      && parser_in_svg_context(parser) == false) {
     char* expected = html_self_closing_tag_string(tag_name->value);
     char* got = html_closing_tag_string(tag_name->value);
 
@@ -931,7 +932,7 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_regular_element(
 
   AST_HTML_CLOSE_TAG_NODE_T* close_tag = parser_parse_html_close_tag(parser);
 
-  if (parser_in_svg_context(parser) == false && is_void_element(close_tag->tag_name->value)) {
+  if (parser_in_svg_context(parser) == false && is_void_element(hb_string_from_c_string(close_tag->tag_name->value))) {
     hb_array_push(body, close_tag);
     parser_parse_in_data_state(parser, body, errors);
     close_tag = parser_parse_html_close_tag(parser);
@@ -966,7 +967,8 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_element(parser_T* parser) {
   if (open_tag->is_void) { return parser_parse_html_self_closing_element(parser, open_tag); }
 
   // <tag>, in void element list, and not in inside an <svg> element
-  if (!open_tag->is_void && is_void_element(open_tag->tag_name->value) && !parser_in_svg_context(parser)) {
+  if (!open_tag->is_void && is_void_element(hb_string_from_c_string(open_tag->tag_name->value))
+      && !parser_in_svg_context(parser)) {
     return parser_parse_html_self_closing_element(parser, open_tag);
   }
 
@@ -1170,7 +1172,7 @@ static void parser_parse_stray_closing_tags(parser_T* parser, hb_array_T* childr
 
     AST_HTML_CLOSE_TAG_NODE_T* close_tag = parser_parse_html_close_tag(parser);
 
-    if (!is_void_element(close_tag->tag_name->value)) {
+    if (!is_void_element(hb_string_from_c_string(close_tag->tag_name->value))) {
       append_missing_opening_tag_error(
         close_tag->tag_name,
         close_tag->base.location.start,

From e9ba568ca037b00298bf4c0b6b40b9a5e569eaf6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Mon, 20 Oct 2025 11:53:14 +0200
Subject: [PATCH 90/97] C: Use `hb_string_T` in `parser_helpers.c` functions
 (#696)

This PR refactors the `parser_get_foreign_content_closing_tag` and
`parser_is_expected_closing_tag_name` to use `hb_string_T` instead of c
strings.
---
 src/include/parser_helpers.h |  4 ++--
 src/parser.c                 |  7 ++++---
 src/parser_helpers.c         | 20 ++++++++++----------
 3 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/src/include/parser_helpers.h b/src/include/parser_helpers.h
index f9ddbbb7d..b3ab98300 100644
--- a/src/include/parser_helpers.h
+++ b/src/include/parser_helpers.h
@@ -32,12 +32,12 @@ bool parser_in_svg_context(const parser_T* parser);
 
 foreign_content_type_T parser_get_foreign_content_type(hb_string_T tag_name);
 bool parser_is_foreign_content_tag(hb_string_T tag_name);
-const char* parser_get_foreign_content_closing_tag(foreign_content_type_T type);
+hb_string_T parser_get_foreign_content_closing_tag(foreign_content_type_T type);
 
 void parser_enter_foreign_content(parser_T* parser, foreign_content_type_T type);
 void parser_exit_foreign_content(parser_T* parser);
 
-bool parser_is_expected_closing_tag_name(const char* tag_name, foreign_content_type_T expected_type);
+bool parser_is_expected_closing_tag_name(hb_string_T tag_name, foreign_content_type_T expected_type);
 
 token_T* parser_advance(parser_T* parser);
 token_T* parser_consume_if_present(parser_T* parser, token_type_T type);
diff --git a/src/parser.c b/src/parser.c
index e72fc194d..0a45c584d 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -1022,9 +1022,9 @@ static void parser_parse_foreign_content(parser_T* parser, hb_array_T* children,
   hb_buffer_T content;
   hb_buffer_init(&content, 1024);
   position_T start = parser->current_token->location.start;
-  const char* expected_closing_tag = parser_get_foreign_content_closing_tag(parser->foreign_content_type);
+  hb_string_T expected_closing_tag = parser_get_foreign_content_closing_tag(parser->foreign_content_type);
 
-  if (expected_closing_tag == NULL) {
+  if (hb_string_is_empty(expected_closing_tag)) {
     parser_exit_foreign_content(parser);
     free(content.value);
 
@@ -1050,7 +1050,8 @@ static void parser_parse_foreign_content(parser_T* parser, hb_array_T* children,
       bool is_potential_match = false;
 
       if (next_token && next_token->type == TOKEN_IDENTIFIER && next_token->value) {
-        is_potential_match = parser_is_expected_closing_tag_name(next_token->value, parser->foreign_content_type);
+        is_potential_match =
+          parser_is_expected_closing_tag_name(hb_string_from_c_string(next_token->value), parser->foreign_content_type);
       }
 
       lexer_restore_state(parser->lexer, saved_state);
diff --git a/src/parser_helpers.c b/src/parser_helpers.c
index 0bf792bf1..85d26d8e8 100644
--- a/src/parser_helpers.c
+++ b/src/parser_helpers.c
@@ -12,7 +12,6 @@
 #include "include/util/hb_string.h"
 
 #include <stdio.h>
-#include <strings.h>
 
 void parser_push_open_tag(const parser_T* parser, token_T* tag_name) {
   token_T* copy = token_copy(tag_name);
@@ -49,7 +48,8 @@ bool parser_in_svg_context(const parser_T* parser) {
     token_T* tag = (token_T*) hb_array_get(parser->open_tags_stack, i);
 
     if (tag && tag->value) {
-      if (strcasecmp(tag->value, "svg") == 0) { return true; }
+      hb_string_T tag_value_string = hb_string_from_c_string(tag->value);
+      if (hb_string_equals(tag_value_string, hb_string_from_c_string("svg"))) { return true; }
     }
   }
 
@@ -71,11 +71,11 @@ bool parser_is_foreign_content_tag(hb_string_T tag_name) {
   return parser_get_foreign_content_type(tag_name) != FOREIGN_CONTENT_UNKNOWN;
 }
 
-const char* parser_get_foreign_content_closing_tag(foreign_content_type_T type) {
+hb_string_T parser_get_foreign_content_closing_tag(foreign_content_type_T type) {
   switch (type) {
-    case FOREIGN_CONTENT_SCRIPT: return "script";
-    case FOREIGN_CONTENT_STYLE: return "style";
-    default: return NULL;
+    case FOREIGN_CONTENT_SCRIPT: return hb_string_from_c_string("script");
+    case FOREIGN_CONTENT_STYLE: return hb_string_from_c_string("style");
+    default: return hb_string_from_c_string("");
   }
 }
 
@@ -212,10 +212,10 @@ void parser_handle_mismatched_tags(
   }
 }
 
-bool parser_is_expected_closing_tag_name(const char* tag_name, foreign_content_type_T expected_type) {
-  const char* expected_tag_name = parser_get_foreign_content_closing_tag(expected_type);
+bool parser_is_expected_closing_tag_name(hb_string_T tag_name, foreign_content_type_T expected_type) {
+  hb_string_T expected_tag_name = parser_get_foreign_content_closing_tag(expected_type);
 
-  if (expected_tag_name == NULL || tag_name == NULL) { return false; }
+  if (hb_string_is_empty(tag_name) || hb_string_is_empty(expected_tag_name)) { return false; }
 
-  return strcmp(tag_name, expected_tag_name) == 0;
+  return hb_string_equals(expected_tag_name, tag_name);
 }

From b858371baa68c88782d6c8db6edb293a2c6bf73a Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Mon, 20 Oct 2025 12:04:28 +0200
Subject: [PATCH 91/97] Linter: Remove `html-no-space-in-tag` from default
 rules for now (#697)

The `html-no-space-in-tag` linter rule (#559 and #642) has quite a few
false positives and corrupts documents when using the `--fix` option
(see #695), which is why this pull request removes the
`html-no-space-in-tag` rule from the default rules for now.

We can enable this rule again in the future when we improve the accuracy
of the rule.
---
 javascript/packages/linter/src/default-rules.ts             | 4 ++--
 .../packages/linter/src/rules/html-no-space-in-tag.ts       | 3 ++-
 .../packages/linter/test/__snapshots__/cli.test.ts.snap     | 6 +++---
 javascript/packages/vscode/package.json                     | 2 +-
 4 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/javascript/packages/linter/src/default-rules.ts b/javascript/packages/linter/src/default-rules.ts
index 39188aa18..3584854d9 100644
--- a/javascript/packages/linter/src/default-rules.ts
+++ b/javascript/packages/linter/src/default-rules.ts
@@ -38,7 +38,7 @@ import { HTMLNoEmptyHeadingsRule } from "./rules/html-no-empty-headings.js"
 import { HTMLNoNestedLinksRule } from "./rules/html-no-nested-links.js"
 import { HTMLNoPositiveTabIndexRule } from "./rules/html-no-positive-tab-index.js"
 import { HTMLNoSelfClosingRule } from "./rules/html-no-self-closing.js"
-import { HTMLNoSpaceInTagRule } from "./rules/html-no-space-in-tag.js"
+// import { HTMLNoSpaceInTagRule } from "./rules/html-no-space-in-tag.js"
 // import { HTMLNoTitleAttributeRule } from "./rules/html-no-title-attribute.js"
 import { HTMLNoUnderscoresInAttributeNamesRule } from "./rules/html-no-underscores-in-attribute-names.js"
 import { HTMLTagNameLowercaseRule } from "./rules/html-tag-name-lowercase.js"
@@ -86,7 +86,7 @@ export const defaultRules: RuleClass[] = [
   HTMLNoNestedLinksRule,
   HTMLNoPositiveTabIndexRule,
   HTMLNoSelfClosingRule,
-  HTMLNoSpaceInTagRule,
+  // HTMLNoSpaceInTagRule,
   // HTMLNoTitleAttributeRule,
   HTMLNoUnderscoresInAttributeNamesRule,
   HTMLTagNameLowercaseRule,
diff --git a/javascript/packages/linter/src/rules/html-no-space-in-tag.ts b/javascript/packages/linter/src/rules/html-no-space-in-tag.ts
index 384251c75..4d064f2ef 100644
--- a/javascript/packages/linter/src/rules/html-no-space-in-tag.ts
+++ b/javascript/packages/linter/src/rules/html-no-space-in-tag.ts
@@ -142,7 +142,8 @@ class HTMLNoSpaceInTagVisitor extends BaseRuleVisitor<HTMLNoSpaceInTagAutofixCon
 }
 
 export class HTMLNoSpaceInTagRule extends ParserRule<HTMLNoSpaceInTagAutofixContext> {
-  static autocorrectable = true
+  // TODO: enable and fix autofix
+  static autocorrectable = false
   name = "html-no-space-in-tag"
 
   check(result: ParseResult, context?: Partial<LintContext>): LintOffense<HTMLNoSpaceInTagAutofixContext>[] {
diff --git a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
index 19680107a..793eed204 100644
--- a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
+++ b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
@@ -610,7 +610,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for bad file 1`]
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 40,
+    "ruleCount": 39,
     "totalErrors": 2,
     "totalIgnored": 0,
     "totalOffenses": 2,
@@ -629,7 +629,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for clean file 1`
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 0,
-    "ruleCount": 40,
+    "ruleCount": 39,
     "totalErrors": 0,
     "totalIgnored": 0,
     "totalOffenses": 0,
@@ -700,7 +700,7 @@ exports[`CLI Output Formatting > formats JSON output correctly for file with err
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 40,
+    "ruleCount": 39,
     "totalErrors": 3,
     "totalIgnored": 0,
     "totalOffenses": 3,
diff --git a/javascript/packages/vscode/package.json b/javascript/packages/vscode/package.json
index f61824304..c4be9b939 100644
--- a/javascript/packages/vscode/package.json
+++ b/javascript/packages/vscode/package.json
@@ -68,8 +68,8 @@
               "erb-no-output-control-flow",
               "erb-no-silent-tag-in-attribute-name",
               "erb-prefer-image-tag-helper",
-              "erb-require-whitespace-inside-tags",
               "erb-require-trailing-newline",
+              "erb-require-whitespace-inside-tags",
               "erb-right-trim",
               "html-anchor-require-href",
               "html-aria-attribute-must-be-valid",

From 34d352a1d55c9c78dd53d87a713a37905f853a72 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Mon, 20 Oct 2025 16:44:26 +0200
Subject: [PATCH 92/97] VS Code: Only show `Report Issue` Code Action for Herb
 Diagnostics (#700)

This pull request changes the VS Code Language Server client to only
show the `Report Issue` Code Action when the `diagnostic.source`
contains `"Herb"`.

<img width="50%" height="188" alt="CleanShot 2025-10-20 at 16 31 49@2x"
src="https://github.com/user-attachments/assets/0d155c93-2517-4083-9cd4-0241338d68cc"
/>

This makes it so the Code Action only shows up on diagnostics issued by
the Herb Language Server.


Resolves https://github.com/marcoroth/herb/issues/308
Resolves https://github.com/marcoroth/herb/issues/699
---
 .../packages/vscode/src/code-action-provider.ts | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/javascript/packages/vscode/src/code-action-provider.ts b/javascript/packages/vscode/src/code-action-provider.ts
index 4a97ef0ca..e03f88497 100644
--- a/javascript/packages/vscode/src/code-action-provider.ts
+++ b/javascript/packages/vscode/src/code-action-provider.ts
@@ -7,18 +7,19 @@ export class HerbCodeActionProvider implements vscode.CodeActionProvider {
     context: vscode.CodeActionContext,
     _token: vscode.CancellationToken
   ): vscode.CodeAction[] {
+    if (context.diagnostics.length === 0) {
+      return []
+    }
+
     const actions: vscode.CodeAction[] = []
 
-    if (!document.fileName.endsWith('.html.erb')) {
-      return actions
-    }
+    for (const diagnostic of context.diagnostics) {
+      const source = typeof diagnostic.source === 'string' ? diagnostic.source.trim() : undefined
 
-    const diagnostics = context.diagnostics
-    if (diagnostics.length === 0) {
-      return actions
-    }
+      if (!source || !source.includes('Herb')) {
+        continue
+      }
 
-    for (const diagnostic of diagnostics) {
       let errorType = 'UNKNOWN_ERROR'
       if (typeof diagnostic.code === 'string' && diagnostic.code) {
         errorType = diagnostic.code

From f92b7dbe8aa228be8eeeccbdc94ecdd47fcf32cb Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 20 Oct 2025 21:20:50 +0200
Subject: [PATCH 93/97] Bump playwright from 1.55.0 to 1.55.1 in the
 npm_and_yarn group across 1 directory (#702)

Bumps the npm_and_yarn group with 1 update in the / directory:
[playwright](https://github.com/microsoft/playwright).

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../tailwind-class-sorter/package.json        |   2 +-
 javascript/packages/vscode/package.json       |   2 +-
 package.json                                  |   2 +-
 playground/package.json                       |   2 +-
 yarn.lock                                     | 344 +++++++++---------
 5 files changed, 176 insertions(+), 176 deletions(-)

diff --git a/javascript/packages/tailwind-class-sorter/package.json b/javascript/packages/tailwind-class-sorter/package.json
index 901efe796..2bbee0cca 100644
--- a/javascript/packages/tailwind-class-sorter/package.json
+++ b/javascript/packages/tailwind-class-sorter/package.json
@@ -46,7 +46,7 @@
   "devDependencies": {
     "@types/node": "^24.1.0",
     "dedent": "^1.6.0",
-    "esbuild": "^0.25.10",
+    "esbuild": "^0.25.11",
     "rimraf": "^6.0.1",
     "tailwindcss": "^3.4.17",
     "tsup": "^8.5.0",
diff --git a/javascript/packages/vscode/package.json b/javascript/packages/vscode/package.json
index c4be9b939..0a26d49c8 100644
--- a/javascript/packages/vscode/package.json
+++ b/javascript/packages/vscode/package.json
@@ -258,7 +258,7 @@
     "@vscode/test-cli": "^0.0.10",
     "@vscode/test-electron": "^2.5.2",
     "@vscode/vsce": "^3.5.0",
-    "esbuild": "^0.25.10",
+    "esbuild": "^0.25.11",
     "esbuild-plugin-copy": "^2.1.1",
     "eslint": "^9.25.1",
     "npm-run-all": "^4.1.5",
diff --git a/package.json b/package.json
index c02b85dfb..a684519d5 100644
--- a/package.json
+++ b/package.json
@@ -23,7 +23,7 @@
     "minimatch": "^10.0.3",
     "nx": "21.1.2",
     "oxlint": "^1.13.0",
-    "playwright": "^1.51.0",
+    "playwright": "^1.55.1",
     "prettier": "^3.6.2",
     "rimraf": "^6.0.1",
     "rollup": "^4.47.1",
diff --git a/playground/package.json b/playground/package.json
index 37c24a366..99560ea5f 100644
--- a/playground/package.json
+++ b/playground/package.json
@@ -28,7 +28,7 @@
     "lz-string": "^1.5.0",
     "monaco-editor": "^0.52.2",
     "prismjs": "^1.30.0",
-    "vite": "^7.1.7"
+    "vite": "^7.1.8"
   },
   "devDependencies": {
     "@types/express": "^4.17.21",
diff --git a/yarn.lock b/yarn.lock
index 67c73992f..7261a5366 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -219,135 +219,135 @@
   dependencies:
     tslib "^2.4.0"
 
-"@esbuild/aix-ppc64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.25.10.tgz#ee6b7163a13528e099ecf562b972f2bcebe0aa97"
-  integrity sha512-0NFWnA+7l41irNuaSVlLfgNT12caWJVLzp5eAVhZ0z1qpxbockccEt3s+149rE64VUI3Ml2zt8Nv5JVc4QXTsw==
-
-"@esbuild/android-arm64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.25.10.tgz#115fc76631e82dd06811bfaf2db0d4979c16e2cb"
-  integrity sha512-LSQa7eDahypv/VO6WKohZGPSJDq5OVOo3UoFR1E4t4Gj1W7zEQMUhI+lo81H+DtB+kP+tDgBp+M4oNCwp6kffg==
-
-"@esbuild/android-arm@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.25.10.tgz#8d5811912da77f615398611e5bbc1333fe321aa9"
-  integrity sha512-dQAxF1dW1C3zpeCDc5KqIYuZ1tgAdRXNoZP7vkBIRtKZPYe2xVr/d3SkirklCHudW1B45tGiUlz2pUWDfbDD4w==
-
-"@esbuild/android-x64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.25.10.tgz#e3e96516b2d50d74105bb92594c473e30ddc16b1"
-  integrity sha512-MiC9CWdPrfhibcXwr39p9ha1x0lZJ9KaVfvzA0Wxwz9ETX4v5CHfF09bx935nHlhi+MxhA63dKRRQLiVgSUtEg==
-
-"@esbuild/darwin-arm64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.25.10.tgz#6af6bb1d05887dac515de1b162b59dc71212ed76"
-  integrity sha512-JC74bdXcQEpW9KkV326WpZZjLguSZ3DfS8wrrvPMHgQOIEIG/sPXEN/V8IssoJhbefLRcRqw6RQH2NnpdprtMA==
-
-"@esbuild/darwin-x64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.25.10.tgz#99ae82347fbd336fc2d28ffd4f05694e6e5b723d"
-  integrity sha512-tguWg1olF6DGqzws97pKZ8G2L7Ig1vjDmGTwcTuYHbuU6TTjJe5FXbgs5C1BBzHbJ2bo1m3WkQDbWO2PvamRcg==
-
-"@esbuild/freebsd-arm64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.10.tgz#0c6d5558a6322b0bdb17f7025c19bd7d2359437d"
-  integrity sha512-3ZioSQSg1HT2N05YxeJWYR+Libe3bREVSdWhEEgExWaDtyFbbXWb49QgPvFH8u03vUPX10JhJPcz7s9t9+boWg==
-
-"@esbuild/freebsd-x64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.25.10.tgz#8c35873fab8c0857a75300a3dcce4324ca0b9844"
-  integrity sha512-LLgJfHJk014Aa4anGDbh8bmI5Lk+QidDmGzuC2D+vP7mv/GeSN+H39zOf7pN5N8p059FcOfs2bVlrRr4SK9WxA==
-
-"@esbuild/linux-arm64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.25.10.tgz#3edc2f87b889a15b4cedaf65f498c2bed7b16b90"
-  integrity sha512-5luJWN6YKBsawd5f9i4+c+geYiVEw20FVW5x0v1kEMWNq8UctFjDiMATBxLvmmHA4bf7F6hTRaJgtghFr9iziQ==
-
-"@esbuild/linux-arm@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.25.10.tgz#86501cfdfb3d110176d80c41b27ed4611471cde7"
-  integrity sha512-oR31GtBTFYCqEBALI9r6WxoU/ZofZl962pouZRTEYECvNF/dtXKku8YXcJkhgK/beU+zedXfIzHijSRapJY3vg==
-
-"@esbuild/linux-ia32@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.25.10.tgz#e6589877876142537c6864680cd5d26a622b9d97"
-  integrity sha512-NrSCx2Kim3EnnWgS4Txn0QGt0Xipoumb6z6sUtl5bOEZIVKhzfyp/Lyw4C1DIYvzeW/5mWYPBFJU3a/8Yr75DQ==
-
-"@esbuild/linux-loong64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.25.10.tgz#11119e18781f136d8083ea10eb6be73db7532de8"
-  integrity sha512-xoSphrd4AZda8+rUDDfD9J6FUMjrkTz8itpTITM4/xgerAZZcFW7Dv+sun7333IfKxGG8gAq+3NbfEMJfiY+Eg==
-
-"@esbuild/linux-mips64el@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.25.10.tgz#3052f5436b0c0c67a25658d5fc87f045e7def9e6"
-  integrity sha512-ab6eiuCwoMmYDyTnyptoKkVS3k8fy/1Uvq7Dj5czXI6DF2GqD2ToInBI0SHOp5/X1BdZ26RKc5+qjQNGRBelRA==
-
-"@esbuild/linux-ppc64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.25.10.tgz#2f098920ee5be2ce799f35e367b28709925a8744"
-  integrity sha512-NLinzzOgZQsGpsTkEbdJTCanwA5/wozN9dSgEl12haXJBzMTpssebuXR42bthOF3z7zXFWH1AmvWunUCkBE4EA==
-
-"@esbuild/linux-riscv64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.25.10.tgz#fa51d7fd0a22a62b51b4b94b405a3198cf7405dd"
-  integrity sha512-FE557XdZDrtX8NMIeA8LBJX3dC2M8VGXwfrQWU7LB5SLOajfJIxmSdyL/gU1m64Zs9CBKvm4UAuBp5aJ8OgnrA==
-
-"@esbuild/linux-s390x@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.25.10.tgz#a27642e36fc282748fdb38954bd3ef4f85791e8a"
-  integrity sha512-3BBSbgzuB9ajLoVZk0mGu+EHlBwkusRmeNYdqmznmMc9zGASFjSsxgkNsqmXugpPk00gJ0JNKh/97nxmjctdew==
-
-"@esbuild/linux-x64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.25.10.tgz#9d9b09c0033d17529570ced6d813f98315dfe4e9"
-  integrity sha512-QSX81KhFoZGwenVyPoberggdW1nrQZSvfVDAIUXr3WqLRZGZqWk/P4T8p2SP+de2Sr5HPcvjhcJzEiulKgnxtA==
-
-"@esbuild/netbsd-arm64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.10.tgz#25c09a659c97e8af19e3f2afd1c9190435802151"
-  integrity sha512-AKQM3gfYfSW8XRk8DdMCzaLUFB15dTrZfnX8WXQoOUpUBQ+NaAFCP1kPS/ykbbGYz7rxn0WS48/81l9hFl3u4A==
-
-"@esbuild/netbsd-x64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.25.10.tgz#7fa5f6ffc19be3a0f6f5fd32c90df3dc2506937a"
-  integrity sha512-7RTytDPGU6fek/hWuN9qQpeGPBZFfB4zZgcz2VK2Z5VpdUxEI8JKYsg3JfO0n/Z1E/6l05n0unDCNc4HnhQGig==
-
-"@esbuild/openbsd-arm64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.10.tgz#8faa6aa1afca0c6d024398321d6cb1c18e72a1c3"
-  integrity sha512-5Se0VM9Wtq797YFn+dLimf2Zx6McttsH2olUBsDml+lm0GOCRVebRWUvDtkY4BWYv/3NgzS8b/UM3jQNh5hYyw==
-
-"@esbuild/openbsd-x64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.25.10.tgz#a42979b016f29559a8453d32440d3c8cd420af5e"
-  integrity sha512-XkA4frq1TLj4bEMB+2HnI0+4RnjbuGZfet2gs/LNs5Hc7D89ZQBHQ0gL2ND6Lzu1+QVkjp3x1gIcPKzRNP8bXw==
-
-"@esbuild/openharmony-arm64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.10.tgz#fd87bfeadd7eeb3aa384bbba907459ffa3197cb1"
-  integrity sha512-AVTSBhTX8Y/Fz6OmIVBip9tJzZEUcY8WLh7I59+upa5/GPhh2/aM6bvOMQySspnCCHvFi79kMtdJS1w0DXAeag==
-
-"@esbuild/sunos-x64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.25.10.tgz#3a18f590e36cb78ae7397976b760b2b8c74407f4"
-  integrity sha512-fswk3XT0Uf2pGJmOpDB7yknqhVkJQkAQOcW/ccVOtfx05LkbWOaRAtn5SaqXypeKQra1QaEa841PgrSL9ubSPQ==
-
-"@esbuild/win32-arm64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.25.10.tgz#e71741a251e3fd971408827a529d2325551f530c"
-  integrity sha512-ah+9b59KDTSfpaCg6VdJoOQvKjI33nTaQr4UluQwW7aEwZQsbMCfTmfEO4VyewOxx4RaDT/xCy9ra2GPWmO7Kw==
-
-"@esbuild/win32-ia32@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.25.10.tgz#c6f010b5d3b943d8901a0c87ea55f93b8b54bf94"
-  integrity sha512-QHPDbKkrGO8/cz9LKVnJU22HOi4pxZnZhhA2HYHez5Pz4JeffhDjf85E57Oyco163GnzNCVkZK0b/n4Y0UHcSw==
-
-"@esbuild/win32-x64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.25.10.tgz#e4b3e255a1b4aea84f6e1d2ae0b73f826c3785bd"
-  integrity sha512-9KpxSVFCu0iK1owoez6aC/s/EdUQLDN3adTxGCqxMVhrPDj6bt5dbrHDXUuq+Bs2vATFBBrQS5vdQ/Ed2P+nbw==
+"@esbuild/aix-ppc64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.25.11.tgz#2ae33300598132cc4cf580dbbb28d30fed3c5c49"
+  integrity sha512-Xt1dOL13m8u0WE8iplx9Ibbm+hFAO0GsU2P34UNoDGvZYkY8ifSiy6Zuc1lYxfG7svWE2fzqCUmFp5HCn51gJg==
+
+"@esbuild/android-arm64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.25.11.tgz#927708b3db5d739d6cb7709136924cc81bec9b03"
+  integrity sha512-9slpyFBc4FPPz48+f6jyiXOx/Y4v34TUeDDXJpZqAWQn/08lKGeD8aDp9TMn9jDz2CiEuHwfhRmGBvpnd/PWIQ==
+
+"@esbuild/android-arm@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.25.11.tgz#571f94e7f4068957ec4c2cfb907deae3d01b55ae"
+  integrity sha512-uoa7dU+Dt3HYsethkJ1k6Z9YdcHjTrSb5NUy66ZfZaSV8hEYGD5ZHbEMXnqLFlbBflLsl89Zke7CAdDJ4JI+Gg==
+
+"@esbuild/android-x64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.25.11.tgz#8a3bf5cae6c560c7ececa3150b2bde76e0fb81e6"
+  integrity sha512-Sgiab4xBjPU1QoPEIqS3Xx+R2lezu0LKIEcYe6pftr56PqPygbB7+szVnzoShbx64MUupqoE0KyRlN7gezbl8g==
+
+"@esbuild/darwin-arm64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.25.11.tgz#0a678c4ac4bf8717e67481e1a797e6c152f93c84"
+  integrity sha512-VekY0PBCukppoQrycFxUqkCojnTQhdec0vevUL/EDOCnXd9LKWqD/bHwMPzigIJXPhC59Vd1WFIL57SKs2mg4w==
+
+"@esbuild/darwin-x64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.25.11.tgz#70f5e925a30c8309f1294d407a5e5e002e0315fe"
+  integrity sha512-+hfp3yfBalNEpTGp9loYgbknjR695HkqtY3d3/JjSRUyPg/xd6q+mQqIb5qdywnDxRZykIHs3axEqU6l1+oWEQ==
+
+"@esbuild/freebsd-arm64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.11.tgz#4ec1db687c5b2b78b44148025da9632397553e8a"
+  integrity sha512-CmKjrnayyTJF2eVuO//uSjl/K3KsMIeYeyN7FyDBjsR3lnSJHaXlVoAK8DZa7lXWChbuOk7NjAc7ygAwrnPBhA==
+
+"@esbuild/freebsd-x64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.25.11.tgz#4c81abd1b142f1e9acfef8c5153d438ca53f44bb"
+  integrity sha512-Dyq+5oscTJvMaYPvW3x3FLpi2+gSZTCE/1ffdwuM6G1ARang/mb3jvjxs0mw6n3Lsw84ocfo9CrNMqc5lTfGOw==
+
+"@esbuild/linux-arm64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.25.11.tgz#69517a111acfc2b93aa0fb5eaeb834c0202ccda5"
+  integrity sha512-Qr8AzcplUhGvdyUF08A1kHU3Vr2O88xxP0Tm8GcdVOUm25XYcMPp2YqSVHbLuXzYQMf9Bh/iKx7YPqECs6ffLA==
+
+"@esbuild/linux-arm@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.25.11.tgz#58dac26eae2dba0fac5405052b9002dac088d38f"
+  integrity sha512-TBMv6B4kCfrGJ8cUPo7vd6NECZH/8hPpBHHlYI3qzoYFvWu2AdTvZNuU/7hsbKWqu/COU7NIK12dHAAqBLLXgw==
+
+"@esbuild/linux-ia32@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.25.11.tgz#b89d4efe9bdad46ba944f0f3b8ddd40834268c2b"
+  integrity sha512-TmnJg8BMGPehs5JKrCLqyWTVAvielc615jbkOirATQvWWB1NMXY77oLMzsUjRLa0+ngecEmDGqt5jiDC6bfvOw==
+
+"@esbuild/linux-loong64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.25.11.tgz#11f603cb60ad14392c3f5c94d64b3cc8b630fbeb"
+  integrity sha512-DIGXL2+gvDaXlaq8xruNXUJdT5tF+SBbJQKbWy/0J7OhU8gOHOzKmGIlfTTl6nHaCOoipxQbuJi7O++ldrxgMw==
+
+"@esbuild/linux-mips64el@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.25.11.tgz#b7d447ff0676b8ab247d69dac40a5cf08e5eeaf5"
+  integrity sha512-Osx1nALUJu4pU43o9OyjSCXokFkFbyzjXb6VhGIJZQ5JZi8ylCQ9/LFagolPsHtgw6himDSyb5ETSfmp4rpiKQ==
+
+"@esbuild/linux-ppc64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.25.11.tgz#b3a28ed7cc252a61b07ff7c8fd8a984ffd3a2f74"
+  integrity sha512-nbLFgsQQEsBa8XSgSTSlrnBSrpoWh7ioFDUmwo158gIm5NNP+17IYmNWzaIzWmgCxq56vfr34xGkOcZ7jX6CPw==
+
+"@esbuild/linux-riscv64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.25.11.tgz#ce75b08f7d871a75edcf4d2125f50b21dc9dc273"
+  integrity sha512-HfyAmqZi9uBAbgKYP1yGuI7tSREXwIb438q0nqvlpxAOs3XnZ8RsisRfmVsgV486NdjD7Mw2UrFSw51lzUk1ww==
+
+"@esbuild/linux-s390x@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.25.11.tgz#cd08f6c73b6b6ff9ccdaabbd3ff6ad3dca99c263"
+  integrity sha512-HjLqVgSSYnVXRisyfmzsH6mXqyvj0SA7pG5g+9W7ESgwA70AXYNpfKBqh1KbTxmQVaYxpzA/SvlB9oclGPbApw==
+
+"@esbuild/linux-x64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.25.11.tgz#3c3718af31a95d8946ebd3c32bb1e699bdf74910"
+  integrity sha512-HSFAT4+WYjIhrHxKBwGmOOSpphjYkcswF449j6EjsjbinTZbp8PJtjsVK1XFJStdzXdy/jaddAep2FGY+wyFAQ==
+
+"@esbuild/netbsd-arm64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.11.tgz#b4c767082401e3a4e8595fe53c47cd7f097c8077"
+  integrity sha512-hr9Oxj1Fa4r04dNpWr3P8QKVVsjQhqrMSUzZzf+LZcYjZNqhA3IAfPQdEh1FLVUJSiu6sgAwp3OmwBfbFgG2Xg==
+
+"@esbuild/netbsd-x64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.25.11.tgz#f2a930458ed2941d1f11ebc34b9c7d61f7a4d034"
+  integrity sha512-u7tKA+qbzBydyj0vgpu+5h5AeudxOAGncb8N6C9Kh1N4n7wU1Xw1JDApsRjpShRpXRQlJLb9wY28ELpwdPcZ7A==
+
+"@esbuild/openbsd-arm64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.11.tgz#b4ae93c75aec48bc1e8a0154957a05f0641f2dad"
+  integrity sha512-Qq6YHhayieor3DxFOoYM1q0q1uMFYb7cSpLD2qzDSvK1NAvqFi8Xgivv0cFC6J+hWVw2teCYltyy9/m/14ryHg==
+
+"@esbuild/openbsd-x64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.25.11.tgz#b42863959c8dcf9b01581522e40012d2c70045e2"
+  integrity sha512-CN+7c++kkbrckTOz5hrehxWN7uIhFFlmS/hqziSFVWpAzpWrQoAG4chH+nN3Be+Kzv/uuo7zhX716x3Sn2Jduw==
+
+"@esbuild/openharmony-arm64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.11.tgz#b2e717141c8fdf6bddd4010f0912e6b39e1640f1"
+  integrity sha512-rOREuNIQgaiR+9QuNkbkxubbp8MSO9rONmwP5nKncnWJ9v5jQ4JxFnLu4zDSRPf3x4u+2VN4pM4RdyIzDty/wQ==
+
+"@esbuild/sunos-x64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.25.11.tgz#9fbea1febe8778927804828883ec0f6dd80eb244"
+  integrity sha512-nq2xdYaWxyg9DcIyXkZhcYulC6pQ2FuCgem3LI92IwMgIZ69KHeY8T4Y88pcwoLIjbed8n36CyKoYRDygNSGhA==
+
+"@esbuild/win32-arm64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.25.11.tgz#501539cedb24468336073383989a7323005a8935"
+  integrity sha512-3XxECOWJq1qMZ3MN8srCJ/QfoLpL+VaxD/WfNRm1O3B4+AZ/BnLVgFbUV3eiRYDMXetciH16dwPbbHqwe1uU0Q==
+
+"@esbuild/win32-ia32@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.25.11.tgz#8ac7229aa82cef8f16ffb58f1176a973a7a15343"
+  integrity sha512-3ukss6gb9XZ8TlRyJlgLn17ecsK4NSQTmdIXRASVsiS2sQ6zPPZklNJT5GR5tE/MUarymmy8kCEf5xPCNCqVOA==
+
+"@esbuild/win32-x64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.25.11.tgz#5ecda6f3fe138b7e456f4e429edde33c823f392f"
+  integrity sha512-D7Hpz6A2L4hzsRpPaCYkQnGOotdUpDzSGRIv9I+1ITdHROSFUWW95ZPZWQmGka1Fg7W3zFJowyn9WGwMJ0+KPA==
 
 "@eslint-community/eslint-utils@^4.2.0", "@eslint-community/eslint-utils@^4.7.0":
   version "4.7.0"
@@ -3930,37 +3930,37 @@ esbuild-plugin-copy@^2.1.1:
     fs-extra "^10.0.1"
     globby "^11.0.3"
 
-esbuild@^0.25.0, esbuild@^0.25.10, esbuild@~0.25.0:
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.25.10.tgz#37f5aa5cd14500f141be121c01b096ca83ac34a9"
-  integrity sha512-9RiGKvCwaqxO2owP61uQ4BgNborAQskMR6QusfWzQqv7AZOg5oGehdY2pRJMTKuwxd1IDBP4rSbI5lHzU7SMsQ==
+esbuild@^0.25.0, esbuild@^0.25.11, esbuild@~0.25.0:
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.25.11.tgz#0f31b82f335652580f75ef6897bba81962d9ae3d"
+  integrity sha512-KohQwyzrKTQmhXDW1PjCv3Tyspn9n5GcY2RTDqeORIdIJY8yKIF7sTSopFmn/wpMPW4rdPXI0UE5LJLuq3bx0Q==
   optionalDependencies:
-    "@esbuild/aix-ppc64" "0.25.10"
-    "@esbuild/android-arm" "0.25.10"
-    "@esbuild/android-arm64" "0.25.10"
-    "@esbuild/android-x64" "0.25.10"
-    "@esbuild/darwin-arm64" "0.25.10"
-    "@esbuild/darwin-x64" "0.25.10"
-    "@esbuild/freebsd-arm64" "0.25.10"
-    "@esbuild/freebsd-x64" "0.25.10"
-    "@esbuild/linux-arm" "0.25.10"
-    "@esbuild/linux-arm64" "0.25.10"
-    "@esbuild/linux-ia32" "0.25.10"
-    "@esbuild/linux-loong64" "0.25.10"
-    "@esbuild/linux-mips64el" "0.25.10"
-    "@esbuild/linux-ppc64" "0.25.10"
-    "@esbuild/linux-riscv64" "0.25.10"
-    "@esbuild/linux-s390x" "0.25.10"
-    "@esbuild/linux-x64" "0.25.10"
-    "@esbuild/netbsd-arm64" "0.25.10"
-    "@esbuild/netbsd-x64" "0.25.10"
-    "@esbuild/openbsd-arm64" "0.25.10"
-    "@esbuild/openbsd-x64" "0.25.10"
-    "@esbuild/openharmony-arm64" "0.25.10"
-    "@esbuild/sunos-x64" "0.25.10"
-    "@esbuild/win32-arm64" "0.25.10"
-    "@esbuild/win32-ia32" "0.25.10"
-    "@esbuild/win32-x64" "0.25.10"
+    "@esbuild/aix-ppc64" "0.25.11"
+    "@esbuild/android-arm" "0.25.11"
+    "@esbuild/android-arm64" "0.25.11"
+    "@esbuild/android-x64" "0.25.11"
+    "@esbuild/darwin-arm64" "0.25.11"
+    "@esbuild/darwin-x64" "0.25.11"
+    "@esbuild/freebsd-arm64" "0.25.11"
+    "@esbuild/freebsd-x64" "0.25.11"
+    "@esbuild/linux-arm" "0.25.11"
+    "@esbuild/linux-arm64" "0.25.11"
+    "@esbuild/linux-ia32" "0.25.11"
+    "@esbuild/linux-loong64" "0.25.11"
+    "@esbuild/linux-mips64el" "0.25.11"
+    "@esbuild/linux-ppc64" "0.25.11"
+    "@esbuild/linux-riscv64" "0.25.11"
+    "@esbuild/linux-s390x" "0.25.11"
+    "@esbuild/linux-x64" "0.25.11"
+    "@esbuild/netbsd-arm64" "0.25.11"
+    "@esbuild/netbsd-x64" "0.25.11"
+    "@esbuild/openbsd-arm64" "0.25.11"
+    "@esbuild/openbsd-x64" "0.25.11"
+    "@esbuild/openharmony-arm64" "0.25.11"
+    "@esbuild/sunos-x64" "0.25.11"
+    "@esbuild/win32-arm64" "0.25.11"
+    "@esbuild/win32-ia32" "0.25.11"
+    "@esbuild/win32-x64" "0.25.11"
 
 escalade@^3.1.1, escalade@^3.2.0:
   version "3.2.0"
@@ -7462,17 +7462,17 @@ pkg-types@^2.3.0:
     exsolve "^1.0.7"
     pathe "^2.0.3"
 
-playwright-core@1.55.0:
-  version "1.55.0"
-  resolved "https://registry.yarnpkg.com/playwright-core/-/playwright-core-1.55.0.tgz#ec8a9f8ef118afb3e86e0f46f1393e3bea32adf4"
-  integrity sha512-GvZs4vU3U5ro2nZpeiwyb0zuFaqb9sUiAJuyrWpcGouD8y9/HLgGbNRjIph7zU9D3hnPaisMl9zG9CgFi/biIg==
+playwright-core@1.55.1:
+  version "1.55.1"
+  resolved "https://registry.yarnpkg.com/playwright-core/-/playwright-core-1.55.1.tgz#5d3bb1846bc4289d364ea1a9dcb33f14545802e9"
+  integrity sha512-Z6Mh9mkwX+zxSlHqdr5AOcJnfp+xUWLCt9uKV18fhzA8eyxUd8NUWzAjxUh55RZKSYwDGX0cfaySdhZJGMoJ+w==
 
-playwright@^1.51.0:
-  version "1.55.0"
-  resolved "https://registry.yarnpkg.com/playwright/-/playwright-1.55.0.tgz#7aca7ac3ffd9e083a8ad8b2514d6f9ba401cc78b"
-  integrity sha512-sdCWStblvV1YU909Xqx0DhOjPZE4/5lJsIS84IfN9dAZfcl/CIZ5O8l3o0j7hPMjDvqoTF8ZUcc+i/GL5erstA==
+playwright@^1.55.1:
+  version "1.55.1"
+  resolved "https://registry.yarnpkg.com/playwright/-/playwright-1.55.1.tgz#8a9954e9e61ed1ab479212af9be336888f8b3f0e"
+  integrity sha512-cJW4Xd/G3v5ovXtJJ52MAOclqeac9S/aGGgRzLabuF8TnIb6xHvMzKIa6JmrRzUkeXJgfL1MhukP0NK6l39h3A==
   dependencies:
-    playwright-core "1.55.0"
+    playwright-core "1.55.1"
   optionalDependencies:
     fsevents "2.3.2"
 
@@ -9757,10 +9757,10 @@ vite-node@3.2.4:
     pathe "^2.0.3"
     vite "^5.0.0 || ^6.0.0 || ^7.0.0-0"
 
-"vite@^5.0.0 || ^6.0.0 || ^7.0.0-0", vite@^7.1.2, vite@^7.1.7:
-  version "7.1.7"
-  resolved "https://registry.yarnpkg.com/vite/-/vite-7.1.7.tgz#ed3f9f06e21d6574fe1ad425f6b0912d027ffc13"
-  integrity sha512-VbA8ScMvAISJNJVbRDTJdCwqQoAareR/wutevKanhR2/1EkoXVZVkkORaYm/tNVCjP/UDTKtcw3bAkwOUdedmA==
+"vite@^5.0.0 || ^6.0.0 || ^7.0.0-0", vite@^7.1.2, vite@^7.1.8:
+  version "7.1.8"
+  resolved "https://registry.yarnpkg.com/vite/-/vite-7.1.8.tgz#ff208eee01658c5b407b6a1afa9b92b25750832e"
+  integrity sha512-oBXvfSHEOL8jF+R9Am7h59Up07kVVGH1NrFGFoEG6bPDZP3tGpQhvkBpy5x7U6+E6wZCu9OihsWgJqDbQIm8LQ==
   dependencies:
     esbuild "^0.25.0"
     fdir "^6.5.0"

From d6ddd241f66431cbd562993fa7a4696efabba0a0 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 21 Oct 2025 01:17:34 +0200
Subject: [PATCH 94/97] Bump vite from 7.1.8 to 7.1.11 in the npm_and_yarn
 group across 1 directory (#705)

Bumps the npm_and_yarn group with 1 update in the / directory:
[vite](https://github.com/vitejs/vite/tree/HEAD/packages/vite).

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 playground/package.json | 2 +-
 yarn.lock               | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/playground/package.json b/playground/package.json
index 99560ea5f..3cb2bb182 100644
--- a/playground/package.json
+++ b/playground/package.json
@@ -28,7 +28,7 @@
     "lz-string": "^1.5.0",
     "monaco-editor": "^0.52.2",
     "prismjs": "^1.30.0",
-    "vite": "^7.1.8"
+    "vite": "^7.1.11"
   },
   "devDependencies": {
     "@types/express": "^4.17.21",
diff --git a/yarn.lock b/yarn.lock
index 7261a5366..bd70e0153 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -9757,10 +9757,10 @@ vite-node@3.2.4:
     pathe "^2.0.3"
     vite "^5.0.0 || ^6.0.0 || ^7.0.0-0"
 
-"vite@^5.0.0 || ^6.0.0 || ^7.0.0-0", vite@^7.1.2, vite@^7.1.8:
-  version "7.1.8"
-  resolved "https://registry.yarnpkg.com/vite/-/vite-7.1.8.tgz#ff208eee01658c5b407b6a1afa9b92b25750832e"
-  integrity sha512-oBXvfSHEOL8jF+R9Am7h59Up07kVVGH1NrFGFoEG6bPDZP3tGpQhvkBpy5x7U6+E6wZCu9OihsWgJqDbQIm8LQ==
+"vite@^5.0.0 || ^6.0.0 || ^7.0.0-0", vite@^7.1.11, vite@^7.1.2:
+  version "7.1.11"
+  resolved "https://registry.yarnpkg.com/vite/-/vite-7.1.11.tgz#4d006746112fee056df64985191e846ebfb6007e"
+  integrity sha512-uzcxnSDVjAopEUjljkWh8EIrg6tlzrjFUfMcR1EVsRDGwf/ccef0qQPRyOrROwhrTDaApueq+ja+KLPlzR/zdg==
   dependencies:
     esbuild "^0.25.0"
     fdir "^6.5.0"

From 81825b5ba7940d55896f4f379e2ac31dbccc1400 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim=20K=C3=A4chele?=
 <3810945+timkaechele@users.noreply.github.com>
Date: Tue, 21 Oct 2025 01:37:26 +0200
Subject: [PATCH 95/97] C: Use `hb_string_T` in `html_util.c` functions (#703)

This PR changes all `html_util` functions to use `hb_string_T` instead
of c strings.
---
 src/html_util.c         | 37 +++++++++++++++----------------------
 src/include/html_util.h |  4 ++--
 src/parser.c            | 13 +++++++------
 test/c/test_html_util.c | 32 ++++++++++++++++++--------------
 4 files changed, 42 insertions(+), 44 deletions(-)

diff --git a/src/html_util.c b/src/html_util.c
index 16432484d..32c6f4527 100644
--- a/src/html_util.c
+++ b/src/html_util.c
@@ -37,25 +37,22 @@ bool is_void_element(hb_string_T tag_name) {
  *
  * Example:
  * @code
- * char* tag = html_closing_tag_string("div");
- * if (tag) {
- *   printf("%s\n", tag); // Prints: </div>
- *   free(tag);
- * }
+ * hb_string_T tag = html_closing_tag_string(hb_string_from_c_string("div"));
+ *
+ * printf("%.*s\n", tag.length, tag.data); // Prints: </div>
+ * free(tag.data);
  * @endcode
  */
-char* html_closing_tag_string(const char* tag_name) {
-  if (tag_name == NULL) { return herb_strdup("</>"); }
-
+hb_string_T html_closing_tag_string(hb_string_T tag_name) {
   hb_buffer_T buffer;
-  hb_buffer_init(&buffer, strlen(tag_name) + 3);
+  hb_buffer_init(&buffer, tag_name.length + 3);
 
   hb_buffer_append_char(&buffer, '<');
   hb_buffer_append_char(&buffer, '/');
-  hb_buffer_append(&buffer, tag_name);
+  hb_buffer_append_string(&buffer, tag_name);
   hb_buffer_append_char(&buffer, '>');
 
-  return buffer.value;
+  return hb_string_from_c_string(buffer.value);
 }
 
 /**
@@ -67,24 +64,20 @@ char* html_closing_tag_string(const char* tag_name) {
  *
  * Example:
  * @code
- * char* tag = html_self_closing_tag_string("br");
- * if (tag) {
- *   printf("%s\n", tag); // Prints: <br />
- *   free(tag);
- * }
+ * hb_string_T tag = html_self_closing_tag_string(hb_string_from_c_string("br"));
+ * printf("%.*s\n", tag.length, tag.data); // Prints: <br />
+ * free(tag);
  * @endcode
  */
-char* html_self_closing_tag_string(const char* tag_name) {
-  if (tag_name == NULL) { return herb_strdup("< />"); }
-
+hb_string_T html_self_closing_tag_string(hb_string_T tag_name) {
   hb_buffer_T buffer;
-  hb_buffer_init(&buffer, strlen(tag_name) + 4);
+  hb_buffer_init(&buffer, tag_name.length + 4);
 
   hb_buffer_append_char(&buffer, '<');
-  hb_buffer_append(&buffer, tag_name);
+  hb_buffer_append_string(&buffer, tag_name);
   hb_buffer_append_char(&buffer, ' ');
   hb_buffer_append_char(&buffer, '/');
   hb_buffer_append_char(&buffer, '>');
 
-  return buffer.value;
+  return hb_string_from_c_string(buffer.value);
 }
diff --git a/src/include/html_util.h b/src/include/html_util.h
index 254c24074..51dbaf71a 100644
--- a/src/include/html_util.h
+++ b/src/include/html_util.h
@@ -6,7 +6,7 @@
 
 bool is_void_element(hb_string_T tag_name);
 
-char* html_closing_tag_string(const char* tag_name);
-char* html_self_closing_tag_string(const char* tag_name);
+hb_string_T html_closing_tag_string(hb_string_T tag_name);
+hb_string_T html_self_closing_tag_string(hb_string_T tag_name);
 
 #endif
diff --git a/src/parser.c b/src/parser.c
index 0a45c584d..03d6e8f80 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -11,6 +11,7 @@
 #include "include/util.h"
 #include "include/util/hb_array.h"
 #include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -859,20 +860,20 @@ static AST_HTML_CLOSE_TAG_NODE_T* parser_parse_html_close_tag(parser_T* parser)
 
   if (tag_name != NULL && is_void_element(hb_string_from_c_string(tag_name->value))
       && parser_in_svg_context(parser) == false) {
-    char* expected = html_self_closing_tag_string(tag_name->value);
-    char* got = html_closing_tag_string(tag_name->value);
+    hb_string_T expected = html_self_closing_tag_string(hb_string_from_c_string(tag_name->value));
+    hb_string_T got = html_closing_tag_string(hb_string_from_c_string(tag_name->value));
 
     append_void_element_closing_tag_error(
       tag_name,
-      expected,
-      got,
+      expected.data,
+      got.data,
       tag_opening->location.start,
       tag_closing->location.end,
       errors
     );
 
-    free(expected);
-    free(got);
+    free(expected.data);
+    free(got.data);
   }
 
   AST_HTML_CLOSE_TAG_NODE_T* close_tag = ast_html_close_tag_node_init(
diff --git a/test/c/test_html_util.c b/test/c/test_html_util.c
index 9515c4b78..64b8c3525 100644
--- a/test/c/test_html_util.c
+++ b/test/c/test_html_util.c
@@ -1,26 +1,30 @@
-#include <stdio.h>
-#include "include/test.h"
 #include "../../src/include/herb.h"
 #include "../../src/include/html_util.h"
+#include "include/test.h"
+#include <stdio.h>
 
 TEST(html_util_html_closing_tag_string)
-  ck_assert_str_eq(html_closing_tag_string(NULL), "</>");
-  ck_assert_str_eq(html_closing_tag_string(""), "</>");
-  ck_assert_str_eq(html_closing_tag_string(" "), "</ >");
-  ck_assert_str_eq(html_closing_tag_string("div"), "</div>");
-  ck_assert_str_eq(html_closing_tag_string("somelongerstring"), "</somelongerstring>");
+  ck_assert(hb_string_equals(html_closing_tag_string((hb_string_T) { .data = NULL, .length = 0 }), hb_string_from_c_string("</>")));
+  ck_assert(hb_string_equals(html_closing_tag_string(hb_string_from_c_string("")), hb_string_from_c_string("</>")));
+  ck_assert(hb_string_equals(html_closing_tag_string(hb_string_from_c_string(" ")), hb_string_from_c_string("</ >")));
+  ck_assert(hb_string_equals(html_closing_tag_string(hb_string_from_c_string("div")), hb_string_from_c_string("</div>")));
+
+  ck_assert(hb_string_equals(
+    html_closing_tag_string(hb_string_from_c_string("somelongerstring")),
+    hb_string_from_c_string("</somelongerstring>")
+  ));
 END
 
 TEST(html_util_html_self_closing_tag_string)
-  ck_assert_str_eq(html_self_closing_tag_string(NULL), "< />");
-  ck_assert_str_eq(html_self_closing_tag_string(""), "< />");
-  ck_assert_str_eq(html_self_closing_tag_string(" "), "<  />");
-  ck_assert_str_eq(html_self_closing_tag_string("br"), "<br />");
-  ck_assert_str_eq(html_self_closing_tag_string("somelongerstring"), "<somelongerstring />");
+  ck_assert(hb_string_equals(html_self_closing_tag_string((hb_string_T) { .data = NULL, .length = 0 }), hb_string_from_c_string("< />")));
+  ck_assert(hb_string_equals(html_self_closing_tag_string(hb_string_from_c_string("")), hb_string_from_c_string("< />")));
+  ck_assert(hb_string_equals(html_self_closing_tag_string(hb_string_from_c_string(" ")), hb_string_from_c_string("<  />")));
+  ck_assert(hb_string_equals(html_self_closing_tag_string(hb_string_from_c_string("br")), hb_string_from_c_string("<br />")));
+  ck_assert(hb_string_equals(html_self_closing_tag_string(hb_string_from_c_string("somelongerstring")), hb_string_from_c_string("<somelongerstring />")));
 END
 
-TCase *html_util_tests(void) {
-  TCase *html_util = tcase_create("HTML Util");
+TCase* html_util_tests(void) {
+  TCase* html_util = tcase_create("HTML Util");
 
   tcase_add_test(html_util, html_util_html_closing_tag_string);
   tcase_add_test(html_util, html_util_html_closing_tag_string);

From a9e63762749c6beaf75c4bc78e275e665f3d26e8 Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Tue, 21 Oct 2025 01:53:15 +0200
Subject: [PATCH 96/97] C: Rename `hb_string_from_c_string` to `hb_string`
 (#706)

This pull request renames the `hb_string_from_c_string` function to just
`hb_string` which makes it a bit easier and more natural to read.
---
 src/analyze.c                |  2 +-
 src/html_util.c              | 16 +++++-----
 src/include/util/hb_string.h |  2 +-
 src/lexer.c                  |  4 +--
 src/lexer_peek_helpers.c     | 20 ++++++------
 src/parser.c                 | 23 ++++++--------
 src/parser_helpers.c         | 16 +++++-----
 src/pretty_print.c           |  6 ++--
 src/util.c                   |  2 +-
 src/util/hb_string.c         |  2 +-
 test/c/test_hb_buffer.c      |  2 +-
 test/c/test_hb_string.c      | 60 ++++++++++++++++++------------------
 test/c/test_html_util.c      | 22 ++++++-------
 13 files changed, 86 insertions(+), 91 deletions(-)

diff --git a/src/analyze.c b/src/analyze.c
index 97e684ec1..c6204e27e 100644
--- a/src/analyze.c
+++ b/src/analyze.c
@@ -53,7 +53,7 @@ static bool analyze_erb_content(const AST_NODE_T* node, void* data) {
     const char* opening = erb_content_node->tag_opening->value;
 
     if (strcmp(opening, "<%%") != 0 && strcmp(opening, "<%%=") != 0 && strcmp(opening, "<%#") != 0) {
-      analyzed_ruby_T* analyzed = herb_analyze_ruby(hb_string_from_c_string(erb_content_node->content->value));
+      analyzed_ruby_T* analyzed = herb_analyze_ruby(hb_string(erb_content_node->content->value));
 
       erb_content_node->parsed = true;
       erb_content_node->valid = analyzed->valid;
diff --git a/src/html_util.c b/src/html_util.c
index 32c6f4527..4371ee5f9 100644
--- a/src/html_util.c
+++ b/src/html_util.c
@@ -14,11 +14,9 @@ bool is_void_element(hb_string_T tag_name) {
   if (hb_string_is_empty(tag_name)) { return false; }
 
   hb_string_T void_tags[14] = {
-    hb_string_from_c_string("area"),  hb_string_from_c_string("base"),  hb_string_from_c_string("br"),
-    hb_string_from_c_string("col"),   hb_string_from_c_string("embed"), hb_string_from_c_string("hr"),
-    hb_string_from_c_string("img"),   hb_string_from_c_string("input"), hb_string_from_c_string("link"),
-    hb_string_from_c_string("meta"),  hb_string_from_c_string("param"), hb_string_from_c_string("source"),
-    hb_string_from_c_string("track"), hb_string_from_c_string("wbr"),
+    hb_string("area"),  hb_string("base"),   hb_string("br"),    hb_string("col"),  hb_string("embed"),
+    hb_string("hr"),    hb_string("img"),    hb_string("input"), hb_string("link"), hb_string("meta"),
+    hb_string("param"), hb_string("source"), hb_string("track"), hb_string("wbr"),
   };
 
   for (size_t i = 0; i < 14; i++) {
@@ -37,7 +35,7 @@ bool is_void_element(hb_string_T tag_name) {
  *
  * Example:
  * @code
- * hb_string_T tag = html_closing_tag_string(hb_string_from_c_string("div"));
+ * hb_string_T tag = html_closing_tag_string(hb_string("div"));
  *
  * printf("%.*s\n", tag.length, tag.data); // Prints: </div>
  * free(tag.data);
@@ -52,7 +50,7 @@ hb_string_T html_closing_tag_string(hb_string_T tag_name) {
   hb_buffer_append_string(&buffer, tag_name);
   hb_buffer_append_char(&buffer, '>');
 
-  return hb_string_from_c_string(buffer.value);
+  return hb_string(buffer.value);
 }
 
 /**
@@ -64,7 +62,7 @@ hb_string_T html_closing_tag_string(hb_string_T tag_name) {
  *
  * Example:
  * @code
- * hb_string_T tag = html_self_closing_tag_string(hb_string_from_c_string("br"));
+ * hb_string_T tag = html_self_closing_tag_string(hb_string("br"));
  * printf("%.*s\n", tag.length, tag.data); // Prints: <br />
  * free(tag);
  * @endcode
@@ -79,5 +77,5 @@ hb_string_T html_self_closing_tag_string(hb_string_T tag_name) {
   hb_buffer_append_char(&buffer, '/');
   hb_buffer_append_char(&buffer, '>');
 
-  return hb_string_from_c_string(buffer.value);
+  return hb_string(buffer.value);
 }
diff --git a/src/include/util/hb_string.h b/src/include/util/hb_string.h
index fee5ba2c7..23419579e 100644
--- a/src/include/util/hb_string.h
+++ b/src/include/util/hb_string.h
@@ -12,7 +12,7 @@ typedef struct HB_STRING_STRUCT {
   uint32_t length;
 } hb_string_T;
 
-hb_string_T hb_string_from_c_string(const char* null_terminated_c_string);
+hb_string_T hb_string(const char* null_terminated_c_string);
 hb_string_T hb_string_slice(hb_string_T string, uint32_t offset);
 bool hb_string_equals(hb_string_T a, hb_string_T b);
 bool hb_string_equals_case_insensitive(hb_string_T a, hb_string_T b);
diff --git a/src/lexer.c b/src/lexer.c
index 0822caedb..45995751c 100644
--- a/src/lexer.c
+++ b/src/lexer.c
@@ -33,9 +33,9 @@ static bool lexer_stalled(lexer_T* lexer) {
 
 void lexer_init(lexer_T* lexer, const char* source) {
   if (source != NULL) {
-    lexer->source = hb_string_from_c_string(source);
+    lexer->source = hb_string(source);
   } else {
-    lexer->source = hb_string_from_c_string("");
+    lexer->source = hb_string("");
   }
 
   lexer->current_character = lexer->source.data[0];
diff --git a/src/lexer_peek_helpers.c b/src/lexer_peek_helpers.c
index e5decf1d9..86cbfe72a 100644
--- a/src/lexer_peek_helpers.c
+++ b/src/lexer_peek_helpers.c
@@ -28,43 +28,43 @@ bool lexer_peek_for(const lexer_T* lexer, uint32_t offset, hb_string_T pattern,
 }
 
 bool lexer_peek_for_doctype(const lexer_T* lexer, uint32_t offset) {
-  return lexer_peek_for(lexer, offset, hb_string_from_c_string("<!DOCTYPE"), true);
+  return lexer_peek_for(lexer, offset, hb_string("<!DOCTYPE"), true);
 }
 
 bool lexer_peek_for_xml_declaration(const lexer_T* lexer, uint32_t offset) {
-  return lexer_peek_for(lexer, offset, hb_string_from_c_string("<?xml"), true);
+  return lexer_peek_for(lexer, offset, hb_string("<?xml"), true);
 }
 
 bool lexer_peek_for_cdata_start(const lexer_T* lexer, uint32_t offset) {
-  return lexer_peek_for(lexer, offset, hb_string_from_c_string("<![CDATA["), false);
+  return lexer_peek_for(lexer, offset, hb_string("<![CDATA["), false);
 }
 
 bool lexer_peek_for_cdata_end(const lexer_T* lexer, uint32_t offset) {
-  return lexer_peek_for(lexer, offset, hb_string_from_c_string("]]>"), false);
+  return lexer_peek_for(lexer, offset, hb_string("]]>"), false);
 }
 
 bool lexer_peek_for_html_comment_start(const lexer_T* lexer, uint32_t offset) {
-  return lexer_peek_for(lexer, offset, hb_string_from_c_string("<!--"), false);
+  return lexer_peek_for(lexer, offset, hb_string("<!--"), false);
 }
 
 bool lexer_peek_for_html_comment_end(const lexer_T* lexer, uint32_t offset) {
-  return lexer_peek_for(lexer, offset, hb_string_from_c_string("-->"), false);
+  return lexer_peek_for(lexer, offset, hb_string("-->"), false);
 }
 
 bool lexer_peek_erb_close_tag(const lexer_T* lexer, uint32_t offset) {
-  return lexer_peek_for(lexer, offset, hb_string_from_c_string("%>"), false);
+  return lexer_peek_for(lexer, offset, hb_string("%>"), false);
 }
 
 bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, uint32_t offset) {
-  return lexer_peek_for(lexer, offset, hb_string_from_c_string("-%>"), false);
+  return lexer_peek_for(lexer, offset, hb_string("-%>"), false);
 }
 
 bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, uint32_t offset) {
-  return lexer_peek_for(lexer, offset, hb_string_from_c_string("%%>"), false);
+  return lexer_peek_for(lexer, offset, hb_string("%%>"), false);
 }
 
 bool lexer_peek_erb_equals_close_tag(const lexer_T* lexer, uint32_t offset) {
-  return lexer_peek_for(lexer, offset, hb_string_from_c_string("=%>"), false);
+  return lexer_peek_for(lexer, offset, hb_string("=%>"), false);
 }
 
 bool lexer_peek_erb_end(const lexer_T* lexer, uint32_t offset) {
diff --git a/src/parser.c b/src/parser.c
index 03d6e8f80..3cc25791a 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -858,10 +858,9 @@ static AST_HTML_CLOSE_TAG_NODE_T* parser_parse_html_close_tag(parser_T* parser)
 
   token_T* tag_closing = parser_consume_expected(parser, TOKEN_HTML_TAG_END, errors);
 
-  if (tag_name != NULL && is_void_element(hb_string_from_c_string(tag_name->value))
-      && parser_in_svg_context(parser) == false) {
-    hb_string_T expected = html_self_closing_tag_string(hb_string_from_c_string(tag_name->value));
-    hb_string_T got = html_closing_tag_string(hb_string_from_c_string(tag_name->value));
+  if (tag_name != NULL && is_void_element(hb_string(tag_name->value)) && parser_in_svg_context(parser) == false) {
+    hb_string_T expected = html_self_closing_tag_string(hb_string(tag_name->value));
+    hb_string_T got = html_closing_tag_string(hb_string(tag_name->value));
 
     append_void_element_closing_tag_error(
       tag_name,
@@ -920,9 +919,8 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_regular_element(
 
   parser_push_open_tag(parser, open_tag->tag_name);
 
-  if (open_tag->tag_name->value && parser_is_foreign_content_tag(hb_string_from_c_string(open_tag->tag_name->value))) {
-    foreign_content_type_T content_type =
-      parser_get_foreign_content_type(hb_string_from_c_string(open_tag->tag_name->value));
+  if (open_tag->tag_name->value && parser_is_foreign_content_tag(hb_string(open_tag->tag_name->value))) {
+    foreign_content_type_T content_type = parser_get_foreign_content_type(hb_string(open_tag->tag_name->value));
     parser_enter_foreign_content(parser, content_type);
     parser_parse_foreign_content(parser, body, errors);
   } else {
@@ -933,13 +931,13 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_regular_element(
 
   AST_HTML_CLOSE_TAG_NODE_T* close_tag = parser_parse_html_close_tag(parser);
 
-  if (parser_in_svg_context(parser) == false && is_void_element(hb_string_from_c_string(close_tag->tag_name->value))) {
+  if (parser_in_svg_context(parser) == false && is_void_element(hb_string(close_tag->tag_name->value))) {
     hb_array_push(body, close_tag);
     parser_parse_in_data_state(parser, body, errors);
     close_tag = parser_parse_html_close_tag(parser);
   }
 
-  bool matches_stack = parser_check_matching_tag(parser, hb_string_from_c_string(close_tag->tag_name->value));
+  bool matches_stack = parser_check_matching_tag(parser, hb_string(close_tag->tag_name->value));
 
   if (matches_stack) {
     token_T* popped_token = parser_pop_open_tag(parser);
@@ -968,8 +966,7 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_element(parser_T* parser) {
   if (open_tag->is_void) { return parser_parse_html_self_closing_element(parser, open_tag); }
 
   // <tag>, in void element list, and not in inside an <svg> element
-  if (!open_tag->is_void && is_void_element(hb_string_from_c_string(open_tag->tag_name->value))
-      && !parser_in_svg_context(parser)) {
+  if (!open_tag->is_void && is_void_element(hb_string(open_tag->tag_name->value)) && !parser_in_svg_context(parser)) {
     return parser_parse_html_self_closing_element(parser, open_tag);
   }
 
@@ -1052,7 +1049,7 @@ static void parser_parse_foreign_content(parser_T* parser, hb_array_T* children,
 
       if (next_token && next_token->type == TOKEN_IDENTIFIER && next_token->value) {
         is_potential_match =
-          parser_is_expected_closing_tag_name(hb_string_from_c_string(next_token->value), parser->foreign_content_type);
+          parser_is_expected_closing_tag_name(hb_string(next_token->value), parser->foreign_content_type);
       }
 
       lexer_restore_state(parser->lexer, saved_state);
@@ -1174,7 +1171,7 @@ static void parser_parse_stray_closing_tags(parser_T* parser, hb_array_T* childr
 
     AST_HTML_CLOSE_TAG_NODE_T* close_tag = parser_parse_html_close_tag(parser);
 
-    if (!is_void_element(hb_string_from_c_string(close_tag->tag_name->value))) {
+    if (!is_void_element(hb_string(close_tag->tag_name->value))) {
       append_missing_opening_tag_error(
         close_tag->tag_name,
         close_tag->base.location.start,
diff --git a/src/parser_helpers.c b/src/parser_helpers.c
index 85d26d8e8..f34d97864 100644
--- a/src/parser_helpers.c
+++ b/src/parser_helpers.c
@@ -24,7 +24,7 @@ bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name) {
   token_T* top_token = hb_array_last(parser->open_tags_stack);
   if (top_token == NULL || top_token->value == NULL) { return false; };
 
-  return hb_string_equals(hb_string_from_c_string(top_token->value), tag_name);
+  return hb_string_equals(hb_string(top_token->value), tag_name);
 }
 
 token_T* parser_pop_open_tag(const parser_T* parser) {
@@ -48,8 +48,8 @@ bool parser_in_svg_context(const parser_T* parser) {
     token_T* tag = (token_T*) hb_array_get(parser->open_tags_stack, i);
 
     if (tag && tag->value) {
-      hb_string_T tag_value_string = hb_string_from_c_string(tag->value);
-      if (hb_string_equals(tag_value_string, hb_string_from_c_string("svg"))) { return true; }
+      hb_string_T tag_value_string = hb_string(tag->value);
+      if (hb_string_equals(tag_value_string, hb_string("svg"))) { return true; }
     }
   }
 
@@ -61,8 +61,8 @@ bool parser_in_svg_context(const parser_T* parser) {
 foreign_content_type_T parser_get_foreign_content_type(hb_string_T tag_name) {
   if (hb_string_is_empty(tag_name)) { return FOREIGN_CONTENT_UNKNOWN; }
 
-  if (hb_string_equals(tag_name, hb_string_from_c_string("script"))) { return FOREIGN_CONTENT_SCRIPT; }
-  if (hb_string_equals(tag_name, hb_string_from_c_string("style"))) { return FOREIGN_CONTENT_STYLE; }
+  if (hb_string_equals(tag_name, hb_string("script"))) { return FOREIGN_CONTENT_SCRIPT; }
+  if (hb_string_equals(tag_name, hb_string("style"))) { return FOREIGN_CONTENT_STYLE; }
 
   return FOREIGN_CONTENT_UNKNOWN;
 }
@@ -73,9 +73,9 @@ bool parser_is_foreign_content_tag(hb_string_T tag_name) {
 
 hb_string_T parser_get_foreign_content_closing_tag(foreign_content_type_T type) {
   switch (type) {
-    case FOREIGN_CONTENT_SCRIPT: return hb_string_from_c_string("script");
-    case FOREIGN_CONTENT_STYLE: return hb_string_from_c_string("style");
-    default: return hb_string_from_c_string("");
+    case FOREIGN_CONTENT_SCRIPT: return hb_string("script");
+    case FOREIGN_CONTENT_STYLE: return hb_string("style");
+    default: return hb_string("");
   }
 }
 
diff --git a/src/pretty_print.c b/src/pretty_print.c
index 1dbf60247..e480dd0b7 100644
--- a/src/pretty_print.c
+++ b/src/pretty_print.c
@@ -53,7 +53,7 @@ void pretty_print_quoted_property(
   const bool last_property,
   hb_buffer_T* buffer
 ) {
-  hb_string_T quoted = quoted_string(hb_string_from_c_string(value));
+  hb_string_T quoted = quoted_string(hb_string(value));
   pretty_print_property(name, quoted.data, indent, relative_indent, last_property, buffer);
   free(quoted.data);
 }
@@ -213,7 +213,7 @@ void pretty_print_token_property(
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
 
   if (token != NULL && token->value != NULL) {
-    hb_string_T quoted = quoted_string(hb_string_from_c_string(token->value));
+    hb_string_T quoted = quoted_string(hb_string(token->value));
     hb_buffer_append_string(buffer, quoted);
     free(quoted.data);
 
@@ -240,7 +240,7 @@ void pretty_print_string_property(
 
   if (string != NULL) {
     escaped = escape_newlines(string);
-    quoted = quoted_string(hb_string_from_c_string(escaped));
+    quoted = quoted_string(hb_string(escaped));
     value = quoted.data;
   }
 
diff --git a/src/util.c b/src/util.c
index 21f19e484..95b7f4cdc 100644
--- a/src/util.c
+++ b/src/util.c
@@ -44,7 +44,7 @@ static hb_string_T wrap_string(hb_string_T input, char character) {
   hb_buffer_append_string(&buffer, input);
   hb_buffer_append_char(&buffer, character);
 
-  return hb_string_from_c_string(buffer.value);
+  return hb_string(buffer.value);
 }
 
 hb_string_T quoted_string(hb_string_T input) {
diff --git a/src/util/hb_string.c b/src/util/hb_string.c
index cf3b4e864..b348ef7e6 100644
--- a/src/util/hb_string.c
+++ b/src/util/hb_string.c
@@ -4,7 +4,7 @@
 #include <string.h>
 #include <strings.h>
 
-hb_string_T hb_string_from_c_string(const char* null_terminated_c_string) {
+hb_string_T hb_string(const char* null_terminated_c_string) {
   hb_string_T string;
 
   string.data = (char*) null_terminated_c_string;
diff --git a/test/c/test_hb_buffer.c b/test/c/test_hb_buffer.c
index 47eee0c8b..a5f3f169d 100644
--- a/test/c/test_hb_buffer.c
+++ b/test/c/test_hb_buffer.c
@@ -68,7 +68,7 @@ TEST(test_hb_buffer_append_string)
   hb_buffer_T buffer;
   hb_buffer_init(&buffer, 1);
 
-  hb_buffer_append_string(&buffer, hb_string_from_c_string("Hello, world"));
+  hb_buffer_append_string(&buffer, hb_string("Hello, world"));
 
   ck_assert_str_eq(buffer.value, "Hello, world");
   ck_assert_int_eq(buffer.length, 12);
diff --git a/test/c/test_hb_string.c b/test/c/test_hb_string.c
index 67e3f3eee..70ef03270 100644
--- a/test/c/test_hb_string.c
+++ b/test/c/test_hb_string.c
@@ -4,22 +4,22 @@
 
 TEST(hb_string_equals_tests)
   {
-    hb_string_T a = hb_string_from_c_string("Hello, world.");
-    hb_string_T b = hb_string_from_c_string("Hello, world.");
+    hb_string_T a = hb_string("Hello, world.");
+    hb_string_T b = hb_string("Hello, world.");
 
     ck_assert(hb_string_equals(a, b));
   }
 
   {
-    hb_string_T a = hb_string_from_c_string("Hello, world.");
-    hb_string_T b = hb_string_from_c_string("Hello, world. Longer text");
+    hb_string_T a = hb_string("Hello, world.");
+    hb_string_T b = hb_string("Hello, world. Longer text");
 
     ck_assert(!hb_string_equals(a, b));
   }
 
   {
-    hb_string_T a = hb_string_from_c_string("Hello, world.");
-    hb_string_T b = hb_string_from_c_string("");
+    hb_string_T a = hb_string("Hello, world.");
+    hb_string_T b = hb_string("");
 
     ck_assert(!hb_string_equals(a, b));
   }
@@ -27,8 +27,8 @@ END
 
 TEST(hb_string_offset_based_slice_tests)
   {
-    hb_string_T source = hb_string_from_c_string("01234");
-    hb_string_T expected_slice = hb_string_from_c_string("234");
+    hb_string_T source = hb_string("01234");
+    hb_string_T expected_slice = hb_string("234");
 
     hb_string_T slice = hb_string_slice(source, 2);
 
@@ -36,8 +36,8 @@ TEST(hb_string_offset_based_slice_tests)
   }
 
   {
-    hb_string_T source = hb_string_from_c_string("01234");
-    hb_string_T expected_slice = hb_string_from_c_string("4");
+    hb_string_T source = hb_string("01234");
+    hb_string_T expected_slice = hb_string("4");
 
     hb_string_T slice = hb_string_slice(source, 4);
 
@@ -45,14 +45,14 @@ TEST(hb_string_offset_based_slice_tests)
   }
 
   {
-    hb_string_T source = hb_string_from_c_string("01234");
+    hb_string_T source = hb_string("01234");
     hb_string_T slice = hb_string_slice(source, 5);
 
     ck_assert(hb_string_is_empty(slice));
   }
 
   {
-    hb_string_T source = hb_string_from_c_string("01234");
+    hb_string_T source = hb_string("01234");
     hb_string_T slice = hb_string_slice(source, 6);
 
     ck_assert(hb_string_is_empty(slice));
@@ -62,22 +62,22 @@ END
 
 TEST(hb_string_equals_case_insensitive_tests)
   {
-    hb_string_T a = hb_string_from_c_string("Hello, world.");
-    hb_string_T b = hb_string_from_c_string("Hello, World. Really?");
+    hb_string_T a = hb_string("Hello, world.");
+    hb_string_T b = hb_string("Hello, World. Really?");
 
     ck_assert(!hb_string_equals_case_insensitive(a, b));
   }
 
   {
-    hb_string_T a = hb_string_from_c_string("Hello, world.");
-    hb_string_T b = hb_string_from_c_string("Hello, World.");
+    hb_string_T a = hb_string("Hello, world.");
+    hb_string_T b = hb_string("Hello, World.");
 
     ck_assert(hb_string_equals_case_insensitive(a, b));
   }
 
   {
-    hb_string_T a = hb_string_from_c_string("This.");
-    hb_string_T b = hb_string_from_c_string("That.");
+    hb_string_T a = hb_string("This.");
+    hb_string_T b = hb_string("That.");
 
     ck_assert(!hb_string_equals_case_insensitive(a, b));
   }
@@ -94,13 +94,13 @@ TEST(hb_string_is_empty_tests)
   }
 
   {
-    hb_string_T str = hb_string_from_c_string("");
+    hb_string_T str = hb_string("");
 
     ck_assert(hb_string_is_empty(str));
   }
 
   {
-    hb_string_T str = hb_string_from_c_string("Content");
+    hb_string_T str = hb_string("Content");
 
     ck_assert(!hb_string_is_empty(str));
   }
@@ -108,7 +108,7 @@ END
 
 TEST(hb_string_starts_with_tests)
   {
-    hb_string_T str = hb_string_from_c_string("This.");
+    hb_string_T str = hb_string("This.");
     hb_string_T prefix = {
       .length = 0,
       .data = NULL,
@@ -122,35 +122,35 @@ TEST(hb_string_starts_with_tests)
       .length = 0,
       .data = NULL,
     };
-    hb_string_T prefix = hb_string_from_c_string("This.");
+    hb_string_T prefix = hb_string("This.");
 
     ck_assert(!hb_string_starts_with(str, prefix));
   }
 
   {
-    hb_string_T str = hb_string_from_c_string("Long text.");
-    hb_string_T prefix = hb_string_from_c_string("Long text.");
+    hb_string_T str = hb_string("Long text.");
+    hb_string_T prefix = hb_string("Long text.");
 
     ck_assert(hb_string_starts_with(str, prefix));
   }
 
   {
-    hb_string_T str = hb_string_from_c_string("Long text.");
-    hb_string_T prefix = hb_string_from_c_string("Long");
+    hb_string_T str = hb_string("Long text.");
+    hb_string_T prefix = hb_string("Long");
 
     ck_assert(hb_string_starts_with(str, prefix));
   }
 
   {
-    hb_string_T str = hb_string_from_c_string("Long text.");
-    hb_string_T prefix = hb_string_from_c_string("No");
+    hb_string_T str = hb_string("Long text.");
+    hb_string_T prefix = hb_string("No");
 
     ck_assert(!hb_string_starts_with(str, prefix));
   }
 
   {
-    hb_string_T str = hb_string_from_c_string("Long text.");
-    hb_string_T prefix = hb_string_from_c_string("This prefix is longer than the text");
+    hb_string_T str = hb_string("Long text.");
+    hb_string_T prefix = hb_string("This prefix is longer than the text");
 
     ck_assert(!hb_string_starts_with(str, prefix));
   }
diff --git a/test/c/test_html_util.c b/test/c/test_html_util.c
index 64b8c3525..dcd592bd2 100644
--- a/test/c/test_html_util.c
+++ b/test/c/test_html_util.c
@@ -4,23 +4,23 @@
 #include <stdio.h>
 
 TEST(html_util_html_closing_tag_string)
-  ck_assert(hb_string_equals(html_closing_tag_string((hb_string_T) { .data = NULL, .length = 0 }), hb_string_from_c_string("</>")));
-  ck_assert(hb_string_equals(html_closing_tag_string(hb_string_from_c_string("")), hb_string_from_c_string("</>")));
-  ck_assert(hb_string_equals(html_closing_tag_string(hb_string_from_c_string(" ")), hb_string_from_c_string("</ >")));
-  ck_assert(hb_string_equals(html_closing_tag_string(hb_string_from_c_string("div")), hb_string_from_c_string("</div>")));
+  ck_assert(hb_string_equals(html_closing_tag_string((hb_string_T) { .data = NULL, .length = 0 }), hb_string("</>")));
+  ck_assert(hb_string_equals(html_closing_tag_string(hb_string("")), hb_string("</>")));
+  ck_assert(hb_string_equals(html_closing_tag_string(hb_string(" ")), hb_string("</ >")));
+  ck_assert(hb_string_equals(html_closing_tag_string(hb_string("div")), hb_string("</div>")));
 
   ck_assert(hb_string_equals(
-    html_closing_tag_string(hb_string_from_c_string("somelongerstring")),
-    hb_string_from_c_string("</somelongerstring>")
+    html_closing_tag_string(hb_string("somelongerstring")),
+    hb_string("</somelongerstring>")
   ));
 END
 
 TEST(html_util_html_self_closing_tag_string)
-  ck_assert(hb_string_equals(html_self_closing_tag_string((hb_string_T) { .data = NULL, .length = 0 }), hb_string_from_c_string("< />")));
-  ck_assert(hb_string_equals(html_self_closing_tag_string(hb_string_from_c_string("")), hb_string_from_c_string("< />")));
-  ck_assert(hb_string_equals(html_self_closing_tag_string(hb_string_from_c_string(" ")), hb_string_from_c_string("<  />")));
-  ck_assert(hb_string_equals(html_self_closing_tag_string(hb_string_from_c_string("br")), hb_string_from_c_string("<br />")));
-  ck_assert(hb_string_equals(html_self_closing_tag_string(hb_string_from_c_string("somelongerstring")), hb_string_from_c_string("<somelongerstring />")));
+  ck_assert(hb_string_equals(html_self_closing_tag_string((hb_string_T) { .data = NULL, .length = 0 }), hb_string("< />")));
+  ck_assert(hb_string_equals(html_self_closing_tag_string(hb_string("")), hb_string("< />")));
+  ck_assert(hb_string_equals(html_self_closing_tag_string(hb_string(" ")), hb_string("<  />")));
+  ck_assert(hb_string_equals(html_self_closing_tag_string(hb_string("br")), hb_string("<br />")));
+  ck_assert(hb_string_equals(html_self_closing_tag_string(hb_string("somelongerstring")), hb_string("<somelongerstring />")));
 END
 
 TCase* html_util_tests(void) {

From 681e3229242e6e9d03039544a33ae70d9f1583ff Mon Sep 17 00:00:00 2001
From: Marco Roth <marco.roth@intergga.ch>
Date: Tue, 21 Oct 2025 02:46:20 +0200
Subject: [PATCH 97/97] C: Move `hb_arena.c` to `src/util/` (#707)

This pull request moves the `hb_arena.c` file into the `src/utils/`
folder in order to be in line with `hb_array.c`, `hb_string.c`, and
`hb_buffer.c`.
---
 javascript/packages/node/binding.gyp | 2 +-
 src/include/{ => util}/hb_arena.h    | 0
 src/include/util/hb_string.h         | 2 +-
 src/{ => util}/hb_arena.c            | 7 ++++++-
 test/c/test_hb_arena.c               | 2 +-
 5 files changed, 9 insertions(+), 4 deletions(-)
 rename src/include/{ => util}/hb_arena.h (100%)
 rename src/{ => util}/hb_arena.c (97%)

diff --git a/javascript/packages/node/binding.gyp b/javascript/packages/node/binding.gyp
index 8f4fffb2f..f01664fa8 100644
--- a/javascript/packages/node/binding.gyp
+++ b/javascript/packages/node/binding.gyp
@@ -25,7 +25,6 @@
         "./extension/libherb/lexer_peek_helpers.c",
         "./extension/libherb/lexer.c",
         "./extension/libherb/location.c",
-        "./extension/libherb/hb_arena.c",
         "./extension/libherb/parser_helpers.c",
         "./extension/libherb/parser.c",
         "./extension/libherb/pretty_print.c",
@@ -35,6 +34,7 @@
         "./extension/libherb/token.c",
         "./extension/libherb/utf8.c",
         "./extension/libherb/util.c",
+        "./extension/libherb/util/hb_arena.c",
         "./extension/libherb/util/hb_array.c",
         "./extension/libherb/util/hb_buffer.c",
         "./extension/libherb/util/hb_string.c",
diff --git a/src/include/hb_arena.h b/src/include/util/hb_arena.h
similarity index 100%
rename from src/include/hb_arena.h
rename to src/include/util/hb_arena.h
diff --git a/src/include/util/hb_string.h b/src/include/util/hb_string.h
index 23419579e..a0b90a5a7 100644
--- a/src/include/util/hb_string.h
+++ b/src/include/util/hb_string.h
@@ -5,7 +5,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include "../hb_arena.h"
+#include "hb_arena.h"
 
 typedef struct HB_STRING_STRUCT {
   char* data;
diff --git a/src/hb_arena.c b/src/util/hb_arena.c
similarity index 97%
rename from src/hb_arena.c
rename to src/util/hb_arena.c
index 81d6dfee7..3eb0e70a0 100644
--- a/src/hb_arena.c
+++ b/src/util/hb_arena.c
@@ -1,7 +1,9 @@
 #ifdef __linux__
 #define _GNU_SOURCE
 #endif
-#include "include/hb_arena.h"
+
+#include "../include/util/hb_arena.h"
+
 #include <stdbool.h>
 #include <sys/mman.h>
 
@@ -15,11 +17,13 @@ bool hb_arena_init(hb_arena_T* allocator, size_t size) {
     allocator->memory = NULL;
     allocator->position = 0;
     allocator->capacity = 0;
+
     return false;
   }
 
   allocator->position = 0;
   allocator->capacity = size;
+
   return true;
 }
 
@@ -50,6 +54,7 @@ void hb_arena_reset_to(hb_arena_T* allocator, size_t new_position) {
 void hb_arena_free(hb_arena_T* allocator) {
   if (allocator->memory != NULL) {
     munmap(allocator->memory, allocator->capacity);
+
     allocator->memory = NULL;
     allocator->position = 0;
     allocator->capacity = 0;
diff --git a/test/c/test_hb_arena.c b/test/c/test_hb_arena.c
index 580c8103a..4196dfe27 100644
--- a/test/c/test_hb_arena.c
+++ b/test/c/test_hb_arena.c
@@ -1,5 +1,5 @@
 #include "include/test.h"
-#include "../../src/include/hb_arena.h"
+#include "../../src/include/util/hb_arena.h"
 
 // Test appending text to buffer
 TEST(test_arena_alloc)