From 34dae62be87bf160e7cc6963315f2e733962e702 Mon Sep 17 00:00:00 2001
From: Philippe Collin <philippe.collin@shopify.com>
Date: Thu, 8 Oct 2026 16:39:11 -0400
Subject: [PATCH 01/20] Tokenize plain text runs in one step in
 liquid-html-parser

The document tokenizer advanced one character at a time and ran every
mode's startsWith checks on each one, even inside plain text. Most
characters cannot start a token in the current mode, so jump straight to
the next one that can and let the main loop re-check it there.

Liquid tag and output bodies use indexOf for their closing delimiter.
The `<` tag-start check uses char codes instead of a regex.

Tokens and ASTs are unchanged.
---
 .changeset/tokenizer-text-fast-path.md        |   7 ++
 .../src/document/tokenizer.test.ts            |  52 ++++++++
 .../src/document/tokenizer.ts                 | 111 ++++++++++++++++--
 3 files changed, 162 insertions(+), 8 deletions(-)
 create mode 100644 .changeset/tokenizer-text-fast-path.md

diff --git a/.changeset/tokenizer-text-fast-path.md b/.changeset/tokenizer-text-fast-path.md
new file mode 100644
index 000000000..45a3e8dcd
--- /dev/null
+++ b/.changeset/tokenizer-text-fast-path.md
@@ -0,0 +1,7 @@
+---
+'@shopify/liquid-html-parser': patch
+---
+
+Tokenize runs of plain text in one step instead of one character at a time. Most characters can't start a token, so the tokenizer now jumps to the next one that can.
+
+Tokens and ASTs are unchanged. On Dawn, Horizon and the base theme, `tokenize` is about 6× faster and `toLiquidHtmlAST`/`toLiquidAST` about 2× faster.
diff --git a/packages/liquid-html-parser/src/document/tokenizer.test.ts b/packages/liquid-html-parser/src/document/tokenizer.test.ts
index b2f7594d6..41356b04b 100644
--- a/packages/liquid-html-parser/src/document/tokenizer.test.ts
+++ b/packages/liquid-html-parser/src/document/tokenizer.test.ts
@@ -543,6 +543,58 @@ describe('Unit: document-tokenizer', () => {
     });
   });
 
+  describe('text runs end at the next token', () => {
+    it('ends a Liquid tag body at a -%} preceded by another -', () => {
+      const source = '{% if a--%}';
+      expect(tokens(source)).toMatchObject([
+        { type: TokenType.LiquidTagOpen, start: 0, end: 2 },
+        { type: TokenType.Text, start: 2, end: 8 },
+        { type: TokenType.LiquidTagClose, start: 8, end: 11 },
+      ]);
+      assertTokenInvariants(source);
+    });
+
+    it('keeps %} as text inside a Liquid drop and ends it at -}}', () => {
+      const source = '{{ "%}" -}}';
+      expect(tokens(source)).toMatchObject([
+        { type: TokenType.LiquidVariableOutputOpen, start: 0, end: 2 },
+        { type: TokenType.Text, start: 2, end: 8 },
+        { type: TokenType.LiquidVariableOutputClose, start: 8, end: 11 },
+      ]);
+      assertTokenInvariants(source);
+    });
+
+    it('ends a curly-quoted value on its partner, not on a straight quote', () => {
+      const source = '<a b=\u201cx"y\u201d c>';
+      expect(tokens(source)).toMatchObject([
+        { type: TokenType.HtmlTagOpen, start: 0, end: 1 },
+        { type: TokenType.Text, start: 1, end: 2 },
+        { type: TokenType.Text, start: 2, end: 3 },
+        { type: TokenType.Text, start: 3, end: 4 },
+        { type: TokenType.HtmlEquals, start: 4, end: 5 },
+        { type: TokenType.HtmlQuoteOpen, start: 5, end: 6 },
+        { type: TokenType.Text, start: 6, end: 9 },
+        { type: TokenType.HtmlQuoteClose, start: 9, end: 10 },
+        { type: TokenType.Text, start: 10, end: 11 },
+        { type: TokenType.Text, start: 11, end: 12 },
+        { type: TokenType.HtmlTagClose, start: 12, end: 13 },
+      ]);
+      assertTokenInvariants(source);
+    });
+
+    it('finds --> and <!-- in the middle of text', () => {
+      const source = 'a-b-->c<!--d';
+      expect(tokens(source)).toMatchObject([
+        { type: TokenType.Text, start: 0, end: 3 },
+        { type: TokenType.HtmlCommentClose, start: 3, end: 6 },
+        { type: TokenType.Text, start: 6, end: 7 },
+        { type: TokenType.HtmlCommentOpen, start: 7, end: 11 },
+        { type: TokenType.Text, start: 11, end: 12 },
+      ]);
+      assertTokenInvariants(source);
+    });
+  });
+
   describe('structural invariants', () => {
     const cases = [
       '{{ x }}',
diff --git a/packages/liquid-html-parser/src/document/tokenizer.ts b/packages/liquid-html-parser/src/document/tokenizer.ts
index 2d9345c0f..2b240c92b 100644
--- a/packages/liquid-html-parser/src/document/tokenizer.ts
+++ b/packages/liquid-html-parser/src/document/tokenizer.ts
@@ -224,7 +224,7 @@ export function createTokenizer(source: string, tokens: Token[]): Tokenizer {
             popMode();
           } else {
             startText();
-            pos++;
+            pos = nextLiquidCloseCandidate(source, pos + 1, '%}');
           }
           break;
         }
@@ -264,8 +264,7 @@ export function createTokenizer(source: string, tokens: Token[]): Tokenizer {
           }
 
           if (match('</')) {
-            const after = ch(2);
-            if (/[a-zA-Z]/.test(after) || after === '{') {
+            if (isTagNameStart(source.charCodeAt(pos + 2))) {
               emit(TokenType.HtmlCloseTagOpen, 2);
               pushMode(Mode.HtmlTag);
               continue;
@@ -273,8 +272,7 @@ export function createTokenizer(source: string, tokens: Token[]): Tokenizer {
           }
 
           if (ch(0) === '<') {
-            const after = ch(1);
-            if (/[a-zA-Z]/.test(after) || after === '{') {
+            if (isTagNameStart(source.charCodeAt(pos + 1))) {
               emit(TokenType.HtmlTagOpen, 1);
               pushMode(Mode.HtmlTag);
               continue;
@@ -282,7 +280,7 @@ export function createTokenizer(source: string, tokens: Token[]): Tokenizer {
           }
 
           startText();
-          pos++;
+          pos = nextDefaultCandidate(source, pos + 1);
           break;
         }
 
@@ -332,7 +330,7 @@ export function createTokenizer(source: string, tokens: Token[]): Tokenizer {
           if (textStart !== -1 && isSpace !== textIsSpace) flushText();
           if (textStart === -1) textIsSpace = isSpace;
           startText();
-          pos++;
+          pos = nextHtmlTagCandidate(source, pos + 1, textIsSpace);
           break;
         }
 
@@ -349,7 +347,7 @@ export function createTokenizer(source: string, tokens: Token[]): Tokenizer {
           }
 
           startText();
-          pos++;
+          pos = nextQuotedValueCandidate(source, pos + 1, quoteChar);
           break;
         }
 
@@ -369,6 +367,103 @@ export function createTokenizer(source: string, tokens: Token[]): Tokenizer {
   return { restart, fill };
 }
 
+/*
+ * Text fast path: most characters cannot start (or close) a token in the
+ * current mode. Each helper returns the first index >= `from` where the
+ * mode's `match()` checks could succeed, so the run of plain text before it is
+ * consumed in one step. Inside an HTML tag a run also ends where text switches
+ * between whitespace and non-whitespace, because each is its own Text token.
+ * Returning a superset of real token starts is safe: the main loop re-checks
+ * that position and treats a non-match as text.
+ */
+
+const CHAR_DOUBLE_QUOTE = 0x22; // "
+const CHAR_SINGLE_QUOTE = 0x27; // '
+const CHAR_DASH = 0x2d; // -
+const CHAR_SLASH = 0x2f; // /
+const CHAR_LESS_THAN = 0x3c; // <
+const CHAR_EQUALS = 0x3d; // =
+const CHAR_GREATER_THAN = 0x3e; // >
+const CHAR_OPEN_BRACE = 0x7b; // {
+const CHAR_LEFT_SINGLE_CURLY_QUOTE = 0x2018; // ‘
+const CHAR_RIGHT_DOUBLE_CURLY_QUOTE = 0x201d; // ”
+
+/** Default mode tokens start with `{` (Liquid), `<` (HTML), or `-` (`-->`). */
+function nextDefaultCandidate(source: string, from: number): number {
+  for (let i = from; i < source.length; i++) {
+    const c = source.charCodeAt(i);
+    if (c === CHAR_OPEN_BRACE || c === CHAR_LESS_THAN || c === CHAR_DASH) return i;
+  }
+  return source.length;
+}
+
+/**
+ * HtmlTag mode tokens start with `{`, `/`, `>`, `=`, or a straight/curly quote;
+ * a Text run also ends where whitespace starts or stops.
+ */
+function nextHtmlTagCandidate(source: string, from: number, textIsSpace: boolean): number {
+  for (let i = from; i < source.length; i++) {
+    const c = source.charCodeAt(i);
+    if (
+      c === CHAR_OPEN_BRACE ||
+      c === CHAR_SLASH ||
+      c === CHAR_GREATER_THAN ||
+      c === CHAR_EQUALS ||
+      c === CHAR_DOUBLE_QUOTE ||
+      c === CHAR_SINGLE_QUOTE ||
+      (c >= CHAR_LEFT_SINGLE_CURLY_QUOTE && c <= CHAR_RIGHT_DOUBLE_CURLY_QUOTE) ||
+      isWhitespace(c) !== textIsSpace
+    ) {
+      return i;
+    }
+  }
+  return source.length;
+}
+
+/** QuotedValue mode tokens start with `{` or either quote of the open pair. */
+function nextQuotedValueCandidate(source: string, from: number, quote: string): number {
+  const open = quote.charCodeAt(0);
+  const close = closingQuoteFor(quote).charCodeAt(0);
+  for (let i = from; i < source.length; i++) {
+    const c = source.charCodeAt(i);
+    if (c === CHAR_OPEN_BRACE || c === open || c === close) return i;
+  }
+  return source.length;
+}
+
+/**
+ * Liquid tag bodies only end at `%}`, optionally preceded by `-`. Any `-%}`
+ * match contains a `%}` one character later, so the earliest close is at the
+ * first `%}` or the `-` immediately before it.
+ */
+function nextLiquidCloseCandidate(source: string, from: number, close: '%}'): number {
+  const i = source.indexOf(close, from);
+  if (i === -1) return source.length;
+  return i > from && source.charCodeAt(i - 1) === CHAR_DASH ? i - 1 : i;
+}
+
+/** `[a-zA-Z{]`: what may follow `<` or `</` to open an HTML tag. */
+function isTagNameStart(c: number): boolean {
+  return (c >= 0x61 && c <= 0x7a) || (c >= 0x41 && c <= 0x5a) || c === CHAR_OPEN_BRACE;
+}
+
+/** Exactly the UTF-16 code units JavaScript's `\s` matches. */
+function isWhitespace(c: number): boolean {
+  return (
+    (c >= 0x09 && c <= 0x0d) ||
+    c === 0x20 ||
+    c === 0xa0 ||
+    c === 0x1680 ||
+    (c >= 0x2000 && c <= 0x200a) ||
+    c === 0x2028 ||
+    c === 0x2029 ||
+    c === 0x202f ||
+    c === 0x205f ||
+    c === 0x3000 ||
+    c === 0xfeff
+  );
+}
+
 enum Mode {
   Default = 'Default',
   HtmlTag = 'HtmlTag',

From f11f8023393d856878f9c9e7f32ab74817c7cfc7 Mon Sep 17 00:00:00 2001
From: Philippe Collin <philippe.collin@shopify.com>
Date: Thu, 8 Oct 2026 17:36:33 -0400
Subject: [PATCH 02/20] Test that the tokenizer fast path stops at every token
 start

The existing tests only had quotes directly after `=`, where the main
loop checks them without the fast path, so a helper missing a stop
character could pass CI. The oracle suites that might catch it are
skipped there because the theme fixtures are gitignored.

Route the five text branches through one `nextTextCandidate` dispatcher,
so a test-only `tokenizeWithoutFastPath` can run the same loop one
character at a time. Tests now:
- put each token start in the middle of plain text in every mode
- compare `tokenize` with `tokenizeWithoutFastPath` on every string of
  up to 4 token-relevant characters, in every entry state
---
 .../src/document/tokenizer.test.ts            | 108 +++++++++++++++++-
 .../src/document/tokenizer.ts                 |  69 +++++++++--
 2 files changed, 164 insertions(+), 13 deletions(-)

diff --git a/packages/liquid-html-parser/src/document/tokenizer.test.ts b/packages/liquid-html-parser/src/document/tokenizer.test.ts
index 41356b04b..623392521 100644
--- a/packages/liquid-html-parser/src/document/tokenizer.test.ts
+++ b/packages/liquid-html-parser/src/document/tokenizer.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
-import { tokenize, TokenType } from './tokenizer';
-import type { Token } from './tokenizer';
+import { tokenize, tokenizeWithoutFastPath, TokenType } from './tokenizer';
+import type { Token, TokenizeOptions } from './tokenizer';
 
 /** Strip the trailing EndOfInput token for cleaner assertions. */
 function tokens(source: string): Token[] {
@@ -595,6 +595,110 @@ describe('Unit: document-tokenizer', () => {
     });
   });
 
+  describe('text fast path stops at every token start mid-text', () => {
+    // No character in `pad` can start a token in any mode, so the fast path
+    // skips the whole pad and must stop exactly where the token begins.
+    const pad = 'abc 1 ';
+    const quotePairs = [
+      ['"', '"'],
+      ["'", "'"],
+      ['\u201c', '\u201d'],
+      ['\u201d', '\u201c'],
+      ['\u2018', '\u2019'],
+      ['\u2019', '\u2018'],
+    ];
+    const cases: Array<[string, string, TokenizeOptions, string[]]> = [
+      [
+        'Default',
+        '',
+        {},
+        ['{{', '{{-', '{%', '{%-', '<!--', '-->', '<!', '</a', '</Z', '</{', '<a', '<Z', '<{'],
+      ],
+      [
+        'HtmlTag',
+        '',
+        { insideHtmlTag: true },
+        [
+          '{{',
+          '{{-',
+          '{%',
+          '{%-',
+          '/>',
+          '>',
+          '=',
+          '"',
+          "'",
+          '\u201c',
+          '\u201d',
+          '\u2018',
+          '\u2019',
+        ],
+      ],
+      ...quotePairs.map(([open, close]): [string, string, TokenizeOptions, string[]] => [
+        `QuotedValue ${open}`,
+        '',
+        { insideQuotedAttribute: open },
+        [...new Set(['{{', '{%', open, close])],
+      ]),
+      ['LiquidTag', '{% ', {}, ['%}', '-%}']],
+      ['LiquidVariableOutput', '{{ ', {}, ['}}', '-}}']],
+    ];
+
+    for (const [mode, prefix, options, starts] of cases) {
+      it.each(starts)(`${mode}: %j`, (start) => {
+        const offset = prefix.length + pad.length;
+        const result = tokenize(prefix + pad + start + pad, options);
+        expect(result.some((t) => t.type !== TokenType.Text && t.start === offset)).toBe(true);
+      });
+    }
+  });
+
+  describe('matches tokenizeWithoutFastPath', () => {
+    // Every string of up to 4 of these characters, in every entry state. The
+    // set covers each character a mode's token can start with, plus near
+    // misses (`!`, `\u201a`) and plain text.
+    const alphabet = [...'{}%-<>/=!"\'\u201c\u201d\u2018\u2019\u201a a\n'];
+    let sources = [''];
+    for (let length = 1, previous = ['']; length <= 4; length++) {
+      previous = previous.flatMap((s) => alphabet.map((c) => s + c));
+      sources = sources.concat(previous);
+    }
+
+    const entryStates: Array<[string, string, TokenizeOptions]> = [
+      ['document start', '', {}],
+      ['skipFrontmatter', '', { skipFrontmatter: true }],
+      ['insideHtmlTag', '', { insideHtmlTag: true }],
+      ...['"', "'", '\u201c', '\u201d', '\u2018', '\u2019'].map(
+        (quote): [string, string, TokenizeOptions] => [
+          `insideQuotedAttribute ${quote}`,
+          '',
+          { insideQuotedAttribute: quote },
+        ],
+      ),
+      ['inside a Liquid tag', '{% ', {}],
+      ['inside a Liquid output', '{{ ', {}],
+    ];
+
+    function sameTokens(a: Token[], b: Token[]): boolean {
+      return (
+        a.length === b.length &&
+        a.every((t, i) => t.type === b[i].type && t.start === b[i].start && t.end === b[i].end)
+      );
+    }
+
+    it.each(entryStates)('%s', (_name, prefix, options) => {
+      const mismatches: string[] = [];
+      for (const source of sources) {
+        const input = prefix + source;
+        if (!sameTokens(tokenize(input, options), tokenizeWithoutFastPath(input, options))) {
+          mismatches.push(input);
+          if (mismatches.length === 10) break;
+        }
+      }
+      expect(mismatches).toEqual([]);
+    });
+  });
+
   describe('structural invariants', () => {
     const cases = [
       '{{ x }}',
diff --git a/packages/liquid-html-parser/src/document/tokenizer.ts b/packages/liquid-html-parser/src/document/tokenizer.ts
index 2b240c92b..21fc1b2a9 100644
--- a/packages/liquid-html-parser/src/document/tokenizer.ts
+++ b/packages/liquid-html-parser/src/document/tokenizer.ts
@@ -62,8 +62,21 @@ export interface TokenizeOptions {
 }
 
 export function tokenize(source: string, options: TokenizeOptions = {}): Token[] {
+  return tokenizeToEnd(source, options, true);
+}
+
+/**
+ * `tokenize` without the text fast path: plain text advances one character at
+ * a time. Test-only reference for checking that the fast path never skips over
+ * a token start. Not exported from the package.
+ */
+export function tokenizeWithoutFastPath(source: string, options: TokenizeOptions = {}): Token[] {
+  return tokenizeToEnd(source, options, false);
+}
+
+function tokenizeToEnd(source: string, options: TokenizeOptions, fastPath: boolean): Token[] {
   const tokens: Token[] = [];
-  const tokenizer = createTokenizer(source, tokens);
+  const tokenizer = createTokenizer(source, tokens, fastPath);
   tokenizer.restart(0, options);
   tokenizer.fill(Infinity);
   return tokens;
@@ -87,7 +100,7 @@ export interface Tokenizer {
   fill(index: number): boolean;
 }
 
-export function createTokenizer(source: string, tokens: Token[]): Tokenizer {
+export function createTokenizer(source: string, tokens: Token[], fastPath = true): Tokenizer {
   const modeStack: Mode[] = [];
   let mode = Mode.Default as Mode;
   let pos = 0;
@@ -137,6 +150,17 @@ export function createTokenizer(source: string, tokens: Token[]): Tokenizer {
     if (textStart === -1) textStart = pos;
   }
 
+  /** Moves past plain text, to where the current mode's next token could start. */
+  function skipText() {
+    if (!fastPath) {
+      pos++;
+    } else if (mode === Mode.LiquidVariableOutput) {
+      pos = nextOutputClose();
+    } else {
+      pos = nextTextCandidate(source, pos + 1, mode, quoteChar, textIsSpace);
+    }
+  }
+
   /**
    * Where the `-}}` or `}}` that closes Liquid output at `pos` begins, or the
    * end of the input. Neither begins at `pos` itself.
@@ -224,7 +248,7 @@ export function createTokenizer(source: string, tokens: Token[]): Tokenizer {
             popMode();
           } else {
             startText();
-            pos = nextLiquidCloseCandidate(source, pos + 1, '%}');
+            skipText();
           }
           break;
         }
@@ -237,9 +261,8 @@ export function createTokenizer(source: string, tokens: Token[]): Tokenizer {
             emit(TokenType.LiquidVariableOutputClose, 2);
             popMode();
           } else {
-            // Jump to the close, rather than step to it a character at a time.
             startText();
-            pos = nextOutputClose();
+            skipText();
           }
           break;
         }
@@ -280,7 +303,7 @@ export function createTokenizer(source: string, tokens: Token[]): Tokenizer {
           }
 
           startText();
-          pos = nextDefaultCandidate(source, pos + 1);
+          skipText();
           break;
         }
 
@@ -330,7 +353,7 @@ export function createTokenizer(source: string, tokens: Token[]): Tokenizer {
           if (textStart !== -1 && isSpace !== textIsSpace) flushText();
           if (textStart === -1) textIsSpace = isSpace;
           startText();
-          pos = nextHtmlTagCandidate(source, pos + 1, textIsSpace);
+          skipText();
           break;
         }
 
@@ -347,7 +370,7 @@ export function createTokenizer(source: string, tokens: Token[]): Tokenizer {
           }
 
           startText();
-          pos = nextQuotedValueCandidate(source, pos + 1, quoteChar);
+          skipText();
           break;
         }
 
@@ -374,9 +397,33 @@ export function createTokenizer(source: string, tokens: Token[]): Tokenizer {
  * consumed in one step. Inside an HTML tag a run also ends where text switches
  * between whitespace and non-whitespace, because each is its own Text token.
  * Returning a superset of real token starts is safe: the main loop re-checks
- * that position and treats a non-match as text.
+ * that position and treats a non-match as text. Missing a token start is not,
+ * so a new token type needs its first character added to its mode's helper
+ * (tokenizer.test.ts compares against `tokenizeWithoutFastPath` to catch this).
+ * Liquid output jumps with `nextOutputClose` instead, which caches its search.
  */
 
+function nextTextCandidate(
+  source: string,
+  from: number,
+  mode: Exclude<Mode, Mode.LiquidVariableOutput>,
+  quoteChar: string,
+  textIsSpace: boolean,
+): number {
+  switch (mode) {
+    case Mode.Default:
+      return nextDefaultCandidate(source, from);
+    case Mode.HtmlTag:
+      return nextHtmlTagCandidate(source, from, textIsSpace);
+    case Mode.QuotedValue:
+      return nextQuotedValueCandidate(source, from, quoteChar);
+    case Mode.LiquidTag:
+      return nextLiquidTagCloseCandidate(source, from);
+    default:
+      return assertNever(mode);
+  }
+}
+
 const CHAR_DOUBLE_QUOTE = 0x22; // "
 const CHAR_SINGLE_QUOTE = 0x27; // '
 const CHAR_DASH = 0x2d; // -
@@ -436,8 +483,8 @@ function nextQuotedValueCandidate(source: string, from: number, quote: string):
  * match contains a `%}` one character later, so the earliest close is at the
  * first `%}` or the `-` immediately before it.
  */
-function nextLiquidCloseCandidate(source: string, from: number, close: '%}'): number {
-  const i = source.indexOf(close, from);
+function nextLiquidTagCloseCandidate(source: string, from: number): number {
+  const i = source.indexOf('%}', from);
   if (i === -1) return source.length;
   return i > from && source.charCodeAt(i - 1) === CHAR_DASH ? i - 1 : i;
 }

From 5b634d936cc3f73968e62b1001404463cf07e250 Mon Sep 17 00:00:00 2001
From: Philippe Collin <philippe.collin@shopify.com>
Date: Thu, 8 Oct 2026 19:14:41 -0400
Subject: [PATCH 03/20] Check character codes before regexes in
 liquid-html-parser tokenizers

- `scanLiquidOpen` returns early unless the character is `{`, instead
  of four failed `startsWith` calls at every `<`, `-`, quote, `/`, `>`
  and `=` the text fast path stops at.
- The Liquid expression tokenizer tests digits with char codes instead
  of evaluating `/\d/` literals per token, and only runs the whitespace
  regex when the character could be whitespace.

Each check is a pre-filter in front of the existing `startsWith` or
regex, so letting extra characters through can't change tokens; only
rejecting a real `{` or digit could, and the suite catches that.
---
 .changeset/markup-tokenizer-fast-checks.md    |  5 ++++
 .../src/document/tokenizer.ts                 |  1 +
 .../src/markup/tokenizer.test.ts              | 17 +++++++++++++
 .../src/markup/tokenizer.ts                   | 24 ++++++++++++++-----
 4 files changed, 41 insertions(+), 6 deletions(-)
 create mode 100644 .changeset/markup-tokenizer-fast-checks.md

diff --git a/.changeset/markup-tokenizer-fast-checks.md b/.changeset/markup-tokenizer-fast-checks.md
new file mode 100644
index 000000000..1bbfed464
--- /dev/null
+++ b/.changeset/markup-tokenizer-fast-checks.md
@@ -0,0 +1,5 @@
+---
+'@shopify/liquid-html-parser': patch
+---
+
+Check character codes before running regular expressions or `startsWith` in the Liquid expression tokenizer and when looking for `{{`/`{%`. Tokens and ASTs are unchanged; parsing is 5–7% faster.
diff --git a/packages/liquid-html-parser/src/document/tokenizer.ts b/packages/liquid-html-parser/src/document/tokenizer.ts
index 21fc1b2a9..a077ff180 100644
--- a/packages/liquid-html-parser/src/document/tokenizer.ts
+++ b/packages/liquid-html-parser/src/document/tokenizer.ts
@@ -213,6 +213,7 @@ export function createTokenizer(source: string, tokens: Token[], fastPath = true
 
   // Liquid open check — reused in Default, HtmlTag, and QuotedValue modes
   function scanLiquidOpen(): boolean {
+    if (source.charCodeAt(pos) !== CHAR_OPEN_BRACE) return false;
     if (match('{{-')) {
       emit(TokenType.LiquidVariableOutputOpen, 3);
       pushMode(Mode.LiquidVariableOutput);
diff --git a/packages/liquid-html-parser/src/markup/tokenizer.test.ts b/packages/liquid-html-parser/src/markup/tokenizer.test.ts
index a83dd7bcf..e898e0ea2 100644
--- a/packages/liquid-html-parser/src/markup/tokenizer.test.ts
+++ b/packages/liquid-html-parser/src/markup/tokenizer.test.ts
@@ -96,6 +96,23 @@ describe('Unit: markup-tokenizer', () => {
       expect(result).toMatchObject([{ type: MarkupTokenType.Number, value: '-100_000' }]);
       expect(result).toHaveLength(1);
     });
+
+    it('treats only ASCII 0-9 as digits', () => {
+      // U+0661 and U+FF15 are digits in other scripts; `\d` without `u` excludes them.
+      expect(tokens('\u0661 -\uff15 0 9 -0')).toMatchObject([
+        { type: MarkupTokenType.Dash, value: '-' },
+        { type: MarkupTokenType.Number, value: '0' },
+        { type: MarkupTokenType.Number, value: '9' },
+        { type: MarkupTokenType.Number, value: '-0' },
+      ]);
+    });
+
+    it('tokenizes a trailing dash as Dash', () => {
+      expect(tokens('a -')).toMatchObject([
+        { type: MarkupTokenType.Id, value: 'a' },
+        { type: MarkupTokenType.Dash, value: '-' },
+      ]);
+    });
   });
 
   describe('operators', () => {
diff --git a/packages/liquid-html-parser/src/markup/tokenizer.ts b/packages/liquid-html-parser/src/markup/tokenizer.ts
index b4aa9da40..744b56b7a 100644
--- a/packages/liquid-html-parser/src/markup/tokenizer.ts
+++ b/packages/liquid-html-parser/src/markup/tokenizer.ts
@@ -31,16 +31,28 @@ const WHITESPACE_RE = /\s+/y;
 const SINGLE_STRING_RE = /'[^']*'/y;
 const DOUBLE_STRING_RE = /"[^"]*"/y;
 
+/** `\d` (no `u` flag): ASCII 0-9 only. NaN past the end is not a digit. */
+function isDigit(c: number): boolean {
+  return c >= 0x30 && c <= 0x39;
+}
+
+/** Pre-check for WHITESPACE_RE: every `\s` character is <= U+0020 or >= U+00A0. */
+function mayBeWhitespace(c: number): boolean {
+  return c <= 0x20 || c >= 0xa0;
+}
+
 export function tokenizeMarkup(markup: string, startOffset = 0): MarkupToken[] {
   const tokens: MarkupToken[] = [];
   let pos = 0;
   let lastTokenType: MarkupTokenType | undefined;
 
   while (pos < markup.length) {
-    WHITESPACE_RE.lastIndex = pos;
-    if (WHITESPACE_RE.test(markup)) {
-      pos = WHITESPACE_RE.lastIndex;
-      continue;
+    if (mayBeWhitespace(markup.charCodeAt(pos))) {
+      WHITESPACE_RE.lastIndex = pos;
+      if (WHITESPACE_RE.test(markup)) {
+        pos = WHITESPACE_RE.lastIndex;
+        continue;
+      }
     }
 
     const ch = markup[pos];
@@ -63,7 +75,7 @@ export function tokenizeMarkup(markup: string, startOffset = 0): MarkupToken[] {
       }
     }
 
-    if (ch === '-' && /\d/.test(next)) {
+    if (ch === '-' && isDigit(markup.charCodeAt(pos + 1))) {
       NUMBER_RE.lastIndex = pos + 1;
       if (NUMBER_RE.test(markup)) {
         const value = markup.slice(pos, NUMBER_RE.lastIndex);
@@ -79,7 +91,7 @@ export function tokenizeMarkup(markup: string, startOffset = 0): MarkupToken[] {
       }
     }
 
-    if (/\d/.test(ch)) {
+    if (isDigit(markup.charCodeAt(pos))) {
       NUMBER_RE.lastIndex = pos;
       if (NUMBER_RE.test(markup)) {
         const matchEnd = NUMBER_RE.lastIndex;

From 320fa1feb643b986cd8b35ee9c8a0d4feeca0742 Mon Sep 17 00:00:00 2001
From: Philippe Collin <philippe.collin@shopify.com>
Date: Thu, 8 Oct 2026 19:01:32 -0400
Subject: [PATCH 04/20] Trim text around Liquid tags with trimStart/trimEnd

`value.replace(/\s+$/, '')` retries the match at every position of each
whitespace run, so its cost grows with the square of the run length.
It was the most expensive single step when parsing Dawn and Horizon.

`trimStart()`/`trimEnd()` strip exactly the characters `\s` matches
(both use the spec's WhiteSpace and LineTerminator sets), in linear
time. A test pins that set and the long-run case.
---
 .changeset/linear-text-trim.md                |  5 ++++
 .../src/document/tree-builder.test.ts         | 28 +++++++++++++++++++
 .../src/document/tree-builder.ts              |  4 +--
 3 files changed, 35 insertions(+), 2 deletions(-)
 create mode 100644 .changeset/linear-text-trim.md

diff --git a/.changeset/linear-text-trim.md b/.changeset/linear-text-trim.md
new file mode 100644
index 000000000..95738e0b8
--- /dev/null
+++ b/.changeset/linear-text-trim.md
@@ -0,0 +1,5 @@
+---
+'@shopify/liquid-html-parser': patch
+---
+
+Trim whitespace around Liquid tags with `trimStart()`/`trimEnd()` instead of regular expressions. The trailing-whitespace regex was quadratic in the length of a whitespace run and was the single most expensive step of parsing a typical theme.
diff --git a/packages/liquid-html-parser/src/document/tree-builder.test.ts b/packages/liquid-html-parser/src/document/tree-builder.test.ts
index 9193bfd68..4560888d4 100644
--- a/packages/liquid-html-parser/src/document/tree-builder.test.ts
+++ b/packages/liquid-html-parser/src/document/tree-builder.test.ts
@@ -124,6 +124,34 @@ describe('Unit: tree-builder', () => {
     });
   });
 
+  describe('whitespace trimming around Liquid tags', () => {
+    function ifBranchChildren(body: string): LiquidHtmlNode[] {
+      const [tag] = toLiquidHtmlAST(`{% if a %}${body}{% endif %}`).children;
+      if (tag.type !== NodeTypes.LiquidTag || !tag.children) throw new Error('expected {% if %}');
+      const [branch] = tag.children;
+      if (branch.type !== NodeTypes.LiquidBranch) throw new Error('expected a branch');
+      return branch.children;
+    }
+
+    it('trims every character that \\s matches, and keeps others', () => {
+      const whitespace =
+        '\t\n\v\f\r \u00a0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008' +
+        '\u2009\u200a\u2028\u2029\u202f\u205f\u3000\ufeff';
+      const text = 'x\u200by'; // zero-width space is not whitespace
+      const start = '{% if a %}'.length + whitespace.length;
+      expect(ifBranchChildren(whitespace + text + whitespace)).toMatchObject([
+        { type: NodeTypes.TextNode, value: text, position: { start, end: start + text.length } },
+      ]);
+    });
+
+    it('trims text containing a long whitespace run in linear time', () => {
+      const text = 'x' + ' '.repeat(100_000) + 'y';
+      expect(ifBranchChildren(` ${text} `)).toMatchObject([
+        { type: NodeTypes.TextNode, value: text },
+      ]);
+    }, 1000);
+  });
+
   describe('compoundNamesMatch', () => {
     it('returns true for two empty arrays', () => {
       expect(compoundNamesMatch([], [])).toBe(true);
diff --git a/packages/liquid-html-parser/src/document/tree-builder.ts b/packages/liquid-html-parser/src/document/tree-builder.ts
index a2ec91789..cb6f1875d 100644
--- a/packages/liquid-html-parser/src/document/tree-builder.ts
+++ b/packages/liquid-html-parser/src/document/tree-builder.ts
@@ -107,7 +107,7 @@ export function mergeAdjacentTextNodesTrimmed(
     // Trim leading whitespace if preceded by a non-text node or at start
     const prev = merged[i - 1];
     if (!prev || !isTextNode(prev)) {
-      const trimmed = value.replace(/^\s+/, '');
+      const trimmed = value.trimStart();
       const trimLen = value.length - trimmed.length;
       value = trimmed;
       start += trimLen;
@@ -116,7 +116,7 @@ export function mergeAdjacentTextNodesTrimmed(
     // Trim trailing whitespace if followed by a non-text node or at end
     const next = merged[i + 1];
     if (!next || !isTextNode(next)) {
-      const trimmed = value.replace(/\s+$/, '');
+      const trimmed = value.trimEnd();
       const trimLen = value.length - trimmed.length;
       value = trimmed;
       end -= trimLen;

From a73b174fa9bb8224babc6e6aaac3f2c0138d7a40 Mon Sep 17 00:00:00 2001
From: Philippe Collin <philippe.collin@shopify.com>
Date: Thu, 8 Oct 2026 19:08:58 -0400
Subject: [PATCH 05/20] Parse Object.prototype names as ordinary names in
 liquid-html-parser

`isLiteralKeyword` used `s in LiquidLiteralValues`, and `tagForName`
read `this.builtins[name]` from a plain object. Both also see inherited
properties, so `{{ constructor }}` became a LiquidLiteral whose value
was the Object function, and `{% constructor %}` / `{% __proto__ %}`
resolved to a non-tag "definition" and threw.

Recognize literal keywords with a switch (also faster than `in` on this
hot path) and store builtin tags in a Map. A test checks every
LiquidLiteralValues key is still recognized.
---
 .changeset/prototype-names-not-keywords.md    |   5 +
 .../src/environment.test.ts                   |   7 +
 .../liquid-html-parser/src/environment.ts     |   7 +-
 .../src/markup/parser.test.ts                 |  23 ++
 .../liquid-html-parser/src/markup/parser.ts   |  14 +-
 specs/parser/liquid-tags.yml                  | 248 ++++++++++++++++++
 6 files changed, 300 insertions(+), 4 deletions(-)
 create mode 100644 .changeset/prototype-names-not-keywords.md

diff --git a/.changeset/prototype-names-not-keywords.md b/.changeset/prototype-names-not-keywords.md
new file mode 100644
index 000000000..db605cabd
--- /dev/null
+++ b/.changeset/prototype-names-not-keywords.md
@@ -0,0 +1,5 @@
+---
+'@shopify/liquid-html-parser': patch
+---
+
+Parse names inherited from `Object.prototype` like any other name. `{{ constructor }}` and `{{ toString }}` were parsed as Liquid literals whose value was a JavaScript function, and `{% constructor %}` or `{% __proto__ %}` made the parser throw instead of producing an unknown tag. Recognizing literal keywords with a `switch` is also slightly faster.
diff --git a/packages/liquid-html-parser/src/environment.test.ts b/packages/liquid-html-parser/src/environment.test.ts
index 5b53161eb..91d1dd3e4 100644
--- a/packages/liquid-html-parser/src/environment.test.ts
+++ b/packages/liquid-html-parser/src/environment.test.ts
@@ -49,6 +49,13 @@ describe('Unit: Environment', () => {
       expect(env.tagForName('nonexistent')).toBeUndefined();
     });
 
+    it('returns undefined for Object.prototype names', () => {
+      const env = new Environment({ if: makeBlockDef(['elsif', 'else']) });
+      for (const name of ['constructor', 'toString', 'hasOwnProperty', '__proto__']) {
+        expect(env.tagForName(name)).toBeUndefined();
+      }
+    });
+
     it('returns the builtin definition when constructed with builtins', () => {
       const ifDef = makeBlockDef(['elsif', 'else']);
       const env = new Environment({ if: ifDef });
diff --git a/packages/liquid-html-parser/src/environment.ts b/packages/liquid-html-parser/src/environment.ts
index 8b2aca21c..18c6addc6 100644
--- a/packages/liquid-html-parser/src/environment.ts
+++ b/packages/liquid-html-parser/src/environment.ts
@@ -16,17 +16,18 @@ import type { TagDefinition } from './tag-definitions';
 import { builtinTags } from './tags/index';
 
 export class Environment {
-  private builtins: Record<string, TagDefinition>;
+  private builtins: Map<string, TagDefinition>;
   private custom: Map<string, TagDefinition>;
   private static _default: Environment | undefined;
 
   constructor(builtins: Record<string, TagDefinition> = {}) {
-    this.builtins = builtins;
+    // A Map so tag names like `constructor` don't resolve to Object.prototype members.
+    this.builtins = new Map(Object.entries(builtins));
     this.custom = new Map();
   }
 
   tagForName(name: string): TagDefinition | undefined {
-    return this.custom.get(name) ?? this.builtins[name];
+    return this.custom.get(name) ?? this.builtins.get(name);
   }
 
   registerTag(name: string, definition: TagDefinition): void {
diff --git a/packages/liquid-html-parser/src/markup/parser.test.ts b/packages/liquid-html-parser/src/markup/parser.test.ts
index c8c9b6e9a..9065aa79a 100644
--- a/packages/liquid-html-parser/src/markup/parser.test.ts
+++ b/packages/liquid-html-parser/src/markup/parser.test.ts
@@ -11,6 +11,7 @@ import type {
   LiquidBooleanExpression,
   LiquidNamedArgument,
 } from '../ast';
+import { LiquidLiteralValues } from '../ast';
 
 function parser(markup: string): MarkupParser {
   return new MarkupParser(tokenizeMarkup(markup), markup);
@@ -268,6 +269,28 @@ describe('Unit: MarkupParser expression parsing', () => {
           value: '',
         });
       });
+
+      it.each(Object.entries(LiquidLiteralValues))(
+        'recognizes %s as a literal',
+        (keyword, value) => {
+          expect(parser(keyword).valueExpression()).toMatchObject({
+            type: NodeTypes.LiquidLiteral,
+            keyword,
+            value,
+          });
+        },
+      );
+
+      it.each(['constructor', 'toString', 'hasOwnProperty', '__proto__', 'valueOf'])(
+        'parses Object.prototype name %s as a variable, not a literal',
+        (name) => {
+          expect(parser(name).valueExpression()).toMatchObject({
+            type: NodeTypes.VariableLookup,
+            name,
+            lookups: [],
+          });
+        },
+      );
     });
 
     describe('variable lookups', () => {
diff --git a/packages/liquid-html-parser/src/markup/parser.ts b/packages/liquid-html-parser/src/markup/parser.ts
index b5fa0b6e5..fc7b7eb4f 100644
--- a/packages/liquid-html-parser/src/markup/parser.ts
+++ b/packages/liquid-html-parser/src/markup/parser.ts
@@ -1438,6 +1438,18 @@ function isLogicalOp(s: string): s is LogicalOperator {
   return LOGICAL_OPERATORS.has(s);
 }
 
+// A switch rather than `s in LiquidLiteralValues`: `in` also matches inherited
+// names like `constructor`, and the switch is faster on this hot path.
 function isLiteralKeyword(s: string): s is keyof typeof LiquidLiteralValues {
-  return s in LiquidLiteralValues;
+  switch (s) {
+    case 'nil':
+    case 'null':
+    case 'true':
+    case 'false':
+    case 'blank':
+    case 'empty':
+      return true;
+    default:
+      return false;
+  }
 }
diff --git a/specs/parser/liquid-tags.yml b/specs/parser/liquid-tags.yml
index 55885f1ae..05c3e4fc8 100644
--- a/specs/parser/liquid-tags.yml
+++ b/specs/parser/liquid-tags.yml
@@ -1911,3 +1911,251 @@ cases:
               value: x
               position: { start: [0, 8], text: '"x"' }
             filters: []
+  - name: parses the Object.prototype name constructor as an unknown tag
+    source: "{% constructor a %}"
+    parse: [html, liquid]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% constructor a %}" }
+      children:
+        - type: LiquidTag
+          name: constructor
+          markup: a
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% constructor a %}" }
+          markupPosition: { start: [0, 15], text: "a " }
+          position: { start: [0, 0], text: "{% constructor a %}" }
+  - name: parses the Object.prototype name constructor as an unknown tag in {% liquid %}
+    source: |-
+      {% liquid
+        constructor a
+      %}
+    parse: [html, liquid]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          {% liquid
+            constructor a
+          %}
+      children:
+        - type: LiquidTag
+          name: liquid
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          blockStartPosition:
+            start: [0, 0]
+            text: |-
+              {% liquid
+                constructor a
+              %}
+          markupPosition:
+            start: [0, 9]
+            text: |2
+              
+                constructor a
+          position:
+            start: [0, 0]
+            text: |-
+              {% liquid
+                constructor a
+              %}
+          markup:
+            - type: LiquidTag
+              name: constructor
+              markup: a
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              blockStartPosition: { start: [1, 2], text: constructor a }
+              markupPosition: { start: [1, 14], text: a }
+              position: { start: [1, 2], text: constructor a }
+  - name: parses the Object.prototype name toString as an unknown tag
+    source: "{% toString a %}"
+    parse: [html, liquid]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% toString a %}" }
+      children:
+        - type: LiquidTag
+          name: toString
+          markup: a
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% toString a %}" }
+          markupPosition: { start: [0, 12], text: "a " }
+          position: { start: [0, 0], text: "{% toString a %}" }
+  - name: parses the Object.prototype name toString as an unknown tag in {% liquid %}
+    source: |-
+      {% liquid
+        toString a
+      %}
+    parse: [html, liquid]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          {% liquid
+            toString a
+          %}
+      children:
+        - type: LiquidTag
+          name: liquid
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          blockStartPosition:
+            start: [0, 0]
+            text: |-
+              {% liquid
+                toString a
+              %}
+          markupPosition:
+            start: [0, 9]
+            text: |2
+              
+                toString a
+          position:
+            start: [0, 0]
+            text: |-
+              {% liquid
+                toString a
+              %}
+          markup:
+            - type: LiquidTag
+              name: toString
+              markup: a
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              blockStartPosition: { start: [1, 2], text: toString a }
+              markupPosition: { start: [1, 11], text: a }
+              position: { start: [1, 2], text: toString a }
+  - name: parses the Object.prototype name hasOwnProperty as an unknown tag
+    source: "{% hasOwnProperty a %}"
+    parse: [html, liquid]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% hasOwnProperty a %}" }
+      children:
+        - type: LiquidTag
+          name: hasOwnProperty
+          markup: a
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% hasOwnProperty a %}" }
+          markupPosition: { start: [0, 18], text: "a " }
+          position: { start: [0, 0], text: "{% hasOwnProperty a %}" }
+  - name: parses the Object.prototype name hasOwnProperty as an unknown tag in {% liquid %}
+    source: |-
+      {% liquid
+        hasOwnProperty a
+      %}
+    parse: [html, liquid]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          {% liquid
+            hasOwnProperty a
+          %}
+      children:
+        - type: LiquidTag
+          name: liquid
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          blockStartPosition:
+            start: [0, 0]
+            text: |-
+              {% liquid
+                hasOwnProperty a
+              %}
+          markupPosition:
+            start: [0, 9]
+            text: |2
+              
+                hasOwnProperty a
+          position:
+            start: [0, 0]
+            text: |-
+              {% liquid
+                hasOwnProperty a
+              %}
+          markup:
+            - type: LiquidTag
+              name: hasOwnProperty
+              markup: a
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              blockStartPosition: { start: [1, 2], text: hasOwnProperty a }
+              markupPosition: { start: [1, 17], text: a }
+              position: { start: [1, 2], text: hasOwnProperty a }
+  - name: parses the Object.prototype name __proto__ as an unknown tag
+    source: "{% __proto__ a %}"
+    parse: [html, liquid]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% __proto__ a %}" }
+      children:
+        - type: LiquidTag
+          name: __proto__
+          markup: a
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% __proto__ a %}" }
+          markupPosition: { start: [0, 13], text: "a " }
+          position: { start: [0, 0], text: "{% __proto__ a %}" }
+  - name: parses the Object.prototype name __proto__ as an unknown tag in {% liquid %}
+    source: |-
+      {% liquid
+        __proto__ a
+      %}
+    parse: [html, liquid]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          {% liquid
+            __proto__ a
+          %}
+      children:
+        - type: LiquidTag
+          name: liquid
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          blockStartPosition:
+            start: [0, 0]
+            text: |-
+              {% liquid
+                __proto__ a
+              %}
+          markupPosition:
+            start: [0, 9]
+            text: |2
+              
+                __proto__ a
+          position:
+            start: [0, 0]
+            text: |-
+              {% liquid
+                __proto__ a
+              %}
+          markup:
+            - type: LiquidTag
+              name: __proto__
+              markup: a
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              blockStartPosition: { start: [1, 2], text: __proto__ a }
+              markupPosition: { start: [1, 12], text: a }
+              position: { start: [1, 2], text: __proto__ a }

From 1d06444db8b42009d945f54a36577f52cb1f1650 Mon Sep 17 00:00:00 2001
From: Natacha Levesque <natacha.levesque@shopify.com>
Date: Thu, 10 Sep 2026 15:54:42 -0400
Subject: [PATCH 06/20] Type block and section arguments as one BlockArgument

Block and section markup now share a single BlockArgument type, whose value is
a scalar or a single-level array literal, instead of a LiquidNamedArgument |
BlockArrayArgument union. Filters in these arguments are still rejected, and
the tag falls back to string markup.

Co-Authored-By: Charles-P. Clermont <charles@cpclermont.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 packages/liquid-html-parser/src/ast.ts        | 28 +++++++------
 .../liquid-html-parser/src/markup/parser.ts   | 39 +++++++------------
 .../liquid-html-parser/src/tags/block.test.ts | 10 +++++
 packages/liquid-html-parser/src/tags/block.ts |  4 +-
 .../src/tags/section.test.ts                  | 11 +++++-
 specs/parser/liquid-tags.yml                  | 38 ++++++++++++++++++
 6 files changed, 92 insertions(+), 38 deletions(-)

diff --git a/packages/liquid-html-parser/src/ast.ts b/packages/liquid-html-parser/src/ast.ts
index cc1051e66..c0451ea17 100644
--- a/packages/liquid-html-parser/src/ast.ts
+++ b/packages/liquid-html-parser/src/ast.ts
@@ -358,11 +358,8 @@ export interface LiquidTagBlock extends LiquidTagNode<NamedTags.block, BlockMark
 export interface BlockMarkup extends ASTNode<NodeTypes.BlockMarkup> {
   /** The name of the block template */
   name: LiquidString;
-  // TODO: BlockArrayArgument exists as a separate type because
-  // LiquidNamedArgument.value is typed as LiquidExpression, which doesn't
-  // include BlockArrayLiteral. Once LiquidExpression supports array literals,
-  // unify BlockArrayArgument into LiquidNamedArgument.
-  args: (LiquidNamedArgument | BlockArrayArgument)[];
+  /** Optional named arguments, including block-local arrays. */
+  args: BlockArgument[];
 }
 
 /** https://shopify.dev/docs/api/liquid/tags#section */
@@ -373,7 +370,7 @@ export interface SectionMarkup extends ASTNode<NodeTypes.SectionMarkup> {
   /** The name of the section template */
   name: LiquidString;
   /** Optional named arguments */
-  args: (LiquidNamedArgument | BlockArrayArgument)[];
+  args: BlockArgument[];
 }
 
 /** https://shopify.dev/docs/api/liquid/tags#sections */
@@ -591,20 +588,29 @@ export interface LiquidRange extends ASTNode<NodeTypes.Range> {
  * A single-level array literal, e.g. `['a', 'b']` or `[1, 2, x]`.
  * Supported as a block or section tag argument value. Nested arrays are rejected.
  *
- * Reachable only via `BlockArrayArgument.value` and the block/section parser path.
+ * Reachable only via `BlockArgument.value` and the block/section parser path.
  */
 export interface BlockArrayLiteral extends ASTNode<'BlockArrayLiteral'> {
   /** The parsed element expressions, in source order */
   elements: LiquidExpression[];
 }
 
-/**
- * Tag arg whose value is a literal array. Lives on block and section markup.
- */
-export interface BlockArrayArgument extends ASTNode<NodeTypes.NamedArgument> {
+/** Value accepted by named arguments on block and section tags. */
+export type BlockArgumentValue = LiquidExpression | BlockArrayLiteral;
+
+/** Named argument accepted by block and section tags. */
+export interface BlockArgument extends ASTNode<NodeTypes.NamedArgument> {
   /** name: value */
   name: string;
 
+  /** Scalar or single-level array value. */
+  value: BlockArgumentValue;
+}
+
+/**
+ * Tag arg whose value is a literal array. Lives on block and section markup.
+ */
+export interface BlockArrayArgument extends BlockArgument {
   /** name: value (always an array literal) */
   value: BlockArrayLiteral;
 }
diff --git a/packages/liquid-html-parser/src/markup/parser.ts b/packages/liquid-html-parser/src/markup/parser.ts
index fc7b7eb4f..889ac2f9d 100644
--- a/packages/liquid-html-parser/src/markup/parser.ts
+++ b/packages/liquid-html-parser/src/markup/parser.ts
@@ -3,7 +3,8 @@ import type {
   LiquidExpression,
   LiquidVariableLookup,
   BlockArrayLiteral,
-  BlockArrayArgument,
+  BlockArgument,
+  BlockArgumentValue,
   LiquidVariableLookupMode,
   LiquidConditionalExpression,
   ComplexLiquidExpression,
@@ -1316,8 +1317,8 @@ export class MarkupParser {
    * section tags use this path because both accept scalar values and
    * single-level array literals.
    */
-  blockNamedArguments(): (LiquidNamedArgument | BlockArrayArgument)[] {
-    const args: (LiquidNamedArgument | BlockArrayArgument)[] = [];
+  blockNamedArguments(): BlockArgument[] {
+    const args: BlockArgument[] = [];
     this.pushBlockNamedArgument(args);
     while (this.consumeOptional(MarkupTokenType.Comma)) {
       if (!this.look(MarkupTokenType.Id)) break; /* trailing comma */
@@ -1328,10 +1329,10 @@ export class MarkupParser {
 
   /*
    * Parses one block named argument and appends it to the unified list.
-   * The if/else is required for TypeScript to narrow the value type into
-   * the correct branch of the LiquidNamedArgument | BlockArrayArgument union.
+   * The block-specific argument type keeps filtered and array values out of
+   * the shared LiquidNamedArgument contract used by other tags.
    */
-  private pushBlockNamedArgument(args: (LiquidNamedArgument | BlockArrayArgument)[]): void {
+  private pushBlockNamedArgument(args: BlockArgument[]): void {
     const nameToken = this.consume(MarkupTokenType.Id);
     let name = nameToken.value;
     while (this.consumeOptional(MarkupTokenType.Dot)) {
@@ -1342,30 +1343,20 @@ export class MarkupParser {
     const value = this.blockValueExpression();
     const position = { start: nameToken.start, end: value.position.end };
 
-    if (value.type === 'BlockArrayLiteral') {
-      args.push({
-        type: NodeTypes.NamedArgument,
-        name,
-        value,
-        position,
-        source: this.source,
-      });
-    } else {
-      args.push({
-        type: NodeTypes.NamedArgument,
-        name,
-        value,
-        position,
-        source: this.source,
-      });
-    }
+    args.push({
+      type: NodeTypes.NamedArgument,
+      name,
+      value,
+      position,
+      source: this.source,
+    });
   }
 
   /*
    * Parses a block or section argument value: a leading `[` opens an array
    * literal, and everything else delegates to the shared `valueExpression()`.
    */
-  private blockValueExpression(): LiquidExpression | BlockArrayLiteral {
+  private blockValueExpression(): BlockArgumentValue {
     if (this.look(MarkupTokenType.OpenSquare)) {
       return this.blockArrayLiteral();
     }
diff --git a/packages/liquid-html-parser/src/tags/block.test.ts b/packages/liquid-html-parser/src/tags/block.test.ts
index b8922ddae..9b0308fd7 100644
--- a/packages/liquid-html-parser/src/tags/block.test.ts
+++ b/packages/liquid-html-parser/src/tags/block.test.ts
@@ -58,6 +58,16 @@ describe('blockTag', () => {
     ]);
   });
 
+  it('rejects filtered named arguments', () => {
+    expect(() =>
+      blockTag.parse(
+        'block',
+        parser("'card', product: collections.frontpage.products | first"),
+        stubParser,
+      ),
+    ).toThrow("Unexpected token in 'block' tag: |");
+  });
+
   describe('array-literal named args (block-only)', () => {
     it('parses an array of strings', () => {
       const result = blockTag.parse('block', parser("'name', items: ['a', 'b']"), stubParser);
diff --git a/packages/liquid-html-parser/src/tags/block.ts b/packages/liquid-html-parser/src/tags/block.ts
index e9232d026..f633bdff4 100644
--- a/packages/liquid-html-parser/src/tags/block.ts
+++ b/packages/liquid-html-parser/src/tags/block.ts
@@ -1,4 +1,4 @@
-import type { BlockMarkup, BlockArrayArgument, LiquidNamedArgument } from '../ast';
+import type { BlockArgument, BlockMarkup } from '../ast';
 import type { MarkupParser } from '../markup/parser';
 import { MarkupTokenType } from '../markup/tokenizer';
 import { NodeTypes } from '../types';
@@ -25,7 +25,7 @@ export const blockTag: TagDefinitionBlock<BlockMarkup> = {
       throw new Error(`in 'block' - '${name.value}' is not a valid block type`);
     }
 
-    let args: (LiquidNamedArgument | BlockArrayArgument)[] = [];
+    let args: BlockArgument[] = [];
     if (markup.consumeOptional(MarkupTokenType.Comma) && !markup.isAtEnd()) {
       args = markup.blockNamedArguments();
     }
diff --git a/packages/liquid-html-parser/src/tags/section.test.ts b/packages/liquid-html-parser/src/tags/section.test.ts
index cef45abf4..8f7917c1a 100644
--- a/packages/liquid-html-parser/src/tags/section.test.ts
+++ b/packages/liquid-html-parser/src/tags/section.test.ts
@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import { sectionTag } from './section';
 import { TagKind, type Parser } from '../environment';
-import { tokenizeMarkup } from '../markup/tokenizer';
+import { MarkupTokenType, tokenizeMarkup } from '../markup/tokenizer';
 import { MarkupParser } from '../markup/parser';
 import { NodeTypes } from '../types';
 
@@ -56,6 +56,15 @@ describe('sectionTag', () => {
     });
   });
 
+  it('leaves filtered named arguments unconsumed', () => {
+    const markup = parser("'featured', product: collections.frontpage.products | first");
+
+    sectionTag.parse('section', markup, stubParser);
+
+    expect(markup.peek().type).toBe(MarkupTokenType.Pipe);
+    expect(markup.isAtEnd()).toBe(false);
+  });
+
   it('parses section setting args with array values', () => {
     const result = sectionTag.parse(
       'section',
diff --git a/specs/parser/liquid-tags.yml b/specs/parser/liquid-tags.yml
index 05c3e4fc8..34fc11e9f 100644
--- a/specs/parser/liquid-tags.yml
+++ b/specs/parser/liquid-tags.yml
@@ -2159,3 +2159,41 @@ cases:
               blockStartPosition: { start: [1, 2], text: __proto__ a }
               markupPosition: { start: [1, 12], text: a }
               position: { start: [1, 2], text: __proto__ a }
+  - name: should keep filtered block arguments as string markup
+    source: "{% block 'card', product: products | first %}{% endblock %}"
+    parse: [html, liquid]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% block 'card', product: products | first %}{% endblock %}" }
+      children:
+        - type: LiquidTag
+          name: block
+          markup: "'card', product: products | first"
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% block 'card', product: products | first %}" }
+          blockEndPosition: { start: [0, 45], text: "{% endblock %}" }
+          markupPosition: { start: [0, 9], text: "'card', product: products | first " }
+          position: { start: [0, 0], text: "{% block 'card', product: products | first %}{% endblock %}" }
+          reason: "Unexpected token in 'block' tag: |"
+          children: []
+  - name: should keep filtered section arguments as string markup
+    source: "{% section 'featured', product: products | first %}"
+    parse: [html, liquid]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% section 'featured', product: products | first %}" }
+      children:
+        - type: LiquidTag
+          name: section
+          markup: "'featured', product: products | first"
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% section 'featured', product: products | first %}" }
+          markupPosition: { start: [0, 11], text: "'featured', product: products | first " }
+          position: { start: [0, 0], text: "{% section 'featured', product: products | first %}" }
+          reason: unexpected tokens after markup

From b8414be8a7d53b87d3bc780f06d3fe7a959afa46 Mon Sep 17 00:00:00 2001
From: Iain Wilson <iain.wilson@shopify.com>
Date: Mon, 31 Aug 2026 14:03:04 +0200
Subject: [PATCH 07/20] Test parse error locations at the end of input

liquid-html-parser already clamps out-of-range indices when it builds a
LiquidHTMLASTParsingError; these tests pin that an unclosed `{{` at the end of
input is reported as a parse error with a real location.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../liquid-html-parser/src/errors.test.ts     | 82 +++++++++++++++++++
 1 file changed, 82 insertions(+)
 create mode 100644 packages/liquid-html-parser/src/errors.test.ts

diff --git a/packages/liquid-html-parser/src/errors.test.ts b/packages/liquid-html-parser/src/errors.test.ts
new file mode 100644
index 000000000..227d71848
--- /dev/null
+++ b/packages/liquid-html-parser/src/errors.test.ts
@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'vitest';
+import { toLiquidHtmlAST } from './ast';
+import { LiquidHTMLASTParsingError } from './errors';
+
+/**
+ * A parse error has to arrive as a parse error. `line-column` answers `null` for an
+ * index outside the source, and the token that fails at the end of input starts at
+ * `source.length` — one past the last character — so building the error used to throw
+ * `TypeError: Cannot read properties of null (reading 'line')` from its own
+ * constructor. A caller that wanted to catch a syntax error instead got an unrelated
+ * TypeError with no position on it.
+ */
+describe('Unit: LiquidHTMLASTParsingError', () => {
+  describe('errors at the end of input', () => {
+    it('reports an unclosed variable output as a parsing error', () => {
+      const source = '{{ unclosed ';
+
+      expect(() => toLiquidHtmlAST(source)).toThrowError(LiquidHTMLASTParsingError);
+    });
+
+    it('points at the last position in the source', () => {
+      const source = '{{ unclosed ';
+      let thrown: LiquidHTMLASTParsingError | undefined;
+
+      try {
+        toLiquidHtmlAST(source);
+      } catch (error) {
+        thrown = error as LiquidHTMLASTParsingError;
+      }
+
+      expect(thrown?.name).to.eql('LiquidHTMLParsingError');
+      // `col` is 1-based, so the last character of the source is `source.length`.
+      expect(thrown?.loc).to.eql({
+        start: { line: 1, column: source.length },
+        end: { line: 1, column: source.length },
+      });
+    });
+
+    it('reports the line an unclosed output starts on, not the first line', () => {
+      const source = 'hello\nworld\n{{ unclosed ';
+      let thrown: LiquidHTMLASTParsingError | undefined;
+
+      try {
+        toLiquidHtmlAST(source);
+      } catch (error) {
+        thrown = error as LiquidHTMLASTParsingError;
+      }
+
+      expect(thrown?.loc?.start.line).to.eql(3);
+    });
+  });
+
+  describe('indices outside the source', () => {
+    it('falls back to the document start for an empty source', () => {
+      const error = new LiquidHTMLASTParsingError('boom', '', 0, 0);
+
+      expect(error.loc).to.eql({ start: { line: 1, column: 1 }, end: { line: 1, column: 1 } });
+    });
+
+    it('clamps an index past the end of the source', () => {
+      const error = new LiquidHTMLASTParsingError('boom', 'ab', 99, 99);
+
+      expect(error.loc).to.eql({ start: { line: 1, column: 2 }, end: { line: 1, column: 2 } });
+    });
+
+    it('clamps a negative index', () => {
+      const error = new LiquidHTMLASTParsingError('boom', 'ab', -5, -5);
+
+      expect(error.loc).to.eql({ start: { line: 1, column: 1 }, end: { line: 1, column: 1 } });
+    });
+  });
+
+  describe('errors inside the source', () => {
+    it('keeps the reported position of an error away from the boundaries', () => {
+      const source = 'line one\nline two\nline three';
+      const index = source.indexOf('two');
+      const error = new LiquidHTMLASTParsingError('boom', source, index, index + 2);
+
+      expect(error.loc).to.eql({ start: { line: 2, column: 6 }, end: { line: 2, column: 8 } });
+    });
+  });
+});

From e391d5ca2bec6a47212630b98270195b54a07f5a Mon Sep 17 00:00:00 2001
From: River <river@shopify.com>
Date: Thu, 8 Oct 2026 13:44:31 +0000
Subject: [PATCH 08/20] Let each raw tag end its body by its own Liquid rule

Each raw tag now carries the rule of the Liquid class that parses it:

- comment nests, skips raw bodies, and closes on a tag named endcomment
  whatever follows the name, as Comment#parse_body does;
- raw, javascript, schema and stylesheet close at the last tag of their first
  end<name> token, as Liquid::Raw does;
- doc reads like raw but rejects a nested doc, as Liquid::Doc does;
- style is a Liquid::Block, so it nests and skips raw bodies inside it.

The same rules apply to raw tags inside {% liquid %}, whose lines are named
only after ASCII indentation. Templates that Liquid reports as never closed
now fail to parse here too.

Co-Authored-By: Martin Morissette <martin.morissette@shopify.com>
Co-Authored-By: Mbarak Bujra <mbarak.bujra@shopify.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../liquid-html-parser/specs/architecture.md  |   2 +-
 .../specs/recursive-descent.md                |  20 +-
 .../src/document/liquid-lines.ts              |  45 +-
 .../src/document/liquid-raw.ts                | 112 +--
 .../src/document/raw-body.ts                  | 169 ++++
 .../src/environment.test.ts                   |   7 +-
 .../liquid-html-parser/src/tag-definitions.ts |  29 +
 .../liquid-html-parser/src/tags/raw.test.ts   |  28 +
 packages/liquid-html-parser/src/tags/raw.ts   |  39 +-
 specs/parser/liquid-lines.yml                 | 422 +++++++-
 specs/parser/liquid-raw.yml                   | 948 +++++++++++++++++-
 11 files changed, 1647 insertions(+), 174 deletions(-)
 create mode 100644 packages/liquid-html-parser/src/document/raw-body.ts

diff --git a/packages/liquid-html-parser/specs/architecture.md b/packages/liquid-html-parser/specs/architecture.md
index 428c1d92e..f91427f56 100644
--- a/packages/liquid-html-parser/specs/architecture.md
+++ b/packages/liquid-html-parser/specs/architecture.md
@@ -745,7 +745,7 @@ liquid tag parse(name, markupParser, parser):
 
 **Block nesting:** Block tags inside `{% liquid %}` consume subsequent lines until their matching `end*` line, reusing `finalizeBranch()`.
 
-**Raw tags inside `{% liquid %}`:** When the line is a raw tag (e.g., `comment`), subsequent lines are consumed until `endcomment`.
+**Raw tags inside `{% liquid %}`:** When the line is a raw tag (e.g., `comment`), subsequent lines are consumed until the line that ends its body under the tag's `body` rule (`findRawLineBodyEnd` in `raw-body.ts`); a `comment` nests, and a `raw` or `doc` body never closes there.
 
 **Nested `{% liquid %}`:** Supported. Inner `liquid` tag processes its own body independently.
 
diff --git a/packages/liquid-html-parser/specs/recursive-descent.md b/packages/liquid-html-parser/specs/recursive-descent.md
index 7265b55f9..98583b9f4 100644
--- a/packages/liquid-html-parser/specs/recursive-descent.md
+++ b/packages/liquid-html-parser/specs/recursive-descent.md
@@ -199,6 +199,24 @@ Block tags (`LiquidTag` with children) have:
 - `for`/`tablerow` can contain `else` branch
 - The **first** branch of any branched tag is an unnamed branch (`LiquidBranchUnnamed` with `name: null`)
 
+**Raw tag bodies:**
+
+Every raw tag definition carries a `body` rule (`RawBodyRule` in `tag-definitions.ts`), and one scanner (`document/raw-body.ts`) ends every raw body by it. The rule mirrors the Liquid class that parses the tag:
+
+| Tag                                         | Liquid class                         | `delimiter` | `sameName` | `opaque`               | Closes in `{% liquid %}` |
+| ------------------------------------------- | ------------------------------------ | ----------- | ---------- | ---------------------- | ------------------------ |
+| `raw`, `javascript`, `schema`, `stylesheet` | `Liquid::Raw`                        | `trailing`  | `ignored`  | none                   | no                       |
+| `doc`                                       | `Liquid::Doc`                        | `trailing`  | `rejected` | none                   | no                       |
+| `comment`                                   | `Liquid::Comment`                    | `leading`   | `nests`    | `raw`                  | yes                      |
+| `style`                                     | `Liquid::Block` (Shopify's `style`)  | `leading`   | `nests`    | the other six raw tags | yes                      |
+
+- The body is read as the tokens `Liquid::Tokenizer` produces: a `{%` tag runs to the first `%}`, and a `{{` output runs to its first `}` (taking a second `}` with it), or through the `%}` of a `{%` that opens inside it
+- `leading` names a `{% %}` token by the `#` or word that opens it (`BlockBody::FullToken`); `trailing` names it by its last tag and keeps any text before that tag in the body (`FullTokenPossiblyInvalid`). Either way markup after the name does not matter, so `{% endcomment xyz %}` closes and `{% endcommentXXXXX %}` does not
+- `sameName` says what an inner tag with the tag's own name does: `nests` opens another level that its own end tag closes, `ignored` does nothing, and `rejected` throws, as Liquid raises `Nested doc tags are not allowed`
+- An `opaque` inner tag is skipped whole, ending by its own rule, so a `{% endcomment %}` inside a `{% raw %}` inside a comment does not count
+- A body that runs out of tokens before it closes throws, as Liquid raises `'<name>' tag was never closed`
+- Inside `{% liquid %}` the same levels apply line by line, each line named by its leading `#` or word after ASCII-only indentation (a line indented with U+00A0 or other non-ASCII whitespace has no name, as in Liquid's `LiquidTagToken`). A `Liquid::Raw` or `Liquid::Doc` body never closes there, because a line cannot hold its `{% end<name> %}`
+
 **Inline comments `{% # %}`:**
 
 - `#` is a valid tag name, producing `LiquidTag` with `name: '#'` and `markup: string` (the rest of the line)
@@ -213,7 +231,7 @@ Block tags (`LiquidTag` with children) have:
 - Nesting is fully supported: `for` inside `if` inside `liquid` is valid
 - Branch tags (`elsif`, `else`, `when`) work inside `{% liquid %}` blocks
 - Blocks open and close within the same `{% liquid %}` boundary
-- Raw tags (`comment`/`endcomment`, `raw`/`endraw`) work inside `{% liquid %}`, consuming lines until their end tag
+- Raw tags (`comment`/`endcomment`, `raw`/`endraw`) work inside `{% liquid %}`, consuming lines until their end tag (a `comment` nests; see Comment bodies)
 - Nested `{% liquid %}` inside `{% liquid %}` is supported (inner scope is per-line)
 - There is no `{{ }}` syntax inside `{% liquid %}` — use `echo` instead
 - `markup` is `LiquidStatement[]`
diff --git a/packages/liquid-html-parser/src/document/liquid-lines.ts b/packages/liquid-html-parser/src/document/liquid-lines.ts
index 46900845a..117ae101e 100644
--- a/packages/liquid-html-parser/src/document/liquid-lines.ts
+++ b/packages/liquid-html-parser/src/document/liquid-lines.ts
@@ -39,6 +39,7 @@ import { envelopeFromLine } from '../shared';
 import { isBranchName, finalizeBranch } from './liquid-blocks';
 import { ChildFilterMode, filterChildren } from './tree-builder';
 import { rawMarkupKindForTag } from './liquid-raw';
+import { findRawLineBodyEnd } from './raw-body';
 
 /**
  * Interface capturing what line-based parsing free functions need from
@@ -171,7 +172,7 @@ export function parseLineBlockTag(
 // lineRawTag := tagName LF line* "end" tagName
 export function parseLineRawTag(
   parser: LineParserDelegate,
-  _def: TagDefinitionRaw,
+  def: TagDefinitionRaw,
   envelope: LiquidTagEnvelope,
   ctx: LiquidLineContext,
 ): LiquidRawTag {
@@ -192,43 +193,11 @@ export function parseLineRawTag(
       ? ctx.lines[ctx.index - 1].lineEnd + 1
       : envelope.blockStartPosition.end;
 
-  // `comment`/`doc` bodies balance nested opens of the same tag before
-  // matching their end line, mirroring the document-path scan in
-  // liquid-raw.ts (Ruby comment.rb v5.13.0 `comment_tag_depth`). A nested
-  // `raw` block is carved out: `raw` is first-match and does not nest, so an
-  // `endcomment`/`comment` word sitting on a line inside a raw body must not
-  // affect the depth. Every other raw tag (`raw`, `javascript`, `schema`,
-  // `style`) keeps the original first-match scan and stays byte-identical.
-  const balanced = tagName === 'comment' || tagName === 'doc';
-  let endLineIndex = -1;
-  if (balanced) {
-    let depth = 0;
-    for (let i = ctx.index; i < ctx.lines.length; i++) {
-      const name = ctx.lines[i].tagName;
-      if (name === 'raw') {
-        // Skip past the nested raw block; its body lines never affect depth.
-        i++;
-        while (i < ctx.lines.length && ctx.lines[i].tagName !== 'endraw') i++;
-        continue;
-      }
-      if (name === tagName) {
-        depth++;
-      } else if (name === endTagName) {
-        if (depth === 0) {
-          endLineIndex = i;
-          break;
-        }
-        depth--;
-      }
-    }
-  } else {
-    for (let i = ctx.index; i < ctx.lines.length; i++) {
-      if (ctx.lines[i].tagName === endTagName) {
-        endLineIndex = i;
-        break;
-      }
-    }
-  }
+  const endLineIndex =
+    findRawLineBodyEnd(parser.getSource(), ctx.lines, ctx.index, tagName, def.body, (name) => {
+      const inner = parser.lineEnv.tagForName(name);
+      return inner?.kind === TagKind.Raw ? inner.body : undefined;
+    }) ?? -1;
 
   if (endLineIndex === -1) {
     throw new LiquidHTMLASTParsingError(
diff --git a/packages/liquid-html-parser/src/document/liquid-raw.ts b/packages/liquid-html-parser/src/document/liquid-raw.ts
index 5e8d67d1e..e4ebda75b 100644
--- a/packages/liquid-html-parser/src/document/liquid-raw.ts
+++ b/packages/liquid-html-parser/src/document/liquid-raw.ts
@@ -2,12 +2,14 @@ import { TokenType } from './tokenizer';
 import type { Token } from './tokenizer';
 import { ParserBase } from './base';
 import { makeTextNode, makeRawMarkup, makeLiquidRawTag } from './factories';
-import type { LiquidTagEnvelope, LiquidOpenWhitespace, LiquidCloseWhitespace } from './factories';
+import type { LiquidTagEnvelope } from './factories';
 import { ChildFilterMode, filterChildren } from './tree-builder';
 import type { Position } from '../types';
 import { RawMarkupKinds } from '../ast';
 import type { LiquidRawTag, LiquidNode, TextNode, LiquidVariableOutput } from '../ast';
-import type { TagDefinitionRaw } from '../environment';
+import { TagKind } from '../environment';
+import type { TagDefinition, TagDefinitionRaw } from '../environment';
+import { findRawBodyEnd } from './raw-body';
 import { LiquidHTMLASTParsingError } from '../errors';
 import { parseLiquidDoc } from '../liquid-doc/parser';
 
@@ -18,6 +20,7 @@ import { parseLiquidDoc } from '../liquid-doc/parser';
  */
 export interface RawParserDelegate extends ParserBase {
   rawParseHtml: boolean;
+  tagForName(name: string): TagDefinition | undefined;
   parseLiquidVariableOutput(): LiquidVariableOutput;
   parseLiquidTag(): LiquidRawTag | import('../ast').LiquidTag;
 }
@@ -30,9 +33,17 @@ export function parseRawTag(
   closeToken: Token,
 ): LiquidRawTag {
   const tagName = envelope.tagName;
-  const endTagName = `end${tagName}`;
 
-  const endTag = scanForEndTag(parser, endTagName);
+  const endTag = findRawBodyEnd(
+    parser.getSource(),
+    parser.tokenAt(parser.getPosition()).start,
+    tagName,
+    def.body,
+    (name) => {
+      const inner = parser.tagForName(name);
+      return inner?.kind === TagKind.Raw ? inner.body : undefined;
+    },
+  );
   if (!endTag) {
     throw new LiquidHTMLASTParsingError(
       `Attempting to end parsing before LiquidRawTag '${tagName}' was closed`,
@@ -165,99 +176,6 @@ export function parseRawTagBody(
   return filterChildren(ChildFilterMode.Syntactic, [textNode], source) as (LiquidNode | TextNode)[];
 }
 
-/**
- * Result of scanning for a raw tag's end tag in the source string.
- *
- * We scan the source directly (rather than the token stream) because the
- * tokenizer doesn't know about raw-tag semantics. Content inside a raw
- * tag body may contain `{%` sequences that the tokenizer greedily enters
- * as LiquidTag mode, mangling the tokens around the real end tag.
- */
-export interface EndTagScanResult {
-  /** Source offset where the end tag starts (the `{`). */
-  tagStart: number;
-  /** Source offset where the end tag ends (after `%}`). */
-  tagEnd: number;
-  /** Opening whitespace-strip marker: `'-'` or `''`. */
-  wsStart: LiquidOpenWhitespace;
-  /** Closing whitespace-strip marker: `'-'` or `''`. */
-  wsEnd: LiquidCloseWhitespace;
-}
-
-export function scanForEndTag(parser: ParserBase, endTagName: string): EndTagScanResult | null {
-  const source = parser.getSource();
-  const searchStart = parser.tokenAt(parser.getPosition()).start;
-
-  // `comment` and `doc` bodies balance nested opens of the same tag before
-  // matching their end tag, mirroring Ruby comment.rb v5.13.0's
-  // `comment_tag_depth`. `raw` (and every other raw tag) keeps first-match
-  // semantics — Ruby's raw does not balance.
-  if (endTagName === 'endcomment' || endTagName === 'enddoc') {
-    return scanForBalancedEndTag(source, searchStart, endTagName);
-  }
-
-  const pattern = new RegExp(`\\{%(-?)\\s*${endTagName}\\s*(-?)%\\}`);
-  const match = pattern.exec(source.slice(searchStart));
-  if (!match) return null;
-
-  const tagStart = searchStart + match.index;
-  const tagEnd = tagStart + match[0].length;
-  const wsStart: LiquidOpenWhitespace = match[1] === '-' ? '-' : '';
-  const wsEnd: LiquidCloseWhitespace = match[2] === '-' ? '-' : '';
-
-  return { tagStart, tagEnd, wsStart, wsEnd };
-}
-
-/**
- * Depth-balancing end-tag scan for `comment`/`doc`. Counts nested opens of the
- * same tag so a `{% comment %}` inside the body is paired with its own
- * `{% endcomment %}` rather than closing the outer block early.
- *
- * `searchStart` is already positioned past the outer open tag, so depth starts
- * at 0 and every `{% comment %}` encountered is a nested open. A nested
- * `{% raw %}`…`{% endraw %}` is carved out — its literal contents (which may
- * contain `{% comment %}`/`{% endcomment %}` text) do not affect the depth —
- * mirroring Ruby's `parse_raw_tag_body`.
- */
-function scanForBalancedEndTag(
-  source: string,
-  searchStart: number,
-  endTagName: string,
-): EndTagScanResult | null {
-  const openTagName = endTagName.slice(3); // "endcomment" -> "comment"
-  const scanner = new RegExp(
-    `\\{%(-?)\\s*(${openTagName}|${endTagName}|raw|endraw)\\b\\s*(-?)%\\}`,
-    'g',
-  );
-  scanner.lastIndex = searchStart;
-
-  let depth = 0;
-  let inRaw = false;
-  let match: RegExpExecArray | null;
-  while ((match = scanner.exec(source)) !== null) {
-    const name = match[2];
-    if (inRaw) {
-      if (name === 'endraw') inRaw = false;
-      continue;
-    }
-    if (name === 'raw') {
-      inRaw = true;
-    } else if (name === openTagName) {
-      depth++;
-    } else if (name === endTagName) {
-      if (depth === 0) {
-        const tagStart = match.index;
-        const tagEnd = tagStart + match[0].length;
-        const wsStart: LiquidOpenWhitespace = match[1] === '-' ? '-' : '';
-        const wsEnd: LiquidCloseWhitespace = match[3] === '-' ? '-' : '';
-        return { tagStart, tagEnd, wsStart, wsEnd };
-      }
-      depth--;
-    }
-  }
-  return null;
-}
-
 export function rawMarkupKindForTag(tagName: string, bodySource: string = ''): RawMarkupKinds {
   switch (tagName) {
     case 'javascript':
diff --git a/packages/liquid-html-parser/src/document/raw-body.ts b/packages/liquid-html-parser/src/document/raw-body.ts
new file mode 100644
index 000000000..5b1000ffa
--- /dev/null
+++ b/packages/liquid-html-parser/src/document/raw-body.ts
@@ -0,0 +1,169 @@
+import type { LiquidLine, RawBodyEnd, RawBodyRule } from '../tag-definitions';
+
+// Liquid's `BlockBody::FullToken`, `FullTokenPossiblyInvalid` and `LiquidTagToken`,
+// with Ruby's ASCII `\s`.
+const RUBY_WHITESPACE = '[ \\t\\n\\v\\f\\r]';
+const FULL_TOKEN = new RegExp(
+  `^\\{%-?${RUBY_WHITESPACE}*(#|\\w+)${RUBY_WHITESPACE}*[\\s\\S]*?-?%\\}$`,
+);
+const FULL_TOKEN_POSSIBLY_INVALID = new RegExp(
+  `^([\\s\\S]*)\\{%-?${RUBY_WHITESPACE}*(\\w+)${RUBY_WHITESPACE}*[\\s\\S]*-?%\\}$`,
+);
+const LIQUID_TAG_NAME = /^(#|\w+)/;
+const RUBY_LINE_INDENT = /^[ \t\v\f\r]*$/;
+const TAG_OR_VARIABLE_START = /\{[{%]/g;
+
+/** Looks up the body rule of another raw tag, for the tags a rule skips as opaque. */
+export type RawBodyRuleFor = (tagName: string) => RawBodyRule | undefined;
+
+/**
+ * Where the body of `tagName` that starts at `bodyStart` ends under `rule`,
+ * reading the source as `Liquid::Tokenizer` tokens. Returns null where Liquid
+ * reports the tag as never closed, or rejects a tag nested inside it.
+ */
+export function findRawBodyEnd(
+  source: string,
+  bodyStart: number,
+  tagName: string,
+  rule: RawBodyRule,
+  ruleFor: RawBodyRuleFor,
+): RawBodyEnd | null {
+  const endName = `end${tagName}`;
+  let tokenStart = bodyStart;
+  let depth = 1;
+
+  while (tokenStart < source.length) {
+    const tokenEnd = liquidTokenEnd(source, tokenStart);
+    const token = source.slice(tokenStart, tokenEnd);
+    const tag = tokenTag(token, rule.delimiter);
+
+    if (tag?.name === endName) {
+      depth -= 1;
+      if (depth === 0) {
+        const tagStart = tokenStart + tag.offset;
+        return {
+          tagStart,
+          tagEnd: tokenEnd,
+          wsStart: source[tagStart + 2] === '-' ? '-' : '',
+          wsEnd: token[token.length - 3] === '-' ? '-' : '',
+        };
+      }
+    } else if (tag?.name === tagName) {
+      if (rule.sameName === 'rejected') return null;
+      if (rule.sameName === 'nests') depth += 1;
+    } else if (tag && rule.opaque.includes(tag.name)) {
+      const innerRule = ruleFor(tag.name);
+      if (innerRule) {
+        const innerEnd = findRawBodyEnd(source, tokenEnd, tag.name, innerRule, ruleFor);
+        if (!innerEnd) return null;
+        tokenStart = innerEnd.tagEnd;
+        continue;
+      }
+    }
+    tokenStart = tokenEnd;
+  }
+
+  return null;
+}
+
+/**
+ * The index of the line that ends the body of `tagName` starting at `lines[from]`
+ * inside `{% liquid %}`, where each line is a token named by its leading `#` or
+ * word. Returns null where Liquid reports the tag as never closed there.
+ */
+export function findRawLineBodyEnd(
+  source: string,
+  lines: readonly LiquidLine[],
+  from: number,
+  tagName: string,
+  rule: RawBodyRule,
+  ruleFor: RawBodyRuleFor,
+): number | null {
+  if (!rule.closesInLiquidTag) return null;
+
+  const endName = `end${tagName}`;
+  let depth = 1;
+
+  for (let index = from; index < lines.length; index++) {
+    const name = lineTagName(source, lines[index]);
+
+    if (name === endName) {
+      depth -= 1;
+      if (depth === 0) return index;
+    } else if (name === tagName) {
+      if (rule.sameName === 'rejected') return null;
+      if (rule.sameName === 'nests') depth += 1;
+    } else if (name !== undefined && rule.opaque.includes(name)) {
+      const innerRule = ruleFor(name);
+      if (innerRule) {
+        const innerEnd = findRawLineBodyEnd(source, lines, index + 1, name, innerRule, ruleFor);
+        if (innerEnd === null) return null;
+        index = innerEnd;
+      }
+    }
+  }
+
+  return null;
+}
+
+// The tag a token names under `delimiter`, and where that tag starts in the token.
+function tokenTag(
+  token: string,
+  delimiter: RawBodyRule['delimiter'],
+): { name: string; offset: number } | undefined {
+  if (delimiter === 'leading') {
+    const name = FULL_TOKEN.exec(token)?.[1];
+    return name === undefined ? undefined : { name, offset: 0 };
+  }
+  const match = FULL_TOKEN_POSSIBLY_INVALID.exec(token);
+  return match ? { name: match[2], offset: match[1].length } : undefined;
+}
+
+// `BlockBody::LiquidTagToken` indents only with ASCII whitespace, so a line
+// indented with a character such as U+00A0 has no name.
+function lineTagName(source: string, line: LiquidLine): string | undefined {
+  const lineStart = source.lastIndexOf('\n', line.nameOffset - 1) + 1;
+  if (!RUBY_LINE_INDENT.test(source.slice(lineStart, line.nameOffset))) return undefined;
+  return LIQUID_TAG_NAME.exec(line.tagName)?.[1];
+}
+
+/**
+ * The end offset of the Liquid token that starts at `start`, split the way
+ * `Liquid::Tokenizer#next_token` splits it: a tag runs to the first `%}`, and
+ * text runs to the next `{{` or `{%`.
+ */
+function liquidTokenEnd(source: string, start: number): number {
+  if (source.startsWith('{%', start)) return tagTokenEnd(source, start + 2);
+  if (source.startsWith('{{', start)) return variableTokenEnd(source, start + 2);
+
+  TAG_OR_VARIABLE_START.lastIndex = start;
+  const next = TAG_OR_VARIABLE_START.exec(source);
+  return next ? next.index : source.length;
+}
+
+// `Tokenizer#next_tag_token`: an unterminated `{%` is a token of its own.
+function tagTokenEnd(source: string, afterOpen: number): number {
+  const close = source.indexOf('%}', afterOpen);
+  return close === -1 ? afterOpen : close + 2;
+}
+
+// `Tokenizer#next_variable_token`: a `{%` inside an unfinished `{{` extends it to that tag's `%}`.
+function variableTokenEnd(source: string, afterOpen: number): number {
+  let position = afterOpen;
+  let current = source[position++];
+  let next = current;
+
+  while (next !== undefined) {
+    while (current !== undefined && current !== '}' && current !== '{') {
+      current = source[position++];
+    }
+    if (current === undefined || position >= source.length) return source.length;
+
+    next = source[position++];
+    if (current === '}') return next === '}' ? position : position - 1;
+    if (current === '{' && next === '%') return tagTokenEnd(source, position);
+    current = next;
+  }
+
+  return source.length;
+}
diff --git a/packages/liquid-html-parser/src/environment.test.ts b/packages/liquid-html-parser/src/environment.test.ts
index 91d1dd3e4..991b78f3a 100644
--- a/packages/liquid-html-parser/src/environment.test.ts
+++ b/packages/liquid-html-parser/src/environment.test.ts
@@ -20,7 +20,12 @@ function makeStandaloneDef(): TagDefinitionTag {
 }
 
 function makeRawDef(parseLiquidInBody?: boolean): TagDefinitionRaw {
-  return { kind: TagKind.Raw, parse: stubParse, parseLiquidInBody };
+  return {
+    kind: TagKind.Raw,
+    parse: stubParse,
+    parseLiquidInBody,
+    body: { delimiter: 'trailing', sameName: 'ignored', opaque: [], closesInLiquidTag: false },
+  };
 }
 
 describe('Unit: Environment', () => {
diff --git a/packages/liquid-html-parser/src/tag-definitions.ts b/packages/liquid-html-parser/src/tag-definitions.ts
index 90d3eb03b..d1feb4fe1 100644
--- a/packages/liquid-html-parser/src/tag-definitions.ts
+++ b/packages/liquid-html-parser/src/tag-definitions.ts
@@ -34,6 +34,35 @@ export interface TagDefinitionRaw<M = unknown> {
   /** true for javascript/style/stylesheet, false for raw/comment/schema. doc uses liquid-doc-parser. */
   parseLiquidInBody?: boolean;
   parse(name: string, markup: MarkupParser, parser: Parser): M;
+  /** Where this tag's body ends, following the Liquid tag class that parses it. */
+  body: RawBodyRule;
+}
+
+/**
+ * How a raw tag's body ends. Each Liquid tag class finds the end of its own body,
+ * so the rule belongs to the tag, not to the parser.
+ */
+export interface RawBodyRule {
+  /**
+   * How a tag is named inside the body: `leading` reads the name at the start of a
+   * `{% %}` token (`BlockBody::FullToken`); `trailing` reads the last tag in the
+   * token and leaves any text before it in the body (`FullTokenPossiblyInvalid`).
+   */
+  delimiter: 'leading' | 'trailing';
+  /** What an inner tag with the same name does: opens another level, is ignored, or is a syntax error. */
+  sameName: 'nests' | 'ignored' | 'rejected';
+  /** Inner tags whose bodies are skipped whole, each ending by its own rule. */
+  opaque: readonly string[];
+  /** Whether the body can close inside `{% liquid %}`, whose lines cannot hold a `{% %}` delimiter. */
+  closesInLiquidTag: boolean;
+}
+
+/** The closing tag of a raw tag's body, as source offsets. */
+export interface RawBodyEnd {
+  tagStart: number;
+  tagEnd: number;
+  wsStart: '-' | '';
+  wsEnd: '-' | '';
 }
 
 export type TagDefinition<M = unknown> =
diff --git a/packages/liquid-html-parser/src/tags/raw.test.ts b/packages/liquid-html-parser/src/tags/raw.test.ts
index 1ef665666..78e993cad 100644
--- a/packages/liquid-html-parser/src/tags/raw.test.ts
+++ b/packages/liquid-html-parser/src/tags/raw.test.ts
@@ -41,6 +41,34 @@ describe('commentRaw', () => {
   });
 });
 
+describe('raw tag body rules', () => {
+  it('follows the Liquid class that parses each tag', () => {
+    const liquidRaw = {
+      delimiter: 'trailing',
+      sameName: 'ignored',
+      opaque: [],
+      closesInLiquidTag: false,
+    };
+    expect(rawRaw.body).toEqual(liquidRaw);
+    expect(javascriptRaw.body).toEqual(liquidRaw);
+    expect(schemaRaw.body).toEqual(liquidRaw);
+    expect(stylesheetRaw.body).toEqual(liquidRaw);
+    expect(docRaw.body).toEqual({ ...liquidRaw, sameName: 'rejected' });
+    expect(commentRaw.body).toEqual({
+      delimiter: 'leading',
+      sameName: 'nests',
+      opaque: ['raw'],
+      closesInLiquidTag: true,
+    });
+    expect(styleRaw.body).toEqual({
+      delimiter: 'leading',
+      sameName: 'nests',
+      opaque: ['comment', 'doc', 'javascript', 'raw', 'schema', 'stylesheet'],
+      closesInLiquidTag: true,
+    });
+  });
+});
+
 describe('docRaw', () => {
   it('has raw kind', () => {
     expect(docRaw.kind).toBe(TagKind.Raw);
diff --git a/packages/liquid-html-parser/src/tags/raw.ts b/packages/liquid-html-parser/src/tags/raw.ts
index e82d16798..a54cae728 100644
--- a/packages/liquid-html-parser/src/tags/raw.ts
+++ b/packages/liquid-html-parser/src/tags/raw.ts
@@ -1,5 +1,35 @@
 import type { MarkupParser } from '../markup/parser';
-import { TagKind, type TagDefinitionRaw, type Parser } from '../tag-definitions';
+import { TagKind, type Parser, type RawBodyRule, type TagDefinitionRaw } from '../tag-definitions';
+
+// `Liquid::Raw` (raw, and liquid_extensions' javascript, schema and stylesheet)
+// closes at the last tag of its first `end<name>` token, and cannot close inside
+// `{% liquid %}`.
+const LIQUID_RAW_BODY: RawBodyRule = {
+  delimiter: 'trailing',
+  sameName: 'ignored',
+  opaque: [],
+  closesInLiquidTag: false,
+};
+
+// `Liquid::Doc` reads tags like `Liquid::Raw` but rejects a nested `doc`.
+const LIQUID_DOC_BODY: RawBodyRule = { ...LIQUID_RAW_BODY, sameName: 'rejected' };
+
+// `Liquid::Comment#parse_body` counts nested comments and skips `raw` bodies.
+const LIQUID_COMMENT_BODY: RawBodyRule = {
+  delimiter: 'leading',
+  sameName: 'nests',
+  opaque: ['raw'],
+  closesInLiquidTag: true,
+};
+
+// Shopify's `style` tag is a `Liquid::Block`, so its body nests like any block and
+// the raw tags inside it end by their own rules.
+const LIQUID_BLOCK_BODY: RawBodyRule = {
+  delimiter: 'leading',
+  sameName: 'nests',
+  opaque: ['comment', 'doc', 'javascript', 'raw', 'schema', 'stylesheet'],
+  closesInLiquidTag: true,
+};
 
 function parseNoMarkup(name: string, markup: MarkupParser, _parser: Parser): void {
   if (!markup.isAtEnd()) {
@@ -9,6 +39,7 @@ function parseNoMarkup(name: string, markup: MarkupParser, _parser: Parser): voi
 
 export const commentRaw: TagDefinitionRaw<void> = {
   kind: TagKind.Raw,
+  body: LIQUID_COMMENT_BODY,
   parseLiquidInBody: false,
   parse: parseNoMarkup,
 };
@@ -18,35 +49,41 @@ export const commentRaw: TagDefinitionRaw<void> = {
 // the body off to the doc-specific parser rather than the standard raw pipeline.
 export const docRaw: TagDefinitionRaw<void> = {
   kind: TagKind.Raw,
+  body: LIQUID_DOC_BODY,
   parse: parseNoMarkup,
 };
 
 export const rawRaw: TagDefinitionRaw<void> = {
   kind: TagKind.Raw,
+  body: LIQUID_RAW_BODY,
   parseLiquidInBody: false,
   parse: parseNoMarkup,
 };
 
 export const javascriptRaw: TagDefinitionRaw<void> = {
   kind: TagKind.Raw,
+  body: LIQUID_RAW_BODY,
   parseLiquidInBody: true,
   parse: parseNoMarkup,
 };
 
 export const schemaRaw: TagDefinitionRaw<void> = {
   kind: TagKind.Raw,
+  body: LIQUID_RAW_BODY,
   parseLiquidInBody: false,
   parse: parseNoMarkup,
 };
 
 export const styleRaw: TagDefinitionRaw<void> = {
   kind: TagKind.Raw,
+  body: LIQUID_BLOCK_BODY,
   parseLiquidInBody: true,
   parse: parseNoMarkup,
 };
 
 export const stylesheetRaw: TagDefinitionRaw<void> = {
   kind: TagKind.Raw,
+  body: LIQUID_RAW_BODY,
   parseLiquidInBody: true,
   parse: parseNoMarkup,
 };
diff --git a/specs/parser/liquid-lines.yml b/specs/parser/liquid-lines.yml
index 6abbf566a..830b7de80 100644
--- a/specs/parser/liquid-lines.yml
+++ b/specs/parser/liquid-lines.yml
@@ -1931,7 +1931,7 @@ cases:
                         comment
                         inner
                         endcomment
-  - name: should carve out a nested raw so a literal endcomment inside it does not close early
+  - name: should leave a comment unclosed when a raw inside it cannot close in {% liquid %}
     source: |-
       {% liquid
       comment
@@ -1961,6 +1961,14 @@ cases:
       children:
         - type: LiquidTag
           name: liquid
+          markup: |-
+            comment
+            before
+            raw
+            endcomment
+            endraw
+            after
+            endcomment
           whitespaceStart: ""
           whitespaceEnd: ""
           blockStartPosition:
@@ -1998,6 +2006,69 @@ cases:
               after
               endcomment
               %}
+          reason: Unclosed raw tag 'comment' in {% liquid %} block
+  - name: should close a nested comment at the endcomment of its outer level
+    source: |-
+      {% liquid
+      comment
+      comment
+      endcomment
+      echo 'X'
+      endcomment
+      echo 'Y'
+      %}
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          {% liquid
+          comment
+          comment
+          endcomment
+          echo 'X'
+          endcomment
+          echo 'Y'
+          %}
+      children:
+        - type: LiquidTag
+          name: liquid
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          blockStartPosition:
+            start: [0, 0]
+            text: |-
+              {% liquid
+              comment
+              comment
+              endcomment
+              echo 'X'
+              endcomment
+              echo 'Y'
+              %}
+          markupPosition:
+            start: [0, 9]
+            text: |
+              
+              comment
+              comment
+              endcomment
+              echo 'X'
+              endcomment
+              echo 'Y'
+          position:
+            start: [0, 0]
+            text: |-
+              {% liquid
+              comment
+              comment
+              endcomment
+              echo 'X'
+              endcomment
+              echo 'Y'
+              %}
           markup:
             - type: LiquidRawTag
               name: comment
@@ -2008,48 +2079,355 @@ cases:
               delimiterWhitespaceStart: ""
               delimiterWhitespaceEnd: ""
               blockStartPosition: { start: [1, 0], text: comment }
-              blockEndPosition: { start: [7, 0], text: endcomment }
+              blockEndPosition: { start: [5, 0], text: endcomment }
               position:
                 start: [1, 0]
                 text: |-
                   comment
-                  before
-                  raw
+                  comment
                   endcomment
-                  endraw
-                  after
+                  echo 'X'
                   endcomment
               body:
                 type: RawMarkup
                 kind: text
                 value: |
-                  before
-                  raw
+                  comment
                   endcomment
-                  endraw
-                  after
+                  echo 'X'
                 position:
                   start: [1, 7]
                   text: |
                     
-                    before
-                    raw
+                    comment
                     endcomment
-                    endraw
-                    after
+                    echo 'X'
                 nodes:
                   - type: TextNode
                     value: |-
-                      before
-                      raw
+                      comment
                       endcomment
-                      endraw
-                      after
+                      echo 'X'
                     position:
                       start: [2, 0]
                       text: |-
-                        before
-                        raw
+                        comment
                         endcomment
-                        endraw
-                        after
+                        echo 'X'
+            - type: LiquidTag
+              name: echo
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              blockStartPosition: { start: [6, 0], text: echo 'Y' }
+              markupPosition: { start: [6, 5], text: "'Y'" }
+              position: { start: [6, 0], text: echo 'Y' }
+              markup:
+                type: LiquidVariable
+                rawSource: "'Y'"
+                position: { start: [6, 5], text: "'Y'" }
+                expression:
+                  type: String
+                  single: true
+                  value: Y
+                  position: { start: [6, 5], text: "'Y'" }
+                filters: []
+  - name: should not count a comment line indented with non-ASCII whitespace
+    source: |-
+      {% liquid
+      comment
+       comment
+      endcomment
+      echo 'Y'
+      %}
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          {% liquid
+          comment
+           comment
+          endcomment
+          echo 'Y'
+          %}
+      children:
+        - type: LiquidTag
+          name: liquid
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          blockStartPosition:
+            start: [0, 0]
+            text: |-
+              {% liquid
+              comment
+               comment
+              endcomment
+              echo 'Y'
+              %}
+          markupPosition:
+            start: [0, 9]
+            text: |
+              
+              comment
+               comment
+              endcomment
+              echo 'Y'
+          position:
+            start: [0, 0]
+            text: |-
+              {% liquid
+              comment
+               comment
+              endcomment
+              echo 'Y'
+              %}
+          markup:
+            - type: LiquidRawTag
+              name: comment
+              markup: ""
+              markupPosition: { start: [1, 7], text: "" }
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              delimiterWhitespaceStart: ""
+              delimiterWhitespaceEnd: ""
+              blockStartPosition: { start: [1, 0], text: comment }
+              blockEndPosition: { start: [3, 0], text: endcomment }
+              position:
+                start: [1, 0]
+                text: |-
+                  comment
+                   comment
+                  endcomment
+              body:
+                type: RawMarkup
+                kind: text
+                value: |
+                   comment
+                position:
+                  start: [1, 7]
+                  text: |
+                    
+                     comment
+                nodes:
+                  - type: TextNode
+                    value: comment
+                    position: { start: [2, 1], text: comment }
+            - type: LiquidTag
+              name: echo
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              blockStartPosition: { start: [4, 0], text: echo 'Y' }
+              markupPosition: { start: [4, 5], text: "'Y'" }
+              position: { start: [4, 0], text: echo 'Y' }
+              markup:
+                type: LiquidVariable
+                rawSource: "'Y'"
+                position: { start: [4, 5], text: "'Y'" }
+                expression:
+                  type: String
+                  single: true
+                  value: Y
+                  position: { start: [4, 5], text: "'Y'" }
+                filters: []
+  - name: should not count a raw line indented with non-ASCII whitespace
+    source: |-
+      {% liquid
+      comment
+       raw
+      endcomment
+      echo 'Y'
+      %}
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          {% liquid
+          comment
+           raw
+          endcomment
+          echo 'Y'
+          %}
+      children:
+        - type: LiquidTag
+          name: liquid
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          blockStartPosition:
+            start: [0, 0]
+            text: |-
+              {% liquid
+              comment
+               raw
+              endcomment
+              echo 'Y'
+              %}
+          markupPosition:
+            start: [0, 9]
+            text: |
+              
+              comment
+               raw
+              endcomment
+              echo 'Y'
+          position:
+            start: [0, 0]
+            text: |-
+              {% liquid
+              comment
+               raw
+              endcomment
+              echo 'Y'
+              %}
+          markup:
+            - type: LiquidRawTag
+              name: comment
+              markup: ""
+              markupPosition: { start: [1, 7], text: "" }
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              delimiterWhitespaceStart: ""
+              delimiterWhitespaceEnd: ""
+              blockStartPosition: { start: [1, 0], text: comment }
+              blockEndPosition: { start: [3, 0], text: endcomment }
+              position:
+                start: [1, 0]
+                text: |-
+                  comment
+                   raw
+                  endcomment
+              body:
+                type: RawMarkup
+                kind: text
+                value: |
+                   raw
+                position:
+                  start: [1, 7]
+                  text: |
+                    
+                     raw
+                nodes:
+                  - type: TextNode
+                    value: raw
+                    position: { start: [2, 1], text: raw }
+            - type: LiquidTag
+              name: echo
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              blockStartPosition: { start: [4, 0], text: echo 'Y' }
+              markupPosition: { start: [4, 5], text: "'Y'" }
+              position: { start: [4, 0], text: echo 'Y' }
+              markup:
+                type: LiquidVariable
+                rawSource: "'Y'"
+                position: { start: [4, 5], text: "'Y'" }
+                expression:
+                  type: String
+                  single: true
+                  value: Y
+                  position: { start: [4, 5], text: "'Y'" }
+                filters: []
+  - name: should not count an endcomment line indented with non-ASCII whitespace
+    source: |-
+      {% liquid
+      comment
+       endcomment
+      endcomment
+      echo 'Y'
+      %}
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          {% liquid
+          comment
+           endcomment
+          endcomment
+          echo 'Y'
+          %}
+      children:
+        - type: LiquidTag
+          name: liquid
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          blockStartPosition:
+            start: [0, 0]
+            text: |-
+              {% liquid
+              comment
+               endcomment
+              endcomment
+              echo 'Y'
+              %}
+          markupPosition:
+            start: [0, 9]
+            text: |
+              
+              comment
+               endcomment
+              endcomment
+              echo 'Y'
+          position:
+            start: [0, 0]
+            text: |-
+              {% liquid
+              comment
+               endcomment
+              endcomment
+              echo 'Y'
+              %}
+          markup:
+            - type: LiquidRawTag
+              name: comment
+              markup: ""
+              markupPosition: { start: [1, 7], text: "" }
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              delimiterWhitespaceStart: ""
+              delimiterWhitespaceEnd: ""
+              blockStartPosition: { start: [1, 0], text: comment }
+              blockEndPosition: { start: [3, 0], text: endcomment }
+              position:
+                start: [1, 0]
+                text: |-
+                  comment
+                   endcomment
+                  endcomment
+              body:
+                type: RawMarkup
+                kind: text
+                value: |
+                   endcomment
+                position:
+                  start: [1, 7]
+                  text: |
+                    
+                     endcomment
+                nodes:
+                  - type: TextNode
+                    value: endcomment
+                    position: { start: [2, 1], text: endcomment }
+            - type: LiquidTag
+              name: echo
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              blockStartPosition: { start: [4, 0], text: echo 'Y' }
+              markupPosition: { start: [4, 5], text: "'Y'" }
+              position: { start: [4, 0], text: echo 'Y' }
+              markup:
+                type: LiquidVariable
+                rawSource: "'Y'"
+                position: { start: [4, 5], text: "'Y'" }
+                expression:
+                  type: String
+                  single: true
+                  value: Y
+                  position: { start: [4, 5], text: "'Y'" }
+                filters: []
diff --git a/specs/parser/liquid-raw.yml b/specs/parser/liquid-raw.yml
index 31febb4d9..ce2b72584 100644
--- a/specs/parser/liquid-raw.yml
+++ b/specs/parser/liquid-raw.yml
@@ -1725,46 +1725,46 @@ cases:
               value: ok
               position: { start: [0, 56], text: ok }
   - name: does not duplicate a straddling {{ into both a Liquid-in-body raw body and a sibling
-    source: "{% style %}{{ invalid {% endstyle %}{{ 1 }}"
+    source: "{% stylesheet %}{{ invalid {% endstylesheet %}{{ 1 }}"
     parse: [html]
     ast:
       type: Document
       name: "#document"
-      position: { start: [0, 0], text: "{% style %}{{ invalid {% endstyle %}{{ 1 }}" }
+      position: { start: [0, 0], text: "{% stylesheet %}{{ invalid {% endstylesheet %}{{ 1 }}" }
       children:
         - type: LiquidRawTag
-          name: style
+          name: stylesheet
           markup: ""
-          markupPosition: { start: [0, 9], text: "" }
+          markupPosition: { start: [0, 14], text: "" }
           whitespaceStart: ""
           whitespaceEnd: ""
           delimiterWhitespaceStart: ""
           delimiterWhitespaceEnd: ""
-          blockStartPosition: { start: [0, 0], text: "{% style %}" }
-          blockEndPosition: { start: [0, 22], text: "{% endstyle %}" }
-          position: { start: [0, 0], text: "{% style %}{{ invalid {% endstyle %}" }
+          blockStartPosition: { start: [0, 0], text: "{% stylesheet %}" }
+          blockEndPosition: { start: [0, 27], text: "{% endstylesheet %}" }
+          position: { start: [0, 0], text: "{% stylesheet %}{{ invalid {% endstylesheet %}" }
           body:
             type: RawMarkup
             kind: text
             value: "{{ invalid "
-            position: { start: [0, 11], text: "{{ invalid " }
+            position: { start: [0, 16], text: "{{ invalid " }
             nodes:
               - type: TextNode
                 value: "{{ invalid"
-                position: { start: [0, 11], text: "{{ invalid" }
+                position: { start: [0, 16], text: "{{ invalid" }
         - type: LiquidVariableOutput
           whitespaceStart: ""
           whitespaceEnd: ""
-          markupPosition: { start: [0, 38], text: " 1 " }
-          position: { start: [0, 36], text: "{{ 1 }}" }
+          markupPosition: { start: [0, 48], text: " 1 " }
+          position: { start: [0, 46], text: "{{ 1 }}" }
           markup:
             type: LiquidVariable
             rawSource: "1"
-            position: { start: [0, 39], text: "1 " }
+            position: { start: [0, 49], text: "1 " }
             expression:
               type: Number
               value: "1"
-              position: { start: [0, 39], text: "1" }
+              position: { start: [0, 49], text: "1" }
             filters: []
   - name: does not let a decoy endcommentXXXXX close the comment; only the real endcomment does
     source: |-
@@ -1952,3 +1952,925 @@ cases:
         - type: TextNode
           value: <
           position: { start: [0, 34], text: < }
+  - name: closes a raw tag on an end tag with extra strings, as Liquid::Raw does
+    source: "{% raw %}x{% endraw xyz %}Y"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% raw %}x{% endraw xyz %}Y" }
+      children:
+        - type: LiquidRawTag
+          name: raw
+          markup: ""
+          markupPosition: { start: [0, 7], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% raw %}" }
+          blockEndPosition: { start: [0, 10], text: "{% endraw xyz %}" }
+          position: { start: [0, 0], text: "{% raw %}x{% endraw xyz %}" }
+          body:
+            type: RawMarkup
+            kind: text
+            value: x
+            position: { start: [0, 9], text: x }
+            nodes:
+              - type: TextNode
+                value: x
+                position: { start: [0, 9], text: x }
+        - type: TextNode
+          value: Y
+          position: { start: [0, 26], text: Y }
+  - name: keeps text before the end tag in the same token in a raw body
+    source: "{% raw %}x{{ a {% endraw %}Y"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% raw %}x{{ a {% endraw %}Y" }
+      children:
+        - type: LiquidRawTag
+          name: raw
+          markup: ""
+          markupPosition: { start: [0, 7], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% raw %}" }
+          blockEndPosition: { start: [0, 15], text: "{% endraw %}" }
+          position: { start: [0, 0], text: "{% raw %}x{{ a {% endraw %}" }
+          body:
+            type: RawMarkup
+            kind: text
+            value: "x{{ a "
+            position: { start: [0, 9], text: "x{{ a " }
+            nodes:
+              - type: TextNode
+                value: x{{ a
+                position: { start: [0, 9], text: "x{{ a" }
+        - type: TextNode
+          value: Y
+          position: { start: [0, 27], text: Y }
+  - name: does not nest a raw tag inside a raw tag
+    source: "{% raw %}{% raw %}x{% endraw %}Y{% endraw %}"
+    parse: [html]
+    error:
+      message: Attempting to close LiquidTag 'raw' before it was opened without a matching 'raw'
+      start: [0, 32]
+      text: "{% endraw %"
+  - name: rejects a doc tag nested in a doc tag, as Liquid::Doc does
+    source: "{% doc %}{% doc %}{% enddoc %}{% enddoc %}"
+    parse: [html]
+    error:
+      message: Attempting to end parsing before LiquidRawTag 'doc' was closed
+      start: [0, 0]
+      text: "{% doc %}"
+  - name: nests a style tag and skips raw bodies inside it, as Liquid::Block does
+    source: "{% style %}a{% style %}b{% endstyle %}{% comment %}{% endstyle %}{% endcomment %}c{% endstyle %}Y"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% style %}a{% style %}b{% endstyle %}{% comment %}{% endstyle %}{% endcomment %}c{% endstyle %}Y" }
+      children:
+        - type: LiquidRawTag
+          name: style
+          markup: ""
+          markupPosition: { start: [0, 9], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% style %}" }
+          blockEndPosition: { start: [0, 82], text: "{% endstyle %}" }
+          position: { start: [0, 0], text: "{% style %}a{% style %}b{% endstyle %}{% comment %}{% endstyle %}{% endcomment %}c{% endstyle %}" }
+          body:
+            type: RawMarkup
+            kind: text
+            value: a{% style %}b{% endstyle %}{% comment %}{% endstyle %}{% endcomment %}c
+            position: { start: [0, 11], text: "a{% style %}b{% endstyle %}{% comment %}{% endstyle %}{% endcomment %}c" }
+            nodes:
+              - type: TextNode
+                value: a
+                position: { start: [0, 11], text: a }
+              - type: LiquidRawTag
+                name: style
+                markup: ""
+                markupPosition: { start: [0, 21], text: "" }
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                delimiterWhitespaceStart: ""
+                delimiterWhitespaceEnd: ""
+                blockStartPosition: { start: [0, 12], text: "{% style %}" }
+                blockEndPosition: { start: [0, 24], text: "{% endstyle %}" }
+                position: { start: [0, 12], text: "{% style %}b{% endstyle %}" }
+                body:
+                  type: RawMarkup
+                  kind: css
+                  value: b
+                  position: { start: [0, 23], text: b }
+                  nodes:
+                    - type: TextNode
+                      value: b
+                      position: { start: [0, 23], text: b }
+              - type: LiquidRawTag
+                name: comment
+                markup: ""
+                markupPosition: { start: [0, 49], text: "" }
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                delimiterWhitespaceStart: ""
+                delimiterWhitespaceEnd: ""
+                blockStartPosition: { start: [0, 38], text: "{% comment %}" }
+                blockEndPosition: { start: [0, 65], text: "{% endcomment %}" }
+                position: { start: [0, 38], text: "{% comment %}{% endstyle %}{% endcomment %}" }
+                body:
+                  type: RawMarkup
+                  kind: text
+                  value: "{% endstyle %}"
+                  position: { start: [0, 51], text: "{% endstyle %}" }
+                  nodes:
+                    - type: TextNode
+                      value: "{% endstyle %}"
+                      position: { start: [0, 51], text: "{% endstyle %}" }
+              - type: TextNode
+                value: c
+                position: { start: [0, 81], text: c }
+        - type: TextNode
+          value: Y
+          position: { start: [0, 96], text: Y }
+  - name: does not parse nodes inside a comment
+    source: |-
+      {% comment %}
+        {% if true %}
+        {% if ... %}
+        {%- for ? -%}
+        {% while true %}
+        {%
+          unless if
+        %}
+        {% endcase %}
+      {% endcomment %}
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          {% comment %}
+            {% if true %}
+            {% if ... %}
+            {%- for ? -%}
+            {% while true %}
+            {%
+              unless if
+            %}
+            {% endcase %}
+          {% endcomment %}
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition: { start: [9, 0], text: "{% endcomment %}" }
+          position:
+            start: [0, 0]
+            text: |-
+              {% comment %}
+                {% if true %}
+                {% if ... %}
+                {%- for ? -%}
+                {% while true %}
+                {%
+                  unless if
+                %}
+                {% endcase %}
+              {% endcomment %}
+          body:
+            type: RawMarkup
+            kind: text
+            value: |2
+              
+                {% if true %}
+                {% if ... %}
+                {%- for ? -%}
+                {% while true %}
+                {%
+                  unless if
+                %}
+                {% endcase %}
+            position:
+              start: [0, 13]
+              text: |2
+                
+                  {% if true %}
+                  {% if ... %}
+                  {%- for ? -%}
+                  {% while true %}
+                  {%
+                    unless if
+                  %}
+                  {% endcase %}
+            nodes:
+              - type: TextNode
+                value: |-
+                  {% if true %}
+                    {% if ... %}
+                    {%- for ? -%}
+                    {% while true %}
+                    {%
+                      unless if
+                    %}
+                    {% endcase %}
+                position:
+                  start: [1, 2]
+                  text: |-
+                    {% if true %}
+                      {% if ... %}
+                      {%- for ? -%}
+                      {% while true %}
+                      {%
+                        unless if
+                      %}
+                      {% endcase %}
+  - name: allows unclosed tags in a comment
+    source: |-
+      {% comment %}
+        {% if true %}
+      {% endcomment %}
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          {% comment %}
+            {% if true %}
+          {% endcomment %}
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition: { start: [2, 0], text: "{% endcomment %}" }
+          position:
+            start: [0, 0]
+            text: |-
+              {% comment %}
+                {% if true %}
+              {% endcomment %}
+          body:
+            type: RawMarkup
+            kind: text
+            value: |2
+              
+                {% if true %}
+            position:
+              start: [0, 13]
+              text: |2
+                
+                  {% if true %}
+            nodes:
+              - type: TextNode
+                value: "{% if true %}"
+                position: { start: [1, 2], text: "{% if true %}" }
+  - name: allows an open tag that runs into a nested comment
+    source: |-
+      {% comment %}
+        {% assign a = 123 {% comment %}
+      {% endcomment %}
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          {% comment %}
+            {% assign a = 123 {% comment %}
+          {% endcomment %}
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition: { start: [2, 0], text: "{% endcomment %}" }
+          position:
+            start: [0, 0]
+            text: |-
+              {% comment %}
+                {% assign a = 123 {% comment %}
+              {% endcomment %}
+          body:
+            type: RawMarkup
+            kind: text
+            value: |2
+              
+                {% assign a = 123 {% comment %}
+            position:
+              start: [0, 13]
+              text: |2
+                
+                  {% assign a = 123 {% comment %}
+            nodes:
+              - type: TextNode
+                value: "{% assign a = 123 {% comment %}"
+                position: { start: [1, 2], text: "{% assign a = 123 {% comment %}" }
+  - name: rejects an open tag that runs into the endcomment
+    source: |-
+      {% comment %}
+        {% assign foo = "1"
+      {% endcomment %}
+    parse: [html]
+    error:
+      message: Attempting to end parsing before LiquidRawTag 'comment' was closed
+      start: [0, 0]
+      text: "{% comment %}"
+  - name: rejects an open tag that runs into a nested endcomment
+    source: |-
+      {% comment %}
+        {% comment %}
+          {% invalid
+        {% endcomment %}
+      {% endcomment %}
+    parse: [html]
+    error:
+      message: Attempting to end parsing before LiquidRawTag 'comment' was closed
+      start: [0, 0]
+      text: "{% comment %}"
+  - name: rejects an open variable that runs into the endcomment
+    source: |-
+      {% comment %}
+      {% {{ {%- endcomment %}
+    parse: [html]
+    error:
+      message: Attempting to end parsing before LiquidRawTag 'comment' was closed
+      start: [0, 0]
+      text: "{% comment %}"
+  - name: closes child comment tags
+    source: |-
+      {% comment %}
+        {% comment %}
+          {% comment %}{%    endcomment     %}
+        {% endcomment %}
+      {% endcomment %}
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          {% comment %}
+            {% comment %}
+              {% comment %}{%    endcomment     %}
+            {% endcomment %}
+          {% endcomment %}
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition: { start: [4, 0], text: "{% endcomment %}" }
+          position:
+            start: [0, 0]
+            text: |-
+              {% comment %}
+                {% comment %}
+                  {% comment %}{%    endcomment     %}
+                {% endcomment %}
+              {% endcomment %}
+          body:
+            type: RawMarkup
+            kind: text
+            value: |2
+              
+                {% comment %}
+                  {% comment %}{%    endcomment     %}
+                {% endcomment %}
+            position:
+              start: [0, 13]
+              text: |2
+                
+                  {% comment %}
+                    {% comment %}{%    endcomment     %}
+                  {% endcomment %}
+            nodes:
+              - type: TextNode
+                value: |-
+                  {% comment %}
+                      {% comment %}{%    endcomment     %}
+                    {% endcomment %}
+                position:
+                  start: [1, 2]
+                  text: |-
+                    {% comment %}
+                        {% comment %}{%    endcomment     %}
+                      {% endcomment %}
+  - name: rejects an unclosed child comment tag
+    source: |-
+      {% comment %}
+        {% comment %}
+          {% comment %}
+        {% endcomment %}
+      {% endcomment %}
+    parse: [html]
+    error:
+      message: Attempting to end parsing before LiquidRawTag 'comment' was closed
+      start: [0, 0]
+      text: "{% comment %}"
+  - name: skips a closed child raw tag in a comment
+    source: |-
+      {% comment %}
+        {% raw %}
+          {% endcomment %}
+        {% endraw %}
+      {% endcomment %}
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          {% comment %}
+            {% raw %}
+              {% endcomment %}
+            {% endraw %}
+          {% endcomment %}
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition: { start: [4, 0], text: "{% endcomment %}" }
+          position:
+            start: [0, 0]
+            text: |-
+              {% comment %}
+                {% raw %}
+                  {% endcomment %}
+                {% endraw %}
+              {% endcomment %}
+          body:
+            type: RawMarkup
+            kind: text
+            value: |2
+              
+                {% raw %}
+                  {% endcomment %}
+                {% endraw %}
+            position:
+              start: [0, 13]
+              text: |2
+                
+                  {% raw %}
+                    {% endcomment %}
+                  {% endraw %}
+            nodes:
+              - type: TextNode
+                value: |-
+                  {% raw %}
+                      {% endcomment %}
+                    {% endraw %}
+                position:
+                  start: [1, 2]
+                  text: |-
+                    {% raw %}
+                        {% endcomment %}
+                      {% endraw %}
+  - name: rejects an unclosed child raw tag in a comment
+    source: |-
+      {% comment %}
+        {% raw %}
+        {% endcomment %}
+      {% endcomment %}
+    parse: [html]
+    error:
+      message: Attempting to end parsing before LiquidRawTag 'comment' was closed
+      start: [0, 0]
+      text: "{% comment %}"
+  - name: closes a nested comment on an endcomment with extra strings
+    source: |-
+      {% comment %}
+        {% comment %}
+        {% endcomment
+        {% if true %}
+        {% endif %}
+      {% endcomment %}
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          {% comment %}
+            {% comment %}
+            {% endcomment
+            {% if true %}
+            {% endif %}
+          {% endcomment %}
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition: { start: [5, 0], text: "{% endcomment %}" }
+          position:
+            start: [0, 0]
+            text: |-
+              {% comment %}
+                {% comment %}
+                {% endcomment
+                {% if true %}
+                {% endif %}
+              {% endcomment %}
+          body:
+            type: RawMarkup
+            kind: text
+            value: |2
+              
+                {% comment %}
+                {% endcomment
+                {% if true %}
+                {% endif %}
+            position:
+              start: [0, 13]
+              text: |2
+                
+                  {% comment %}
+                  {% endcomment
+                  {% if true %}
+                  {% endif %}
+            nodes:
+              - type: TextNode
+                value: |-
+                  {% comment %}
+                    {% endcomment
+                    {% if true %}
+                    {% endif %}
+                position:
+                  start: [1, 2]
+                  text: |-
+                    {% comment %}
+                      {% endcomment
+                      {% if true %}
+                      {% endif %}
+  - name: opens and closes a nested comment with extra strings
+    source: |-
+      {% comment %}
+        {% comment
+          {% assign foo = 1 %}
+        {% endcomment
+        {% assign foo = 1 %}
+      {% endcomment %}
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          {% comment %}
+            {% comment
+              {% assign foo = 1 %}
+            {% endcomment
+            {% assign foo = 1 %}
+          {% endcomment %}
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition: { start: [5, 0], text: "{% endcomment %}" }
+          position:
+            start: [0, 0]
+            text: |-
+              {% comment %}
+                {% comment
+                  {% assign foo = 1 %}
+                {% endcomment
+                {% assign foo = 1 %}
+              {% endcomment %}
+          body:
+            type: RawMarkup
+            kind: text
+            value: |2
+              
+                {% comment
+                  {% assign foo = 1 %}
+                {% endcomment
+                {% assign foo = 1 %}
+            position:
+              start: [0, 13]
+              text: |2
+                
+                  {% comment
+                    {% assign foo = 1 %}
+                  {% endcomment
+                  {% assign foo = 1 %}
+            nodes:
+              - type: TextNode
+                value: |-
+                  {% comment
+                      {% assign foo = 1 %}
+                    {% endcomment
+                    {% assign foo = 1 %}
+                position:
+                  start: [1, 2]
+                  text: |-
+                    {% comment
+                        {% assign foo = 1 %}
+                      {% endcomment
+                      {% assign foo = 1 %}
+  - name: closes a comment on an endcomment followed by a space and extra strings
+    source: "{% comment %}123{% endcomment xyz %}"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% comment %}123{% endcomment xyz %}" }
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition: { start: [0, 16], text: "{% endcomment xyz %}" }
+          position: { start: [0, 0], text: "{% comment %}123{% endcomment xyz %}" }
+          body:
+            type: RawMarkup
+            kind: text
+            value: "123"
+            position: { start: [0, 13], text: "123" }
+            nodes:
+              - type: TextNode
+                value: "123"
+                position: { start: [0, 13], text: "123" }
+  - name: closes a comment on an endcomment followed by a tab and extra strings
+    source: "{% comment %}123{% endcomment\txyz %}"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% comment %}123{% endcomment\txyz %}" }
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition: { start: [0, 16], text: "{% endcomment\txyz %}" }
+          position: { start: [0, 0], text: "{% comment %}123{% endcomment\txyz %}" }
+          body:
+            type: RawMarkup
+            kind: text
+            value: "123"
+            position: { start: [0, 13], text: "123" }
+            nodes:
+              - type: TextNode
+                value: "123"
+                position: { start: [0, 13], text: "123" }
+  - name: closes a comment on an endcomment followed by a newline and extra strings
+    source: |-
+      {% comment %}123{% endcomment
+      xyz %}
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          {% comment %}123{% endcomment
+          xyz %}
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition:
+            start: [0, 16]
+            text: |-
+              {% endcomment
+              xyz %}
+          position:
+            start: [0, 0]
+            text: |-
+              {% comment %}123{% endcomment
+              xyz %}
+          body:
+            type: RawMarkup
+            kind: text
+            value: "123"
+            position: { start: [0, 13], text: "123" }
+            nodes:
+              - type: TextNode
+                value: "123"
+                position: { start: [0, 13], text: "123" }
+  - name: closes a comment on an endcomment whose extra strings repeat endcomment
+    source: |-
+      {% comment %}123{% endcomment
+         xyz  endcomment %}
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          {% comment %}123{% endcomment
+             xyz  endcomment %}
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition:
+            start: [0, 16]
+            text: |-
+              {% endcomment
+                 xyz  endcomment %}
+          position:
+            start: [0, 0]
+            text: |-
+              {% comment %}123{% endcomment
+                 xyz  endcomment %}
+          body:
+            type: RawMarkup
+            kind: text
+            value: "123"
+            position: { start: [0, 13], text: "123" }
+            nodes:
+              - type: TextNode
+                value: "123"
+                position: { start: [0, 13], text: "123" }
+  - name: keeps whitespace control on a comment
+    source: "{%- comment -%}123{%- endcomment -%}"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{%- comment -%}123{%- endcomment -%}" }
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 12], text: "" }
+          whitespaceStart: "-"
+          whitespaceEnd: "-"
+          delimiterWhitespaceStart: "-"
+          delimiterWhitespaceEnd: "-"
+          blockStartPosition: { start: [0, 0], text: "{%- comment -%}" }
+          blockEndPosition: { start: [0, 18], text: "{%- endcomment -%}" }
+          position: { start: [0, 0], text: "{%- comment -%}123{%- endcomment -%}" }
+          body:
+            type: RawMarkup
+            kind: text
+            value: "123"
+            position: { start: [0, 15], text: "123" }
+            nodes:
+              - type: TextNode
+                value: "123"
+                position: { start: [0, 15], text: "123" }
+  - name: keeps the outer whitespace control on a nested comment
+    source: "{% comment %}{%- comment -%}inner{%- endcomment -%}{% endcomment -%}"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% comment %}{%- comment -%}inner{%- endcomment -%}{% endcomment -%}" }
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: "-"
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition: { start: [0, 51], text: "{% endcomment -%}" }
+          position: { start: [0, 0], text: "{% comment %}{%- comment -%}inner{%- endcomment -%}{% endcomment -%}" }
+          body:
+            type: RawMarkup
+            kind: text
+            value: "{%- comment -%}inner{%- endcomment -%}"
+            position: { start: [0, 13], text: "{%- comment -%}inner{%- endcomment -%}" }
+            nodes:
+              - type: TextNode
+                value: "{%- comment -%}inner{%- endcomment -%}"
+                position: { start: [0, 13], text: "{%- comment -%}inner{%- endcomment -%}" }
+  - name: parses the markup that follows a nested comment
+    source: "{% comment %}a{% comment %}b{% endcomment %}c{% endcomment %}<title>{{ x }}</title>"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% comment %}a{% comment %}b{% endcomment %}c{% endcomment %}<title>{{ x }}</title>" }
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition: { start: [0, 45], text: "{% endcomment %}" }
+          position: { start: [0, 0], text: "{% comment %}a{% comment %}b{% endcomment %}c{% endcomment %}" }
+          body:
+            type: RawMarkup
+            kind: text
+            value: a{% comment %}b{% endcomment %}c
+            position: { start: [0, 13], text: "a{% comment %}b{% endcomment %}c" }
+            nodes:
+              - type: TextNode
+                value: a{% comment %}b{% endcomment %}c
+                position: { start: [0, 13], text: "a{% comment %}b{% endcomment %}c" }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 61], text: <title> }
+          blockEndPosition: { start: [0, 75], text: </title> }
+          position: { start: [0, 61], text: "<title>{{ x }}</title>" }
+          name:
+            - type: TextNode
+              value: title
+              position: { start: [0, 62], text: title }
+          attributes: []
+          children:
+            - type: LiquidVariableOutput
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              markupPosition: { start: [0, 70], text: " x " }
+              position: { start: [0, 68], text: "{{ x }}" }
+              markup:
+                type: LiquidVariable
+                rawSource: x
+                position: { start: [0, 71], text: "x " }
+                expression:
+                  type: VariableLookup
+                  name: x
+                  position: { start: [0, 71], text: x }
+                  lookups: []
+                  lookupModes: []
+                filters: []

From 81bf98bf06ce8ba096359f4bb85398704182a0e4 Mon Sep 17 00:00:00 2001
From: Philippe Collin <philippe.collin@shopify.com>
Date: Fri, 30 Oct 2026 11:13:27 -0400
Subject: [PATCH 09/20] Complete block arguments through the BlockArgument type

Block and section arguments are now one BlockArgument type, so the completion
params narrow on the argument's value rather than on the argument.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../completions/params/LiquidCompletionParams.ts   | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/packages/theme-language-server-common/src/completions/params/LiquidCompletionParams.ts b/packages/theme-language-server-common/src/completions/params/LiquidCompletionParams.ts
index 2b6b9372e..e0bcc5f3c 100644
--- a/packages/theme-language-server-common/src/completions/params/LiquidCompletionParams.ts
+++ b/packages/theme-language-server-common/src/completions/params/LiquidCompletionParams.ts
@@ -1,7 +1,9 @@
 import {
+  BlockArgument,
   BlockMarkup,
   findErrorNodeAtOffset,
   LiquidHtmlNode,
+  LiquidNamedArgument,
   LiquidTag,
   MarkupToken,
   MarkupTokenType,
@@ -746,7 +748,7 @@ function findCompletionNode(
       case NodeTypes.SectionMarkup: {
         if (isNotEmpty(current.args)) {
           const arg = last(current.args);
-          finder.current = isBlockArrayArgument(arg) ? arg.value.elements.at(-1) : arg;
+          finder.current = blockArgumentNode(arg);
         } else if (isCovered(cursor, current.name.position)) {
           finder.current = current.name;
         }
@@ -1835,7 +1837,7 @@ function blockMarkupChild(
   }
 
   if (coveredArg) {
-    return isBlockArrayArgument(coveredArg) ? coveredArg.value.elements.at(-1) : coveredArg;
+    return blockArgumentNode(coveredArg);
   }
 
   if (isCovered(cursor, markup.name.position)) return markup.name;
@@ -2401,8 +2403,12 @@ function isDefined<T>(x: T | undefined): x is T {
   return x !== undefined;
 }
 
-function isBlockArrayArgument(arg: any): arg is { value: { elements: LiquidHtmlNode[] } } {
-  return arg.value?.type === 'BlockArrayLiteral';
+// The node to complete in a block argument: its last array element, or the argument itself,
+// which is a LiquidNamedArgument once its value isn't an array literal.
+function blockArgumentNode(arg: BlockArgument): LiquidHtmlNode | undefined {
+  return arg.value.type === 'BlockArrayLiteral'
+    ? arg.value.elements.at(-1)
+    : (arg as LiquidNamedArgument);
 }
 
 function last<T = any>(x: NonEmptyArray<T>): T {

From ca054cfec3a2f756fe562140c520e352012547e5 Mon Sep 17 00:00:00 2001
From: Philippe Collin <philippe.collin@shopify.com>
Date: Fri, 30 Oct 2026 11:15:25 -0400
Subject: [PATCH 10/20] Expect raw tag syntax errors where the parser now
 reports them

The parser now closes {% raw %} and {% doc %} on an end tag with extra strings,
as Liquid does, so a later unclosed tag is the one reported. It also rejects a
comment whose body Liquid's tokenizer runs past the endcomment, so
LiquidSyntaxError reports the parser's error at the comment's open tag.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 specs/checks/liquid-syntax-error.yml | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/specs/checks/liquid-syntax-error.yml b/specs/checks/liquid-syntax-error.yml
index 7685f9c3a..0257d29b7 100644
--- a/specs/checks/liquid-syntax-error.yml
+++ b/specs/checks/liquid-syntax-error.yml
@@ -1037,8 +1037,8 @@ cases:
     offenses:
       - file: snippets/test.liquid
         message: "Attempting to end parsing before LiquidRawTag 'doc' was closed"
-        start: [0, 0]
-        highlight: "{% doc %}"
+        start: [0, 32]
+        highlight: "{% doc %"
   - name: accepts later balanced doc blocks after accepted doc closing markup
     files:
       snippets/test.liquid: "{% doc %}content{% enddoc foo %}{% doc %}later{% enddoc %}"
@@ -1090,8 +1090,8 @@ cases:
     offenses:
       - file: snippets/test.liquid
         message: "Attempting to end parsing before LiquidRawTag 'raw' was closed"
-        start: [0, 0]
-        highlight: "{% raw %}"
+        start: [0, 26]
+        highlight: "{% raw %"
   - name: accepts later balanced raw blocks after accepted raw closing markup
     files:
       snippets/test.liquid: "{% raw %}c{% endraw foo %}{% raw %}later{% endraw %}"
@@ -1278,17 +1278,17 @@ cases:
       snippets/test.liquid: "{% comment %}this is {{{ not }}} valid{{ liquid{% endcomment %}"
     offenses:
       - file: snippets/test.liquid
-        message: "Liquid syntax error: 'comment' tag was never closed"
-        start: [0, 13]
-        highlight: this is {{{ not }}} valid{{ liquid
+        message: "Attempting to end parsing before LiquidRawTag 'comment' was closed"
+        start: [0, 0]
+        highlight: "{% comment %}"
   - name: "reports LiquidSyntaxError for Ruby-stricter comment raw bodies: {% comment %}this is {% if liquid{% endcomment %}"
     files:
       snippets/test.liquid: "{% comment %}this is {% if liquid{% endcomment %}"
     offenses:
       - file: snippets/test.liquid
-        message: "Liquid syntax error: 'comment' tag was never closed"
-        start: [0, 13]
-        highlight: this is {% if liquid
+        message: "Attempting to end parsing before LiquidRawTag 'comment' was closed"
+        start: [0, 0]
+        highlight: "{% comment %}"
   - name: produces no diagnostics for inert closed Liquid tags inside comment bodies
     files:
       snippets/test.liquid: "{% comment %}{% if %}{% endcomment %}"

From 3b427704d12835e65a31efb5d4014cb2062ad680 Mon Sep 17 00:00:00 2001
From: River <river@shopify.com>
Date: Wed, 30 Sep 2026 16:31:13 +0000
Subject: [PATCH 11/20] Add a pairDanglingCloseTags option for branch-opened
 elements

Themes often open an element in each branch of a conditional and close it
once after the conditional:

  {% if a %}<div class="x">{% else %}<div class="y">{% endif %}
    {{ content_for_layout }}
  </div>

Liquid writes this as text, so Shopify renders it, but the parser matched the
close tag against the enclosing element and threw a few tags later.

With the new pairDanglingCloseTags option, off by default, such a close tag
becomes an HtmlDanglingMarkerClose when an earlier if, unless or case in the
same scope leaves an element of that name open on every path.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../liquid-html-parser/specs/architecture.md  |   2 +
 packages/liquid-html-parser/src/ast.ts        |  14 ++
 .../document/branch-opened-elements.test.ts   | 178 ++++++++++++++++++
 .../src/document/branch-opened-elements.ts    |  76 ++++++++
 .../liquid-html-parser/src/document/html.ts   |  27 +++
 .../src/document/liquid-blocks.ts             |   5 +-
 .../liquid-html-parser/src/document/parser.ts |  22 ++-
 7 files changed, 321 insertions(+), 3 deletions(-)
 create mode 100644 packages/liquid-html-parser/src/document/branch-opened-elements.test.ts
 create mode 100644 packages/liquid-html-parser/src/document/branch-opened-elements.ts

diff --git a/packages/liquid-html-parser/specs/architecture.md b/packages/liquid-html-parser/specs/architecture.md
index f91427f56..88a44245b 100644
--- a/packages/liquid-html-parser/specs/architecture.md
+++ b/packages/liquid-html-parser/specs/architecture.md
@@ -594,6 +594,8 @@ All except `AttrEmpty` extend `AttributeNodeBase<T>` with `name: (TextNode | Liq
 
 Defined in frozen `ast.ts`. Produced when a `</tagName>` close tag does not match any open element AND the current context has `allowUnclosedHtml: true` (i.e., inside `if`/`unless`/`case` branches). Has `name: (TextNode | LiquidVariableOutput)[]` and `blockStartPosition: Position`.
 
+With the `pairDanglingCloseTags` option, it is also produced for a close tag that ends an element an earlier `if`/`unless`/`case` in the same scope left open on every path (`document/branch-opened-elements.ts`). That case is checked before the close tag is matched against the enclosing element.
+
 ---
 
 ## 5. Decisions Log
diff --git a/packages/liquid-html-parser/src/ast.ts b/packages/liquid-html-parser/src/ast.ts
index c0451ea17..211d08473 100644
--- a/packages/liquid-html-parser/src/ast.ts
+++ b/packages/liquid-html-parser/src/ast.ts
@@ -938,6 +938,19 @@ export interface ASTBuildOptions {
 
   /** Optional environment for tag registration. Uses Environment.default() if omitted. */
   environment?: Environment;
+
+  /**
+   * Parse a close tag as an `HtmlDanglingMarkerClose` when it ends an element
+   * that an earlier `if` / `unless` / `case` in the same scope left open on
+   * every branch, instead of matching it against the enclosing element:
+   *
+   *   {% if a %}<div class="x">{% else %}<div class="y">{% endif %}...</div>
+   *
+   * Without it such a template throws. Liquid treats the markup as text, so
+   * Shopify renders it, and a renderer can pair the marker with the open
+   * element. Off by default: it accepts templates the strict grammar rejects.
+   */
+  pairDanglingCloseTags?: boolean;
 }
 
 export function isBranchedTag(node: LiquidHtmlNode) {
@@ -967,6 +980,7 @@ export function toLiquidHtmlAST(
   const env = options.environment ?? Environment.default();
   const tokens = tokenize(source);
   const parser = new DocumentParser(tokens, source, env, true, options.allowUnclosedDocumentNode);
+  parser.pairDanglingCloseTags = options.pairDanglingCloseTags ?? false;
   return parser.parseDocument();
 }
 
diff --git a/packages/liquid-html-parser/src/document/branch-opened-elements.test.ts b/packages/liquid-html-parser/src/document/branch-opened-elements.test.ts
new file mode 100644
index 000000000..30cef99f1
--- /dev/null
+++ b/packages/liquid-html-parser/src/document/branch-opened-elements.test.ts
@@ -0,0 +1,178 @@
+import { describe, it, expect } from 'vitest';
+import { toLiquidHtmlAST } from '../ast';
+import type { DocumentNode, LiquidHtmlNode } from '../ast';
+import { NodeTypes } from '../types';
+
+const PAIRING = {
+  mode: 'strict',
+  allowUnclosedDocumentNode: false,
+  pairDanglingCloseTags: true,
+} as const;
+const STRICT = { mode: 'strict', allowUnclosedDocumentNode: false } as const;
+
+/** One line per node: its type, its plain name, and whether it is left open. */
+function outline(nodes: LiquidHtmlNode[], depth = 0): string[] {
+  const lines: string[] = [];
+  for (const node of nodes) {
+    if (node.type === NodeTypes.TextNode) continue;
+    const pad = '  '.repeat(depth);
+    if (node.type === NodeTypes.HtmlElement) {
+      const name = node.name.map((s) => ('value' in s ? s.value : '?')).join('');
+      const open = node.blockEndPosition.start === node.blockEndPosition.end ? ' (open)' : '';
+      lines.push(`${pad}<${name}>${open}`);
+      lines.push(...outline(node.children, depth + 1));
+    } else if (node.type === NodeTypes.HtmlDanglingMarkerClose) {
+      const name = node.name.map((s) => ('value' in s ? s.value : '?')).join('');
+      lines.push(`${pad}</${name}> (dangling)`);
+    } else if (node.type === NodeTypes.LiquidTag) {
+      lines.push(`${pad}{% ${node.name} %}`);
+      if (Array.isArray(node.children)) lines.push(...outline(node.children, depth + 1));
+    } else if (node.type === NodeTypes.LiquidBranch) {
+      lines.push(`${pad}branch ${node.name ?? '(first)'}`);
+      lines.push(...outline(node.children, depth + 1));
+    } else if (node.type === NodeTypes.LiquidVariableOutput) {
+      lines.push(`${pad}{{ }}`);
+    }
+  }
+  return lines;
+}
+
+function parseOutline(source: string): string[] {
+  const ast: DocumentNode = toLiquidHtmlAST(source, PAIRING);
+  return outline(ast.children);
+}
+
+describe('pairDanglingCloseTags', () => {
+  const LAYOUT = [
+    '<body>',
+    '<div id="PageContainer">',
+    '{% if a %}',
+    '<div id="MainContent" class="x">',
+    '{% elsif b %}',
+    '<div id="MainContent" class="y">',
+    '{% else %}',
+    '<div id="MainContent" class="z">',
+    '{% endif %}',
+    '{{ content_for_layout }}',
+    '</div>',
+    '</div>',
+    '<div class="footer"></div>',
+    '</body>',
+  ].join('\n');
+
+  it('throws on an element opened in every branch and closed after endif, without the option', () => {
+    expect(() => toLiquidHtmlAST(LAYOUT, STRICT)).toThrow(
+      "Attempting to close HtmlElement 'div' before HtmlElement 'body' was closed",
+    );
+  });
+
+  it('parses the close as a dangling marker inside the enclosing element', () => {
+    expect(parseOutline(LAYOUT)).toEqual([
+      '<body>',
+      '  <div>',
+      '    {% if %}',
+      '      branch (first)',
+      '        <div> (open)',
+      '      branch elsif',
+      '        <div> (open)',
+      '      branch else',
+      '        <div> (open)',
+      '    {{ }}',
+      '    </div> (dangling)',
+      '  <div>',
+    ]);
+  });
+
+  it('parses a close at the document level the same way', () => {
+    const source = '{% if a %}<div class="x">{% else %}<div class="y">{% endif %}hi</div>';
+    expect(() => toLiquidHtmlAST(source, STRICT)).toThrow(
+      "Attempting to close HtmlElement 'div' before it was opened",
+    );
+    expect(parseOutline(source)).toEqual([
+      '{% if %}',
+      '  branch (first)',
+      '    <div> (open)',
+      '  branch else',
+      '    <div> (open)',
+      '</div> (dangling)',
+    ]);
+  });
+
+  it('parses a close in a loop body the same way', () => {
+    const source =
+      '<ul>{% for i in (1..2) %}{% if s %}<div class="slide">{% else %}<div class="item">{% endif %}{{ i }}</div>{% endfor %}</ul>';
+    expect(() => toLiquidHtmlAST(source, STRICT)).toThrow();
+    expect(parseOutline(source)).toEqual([
+      '<ul>',
+      '  {% for %}',
+      '    branch (first)',
+      '      {% if %}',
+      '        branch (first)',
+      '          <div> (open)',
+      '        branch else',
+      '          <div> (open)',
+      '      {{ }}',
+      '      </div> (dangling)',
+    ]);
+  });
+
+  it('pairs one close per element every branch leaves open', () => {
+    const source = '<main>{% if a %}<div><p>{% else %}<div><p>{% endif %}x</p></div></main>';
+    expect(parseOutline(source)).toEqual([
+      '<main>',
+      '  {% if %}',
+      '    branch (first)',
+      '      <div> (open)',
+      '        <p> (open)',
+      '    branch else',
+      '      <div> (open)',
+      '        <p> (open)',
+      '  </p> (dangling)',
+      '  </div> (dangling)',
+    ]);
+  });
+
+  it('counts a case by its when and else branches, not the text before the first when', () => {
+    const source =
+      '<main>{% case t %}{% when \'a\' %}<div class="a">{% else %}<div class="b">{% endcase %}x</div></main>';
+    expect(parseOutline(source)).toContain('  </div> (dangling)');
+  });
+
+  it('does not count a conditional that leaves the element open on only some paths', () => {
+    // `{% if c %}<div>{% endif %}` has an empty path, so the `</div>` after it
+    // keeps closing `<main>`'s sibling structure as before, and this still throws.
+    const source = '<main><section>{% if c %}<div>{% endif %}x</div></section></main>';
+    expect(() => toLiquidHtmlAST(source, PAIRING)).toThrow();
+  });
+
+  it('keeps closing the enclosing element once the branch-opened elements are closed', () => {
+    const source = '<main>{% if a %}<div>{% else %}<div>{% endif %}x</div></main><p>after</p>';
+    expect(parseOutline(source)).toEqual([
+      '<main>',
+      '  {% if %}',
+      '    branch (first)',
+      '      <div> (open)',
+      '    branch else',
+      '      <div> (open)',
+      '  </div> (dangling)',
+      '<p>',
+    ]);
+  });
+
+  it('leaves a conditional open and close pair to the existing branch markers', () => {
+    const source = '<main>{% if c %}<a>{% endif %}x{% if c %}</a>{% endif %}</main>';
+    expect(toLiquidHtmlAST(source, PAIRING)).toEqual(toLiquidHtmlAST(source, STRICT));
+  });
+
+  it('does not change the AST of a template the strict parse accepts', () => {
+    const sources = [
+      '<div><span>a</span></div>',
+      '{% if a %}<div>{% else %}<div>{% endif %}',
+      '<div>{% if a %}<p>{% else %}</p>{% endif %}</div>',
+      '{% for x in y %}<li>{{ x }}</li>{% endfor %}',
+    ];
+    for (const source of sources) {
+      expect(toLiquidHtmlAST(source, PAIRING)).toEqual(toLiquidHtmlAST(source, STRICT));
+    }
+  });
+});
diff --git a/packages/liquid-html-parser/src/document/branch-opened-elements.ts b/packages/liquid-html-parser/src/document/branch-opened-elements.ts
new file mode 100644
index 000000000..f374dd6f1
--- /dev/null
+++ b/packages/liquid-html-parser/src/document/branch-opened-elements.ts
@@ -0,0 +1,76 @@
+import { NodeTypes } from '../types';
+import type { CompoundNameSegment, LiquidHtmlNode } from '../ast';
+
+/**
+ * How many `<name>` elements the nodes of one scope leave open on every output
+ * path — the count a later `</name>` in the same scope can close.
+ *
+ * A conditional may leave an element open when its branch ends (the parser marks
+ * it with a zero-width `blockEndPosition`):
+ *
+ *   {% if a %}<div class="x">{% else %}<div class="y">{% endif %}
+ *     {{ content_for_layout }}
+ *   </div>
+ *
+ * Liquid writes whichever branch ran, so the `</div>` closes that `<div>`. Every
+ * branch leaves one open, so the balance is 1. A close counted here is parsed as
+ * an `HtmlDanglingMarkerClose`, which a renderer can pair with the open.
+ *
+ * A conditional counts only when all its paths agree, including the empty path
+ * of an `if` / `unless` / `case` without an `else`. `{% if c %}<a>{% endif %}`
+ * leaves an `<a>` open only when `c` holds, so it counts as 0: a later `</a>`
+ * is not known to close it, and the parser keeps its existing answer for it.
+ * Other block tags count as 0. Only elements opened in a branch count, never an
+ * element the scope closed itself.
+ */
+export function branchOpenedElementBalance(nodes: LiquidHtmlNode[], name: string): number {
+  let balance = 0;
+  for (const node of nodes) balance += nodeBalance(node, name);
+  return balance;
+}
+
+const CONDITIONAL_TAGS = new Set(['if', 'unless', 'case']);
+
+function nodeBalance(node: LiquidHtmlNode, name: string): number {
+  switch (node.type) {
+    case NodeTypes.HtmlElement: {
+      const end = node.blockEndPosition;
+      if (end.start !== end.end) return 0;
+      const own = plainNameMatches(node.name, name) ? 1 : 0;
+      return own + branchOpenedElementBalance(node.children, name);
+    }
+    case NodeTypes.HtmlDanglingMarkerClose:
+      return plainNameMatches(node.name, name) ? -1 : 0;
+    case NodeTypes.LiquidTag:
+      return conditionalBalance(node, name);
+    default:
+      return 0;
+  }
+}
+
+function conditionalBalance(
+  node: Extract<LiquidHtmlNode, { type: NodeTypes.LiquidTag }>,
+  name: string,
+): number {
+  if (!CONDITIONAL_TAGS.has(node.name) || !Array.isArray(node.children)) return 0;
+
+  const paths: number[] = [];
+  let hasElse = false;
+  for (const branch of node.children) {
+    if (branch.type !== NodeTypes.LiquidBranch) return 0;
+    // Liquid never writes what sits between `{% case %}` and its first `{% when %}`.
+    if (node.name === 'case' && branch.name === null) continue;
+    if (branch.name === 'else') hasElse = true;
+    paths.push(branchOpenedElementBalance(branch.children, name));
+  }
+  if (!hasElse) paths.push(0);
+
+  const first = paths[0] ?? 0;
+  return paths.every((path) => path === first) ? first : 0;
+}
+
+function plainNameMatches(segments: CompoundNameSegment[], name: string): boolean {
+  if (segments.length !== 1) return false;
+  const segment = segments[0];
+  return segment.type === NodeTypes.TextNode && segment.value.toLowerCase() === name;
+}
diff --git a/packages/liquid-html-parser/src/document/html.ts b/packages/liquid-html-parser/src/document/html.ts
index ad800f378..b81dcba21 100644
--- a/packages/liquid-html-parser/src/document/html.ts
+++ b/packages/liquid-html-parser/src/document/html.ts
@@ -42,6 +42,7 @@ import type {
 } from '../ast';
 import { VOID_ELEMENTS, HTML_RAW_TAGS, BLOCKS } from '../grammar';
 import { LiquidHTMLASTParsingError } from '../errors';
+import { branchOpenedElementBalance } from './branch-opened-elements';
 
 /**
  * Interface capturing what HTML-parsing free functions need from the
@@ -51,6 +52,8 @@ import { LiquidHTMLASTParsingError } from '../errors';
 export interface HtmlParserDelegate extends ParserBase {
   readonly htmlParseHtml: boolean;
   htmlAllowUnclosedHtml: boolean;
+  /** See `ASTBuildOptions.pairDanglingCloseTags`. */
+  readonly htmlPairDanglingCloseTags: boolean;
   htmlInAttributeContext: boolean;
   htmlInAttributeValueContext: boolean;
 
@@ -96,6 +99,10 @@ export function parseHtmlElement(
   const children: LiquidHtmlNode[] = [];
   while (!parser.isAtEnd()) {
     if (parser.check(TokenType.HtmlCloseTagOpen)) {
+      if (closesBranchOpenedElement(parser, children)) {
+        children.push(parseHtmlDanglingMarkerClose(parser));
+        continue;
+      }
       break;
     }
     if (parser.isBlockTerminator()) {
@@ -287,6 +294,26 @@ export function parseOrphanedHtmlCloseTag(parser: HtmlParserDelegate): never {
   );
 }
 
+/**
+ * Whether the close tag at the cursor ends an element that an earlier
+ * conditional in the same scope left open, rather than the enclosing element.
+ * Only asked under `pairDanglingCloseTags`; see `branchOpenedElementBalance`.
+ * Reads the name from the source so the cursor never moves, and answers false
+ * for a compound (Liquid) name.
+ */
+export function closesBranchOpenedElement(
+  parser: HtmlParserDelegate,
+  scopeChildren: LiquidHtmlNode[],
+): boolean {
+  if (!parser.htmlPairDanglingCloseTags) return false;
+  const nameStart = parser.peek().end;
+  const match = /^([A-Za-z][^\s/>{}]*)\s*>/.exec(
+    parser.getSource().slice(nameStart, nameStart + 256),
+  );
+  if (!match) return false;
+  return branchOpenedElementBalance(scopeChildren, match[1].toLowerCase()) > 0;
+}
+
 export function parseHtmlDanglingMarkerClose(parser: HtmlParserDelegate): HtmlDanglingMarkerClose {
   const source = parser.getSource();
   const start = parser.peek().start;
diff --git a/packages/liquid-html-parser/src/document/liquid-blocks.ts b/packages/liquid-html-parser/src/document/liquid-blocks.ts
index a8e992c49..82eed26d9 100644
--- a/packages/liquid-html-parser/src/document/liquid-blocks.ts
+++ b/packages/liquid-html-parser/src/document/liquid-blocks.ts
@@ -45,6 +45,7 @@ export interface BlockParserDelegate extends ParserBase, Parser {
   readonly blockInAttributeValueContext: boolean;
 
   parseNode(): LiquidHtmlNode;
+  parseNodeInScope(scope: LiquidHtmlNode[]): LiquidHtmlNode;
   peekTagName(): string | null;
   consumeEndTag(): {
     position: Position;
@@ -150,7 +151,7 @@ export function parseBlockBody(
     if (parser.blockInAttributeContext && !parser.blockInAttributeValueContext) {
       children.push(...(parser.parseBranchAttributes() as unknown as LiquidHtmlNode[]));
     } else {
-      children.push(parser.parseNode());
+      children.push(parser.parseNodeInScope(children));
     }
     if (parser.getPosition() === progressStart) {
       if (!parser.blockAllowUnclosedDocumentNode) {
@@ -267,7 +268,7 @@ export function parseBranchedBody(
     if (parser.blockInAttributeContext && !parser.blockInAttributeValueContext) {
       currentChildren.push(...(parser.parseBranchAttributes() as unknown as LiquidHtmlNode[]));
     } else {
-      currentChildren.push(parser.parseNode());
+      currentChildren.push(parser.parseNodeInScope(currentChildren));
     }
     if (parser.getPosition() === progressStart) {
       if (!parser.blockAllowUnclosedDocumentNode) {
diff --git a/packages/liquid-html-parser/src/document/parser.ts b/packages/liquid-html-parser/src/document/parser.ts
index aa2ba2836..079c8a149 100644
--- a/packages/liquid-html-parser/src/document/parser.ts
+++ b/packages/liquid-html-parser/src/document/parser.ts
@@ -43,6 +43,7 @@ import {
   parseOrphanedHtmlCloseTag as parseOrphanedHtmlCloseTagFn,
   parseHtmlDanglingMarkerClose as parseHtmlDanglingMarkerCloseFn,
   parseBranchAttributesImpl as parseBranchAttributesFn,
+  closesBranchOpenedElement,
 } from './html';
 import type { HtmlParserDelegate } from './html';
 import { parseLiquidStatement as parseLiquidStatementFn } from './liquid-lines';
@@ -64,6 +65,7 @@ export class DocumentParser
   private _parseHtml: boolean;
   private _allowUnclosedHtml: boolean;
   private readonly _allowUnclosedDocumentNode: boolean;
+  private _pairDanglingCloseTags: boolean = false;
   private _inAttributeContext: boolean = false;
   private _inAttributeValueContext: boolean = false;
 
@@ -120,6 +122,13 @@ export class DocumentParser
   set htmlAllowUnclosedHtml(v: boolean) {
     this._allowUnclosedHtml = v;
   }
+  get htmlPairDanglingCloseTags(): boolean {
+    return this._pairDanglingCloseTags;
+  }
+  /** See `ASTBuildOptions.pairDanglingCloseTags`. Set before `parseDocument`. */
+  set pairDanglingCloseTags(v: boolean) {
+    this._pairDanglingCloseTags = v;
+  }
   get htmlInAttributeContext(): boolean {
     return this._inAttributeContext;
   }
@@ -156,7 +165,7 @@ export class DocumentParser
   parseDocument(): DocumentNode {
     const children: LiquidHtmlNode[] = [];
     if (this.check(TokenType.YamlFrontmatter)) children.push(parseNodeFn(this));
-    while (!this.isAtEnd()) children.push(this.parseNode());
+    while (!this.isAtEnd()) children.push(this.parseNodeInScope(children));
     return makeDocumentNode(
       filterChildren(ChildFilterMode.Syntactic, children, this.source),
       this.source,
@@ -166,6 +175,17 @@ export class DocumentParser
   parseNode(): LiquidHtmlNode {
     return parseNodeFn(this);
   }
+  /**
+   * `parseNode` for a node whose earlier siblings are `scope`. Under
+   * `pairDanglingCloseTags`, a close tag ending an element those siblings left
+   * open in a conditional's branches is a dangling marker, not an orphan.
+   */
+  parseNodeInScope(scope: LiquidHtmlNode[]): LiquidHtmlNode {
+    if (this.check(TokenType.HtmlCloseTagOpen) && closesBranchOpenedElement(this, scope)) {
+      return this.parseHtmlDanglingMarkerClose();
+    }
+    return this.parseNode();
+  }
   parseLiquidTag(): LiquidTag | LiquidRawTag {
     return parseLiquidTagFn(this);
   }

From 08b22df7703287a70ee17081e6af1848a1eb7f2f Mon Sep 17 00:00:00 2001
From: River <river@shopify.com>
Date: Wed, 30 Sep 2026 19:17:29 +0000
Subject: [PATCH 12/20] Pair a dangling close only with the innermost
 branch-opened element
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Branch-opened elements are now tracked as a stack per scope, so a crossed close
like <section><div> … </section> is no longer converted, and an unmatched
dangling close leaves no debt against elements opened later.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../liquid-html-parser/specs/architecture.md  |   2 +-
 packages/liquid-html-parser/src/ast.ts        |   7 +-
 .../document/branch-opened-elements.test.ts   |  43 +++++
 .../src/document/branch-opened-elements.ts    | 149 +++++++++++++-----
 .../liquid-html-parser/src/document/html.ts   |   6 +-
 5 files changed, 159 insertions(+), 48 deletions(-)

diff --git a/packages/liquid-html-parser/specs/architecture.md b/packages/liquid-html-parser/specs/architecture.md
index 88a44245b..9813788a8 100644
--- a/packages/liquid-html-parser/specs/architecture.md
+++ b/packages/liquid-html-parser/specs/architecture.md
@@ -594,7 +594,7 @@ All except `AttrEmpty` extend `AttributeNodeBase<T>` with `name: (TextNode | Liq
 
 Defined in frozen `ast.ts`. Produced when a `</tagName>` close tag does not match any open element AND the current context has `allowUnclosedHtml: true` (i.e., inside `if`/`unless`/`case` branches). Has `name: (TextNode | LiquidVariableOutput)[]` and `blockStartPosition: Position`.
 
-With the `pairDanglingCloseTags` option, it is also produced for a close tag that ends an element an earlier `if`/`unless`/`case` in the same scope left open on every path (`document/branch-opened-elements.ts`). That case is checked before the close tag is matched against the enclosing element.
+With the `pairDanglingCloseTags` option, it is also produced for a close tag that names the innermost element earlier `if`/`unless`/`case` tags in the same scope left open on every path (`document/branch-opened-elements.ts`, which keeps that open stack per scope and extends it as nodes are appended). That case is checked before the close tag is matched against the enclosing element.
 
 ---
 
diff --git a/packages/liquid-html-parser/src/ast.ts b/packages/liquid-html-parser/src/ast.ts
index 211d08473..76c478757 100644
--- a/packages/liquid-html-parser/src/ast.ts
+++ b/packages/liquid-html-parser/src/ast.ts
@@ -940,9 +940,10 @@ export interface ASTBuildOptions {
   environment?: Environment;
 
   /**
-   * Parse a close tag as an `HtmlDanglingMarkerClose` when it ends an element
-   * that an earlier `if` / `unless` / `case` in the same scope left open on
-   * every branch, instead of matching it against the enclosing element:
+   * Parse a close tag as an `HtmlDanglingMarkerClose` when it names the
+   * innermost element that earlier `if` / `unless` / `case` tags in the same
+   * scope left open on every path, instead of matching it against the enclosing
+   * element:
    *
    *   {% if a %}<div class="x">{% else %}<div class="y">{% endif %}...</div>
    *
diff --git a/packages/liquid-html-parser/src/document/branch-opened-elements.test.ts b/packages/liquid-html-parser/src/document/branch-opened-elements.test.ts
index 30cef99f1..ac86fe922 100644
--- a/packages/liquid-html-parser/src/document/branch-opened-elements.test.ts
+++ b/packages/liquid-html-parser/src/document/branch-opened-elements.test.ts
@@ -159,6 +159,49 @@ describe('pairDanglingCloseTags', () => {
     ]);
   });
 
+  it('does not let an unmatched earlier close cancel an element opened later', () => {
+    const source =
+      '{% if a %}</div>{% else %}</div>{% endif %}{% if b %}<div>{% else %}<div>{% endif %}x</div>';
+    expect(parseOutline(source)).toEqual([
+      '{% if %}',
+      '  branch (first)',
+      '    </div> (dangling)',
+      '  branch else',
+      '    </div> (dangling)',
+      '{% if %}',
+      '  branch (first)',
+      '    <div> (open)',
+      '  branch else',
+      '    <div> (open)',
+      '</div> (dangling)',
+    ]);
+  });
+
+  it('does not convert a close that crosses the innermost branch-opened element', () => {
+    const source = '{% if a %}<section><div>{% else %}<section><div>{% endif %}</section></div>';
+    expect(() => toLiquidHtmlAST(source, PAIRING)).toThrow(
+      "Attempting to close HtmlElement 'section' before it was opened",
+    );
+  });
+
+  it('does not convert a close for an element a branch-opened element sits inside of', () => {
+    // The innermost open is `<p>`, so `</div>` is not taken from the branches and
+    // closes `<main>`'s `<div>` sibling structure as before, which throws here.
+    const source = '<main>{% if a %}<div><p>{% else %}<div><p>{% endif %}x</div></main>';
+    expect(() => toLiquidHtmlAST(source, PAIRING)).toThrow();
+  });
+
+  it('reads each node of a scope once, however many closes the scope meets', () => {
+    const count = 2000;
+    const source = `<main>${'{% if a %}<div>{% else %}<div>{% endif %}'.repeat(count)}x${'</div>'.repeat(count)}</main>`;
+    const started = performance.now();
+    const ast = toLiquidHtmlAST(source, PAIRING);
+    expect(performance.now() - started).toBeLessThan(2000);
+    const main = ast.children[0] as { children: LiquidHtmlNode[] };
+    const closes = main.children.filter((n) => n.type === NodeTypes.HtmlDanglingMarkerClose);
+    expect(closes).toHaveLength(count);
+  });
+
   it('leaves a conditional open and close pair to the existing branch markers', () => {
     const source = '<main>{% if c %}<a>{% endif %}x{% if c %}</a>{% endif %}</main>';
     expect(toLiquidHtmlAST(source, PAIRING)).toEqual(toLiquidHtmlAST(source, STRICT));
diff --git a/packages/liquid-html-parser/src/document/branch-opened-elements.ts b/packages/liquid-html-parser/src/document/branch-opened-elements.ts
index f374dd6f1..406c627db 100644
--- a/packages/liquid-html-parser/src/document/branch-opened-elements.ts
+++ b/packages/liquid-html-parser/src/document/branch-opened-elements.ts
@@ -2,8 +2,9 @@ import { NodeTypes } from '../types';
 import type { CompoundNameSegment, LiquidHtmlNode } from '../ast';
 
 /**
- * How many `<name>` elements the nodes of one scope leave open on every output
- * path — the count a later `</name>` in the same scope can close.
+ * Whether a `</name>` close tag, met after the nodes already parsed into
+ * `scope`, ends an element a conditional in that scope left open, rather than
+ * the enclosing element.
  *
  * A conditional may leave an element open when its branch ends (the parser marks
  * it with a zero-width `blockEndPosition`):
@@ -12,65 +13,131 @@ import type { CompoundNameSegment, LiquidHtmlNode } from '../ast';
  *     {{ content_for_layout }}
  *   </div>
  *
- * Liquid writes whichever branch ran, so the `</div>` closes that `<div>`. Every
- * branch leaves one open, so the balance is 1. A close counted here is parsed as
- * an `HtmlDanglingMarkerClose`, which a renderer can pair with the open.
+ * Liquid writes whichever branch ran, so the `</div>` closes that `<div>`. Such
+ * a close is parsed as an `HtmlDanglingMarkerClose`, which a renderer can pair
+ * with the open element.
  *
- * A conditional counts only when all its paths agree, including the empty path
- * of an `if` / `unless` / `case` without an `else`. `{% if c %}<a>{% endif %}`
- * leaves an `<a>` open only when `c` holds, so it counts as 0: a later `</a>`
- * is not known to close it, and the parser keeps its existing answer for it.
- * Other block tags count as 0. Only elements opened in a branch count, never an
- * element the scope closed itself.
+ * The scope's nodes are read in output order into a stack of the elements left
+ * open on every path, innermost last. A close converts only when it names the
+ * innermost element on that stack, so a crossed close
+ * (`<section><div>` … `</section>`) never converts. A dangling close pops the
+ * stack only when it names the innermost element; otherwise it closes nothing,
+ * so it leaves no debt against elements opened later.
+ *
+ * Each path through an `if` / `unless` / `case` starts from the current stack,
+ * and an `if` / `unless` / `case` without an `else` adds the empty path. The
+ * stack after the tag is the longest prefix every path agrees on:
+ * `{% if c %}<a>{% endif %}` leaves an `<a>` open only when `c` holds, so it adds
+ * nothing, and a later `</a>` keeps the parser's existing answer. Other block tags
+ * are read the same way with their body as one path beside the empty one.
+ *
+ * The stack is kept per scope array and extended as nodes are appended, so each
+ * node is read once however many close tags the scope meets.
  */
-export function branchOpenedElementBalance(nodes: LiquidHtmlNode[], name: string): number {
-  let balance = 0;
-  for (const node of nodes) balance += nodeBalance(node, name);
-  return balance;
+export function closesInnermostBranchOpenedElement(scope: LiquidHtmlNode[], name: string): boolean {
+  let state = scopeStates.get(scope);
+  if (state === undefined) {
+    state = { read: 0, stack: EMPTY };
+    scopeStates.set(scope, state);
+  }
+  while (state.read < scope.length) {
+    state.stack = applyNode(state.stack, scope[state.read]);
+    state.read += 1;
+  }
+  return state.stack.length > 0 && state.stack[state.stack.length - 1] === name.toLowerCase();
 }
 
+type OpenStack = readonly string[];
+
+const EMPTY: OpenStack = [];
+
+/**
+ * The open stack after the nodes read so far, per scope. The parser only appends
+ * to a scope's children while it parses that scope, so reading from `read` on is
+ * enough to stay current.
+ */
+const scopeStates = new WeakMap<LiquidHtmlNode[], { read: number; stack: OpenStack }>();
+
 const CONDITIONAL_TAGS = new Set(['if', 'unless', 'case']);
 
-function nodeBalance(node: LiquidHtmlNode, name: string): number {
+/**
+ * Stands in for a branch-opened element with a Liquid (compound) name. No close
+ * tag can name it, so it only blocks closes from reaching elements beneath it.
+ */
+const UNNAMED = '';
+
+function applyNodes(stack: OpenStack, nodes: LiquidHtmlNode[]): OpenStack {
+  let current = stack;
+  for (const node of nodes) current = applyNode(current, node);
+  return current;
+}
+
+function applyNode(stack: OpenStack, node: LiquidHtmlNode): OpenStack {
   switch (node.type) {
     case NodeTypes.HtmlElement: {
       const end = node.blockEndPosition;
-      if (end.start !== end.end) return 0;
-      const own = plainNameMatches(node.name, name) ? 1 : 0;
-      return own + branchOpenedElementBalance(node.children, name);
+      if (end.start !== end.end) return stack;
+      return applyNodes([...stack, plainName(node.name) ?? UNNAMED], node.children);
+    }
+    case NodeTypes.HtmlDanglingMarkerClose: {
+      const name = plainName(node.name);
+      const top = stack[stack.length - 1];
+      return name !== null && top === name ? stack.slice(0, -1) : stack;
     }
-    case NodeTypes.HtmlDanglingMarkerClose:
-      return plainNameMatches(node.name, name) ? -1 : 0;
     case NodeTypes.LiquidTag:
-      return conditionalBalance(node, name);
+      return applyBlock(stack, node);
     default:
-      return 0;
+      return stack;
   }
 }
 
-function conditionalBalance(
+function applyBlock(
+  stack: OpenStack,
   node: Extract<LiquidHtmlNode, { type: NodeTypes.LiquidTag }>,
-  name: string,
-): number {
-  if (!CONDITIONAL_TAGS.has(node.name) || !Array.isArray(node.children)) return 0;
+): OpenStack {
+  if (!Array.isArray(node.children) || node.children.length === 0) return stack;
 
-  const paths: number[] = [];
-  let hasElse = false;
-  for (const branch of node.children) {
-    if (branch.type !== NodeTypes.LiquidBranch) return 0;
-    // Liquid never writes what sits between `{% case %}` and its first `{% when %}`.
-    if (node.name === 'case' && branch.name === null) continue;
-    if (branch.name === 'else') hasElse = true;
-    paths.push(branchOpenedElementBalance(branch.children, name));
+  const paths: OpenStack[] = [];
+  const branched = node.children.every((child) => child.type === NodeTypes.LiquidBranch);
+  if (CONDITIONAL_TAGS.has(node.name) && branched) {
+    let hasElse = false;
+    for (const branch of node.children) {
+      if (branch.type !== NodeTypes.LiquidBranch) continue;
+      // Liquid never writes what sits between `{% case %}` and its first `{% when %}`.
+      if (node.name === 'case' && branch.name === null) continue;
+      if (branch.name === 'else') hasElse = true;
+      paths.push(applyNodes(stack, branch.children));
+    }
+    if (!hasElse) paths.push(stack);
+  } else {
+    const body = branched
+      ? node.children.flatMap((child) =>
+          child.type === NodeTypes.LiquidBranch ? child.children : [],
+        )
+      : node.children;
+    paths.push(applyNodes(stack, body), stack);
   }
-  if (!hasElse) paths.push(0);
+  return commonPrefix(paths);
+}
 
-  const first = paths[0] ?? 0;
-  return paths.every((path) => path === first) ? first : 0;
+function commonPrefix(paths: OpenStack[]): OpenStack {
+  const [first, ...rest] = paths;
+  if (first === undefined) return EMPTY;
+  let length = first.length;
+  for (const path of rest) {
+    length = Math.min(length, path.length);
+    for (let i = 0; i < length; i++) {
+      if (path[i] !== first[i]) {
+        length = i;
+        break;
+      }
+    }
+  }
+  return length === first.length ? first : first.slice(0, length);
 }
 
-function plainNameMatches(segments: CompoundNameSegment[], name: string): boolean {
-  if (segments.length !== 1) return false;
+function plainName(segments: CompoundNameSegment[]): string | null {
+  if (segments.length !== 1) return null;
   const segment = segments[0];
-  return segment.type === NodeTypes.TextNode && segment.value.toLowerCase() === name;
+  return segment.type === NodeTypes.TextNode ? segment.value.toLowerCase() : null;
 }
diff --git a/packages/liquid-html-parser/src/document/html.ts b/packages/liquid-html-parser/src/document/html.ts
index b81dcba21..9f2a2bc10 100644
--- a/packages/liquid-html-parser/src/document/html.ts
+++ b/packages/liquid-html-parser/src/document/html.ts
@@ -42,7 +42,7 @@ import type {
 } from '../ast';
 import { VOID_ELEMENTS, HTML_RAW_TAGS, BLOCKS } from '../grammar';
 import { LiquidHTMLASTParsingError } from '../errors';
-import { branchOpenedElementBalance } from './branch-opened-elements';
+import { closesInnermostBranchOpenedElement } from './branch-opened-elements';
 
 /**
  * Interface capturing what HTML-parsing free functions need from the
@@ -297,7 +297,7 @@ export function parseOrphanedHtmlCloseTag(parser: HtmlParserDelegate): never {
 /**
  * Whether the close tag at the cursor ends an element that an earlier
  * conditional in the same scope left open, rather than the enclosing element.
- * Only asked under `pairDanglingCloseTags`; see `branchOpenedElementBalance`.
+ * Only asked under `pairDanglingCloseTags`; see `closesInnermostBranchOpenedElement`.
  * Reads the name from the source so the cursor never moves, and answers false
  * for a compound (Liquid) name.
  */
@@ -311,7 +311,7 @@ export function closesBranchOpenedElement(
     parser.getSource().slice(nameStart, nameStart + 256),
   );
   if (!match) return false;
-  return branchOpenedElementBalance(scopeChildren, match[1].toLowerCase()) > 0;
+  return closesInnermostBranchOpenedElement(scopeChildren, match[1]);
 }
 
 export function parseHtmlDanglingMarkerClose(parser: HtmlParserDelegate): HtmlDanglingMarkerClose {

From b9ab5c736b101623ff5eac3cb72dd2c48529c690 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Claud=C3=A9ric=20Demers?= <clauderic.demers@shopify.com>
Date: Fri, 25 Sep 2026 14:51:17 -0400
Subject: [PATCH 13/20] Test that block and section markup keep the full source

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 packages/liquid-html-parser/src/tags/block.test.ts   | 11 +++++++++++
 packages/liquid-html-parser/src/tags/section.test.ts | 11 +++++++++++
 2 files changed, 22 insertions(+)

diff --git a/packages/liquid-html-parser/src/tags/block.test.ts b/packages/liquid-html-parser/src/tags/block.test.ts
index 9b0308fd7..80cfb53bf 100644
--- a/packages/liquid-html-parser/src/tags/block.test.ts
+++ b/packages/liquid-html-parser/src/tags/block.test.ts
@@ -16,6 +16,17 @@ function parser(markup: string): MarkupParser {
 const stubParser = {} as Parser;
 
 describe('blockTag', () => {
+  it.each([
+    "'card' ",
+    "'card',  title: 'Hello',\n color: 'red' ",
+    "'card', products: ['classic-crewneck', 'cozy-beanie'] ",
+  ])('retains the full source for absolute markup positions: %s', (markup) => {
+    const result = blockTag.parse('block', parser(markup), stubParser);
+    expect(result.source).toBe(PADDING + markup);
+    expect(result.position).toEqual({ start: OFFSET, end: OFFSET + markup.length });
+    expect(result.source.slice(result.position.start, result.position.end)).toBe(markup);
+  });
+
   it('has block kind', () => {
     expect(blockTag.kind).toBe(TagKind.Block);
   });
diff --git a/packages/liquid-html-parser/src/tags/section.test.ts b/packages/liquid-html-parser/src/tags/section.test.ts
index 8f7917c1a..f18732dce 100644
--- a/packages/liquid-html-parser/src/tags/section.test.ts
+++ b/packages/liquid-html-parser/src/tags/section.test.ts
@@ -15,6 +15,17 @@ function parser(markup: string): MarkupParser {
 const stubParser = {} as Parser;
 
 describe('sectionTag', () => {
+  it.each([
+    "'card' ",
+    "'card',  title: 'Hello',\n color: 'red' ",
+    "'card', products: ['classic-crewneck', 'cozy-beanie'] ",
+  ])('retains the full source for absolute markup positions: %s', (markup) => {
+    const result = sectionTag.parse('section', parser(markup), stubParser);
+    expect(result.source).toBe(PADDING + markup);
+    expect(result.position).toEqual({ start: OFFSET, end: OFFSET + markup.length });
+    expect(result.source.slice(result.position.start, result.position.end)).toBe(markup);
+  });
+
   it('has tag kind', () => {
     expect(sectionTag.kind).toBe(TagKind.Tag);
   });

From 64e4ffb380fa0d65909b8f5b9b530dc9f84a8db6 Mon Sep 17 00:00:00 2001
From: River <river@shopify.com>
Date: Wed, 14 Oct 2026 02:16:17 +0000
Subject: [PATCH 14/20] Read script and style bodies as raw text

A <script> or <style> body is raw text: a < followed by a letter, ! or { in
it is JavaScript or CSS, not an HTML tag. When the token stream doesn't
close the element where the source does, the body is tokenized again in a
raw-text mode that only reads Liquid delimiters, and the rest of the
document after the close tag is tokenized again if the old stream ran past
it.

The close tag is found in the source, skipping Liquid delimiters and the
bodies of Liquid raw tags such as {% comment %}, so a </script> inside
either doesn't close the element. A raw tag inside the body that reslices
the stream stays within the body.

Co-Authored-By: Martin Morissette <martin.morissette@shopify.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../liquid-html-parser/src/document/base.ts   |   78 +-
 .../liquid-html-parser/src/document/html.ts   |   82 +-
 .../src/document/liquid-raw.ts                |    8 +-
 .../src/document/raw-body.ts                  |   18 +-
 .../src/document/tokenizer.test.ts            |    1 +
 .../src/document/tokenizer.ts                 |   28 +
 specs/parser/html.yml                         | 1042 +++++++++++++++++
 specs/parser/liquid-raw.yml                   |   28 +-
 8 files changed, 1251 insertions(+), 34 deletions(-)

diff --git a/packages/liquid-html-parser/src/document/base.ts b/packages/liquid-html-parser/src/document/base.ts
index 57a8d6acc..84d4fa04a 100644
--- a/packages/liquid-html-parser/src/document/base.ts
+++ b/packages/liquid-html-parser/src/document/base.ts
@@ -1,5 +1,5 @@
-import { TokenType, createTokenizer } from './tokenizer';
-import type { Token, Tokenizer } from './tokenizer';
+import { TokenType, createTokenizer, tokenize } from './tokenizer';
+import type { Token, TokenizeOptions, Tokenizer } from './tokenizer';
 import { LiquidHTMLASTParsingError } from '../errors';
 
 export class ParserBase {
@@ -208,6 +208,14 @@ export class ParserBase {
     const before = this.countTokensWhile((token) => token.end <= sourceOffset);
     const straddles = this.hasToken(before) && this.tokens[before].start < sourceOffset;
 
+    if (straddles && this.rawTextBound !== null && sourceOffset < this.rawTextBound) {
+      const bound = this.rawTextBound;
+      const rest = this.countTokensWhile((token) => token.start < bound);
+      this.replaceTokens(before, rest, this.tokenizeSlice(sourceOffset, bound, { rawText: true }));
+      this.p = before;
+      return;
+    }
+
     if (straddles) {
       this.scanHtmlContext(before);
       // If the boundary lies inside a quoted HTML attribute value (the raw tag
@@ -243,4 +251,70 @@ export class ParserBase {
     // never skipped past, keeping `this.p` in bounds.)
     this.seekToSourceOffset(sourceOffset);
   }
+
+  /**
+   * Re-tokenize the `<script>`/`<style>` body from `bodyStart` to `bodyEnd` as
+   * raw text, with the close tag `bodyEnd`..`closeEnd` and the rest of the
+   * source as a normal document.
+   *
+   * The body is tokenized on its own, so no Liquid mode in it can run past the
+   * close tag. After the close tag the existing tokens are kept when the old
+   * stream already resumed a normal document there, which is the case when its
+   * `HtmlTagClose` ends exactly at `closeEnd`: a tag mode only pops back to the
+   * document. Otherwise the rest of the source is tokenized again, as it's read.
+   *
+   * Like `resliceTokensFrom`, this renumbers every token slot after `bodyStart`.
+   * Callers must recompute any token index they cached, or re-seek by source
+   * offset. Leaves the cursor at the first body token.
+   */
+  retokenizeRawText(bodyStart: number, bodyEnd: number, closeEnd: number): void {
+    const before = this.countTokensWhile((token) => token.end <= bodyStart);
+    const body = this.tokenizeSlice(bodyStart, bodyEnd, { rawText: true });
+    // Tokens don't overlap, so a token ending at `closeEnd` is the first one
+    // that doesn't end before it.
+    const close = this.countTokensWhile((token) => token.end < closeEnd);
+    const resumes =
+      this.hasToken(close + 1) &&
+      this.tokens[close].type === TokenType.HtmlTagClose &&
+      this.tokens[close].end === closeEnd &&
+      this.tokens[close + 1].start === closeEnd;
+    if (resumes) {
+      this.replaceTokens(before, close + 1, [...body, ...this.tokenizeSlice(bodyEnd, closeEnd)]);
+    } else {
+      this.replaceTokens(before, this.tokens.length, body);
+      this.tokenizer ??= createTokenizer(this.source, this.tokens);
+      this.tokenizer.restart(bodyEnd, { skipFrontmatter: true });
+    }
+    this.p = before;
+  }
+
+  /**
+   * While a `<script>`/`<style>` body is parsed, the offset its close tag starts
+   * at, or null. `resliceTokensFrom` re-tokenizes inside the body as raw text up
+   * to this offset and keeps the tokens after it.
+   */
+  rawTextBound: number | null = null;
+
+  // In place, since the tokenizer appends to this same array. Not `splice`,
+  // whose spread arguments overflow the stack for a large body.
+  private replaceTokens(start: number, end: number, replacement: Token[]): void {
+    const rest = this.tokens.slice(end);
+    this.tokens.length = start;
+    for (const token of replacement) this.tokens.push(token);
+    for (const token of rest) this.tokens.push(token);
+    if (this.scanned > start) {
+      this.scanned = 0;
+      this.openQuote = undefined;
+      this.openTag = false;
+    }
+  }
+
+  // Tokens for `source[start, end)`, with offsets in the whole source, without
+  // the slice's EndOfInput.
+  private tokenizeSlice(start: number, end: number, options: TokenizeOptions = {}): Token[] {
+    const tokens = tokenize(this.source.slice(start, end), { ...options, skipFrontmatter: true });
+    return tokens
+      .filter((token) => token.type !== TokenType.EndOfInput)
+      .map((token) => ({ type: token.type, start: token.start + start, end: token.end + start }));
+  }
 }
diff --git a/packages/liquid-html-parser/src/document/html.ts b/packages/liquid-html-parser/src/document/html.ts
index 9f2a2bc10..8c8e04851 100644
--- a/packages/liquid-html-parser/src/document/html.ts
+++ b/packages/liquid-html-parser/src/document/html.ts
@@ -43,6 +43,9 @@ import type {
 import { VOID_ELEMENTS, HTML_RAW_TAGS, BLOCKS } from '../grammar';
 import { LiquidHTMLASTParsingError } from '../errors';
 import { closesInnermostBranchOpenedElement } from './branch-opened-elements';
+import { findRawBodyEnd, liquidTagTokenName, rawBodyRuleLookup } from './raw-body';
+import type { RawBodyRuleFor } from './raw-body';
+import type { TagDefinition } from '../environment';
 
 /**
  * Interface capturing what HTML-parsing free functions need from the
@@ -64,6 +67,7 @@ export interface HtmlParserDelegate extends ParserBase {
   isBlockTerminator(): boolean;
   parseBranchAttributes(): AttributeNode[];
   parseLiquidInRange(bodyStart: number, bodyEnd: number): (LiquidNode | TextNode)[];
+  tagForName(name: string): TagDefinition | undefined;
 }
 
 // htmlElement := "<" compoundName attributes ("/" | ">") children? "</" compoundName ">"
@@ -179,8 +183,18 @@ export function parseHtmlRawBody(
   const source = parser.getSource();
   const bodyStart = blockStartPosition.end;
 
+  const rawText = RAW_TEXT_ELEMENTS.has(plainName.toLowerCase())
+    ? findRawTextClose(
+        source,
+        bodyStart,
+        plainName,
+        rawBodyRuleLookup((name) => parser.tagForName(name)),
+      )
+    : null;
   const closeIdx = scanForHtmlCloseTag(parser, plainName);
-  if (closeIdx === -1) {
+  if (rawText && (closeIdx === -1 || parser.tokenAt(closeIdx).start !== rawText.start)) {
+    parser.retokenizeRawText(bodyStart, rawText.start, rawText.end);
+  } else if (!rawText && closeIdx === -1) {
     throw new LiquidHTMLASTParsingError(
       `Attempting to end parsing before HtmlRawNode '${plainName}' was closed`,
       source,
@@ -189,10 +203,17 @@ export function parseHtmlRawBody(
     );
   }
 
-  const bodyEnd = parser.tokenAt(closeIdx).start;
+  const bodyEnd = rawText ? rawText.start : parser.tokenAt(closeIdx).start;
   const bodyString = source.slice(bodyStart, bodyEnd);
 
-  const bodyNodes = parser.parseLiquidInRange(bodyStart, bodyEnd);
+  const savedRawTextBound = parser.rawTextBound;
+  if (rawText) parser.rawTextBound = bodyEnd;
+  let bodyNodes: (LiquidNode | TextNode)[];
+  try {
+    bodyNodes = parser.parseLiquidInRange(bodyStart, bodyEnd);
+  } finally {
+    parser.rawTextBound = savedRawTextBound;
+  }
 
   const kind = rawMarkupKindForHtmlTag(plainName, attributes, bodyString);
   const body = makeRawMarkup(kind, bodyString, bodyNodes, bodyStart, bodyEnd, source);
@@ -749,6 +770,61 @@ export function scanForHtmlCloseTag(parser: ParserBase, tagName: string): number
   return -1;
 }
 
+// The HTML elements whose bodies are raw text: nothing in them but their own
+// close tag (and, in a theme, Liquid) is markup.
+const RAW_TEXT_ELEMENTS = new Set(['script', 'style']);
+
+const CLOSE_TAG_END = /\s*>/y;
+
+/**
+ * Where the first `</tagName>` after `from` starts and ends, read from the source
+ * rather than the token stream. Liquid delimiters are skipped the way the
+ * tokenizer skips them, and so is the body of a Liquid raw tag such as
+ * `{% comment %}`, so a close tag inside either does not count. An unterminated
+ * delimiter or raw tag leaves the element unclosed: returns null.
+ */
+function findRawTextClose(
+  source: string,
+  from: number,
+  tagName: string,
+  rawBodyRuleFor: RawBodyRuleFor,
+): { start: number; end: number } | null {
+  const lowerName = tagName.toLowerCase();
+  let i = from;
+  while (i < source.length) {
+    const liquidCloser = source.startsWith('{{', i)
+      ? '}}'
+      : source.startsWith('{%', i)
+        ? '%}'
+        : null;
+    if (liquidCloser) {
+      const close = source.indexOf(liquidCloser, i + 2);
+      if (close === -1) return null;
+      const tokenEnd = close + 2;
+      const name =
+        liquidCloser === '%}' ? liquidTagTokenName(source.slice(i, tokenEnd)) : undefined;
+      const rule = name ? rawBodyRuleFor(name) : undefined;
+      if (name && rule) {
+        const bodyEnd = findRawBodyEnd(source, tokenEnd, name, rule, rawBodyRuleFor);
+        if (!bodyEnd) return null;
+        i = bodyEnd.tagEnd;
+      } else {
+        i = tokenEnd;
+      }
+      continue;
+    }
+    if (
+      source.startsWith('</', i) &&
+      source.slice(i + 2, i + 2 + lowerName.length).toLowerCase() === lowerName
+    ) {
+      CLOSE_TAG_END.lastIndex = i + 2 + lowerName.length;
+      if (CLOSE_TAG_END.test(source)) return { start: i, end: CLOSE_TAG_END.lastIndex };
+    }
+    i++;
+  }
+  return null;
+}
+
 export function rawMarkupKindForHtmlTag(
   tagName: string,
   attributes: AttributeNode[] = [],
diff --git a/packages/liquid-html-parser/src/document/liquid-raw.ts b/packages/liquid-html-parser/src/document/liquid-raw.ts
index e4ebda75b..e7d20c145 100644
--- a/packages/liquid-html-parser/src/document/liquid-raw.ts
+++ b/packages/liquid-html-parser/src/document/liquid-raw.ts
@@ -7,9 +7,8 @@ import { ChildFilterMode, filterChildren } from './tree-builder';
 import type { Position } from '../types';
 import { RawMarkupKinds } from '../ast';
 import type { LiquidRawTag, LiquidNode, TextNode, LiquidVariableOutput } from '../ast';
-import { TagKind } from '../environment';
 import type { TagDefinition, TagDefinitionRaw } from '../environment';
-import { findRawBodyEnd } from './raw-body';
+import { findRawBodyEnd, rawBodyRuleLookup } from './raw-body';
 import { LiquidHTMLASTParsingError } from '../errors';
 import { parseLiquidDoc } from '../liquid-doc/parser';
 
@@ -39,10 +38,7 @@ export function parseRawTag(
     parser.tokenAt(parser.getPosition()).start,
     tagName,
     def.body,
-    (name) => {
-      const inner = parser.tagForName(name);
-      return inner?.kind === TagKind.Raw ? inner.body : undefined;
-    },
+    rawBodyRuleLookup((name) => parser.tagForName(name)),
   );
   if (!endTag) {
     throw new LiquidHTMLASTParsingError(
diff --git a/packages/liquid-html-parser/src/document/raw-body.ts b/packages/liquid-html-parser/src/document/raw-body.ts
index 5b1000ffa..de9f0637c 100644
--- a/packages/liquid-html-parser/src/document/raw-body.ts
+++ b/packages/liquid-html-parser/src/document/raw-body.ts
@@ -1,4 +1,5 @@
-import type { LiquidLine, RawBodyEnd, RawBodyRule } from '../tag-definitions';
+import { TagKind } from '../tag-definitions';
+import type { LiquidLine, RawBodyEnd, RawBodyRule, TagDefinition } from '../tag-definitions';
 
 // Liquid's `BlockBody::FullToken`, `FullTokenPossiblyInvalid` and `LiquidTagToken`,
 // with Ruby's ASCII `\s`.
@@ -16,6 +17,21 @@ const TAG_OR_VARIABLE_START = /\{[{%]/g;
 /** Looks up the body rule of another raw tag, for the tags a rule skips as opaque. */
 export type RawBodyRuleFor = (tagName: string) => RawBodyRule | undefined;
 
+/** The `RawBodyRuleFor` of a tag registry: a raw tag's body rule, or undefined for any other tag. */
+export function rawBodyRuleLookup(
+  tagForName: (name: string) => TagDefinition | undefined,
+): RawBodyRuleFor {
+  return (name) => {
+    const def = tagForName(name);
+    return def?.kind === TagKind.Raw ? def.body : undefined;
+  };
+}
+
+/** The name of the tag a whole `{% … %}` token opens, read the way `findRawBodyEnd` reads it. */
+export function liquidTagTokenName(token: string): string | undefined {
+  return FULL_TOKEN.exec(token)?.[1];
+}
+
 /**
  * Where the body of `tagName` that starts at `bodyStart` ends under `rule`,
  * reading the source as `Liquid::Tokenizer` tokens. Returns null where Liquid
diff --git a/packages/liquid-html-parser/src/document/tokenizer.test.ts b/packages/liquid-html-parser/src/document/tokenizer.test.ts
index 623392521..e198d37ae 100644
--- a/packages/liquid-html-parser/src/document/tokenizer.test.ts
+++ b/packages/liquid-html-parser/src/document/tokenizer.test.ts
@@ -668,6 +668,7 @@ describe('Unit: document-tokenizer', () => {
       ['document start', '', {}],
       ['skipFrontmatter', '', { skipFrontmatter: true }],
       ['insideHtmlTag', '', { insideHtmlTag: true }],
+      ['rawText', '', { rawText: true }],
       ...['"', "'", '\u201c', '\u201d', '\u2018', '\u2019'].map(
         (quote): [string, string, TokenizeOptions] => [
           `insideQuotedAttribute ${quote}`,
diff --git a/packages/liquid-html-parser/src/document/tokenizer.ts b/packages/liquid-html-parser/src/document/tokenizer.ts
index a077ff180..a236f1ea8 100644
--- a/packages/liquid-html-parser/src/document/tokenizer.ts
+++ b/packages/liquid-html-parser/src/document/tokenizer.ts
@@ -59,6 +59,15 @@ export interface TokenizeOptions {
    * `QuotedValue`).
    */
   insideHtmlTag?: boolean;
+
+  /**
+   * Tokenize the whole input as the body of a `<script>` or `<style>` element:
+   * only Liquid delimiters are recognized, and everything else is Text, so
+   * JavaScript like `i<n` cannot open an HTML tag. The caller passes exactly the
+   * body, so no mode can run past its close tag. See
+   * `ParserBase.retokenizeRawText`.
+   */
+  rawText?: boolean;
 }
 
 export function tokenize(source: string, options: TokenizeOptions = {}): Token[] {
@@ -194,6 +203,8 @@ export function createTokenizer(source: string, tokens: Token[], fastPath = true
       // means the closing `>` pops back to `Default`, so the rest of the suffix
       // (`>ok</div>`) tokenizes as normal document content.
       mode = Mode.HtmlTag;
+    } else if (options.rawText) {
+      mode = Mode.RawText;
     }
 
     // YAML frontmatter: only at position 0
@@ -375,6 +386,14 @@ export function createTokenizer(source: string, tokens: Token[], fastPath = true
           break;
         }
 
+        case Mode.RawText: {
+          if (scanLiquidOpen()) continue;
+
+          startText();
+          skipText();
+          break;
+        }
+
         default:
           assertNever(mode);
       }
@@ -420,6 +439,8 @@ function nextTextCandidate(
       return nextQuotedValueCandidate(source, from, quoteChar);
     case Mode.LiquidTag:
       return nextLiquidTagCloseCandidate(source, from);
+    case Mode.RawText:
+      return nextRawTextCandidate(source, from);
     default:
       return assertNever(mode);
   }
@@ -445,6 +466,12 @@ function nextDefaultCandidate(source: string, from: number): number {
   return source.length;
 }
 
+/** RawText mode tokens start with `{` (Liquid). */
+function nextRawTextCandidate(source: string, from: number): number {
+  const i = source.indexOf('{', from);
+  return i === -1 ? source.length : i;
+}
+
 /**
  * HtmlTag mode tokens start with `{`, `/`, `>`, `=`, or a straight/curly quote;
  * a Text run also ends where whitespace starts or stops.
@@ -518,6 +545,7 @@ enum Mode {
   QuotedValue = 'QuotedValue',
   LiquidTag = 'LiquidTag',
   LiquidVariableOutput = 'LiquidVariableOutput',
+  RawText = 'RawText',
 }
 
 // Curly (smart) quotes come in directional pairs: a value opened with a left
diff --git a/specs/parser/html.yml b/specs/parser/html.yml
index 7df09c1f6..fa87bd545 100644
--- a/specs/parser/html.yml
+++ b/specs/parser/html.yml
@@ -4972,3 +4972,1045 @@ cases:
               - type: TextNode
                 value: d
                 position: { start: [0, 41], text: d }
+  - name: parses a script body with a loop condition with no spaces around <
+    source: <script>for (var i=0;i<arr.length;i++){}</script>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<script>for (var i=0;i<arr.length;i++){}</script>" }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 40], text: </script> }
+          position: { start: [0, 0], text: "<script>for (var i=0;i<arr.length;i++){}</script>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: for (var i=0;i<arr.length;i++){}
+            position: { start: [0, 8], text: "for (var i=0;i<arr.length;i++){}" }
+            nodes:
+              - type: TextNode
+                value: for (var i=0;i<arr.length;i++){}
+                position: { start: [0, 8], text: "for (var i=0;i<arr.length;i++){}" }
+  - name: parses a script body with a comparison followed by a double-quoted string
+    source: <script>if(a<b){alert("x")}</script>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: '<script>if(a<b){alert("x")}</script>' }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 27], text: </script> }
+          position: { start: [0, 0], text: '<script>if(a<b){alert("x")}</script>' }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: if(a<b){alert("x")}
+            position: { start: [0, 8], text: 'if(a<b){alert("x")}' }
+            nodes:
+              - type: TextNode
+                value: if(a<b){alert("x")}
+                position: { start: [0, 8], text: 'if(a<b){alert("x")}' }
+  - name: parses a script body with a comparison followed by an apostrophe in a comment
+    source: |-
+      <script>if (i<n) { x() } // don't
+      </script>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          <script>if (i<n) { x() } // don't
+          </script>
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [1, 0], text: </script> }
+          position:
+            start: [0, 0]
+            text: |-
+              <script>if (i<n) { x() } // don't
+              </script>
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: |
+              if (i<n) { x() } // don't
+            position:
+              start: [0, 8]
+              text: |
+                if (i<n) { x() } // don't
+            nodes:
+              - type: TextNode
+                value: if (i<n) { x() } // don't
+                position: { start: [0, 8], text: "if (i<n) { x() } // don't" }
+  - name: parses a script body with a comparison against !
+    source: <script>if (a<!b) {}</script>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<script>if (a<!b) {}</script>" }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 20], text: </script> }
+          position: { start: [0, 0], text: "<script>if (a<!b) {}</script>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: if (a<!b) {}
+            position: { start: [0, 8], text: "if (a<!b) {}" }
+            nodes:
+              - type: TextNode
+                value: if (a<!b) {}
+                position: { start: [0, 8], text: "if (a<!b) {}" }
+  - name: parses a script body with a regex literal followed by an apostrophe
+    source: <script>var r = /<b/; var q = "it's";</script>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <script>var r = /<b/; var q = "it's";</script> }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 37], text: </script> }
+          position: { start: [0, 0], text: <script>var r = /<b/; var q = "it's";</script> }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: var r = /<b/; var q = "it's";
+            position: { start: [0, 8], text: var r = /<b/; var q = "it's"; }
+            nodes:
+              - type: TextNode
+                value: var r = /<b/; var q = "it's";
+                position: { start: [0, 8], text: var r = /<b/; var q = "it's"; }
+  - name: parses a script body with a line comment containing <
+    source: |-
+      <script>// show if count <limit
+      x()</script>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          <script>// show if count <limit
+          x()</script>
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [1, 3], text: </script> }
+          position:
+            start: [0, 0]
+            text: |-
+              <script>// show if count <limit
+              x()</script>
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: |-
+              // show if count <limit
+              x()
+            position:
+              start: [0, 8]
+              text: |-
+                // show if count <limit
+                x()
+            nodes:
+              - type: TextNode
+                value: |-
+                  // show if count <limit
+                  x()
+                position:
+                  start: [0, 8]
+                  text: |-
+                    // show if count <limit
+                    x()
+  - name: parses a minified script body
+    source: <script>for(var e=0;e<t.length;e++){t[e].classList.add("on")}</script>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: '<script>for(var e=0;e<t.length;e++){t[e].classList.add("on")}</script>' }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 61], text: </script> }
+          position: { start: [0, 0], text: '<script>for(var e=0;e<t.length;e++){t[e].classList.add("on")}</script>' }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: for(var e=0;e<t.length;e++){t[e].classList.add("on")}
+            position: { start: [0, 8], text: 'for(var e=0;e<t.length;e++){t[e].classList.add("on")}' }
+            nodes:
+              - type: TextNode
+                value: for(var e=0;e<t.length;e++){t[e].classList.add("on")}
+                position: { start: [0, 8], text: 'for(var e=0;e<t.length;e++){t[e].classList.add("on")}' }
+  - name: parses a style body whose comment contains < and an apostrophe
+    source: "<style>/* <b isn't bold here */ .a { color: red; }</style>"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<style>/* <b isn't bold here */ .a { color: red; }</style>" }
+      children:
+        - type: HtmlRawNode
+          name: style
+          blockStartPosition: { start: [0, 0], text: <style> }
+          blockEndPosition: { start: [0, 50], text: </style> }
+          position: { start: [0, 0], text: "<style>/* <b isn't bold here */ .a { color: red; }</style>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: css
+            value: "/* <b isn't bold here */ .a { color: red; }"
+            position: { start: [0, 7], text: "/* <b isn't bold here */ .a { color: red; }" }
+            nodes:
+              - type: TextNode
+                value: "/* <b isn't bold here */ .a { color: red; }"
+                position: { start: [0, 7], text: "/* <b isn't bold here */ .a { color: red; }" }
+  - name: closes a script body on an upper-case close tag
+    source: <SCRIPT>for(i=0;i<n;i++){}</SCRIPT>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<SCRIPT>for(i=0;i<n;i++){}</SCRIPT>" }
+      children:
+        - type: HtmlRawNode
+          name: SCRIPT
+          blockStartPosition: { start: [0, 0], text: <SCRIPT> }
+          blockEndPosition: { start: [0, 26], text: </SCRIPT> }
+          position: { start: [0, 0], text: "<SCRIPT>for(i=0;i<n;i++){}</SCRIPT>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: for(i=0;i<n;i++){}
+            position: { start: [0, 8], text: "for(i=0;i<n;i++){}" }
+            nodes:
+              - type: TextNode
+                value: for(i=0;i<n;i++){}
+                position: { start: [0, 8], text: "for(i=0;i<n;i++){}" }
+  - name: closes a script body on a close tag with whitespace before >
+    source: |-
+      <script>for(i=0;i<n;i++){}</script 
+      >
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          <script>for(i=0;i<n;i++){}</script 
+          >
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition:
+            start: [0, 26]
+            text: |-
+              </script 
+              >
+          position:
+            start: [0, 0]
+            text: |-
+              <script>for(i=0;i<n;i++){}</script 
+              >
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: for(i=0;i<n;i++){}
+            position: { start: [0, 8], text: "for(i=0;i<n;i++){}" }
+            nodes:
+              - type: TextNode
+                value: for(i=0;i<n;i++){}
+                position: { start: [0, 8], text: "for(i=0;i<n;i++){}" }
+  - name: parses a drop glued to < in a script body
+    source: <script>if (i<{{ max }}) {}</script>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<script>if (i<{{ max }}) {}</script>" }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 27], text: </script> }
+          position: { start: [0, 0], text: "<script>if (i<{{ max }}) {}</script>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: if (i<{{ max }}) {}
+            position: { start: [0, 8], text: "if (i<{{ max }}) {}" }
+            nodes:
+              - type: TextNode
+                value: if (i<
+                position: { start: [0, 8], text: if (i< }
+              - type: LiquidVariableOutput
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                markupPosition: { start: [0, 16], text: " max " }
+                position: { start: [0, 14], text: "{{ max }}" }
+                markup:
+                  type: LiquidVariable
+                  rawSource: max
+                  position: { start: [0, 17], text: "max " }
+                  expression:
+                    type: VariableLookup
+                    name: max
+                    position: { start: [0, 17], text: max }
+                    lookups: []
+                    lookupModes: []
+                  filters: []
+              - type: TextNode
+                value: ) {}
+                position: { start: [0, 23], text: ") {}" }
+  - name: parses a Liquid block after a < comparison in a script body
+    source: <script>for(i=0;i<n;i++){ {% if x %}a(){% endif %} }</script>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<script>for(i=0;i<n;i++){ {% if x %}a(){% endif %} }</script>" }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 52], text: </script> }
+          position: { start: [0, 0], text: "<script>for(i=0;i<n;i++){ {% if x %}a(){% endif %} }</script>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: for(i=0;i<n;i++){ {% if x %}a(){% endif %} }
+            position: { start: [0, 8], text: "for(i=0;i<n;i++){ {% if x %}a(){% endif %} }" }
+            nodes:
+              - type: TextNode
+                value: for(i=0;i<n;i++){
+                position: { start: [0, 8], text: "for(i=0;i<n;i++){" }
+              - type: LiquidTag
+                name: if
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                delimiterWhitespaceStart: ""
+                delimiterWhitespaceEnd: ""
+                blockStartPosition: { start: [0, 26], text: "{% if x %}" }
+                blockEndPosition: { start: [0, 39], text: "{% endif %}" }
+                markupPosition: { start: [0, 32], text: "x " }
+                position: { start: [0, 26], text: "{% if x %}a(){% endif %}" }
+                markup:
+                  type: VariableLookup
+                  name: x
+                  position: { start: [0, 32], text: x }
+                  lookups: []
+                  lookupModes: []
+                children:
+                  - type: LiquidBranch
+                    name: null
+                    markup: ""
+                    whitespaceStart: ""
+                    whitespaceEnd: ""
+                    markupPosition: { start: [0, 36], text: "" }
+                    blockStartPosition: { start: [0, 36], text: "" }
+                    blockEndPosition: { start: [0, 39], text: "" }
+                    position: { start: [0, 36], text: a() }
+                    children:
+                      - type: TextNode
+                        value: a()
+                        position: { start: [0, 36], text: a() }
+              - type: TextNode
+                value: "}"
+                position: { start: [0, 51], text: "}" }
+  - name: parses the HTML after a script body with a < comparison
+    source: <script>if(a<b){}</script><div>after</div>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<script>if(a<b){}</script><div>after</div>" }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 17], text: </script> }
+          position: { start: [0, 0], text: "<script>if(a<b){}</script>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: if(a<b){}
+            position: { start: [0, 8], text: "if(a<b){}" }
+            nodes:
+              - type: TextNode
+                value: if(a<b){}
+                position: { start: [0, 8], text: "if(a<b){}" }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 26], text: <div> }
+          blockEndPosition: { start: [0, 36], text: </div> }
+          position: { start: [0, 26], text: <div>after</div> }
+          name:
+            - type: TextNode
+              value: div
+              position: { start: [0, 27], text: div }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 31], text: after }
+  - name: closes a script body at its own close tag rather than a later script's
+    source: |-
+      <script>if (a<b) {}</script>
+      <div>hi</div>
+      <script>x()</script>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position:
+        start: [0, 0]
+        text: |-
+          <script>if (a<b) {}</script>
+          <div>hi</div>
+          <script>x()</script>
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 19], text: </script> }
+          position: { start: [0, 0], text: "<script>if (a<b) {}</script>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: if (a<b) {}
+            position: { start: [0, 8], text: "if (a<b) {}" }
+            nodes:
+              - type: TextNode
+                value: if (a<b) {}
+                position: { start: [0, 8], text: "if (a<b) {}" }
+        - type: HtmlElement
+          blockStartPosition: { start: [1, 0], text: <div> }
+          blockEndPosition: { start: [1, 7], text: </div> }
+          position: { start: [1, 0], text: <div>hi</div> }
+          name:
+            - type: TextNode
+              value: div
+              position: { start: [1, 1], text: div }
+          attributes: []
+          children:
+            - type: TextNode
+              value: hi
+              position: { start: [1, 5], text: hi }
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [2, 0], text: <script> }
+          blockEndPosition: { start: [2, 11], text: </script> }
+          position: { start: [2, 0], text: <script>x()</script> }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: x()
+            position: { start: [2, 8], text: x() }
+            nodes:
+              - type: TextNode
+                value: x()
+                position: { start: [2, 8], text: x() }
+  - name: does not close a script body on a close tag inside a drop
+    source: <script>for(i=0;i<n;i++){} var s = {{ '</script>' | json }};</script>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<script>for(i=0;i<n;i++){} var s = {{ '</script>' | json }};</script>" }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 60], text: </script> }
+          position: { start: [0, 0], text: "<script>for(i=0;i<n;i++){} var s = {{ '</script>' | json }};</script>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: for(i=0;i<n;i++){} var s = {{ '</script>' | json }};
+            position: { start: [0, 8], text: "for(i=0;i<n;i++){} var s = {{ '</script>' | json }};" }
+            nodes:
+              - type: TextNode
+                value: for(i=0;i<n;i++){} var s =
+                position: { start: [0, 8], text: "for(i=0;i<n;i++){} var s =" }
+              - type: LiquidVariableOutput
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                markupPosition: { start: [0, 37], text: " '</script>' | json " }
+                position: { start: [0, 35], text: "{{ '</script>' | json }}" }
+                markup:
+                  type: LiquidVariable
+                  rawSource: "'</script>' | json"
+                  position: { start: [0, 38], text: "'</script>' | json " }
+                  expression:
+                    type: String
+                    single: true
+                    value: </script>
+                    position: { start: [0, 38], text: "'</script>'" }
+                  filters:
+                    - type: LiquidFilter
+                      name: json
+                      position: { start: [0, 49], text: " | json" }
+                      args: []
+              - type: TextNode
+                value: ;
+                position: { start: [0, 59], text: ; }
+  - name: does not close a script body on a close tag inside a comment
+    source: "<script>if (i<n) {}{% comment %}old: </script>{% endcomment %}</script>"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<script>if (i<n) {}{% comment %}old: </script>{% endcomment %}</script>" }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 62], text: </script> }
+          position: { start: [0, 0], text: "<script>if (i<n) {}{% comment %}old: </script>{% endcomment %}</script>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: "if (i<n) {}{% comment %}old: </script>{% endcomment %}"
+            position: { start: [0, 8], text: "if (i<n) {}{% comment %}old: </script>{% endcomment %}" }
+            nodes:
+              - type: TextNode
+                value: if (i<n) {}
+                position: { start: [0, 8], text: "if (i<n) {}" }
+              - type: LiquidRawTag
+                name: comment
+                markup: ""
+                markupPosition: { start: [0, 30], text: "" }
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                delimiterWhitespaceStart: ""
+                delimiterWhitespaceEnd: ""
+                blockStartPosition: { start: [0, 19], text: "{% comment %}" }
+                blockEndPosition: { start: [0, 46], text: "{% endcomment %}" }
+                position: { start: [0, 19], text: "{% comment %}old: </script>{% endcomment %}" }
+                body:
+                  type: RawMarkup
+                  kind: text
+                  value: "old: </script>"
+                  position: { start: [0, 32], text: "old: </script>" }
+                  nodes:
+                    - type: TextNode
+                      value: "old: </script>"
+                      position: { start: [0, 32], text: "old: </script>" }
+  - name: does not close a script body without a < comparison on a close tag inside a comment
+    source: "<script>x(){% comment %}old: </script>{% endcomment %}</script>"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<script>x(){% comment %}old: </script>{% endcomment %}</script>" }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 54], text: </script> }
+          position: { start: [0, 0], text: "<script>x(){% comment %}old: </script>{% endcomment %}</script>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: "x(){% comment %}old: </script>{% endcomment %}"
+            position: { start: [0, 8], text: "x(){% comment %}old: </script>{% endcomment %}" }
+            nodes:
+              - type: TextNode
+                value: x()
+                position: { start: [0, 8], text: x() }
+              - type: LiquidRawTag
+                name: comment
+                markup: ""
+                markupPosition: { start: [0, 22], text: "" }
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                delimiterWhitespaceStart: ""
+                delimiterWhitespaceEnd: ""
+                blockStartPosition: { start: [0, 11], text: "{% comment %}" }
+                blockEndPosition: { start: [0, 38], text: "{% endcomment %}" }
+                position: { start: [0, 11], text: "{% comment %}old: </script>{% endcomment %}" }
+                body:
+                  type: RawMarkup
+                  kind: text
+                  value: "old: </script>"
+                  position: { start: [0, 24], text: "old: </script>" }
+                  nodes:
+                    - type: TextNode
+                      value: "old: </script>"
+                      position: { start: [0, 24], text: "old: </script>" }
+  - name: does not close a script body on a close tag inside a doc
+    source: <script>if(i<n){}{% doc %}</script>{% enddoc %}</script>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<script>if(i<n){}{% doc %}</script>{% enddoc %}</script>" }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 47], text: </script> }
+          position: { start: [0, 0], text: "<script>if(i<n){}{% doc %}</script>{% enddoc %}</script>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: if(i<n){}{% doc %}</script>{% enddoc %}
+            position: { start: [0, 8], text: "if(i<n){}{% doc %}</script>{% enddoc %}" }
+            nodes:
+              - type: TextNode
+                value: if(i<n){}
+                position: { start: [0, 8], text: "if(i<n){}" }
+              - type: LiquidRawTag
+                name: doc
+                markup: ""
+                markupPosition: { start: [0, 24], text: "" }
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                delimiterWhitespaceStart: ""
+                delimiterWhitespaceEnd: ""
+                blockStartPosition: { start: [0, 17], text: "{% doc %}" }
+                blockEndPosition: { start: [0, 35], text: "{% enddoc %}" }
+                position: { start: [0, 17], text: "{% doc %}</script>{% enddoc %}" }
+                body:
+                  type: RawMarkup
+                  kind: text
+                  value: </script>
+                  position: { start: [0, 26], text: </script> }
+                  nodes:
+                    - type: LiquidDocDescriptionNode
+                      name: description
+                      isImplicit: true
+                      isInline: true
+                      position: { start: [0, 26], text: </script> }
+                      content:
+                        type: TextNode
+                        value: </script>
+                        position: { start: [0, 26], text: </script> }
+  - name: does not close a script body on a close tag inside a raw
+    source: <script>if(i<n){}{% raw %}</script>{% endraw %}</script>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<script>if(i<n){}{% raw %}</script>{% endraw %}</script>" }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 47], text: </script> }
+          position: { start: [0, 0], text: "<script>if(i<n){}{% raw %}</script>{% endraw %}</script>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: if(i<n){}{% raw %}</script>{% endraw %}
+            position: { start: [0, 8], text: "if(i<n){}{% raw %}</script>{% endraw %}" }
+            nodes:
+              - type: TextNode
+                value: if(i<n){}
+                position: { start: [0, 8], text: "if(i<n){}" }
+              - type: LiquidRawTag
+                name: raw
+                markup: ""
+                markupPosition: { start: [0, 24], text: "" }
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                delimiterWhitespaceStart: ""
+                delimiterWhitespaceEnd: ""
+                blockStartPosition: { start: [0, 17], text: "{% raw %}" }
+                blockEndPosition: { start: [0, 35], text: "{% endraw %}" }
+                position: { start: [0, 17], text: "{% raw %}</script>{% endraw %}" }
+                body:
+                  type: RawMarkup
+                  kind: text
+                  value: </script>
+                  position: { start: [0, 26], text: </script> }
+                  nodes:
+                    - type: TextNode
+                      value: </script>
+                      position: { start: [0, 26], text: </script> }
+  - name: does not close a style body on a close tag inside a comment
+    source: <style>/* <b isn't */{% comment %}</style>{% endcomment %}</style>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<style>/* <b isn't */{% comment %}</style>{% endcomment %}</style>" }
+      children:
+        - type: HtmlRawNode
+          name: style
+          blockStartPosition: { start: [0, 0], text: <style> }
+          blockEndPosition: { start: [0, 58], text: </style> }
+          position: { start: [0, 0], text: "<style>/* <b isn't */{% comment %}</style>{% endcomment %}</style>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: text
+            value: /* <b isn't */{% comment %}</style>{% endcomment %}
+            position: { start: [0, 7], text: "/* <b isn't */{% comment %}</style>{% endcomment %}" }
+            nodes:
+              - type: TextNode
+                value: /* <b isn't */
+                position: { start: [0, 7], text: /* <b isn't */ }
+              - type: LiquidRawTag
+                name: comment
+                markup: ""
+                markupPosition: { start: [0, 32], text: "" }
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                delimiterWhitespaceStart: ""
+                delimiterWhitespaceEnd: ""
+                blockStartPosition: { start: [0, 21], text: "{% comment %}" }
+                blockEndPosition: { start: [0, 42], text: "{% endcomment %}" }
+                position: { start: [0, 21], text: "{% comment %}</style>{% endcomment %}" }
+                body:
+                  type: RawMarkup
+                  kind: text
+                  value: </style>
+                  position: { start: [0, 34], text: </style> }
+                  nodes:
+                    - type: TextNode
+                      value: </style>
+                      position: { start: [0, 34], text: </style> }
+  - name: closes a script body after a raw {{ in a string, and parses the markup after it
+    source: <script>var o="{% raw %}{{{% endraw %}";</script><p>{{ x }}</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: '<script>var o="{% raw %}{{{% endraw %}";</script><p>{{ x }}</p>' }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 40], text: </script> }
+          position: { start: [0, 0], text: '<script>var o="{% raw %}{{{% endraw %}";</script>' }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: var o="{% raw %}{{{% endraw %}";
+            position: { start: [0, 8], text: 'var o="{% raw %}{{{% endraw %}";' }
+            nodes:
+              - type: TextNode
+                value: var o="
+                position: { start: [0, 8], text: var o=" }
+              - type: LiquidRawTag
+                name: raw
+                markup: ""
+                markupPosition: { start: [0, 22], text: "" }
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                delimiterWhitespaceStart: ""
+                delimiterWhitespaceEnd: ""
+                blockStartPosition: { start: [0, 15], text: "{% raw %}" }
+                blockEndPosition: { start: [0, 26], text: "{% endraw %}" }
+                position: { start: [0, 15], text: "{% raw %}{{{% endraw %}" }
+                body:
+                  type: RawMarkup
+                  kind: text
+                  value: "{{"
+                  position: { start: [0, 24], text: "{{" }
+                  nodes:
+                    - type: TextNode
+                      value: "{{"
+                      position: { start: [0, 24], text: "{{" }
+              - type: TextNode
+                value: '";'
+                position: { start: [0, 38], text: '";' }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 49], text: <p> }
+          blockEndPosition: { start: [0, 59], text: </p> }
+          position: { start: [0, 49], text: "<p>{{ x }}</p>" }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 50], text: p }
+          attributes: []
+          children:
+            - type: LiquidVariableOutput
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              markupPosition: { start: [0, 54], text: " x " }
+              position: { start: [0, 52], text: "{{ x }}" }
+              markup:
+                type: LiquidVariable
+                rawSource: x
+                position: { start: [0, 55], text: "x " }
+                expression:
+                  type: VariableLookup
+                  name: x
+                  position: { start: [0, 55], text: x }
+                  lookups: []
+                  lookupModes: []
+                filters: []
+  - name: closes a script body after a raw {{ before a < comparison
+    source: <script>{% raw %}{{{% endraw %}if(a<b){}</script><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<script>{% raw %}{{{% endraw %}if(a<b){}</script><p>after</p>" }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 40], text: </script> }
+          position: { start: [0, 0], text: "<script>{% raw %}{{{% endraw %}if(a<b){}</script>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: "{% raw %}{{{% endraw %}if(a<b){}"
+            position: { start: [0, 8], text: "{% raw %}{{{% endraw %}if(a<b){}" }
+            nodes:
+              - type: LiquidRawTag
+                name: raw
+                markup: ""
+                markupPosition: { start: [0, 15], text: "" }
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                delimiterWhitespaceStart: ""
+                delimiterWhitespaceEnd: ""
+                blockStartPosition: { start: [0, 8], text: "{% raw %}" }
+                blockEndPosition: { start: [0, 19], text: "{% endraw %}" }
+                position: { start: [0, 8], text: "{% raw %}{{{% endraw %}" }
+                body:
+                  type: RawMarkup
+                  kind: text
+                  value: "{{"
+                  position: { start: [0, 17], text: "{{" }
+                  nodes:
+                    - type: TextNode
+                      value: "{{"
+                      position: { start: [0, 17], text: "{{" }
+              - type: TextNode
+                value: if(a<b){}
+                position: { start: [0, 31], text: "if(a<b){}" }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 49], text: <p> }
+          blockEndPosition: { start: [0, 57], text: </p> }
+          position: { start: [0, 49], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 50], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 52], text: after }
+  - name: closes a script body after a raw {{ and a later }} around a loop
+    source: <script>var o="{% raw %}{{{% endraw %}"; for(i=0;i<n;i++){} var c="}}";</script><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: '<script>var o="{% raw %}{{{% endraw %}"; for(i=0;i<n;i++){} var c="}}";</script><p>after</p>' }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 71], text: </script> }
+          position: { start: [0, 0], text: '<script>var o="{% raw %}{{{% endraw %}"; for(i=0;i<n;i++){} var c="}}";</script>' }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: var o="{% raw %}{{{% endraw %}"; for(i=0;i<n;i++){} var c="}}";
+            position: { start: [0, 8], text: 'var o="{% raw %}{{{% endraw %}"; for(i=0;i<n;i++){} var c="}}";' }
+            nodes:
+              - type: TextNode
+                value: var o="
+                position: { start: [0, 8], text: var o=" }
+              - type: LiquidRawTag
+                name: raw
+                markup: ""
+                markupPosition: { start: [0, 22], text: "" }
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                delimiterWhitespaceStart: ""
+                delimiterWhitespaceEnd: ""
+                blockStartPosition: { start: [0, 15], text: "{% raw %}" }
+                blockEndPosition: { start: [0, 26], text: "{% endraw %}" }
+                position: { start: [0, 15], text: "{% raw %}{{{% endraw %}" }
+                body:
+                  type: RawMarkup
+                  kind: text
+                  value: "{{"
+                  position: { start: [0, 24], text: "{{" }
+                  nodes:
+                    - type: TextNode
+                      value: "{{"
+                      position: { start: [0, 24], text: "{{" }
+              - type: TextNode
+                value: '"; for(i=0;i<n;i++){} var c="}}";'
+                position: { start: [0, 38], text: '"; for(i=0;i<n;i++){} var c="}}";' }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 80], text: <p> }
+          blockEndPosition: { start: [0, 88], text: </p> }
+          position: { start: [0, 80], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 81], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 83], text: after }
+  - name: closes a script body after raw {{ and }} split across two raw tags
+    source: <script>{% raw %}{{{% endraw %} x {% raw %}}}{% endraw %}; if(a<b){}</script><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<script>{% raw %}{{{% endraw %} x {% raw %}}}{% endraw %}; if(a<b){}</script><p>after</p>" }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 68], text: </script> }
+          position: { start: [0, 0], text: "<script>{% raw %}{{{% endraw %} x {% raw %}}}{% endraw %}; if(a<b){}</script>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: "{% raw %}{{{% endraw %} x {% raw %}}}{% endraw %}; if(a<b){}"
+            position: { start: [0, 8], text: "{% raw %}{{{% endraw %} x {% raw %}}}{% endraw %}; if(a<b){}" }
+            nodes:
+              - type: LiquidRawTag
+                name: raw
+                markup: ""
+                markupPosition: { start: [0, 15], text: "" }
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                delimiterWhitespaceStart: ""
+                delimiterWhitespaceEnd: ""
+                blockStartPosition: { start: [0, 8], text: "{% raw %}" }
+                blockEndPosition: { start: [0, 19], text: "{% endraw %}" }
+                position: { start: [0, 8], text: "{% raw %}{{{% endraw %}" }
+                body:
+                  type: RawMarkup
+                  kind: text
+                  value: "{{"
+                  position: { start: [0, 17], text: "{{" }
+                  nodes:
+                    - type: TextNode
+                      value: "{{"
+                      position: { start: [0, 17], text: "{{" }
+              - type: TextNode
+                value: x
+                position: { start: [0, 32], text: x }
+              - type: LiquidRawTag
+                name: raw
+                markup: ""
+                markupPosition: { start: [0, 41], text: "" }
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                delimiterWhitespaceStart: ""
+                delimiterWhitespaceEnd: ""
+                blockStartPosition: { start: [0, 34], text: "{% raw %}" }
+                blockEndPosition: { start: [0, 45], text: "{% endraw %}" }
+                position: { start: [0, 34], text: "{% raw %}}}{% endraw %}" }
+                body:
+                  type: RawMarkup
+                  kind: text
+                  value: "}}"
+                  position: { start: [0, 43], text: "}}" }
+                  nodes:
+                    - type: TextNode
+                      value: "}}"
+                      position: { start: [0, 43], text: "}}" }
+              - type: TextNode
+                value: ; if(a<b){}
+                position: { start: [0, 57], text: "; if(a<b){}" }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 77], text: <p> }
+          blockEndPosition: { start: [0, 85], text: </p> }
+          position: { start: [0, 77], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 78], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 80], text: after }
+  - name: rejects a script body whose comment has a {{ that swallows the endcomment, as Liquid::Tokenizer does
+    source: <script>{% comment %}{{ old {% endcomment %}for(i=0;i<n;i++){}</script><p>after</p>
+    parse: [html]
+    error:
+      message: Attempting to end parsing before HtmlRawNode 'script' was closed
+      start: [0, 0]
+      text: <script>
+  - name: rejects a script body whose comment has a bare {{ that swallows the endcomment
+    source: <script>{% comment %} {{ {% endcomment %}</script><p>after</p>
+    parse: [html]
+    error:
+      message: Attempting to end parsing before HtmlRawNode 'script' was closed
+      start: [0, 0]
+      text: <script>
+  - name: rejects a script body with an unclosed comment
+    source: <script>if(i<n){}{% comment %}</script>
+    parse: [html]
+    error:
+      message: Attempting to end parsing before HtmlRawNode 'script' was closed
+      start: [0, 0]
+      text: <script>
+  - name: rejects a script with a < comparison that is never closed
+    source: |
+      <script>
+        for (var i=0;i<n;i++){}
+    parse: [html]
+    error:
+      message: Attempting to end parsing before HtmlRawNode 'script' was closed
+      start: [0, 0]
+      text: <script>
+  - name: rejects a script body with an unterminated drop
+    source: <script>if(a<b){} var t = "{{";</script>
+    parse: [html]
+    error:
+      message: Attempting to end parsing before HtmlRawNode 'script' was closed
+      start: [0, 0]
+      text: <script>
diff --git a/specs/parser/liquid-raw.yml b/specs/parser/liquid-raw.yml
index ce2b72584..e2d29988f 100644
--- a/specs/parser/liquid-raw.yml
+++ b/specs/parser/liquid-raw.yml
@@ -667,7 +667,7 @@ cases:
                       - type: TextNode
                         value: <use href="#icon" />
                         position: { start: [0, 18], text: <use href="#icon" /> }
-  - name: should depth-balance nested same-name raw tags and close at the outer tag (issue 156) (1)
+  - name: should depth-balance nested same-name raw tags and close at the outer tag (issue 156)
     source: <svg>a<svg>b</svg>c</svg>
     parse: [html]
     ast:
@@ -690,29 +690,13 @@ cases:
               - type: TextNode
                 value: a<svg>b</svg>c
                 position: { start: [0, 5], text: a<svg>b</svg>c }
-  - name: should depth-balance nested same-name raw tags and close at the outer tag (issue 156) (2)
+  - name: closes a script at its first close tag, as a browser does, so a nested script's close is the script's
     source: <script>a<script>b</script>c</script>
     parse: [html]
-    ast:
-      type: Document
-      name: "#document"
-      position: { start: [0, 0], text: <script>a<script>b</script>c</script> }
-      children:
-        - type: HtmlRawNode
-          name: script
-          blockStartPosition: { start: [0, 0], text: <script> }
-          blockEndPosition: { start: [0, 28], text: </script> }
-          position: { start: [0, 0], text: <script>a<script>b</script>c</script> }
-          attributes: []
-          body:
-            type: RawMarkup
-            kind: javascript
-            value: a<script>b</script>c
-            position: { start: [0, 8], text: a<script>b</script>c }
-            nodes:
-              - type: TextNode
-                value: a<script>b</script>c
-                position: { start: [0, 8], text: a<script>b</script>c }
+    error:
+      message: Attempting to close HtmlElement 'script' before it was opened
+      start: [0, 28]
+      text: </script
   - name: should parse basic raw tag
     source: "{% raw %}hello world{% endraw %}"
     parse: [html]

From f5e177e6079915ee3200e0828bb93b9d7298f74b Mon Sep 17 00:00:00 2001
From: River <river@shopify.com>
Date: Wed, 21 Oct 2026 17:32:57 +0000
Subject: [PATCH 15/20] Give the tokenizer an HTML comment mode

After <!-- the tokenizer recognizes only Liquid delimiters and the
comment's close, so markup in a comment (a <b, an unbalanced quote, a
nested <!--) can't open a tag mode that swallows the -->. The close is -->
or --!>, plus the HTML spec's empty comments <!--> and <!--->. Outside a
comment, --> is text. The parser finds the close by its token, which
replaces the source scan for --> that conditional comments needed.

Liquid raw tag bodies are opaque to the tokenizer too: given the
registry's body rules, it ends a raw body where the parser does,
tokenizes it on its own, and resumes after the end tag in the mode the
tag sat in. So {% comment %}<!-- old {% endcomment %} can't turn the rest
of the file into comment text, and a <b or a quote in a raw body no
longer leaks out.

Outside SVG, <script> and <style> bodies are raw text on the first pass.
Inside an <svg>, up to the </svg> that balances it, <!-- opens no mode:
the parser keeps an svg body raw, and SVG holds CDATA and foreignObject
scripts where <!-- isn't a comment.

Co-Authored-By: Mbarak Bujra <mbarak.bujra@shopify.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../liquid-html-parser/specs/architecture.md  |   10 +-
 .../specs/recursive-descent.md                |    2 +-
 packages/liquid-html-parser/src/ast.ts        |    9 +-
 .../liquid-html-parser/src/document/base.ts   |   15 +-
 .../liquid-html-parser/src/document/html.ts   |   22 +-
 .../liquid-html-parser/src/document/parser.ts |    2 +
 .../src/document/tokenizer.test.ts            |  258 +++-
 .../src/document/tokenizer.ts                 |  212 ++-
 packages/liquid-html-parser/src/tolerant.ts   |    9 +-
 specs/parser/html.yml                         | 1152 ++++++++++++++++-
 specs/parser/liquid-raw.yml                   |  542 ++++++++
 11 files changed, 2192 insertions(+), 41 deletions(-)

diff --git a/packages/liquid-html-parser/specs/architecture.md b/packages/liquid-html-parser/specs/architecture.md
index 9813788a8..2a956d3fa 100644
--- a/packages/liquid-html-parser/specs/architecture.md
+++ b/packages/liquid-html-parser/specs/architecture.md
@@ -146,7 +146,7 @@ The parser calls these utilities while building the AST.
 
 | Module                               | Owns                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Does NOT do                                                                                                                                                   |
 | ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `document/tokenizer.ts`              | Modal document tokenizer. Default mode: scan for `{%`, `%}`, `{{`, `}}`, `<`, `>`, `/>`, `</`, `<!--`, `-->`, `<!`, `---`. In HTML tag context: `=` emits `HtmlEquals`, quotes emit `HtmlQuoteOpen`/`HtmlQuoteClose`. Liquid delimiters take priority inside quoted attribute values. Produces flat `Token[]`.                                                                                                                                                                                                                                                                                                                                      | Expression parsing. Tag-internal parsing. AST construction.                                                                                                   |
+| `document/tokenizer.ts`              | Modal document tokenizer. Default mode: scan for `{%`, `%}`, `{{`, `}}`, `<`, `>`, `/>`, `</`, `<!--`, `<!`, `---`. In HTML comment context and in a Liquid raw tag's body: only Liquid delimiters (and the comment's close). In HTML tag context: `=` emits `HtmlEquals`, quotes emit `HtmlQuoteOpen`/`HtmlQuoteClose`, and each whitespace run is its own `Text` token. Liquid delimiters take priority inside quoted attribute values. Produces flat `Token[]`.                                                                                                                                                                                  | Expression parsing. Tag-internal parsing. AST construction.                                                                                                   |
 | `document/base.ts`                   | `ParserBase` class: shared token consumption primitives (`consume`, `accept`, `check`, `peek`, `advance`, `isAtEnd`, `getSource`, `tokenAt`, `tokenCount`, `getPosition`, `setPosition`).                                                                                                                                                                                                                                                                                                                                                                                                                                                           | Parsing logic. Node construction.                                                                                                                             |
 | `document/parser.ts`                 | `DocumentParser extends ParserBase`. Implements all delegate interfaces. Owns parser-level state: `parseHtml`, `allowUnclosedHtml`, `allowUnclosedDocumentNode`, `inAttributeContext`, `inAttributeValueContext`. Delegates all parsing to free functions in sibling modules via typed interfaces.                                                                                                                                                                                                                                                                                                                                                  | Expression parsing (delegates to `MarkupParser`). Tag-specific markup (delegates to tag functions). Node construction (delegates to `document/factories.ts`). |
 | `document/node-dispatch.ts`          | `parseNode()`: exhaustive switch on `TokenType` routing to the appropriate parse function. `parseYamlFrontmatter()`. `advanceAsText()`. Defines the `NodeDispatchDelegate` interface.                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Liquid tag parsing. HTML element parsing. Expression parsing.                                                                                                 |
@@ -206,7 +206,7 @@ enum TokenType {
   HtmlTagClose, // >
   HtmlSelfClose, // />
   HtmlCommentOpen, // <!--
-  HtmlCommentClose, // -->
+  HtmlCommentClose, // --> or --!>, or > / -> right after <!-- (only in a comment)
   HtmlDoctypeOpen, // <! (not followed by --)
 
   // HTML attribute tokens (emitted only in HTML tag context)
@@ -231,6 +231,10 @@ function tokenize(source: string): Token[];
 
 The tokenizer is modal. After emitting `HtmlTagOpen` or `HtmlCloseTagOpen`, it enters **HTML tag context** where `=` and quotes are significant. It exits HTML tag context on `HtmlTagClose`, `HtmlSelfClose`, or any Liquid open delimiter. Inside quoted attribute values, Liquid delimiters (`{{`, `{%`) take priority and are emitted as their own tokens; the quote context resumes after the Liquid close delimiter.
 
+After `HtmlCommentOpen` (`<!--`), the tokenizer enters **HTML comment context**, where only Liquid delimiters and the comment's close are significant and everything else is `Text`. A tag opener, a quote, a close tag, or a nested `<!--` in a comment can't open a mode that hides the close. The close is `-->` or `--!>`, or `>` or `->` right after `<!--` (the HTML spec's empty comments `<!-->` and `<!--->`). Outside a comment, `-->` is `Text`. Liquid inside a comment is still tokenized, because it still renders. Outside SVG, a `<script>` or `<style>` body is tokenized as raw text (only Liquid and its own close tag), so a `<!--` there is text. Inside an `<svg>` (from its open tag to the `</svg>` token that balances it, where the parser closes it, counting nested `<svg` open tags), `<!--` and `-->` tokenize as they did before comment mode existed and open no mode. An `<svg` glued to Liquid (`<svg{% if x %} class="x"{% endif %}>`) counts as an `<svg>`. The parser keeps an `<svg>` body raw and closes it at that `</svg>` token, and SVG can hold CDATA, `foreignObject` scripts, and other text where `<!--` isn't a comment.
+
+A Liquid raw tag's body (`{% comment %}`, `{% raw %}`, `{% doc %}`, `{% schema %}`, …) is opaque to the tokenizer as well as the parser. `tokenize` takes the tag registry's body rules (`rawBodyRule`, built by `rawBodyRuleLookup`), and after the `%}` of a raw tag it ends the body with `findRawBodyEnd`, the same rule the parser uses. It tokenizes the body on its own as raw text (Liquid delimiters only), then resumes at the end tag in the mode the raw tag sat in. A `<!--`, `<b`, or quote in the body can't change the mode around it, and a stray `{{` in it can't run past the end tag. A body Liquid reports as never closed is tokenized as markup and left to the parser, which throws. `ParserBase` passes the same rules to every re-tokenize.
+
 Tag name extraction is not tokenized. The parser slices the first word from the `Text` token content between `{%` and `%}`. No `LiquidTagName` token type.
 
 When `parseHtml` is false (`toLiquidAST`), the parser ignores HTML token types and accumulates them into `TextNode`. One tokenizer, two parser modes.
@@ -618,7 +622,7 @@ The parser internally uses `BinaryExpr { kind: 'comparison' | 'logical', left, o
 
 ### D5: Modal document tokenizer
 
-After `<` (tag open), the tokenizer enters HTML tag context, emitting `HtmlEquals`, `HtmlQuoteOpen`, `HtmlQuoteClose`. Liquid delimiters take priority inside quoted values. This eliminates all character-level scanning in the parser for attributes.
+After `<` (tag open), the tokenizer enters HTML tag context, emitting `HtmlEquals`, `HtmlQuoteOpen`, `HtmlQuoteClose`. Liquid delimiters take priority inside quoted values. After `<!--`, it enters HTML comment context, where only Liquid and the comment's close are tokens; a Liquid raw tag's body is tokenized on its own as raw text. This eliminates all character-level scanning in the parser for attributes.
 
 Tag name extraction stays simple: slice first word from content between `{%` and `%}`. No `LiquidTagName` token.
 
diff --git a/packages/liquid-html-parser/specs/recursive-descent.md b/packages/liquid-html-parser/specs/recursive-descent.md
index 98583b9f4..de3e0537d 100644
--- a/packages/liquid-html-parser/specs/recursive-descent.md
+++ b/packages/liquid-html-parser/specs/recursive-descent.md
@@ -307,7 +307,7 @@ htmlVoid     := '<' voidTagName attributes '>'
 htmlSelfClosing := '<' tagName attributes '/>'
 htmlRawNode  := '<' rawTagName attributes '>' rawBody '</' rawTagName '>'
 htmlDoctype  := '<!doctype' ... '>'
-htmlComment  := '<!--' ... '-->'
+htmlComment  := '<!--' ... ('-->' | '--!>') | '<!-->' | '<!--->'
 ```
 
 **Tag names can be compound** — they may contain Liquid variable outputs: `<{{ header_type }}--header>`.
diff --git a/packages/liquid-html-parser/src/ast.ts b/packages/liquid-html-parser/src/ast.ts
index 76c478757..dbf19e874 100644
--- a/packages/liquid-html-parser/src/ast.ts
+++ b/packages/liquid-html-parser/src/ast.ts
@@ -18,6 +18,7 @@ import { Comparators, NamedTags, NodeTypes, RawTags, nonTraversableProperties }
 import type { Position } from './types';
 import { DocumentParser } from './document/parser';
 import { tokenize } from './document/tokenizer';
+import { rawBodyRuleLookup } from './document/raw-body';
 import { Environment } from './environment';
 
 /** The union type of all possible node types inside a LiquidHTML AST. */
@@ -966,7 +967,9 @@ export function toLiquidAST(
   },
 ) {
   const env = options.environment ?? Environment.default();
-  const tokens = tokenize(source);
+  const tokens = tokenize(source, {
+    rawBodyRule: rawBodyRuleLookup((name) => env.tagForName(name)),
+  });
   const parser = new DocumentParser(tokens, source, env, false, options.allowUnclosedDocumentNode);
   return parser.parseDocument();
 }
@@ -979,7 +982,9 @@ export function toLiquidHtmlAST(
   },
 ): DocumentNode {
   const env = options.environment ?? Environment.default();
-  const tokens = tokenize(source);
+  const tokens = tokenize(source, {
+    rawBodyRule: rawBodyRuleLookup((name) => env.tagForName(name)),
+  });
   const parser = new DocumentParser(tokens, source, env, true, options.allowUnclosedDocumentNode);
   parser.pairDanglingCloseTags = options.pairDanglingCloseTags ?? false;
   return parser.parseDocument();
diff --git a/packages/liquid-html-parser/src/document/base.ts b/packages/liquid-html-parser/src/document/base.ts
index 84d4fa04a..62a5fb469 100644
--- a/packages/liquid-html-parser/src/document/base.ts
+++ b/packages/liquid-html-parser/src/document/base.ts
@@ -1,6 +1,7 @@
 import { TokenType, createTokenizer, tokenize } from './tokenizer';
 import type { Token, TokenizeOptions, Tokenizer } from './tokenizer';
 import { LiquidHTMLASTParsingError } from '../errors';
+import type { RawBodyRuleFor } from './raw-body';
 
 export class ParserBase {
   protected tokens: Token[];
@@ -16,6 +17,11 @@ export class ParserBase {
   private scanned = 0;
   private openQuote: Token | undefined;
   private openTag = false;
+  /**
+   * The tag registry's raw-tag body rules, passed to every re-tokenize so raw
+   * bodies stay opaque there too (see `TokenizeOptions.rawBodyRule`).
+   */
+  protected rawBodyRule: RawBodyRuleFor | undefined;
   constructor(tokens: Token[], source: string) {
     this.tokens = tokens;
     this.source = source;
@@ -236,6 +242,7 @@ export class ParserBase {
       this.tokens.length = before;
       this.tokenizer ??= createTokenizer(this.source, this.tokens);
       this.tokenizer.restart(sourceOffset, {
+        rawBodyRule: this.rawBodyRule,
         skipFrontmatter: true,
         insideQuotedAttribute,
         insideHtmlTag,
@@ -283,7 +290,7 @@ export class ParserBase {
     } else {
       this.replaceTokens(before, this.tokens.length, body);
       this.tokenizer ??= createTokenizer(this.source, this.tokens);
-      this.tokenizer.restart(bodyEnd, { skipFrontmatter: true });
+      this.tokenizer.restart(bodyEnd, { rawBodyRule: this.rawBodyRule, skipFrontmatter: true });
     }
     this.p = before;
   }
@@ -312,7 +319,11 @@ export class ParserBase {
   // Tokens for `source[start, end)`, with offsets in the whole source, without
   // the slice's EndOfInput.
   private tokenizeSlice(start: number, end: number, options: TokenizeOptions = {}): Token[] {
-    const tokens = tokenize(this.source.slice(start, end), { ...options, skipFrontmatter: true });
+    const tokens = tokenize(this.source.slice(start, end), {
+      ...options,
+      rawBodyRule: this.rawBodyRule,
+      skipFrontmatter: true,
+    });
     return tokens
       .filter((token) => token.type !== TokenType.EndOfInput)
       .map((token) => ({ type: token.type, start: token.start + start, end: token.end + start }));
diff --git a/packages/liquid-html-parser/src/document/html.ts b/packages/liquid-html-parser/src/document/html.ts
index 8c8e04851..6d06459d0 100644
--- a/packages/liquid-html-parser/src/document/html.ts
+++ b/packages/liquid-html-parser/src/document/html.ts
@@ -245,15 +245,11 @@ export function parseHtmlComment(parser: HtmlParserDelegate): HtmlComment {
   const openToken = parser.consume(TokenType.HtmlCommentOpen);
   const bodyStart = openToken.end;
 
-  // Find the closing `-->` by scanning the source rather than walking tokens.
-  // A conditional comment body (`<!--[if IE]>…<![endif]-->`) contains
-  // `<![endif]`, which the tokenizer treats as a doctype open — it enters
-  // HtmlTag mode and consumes the trailing `-->` as an HtmlTagClose, so no
-  // HtmlCommentClose token is ever emitted and the token walk would run to EOF.
-  // A source scan pins us to the real comment close, so the (unchanged)
-  // HtmlComment node feeds getConditionalComment correctly in the printer.
-  const closeIdx = source.indexOf('-->', bodyStart);
-  if (closeIdx === -1) {
+  while (!parser.isAtEnd() && !parser.check(TokenType.HtmlCommentClose)) {
+    parser.advance();
+  }
+
+  if (parser.isAtEnd()) {
     throw new LiquidHTMLASTParsingError(
       `Attempting to end parsing before HtmlComment '<!--' was closed`,
       source,
@@ -262,13 +258,11 @@ export function parseHtmlComment(parser: HtmlParserDelegate): HtmlComment {
     );
   }
 
-  const bodyEnd = closeIdx;
-  const commentEnd = closeIdx + 3; // past `-->`
+  const bodyEnd = parser.peek().start;
+  const closeToken = parser.consume(TokenType.HtmlCommentClose);
   const body = source.slice(bodyStart, bodyEnd).trim();
 
-  parser.seekToSourceOffset(commentEnd);
-
-  return makeHtmlComment(body, openToken.start, commentEnd, source);
+  return makeHtmlComment(body, openToken.start, closeToken.end, source);
 }
 
 // htmlDoctype := "<!" text ">"
diff --git a/packages/liquid-html-parser/src/document/parser.ts b/packages/liquid-html-parser/src/document/parser.ts
index 079c8a149..dac39383e 100644
--- a/packages/liquid-html-parser/src/document/parser.ts
+++ b/packages/liquid-html-parser/src/document/parser.ts
@@ -1,5 +1,6 @@
 import { TokenType } from './tokenizer';
 import type { Token } from './tokenizer';
+import { rawBodyRuleLookup } from './raw-body';
 import { ParserBase } from './base';
 import { makeDocumentNode } from './factories';
 import { ChildFilterMode, filterChildren } from './tree-builder';
@@ -78,6 +79,7 @@ export class DocumentParser
   ) {
     super(tokens, source);
     this.env = env;
+    this.rawBodyRule = rawBodyRuleLookup((name) => env.tagForName(name));
     this._parseHtml = parseHtml;
     this._allowUnclosedHtml = allowUnclosedDocumentNode;
     this._allowUnclosedDocumentNode = allowUnclosedDocumentNode;
diff --git a/packages/liquid-html-parser/src/document/tokenizer.test.ts b/packages/liquid-html-parser/src/document/tokenizer.test.ts
index e198d37ae..89796e2e4 100644
--- a/packages/liquid-html-parser/src/document/tokenizer.test.ts
+++ b/packages/liquid-html-parser/src/document/tokenizer.test.ts
@@ -1,6 +1,8 @@
 import { describe, expect, it } from 'vitest';
 import { tokenize, tokenizeWithoutFastPath, TokenType } from './tokenizer';
 import type { Token, TokenizeOptions } from './tokenizer';
+import { rawBodyRuleLookup } from './raw-body';
+import { Environment } from '../environment';
 
 /** Strip the trailing EndOfInput token for cleaner assertions. */
 function tokens(source: string): Token[] {
@@ -195,6 +197,235 @@ describe('Unit: document-tokenizer', () => {
     });
   });
 
+  describe('HTML comment context (modal)', () => {
+    /** Each token as `[type, source text]`, without EndOfInput. */
+    function texts(source: string): [TokenType, string][] {
+      return tokens(source).map((t) => [t.type, source.slice(t.start, t.end)]);
+    }
+
+    it("reads a tag opener in a comment's body as text", () => {
+      // Before comment mode, `<b` opened HtmlTag mode and `>` closed the tag,
+      // so `-->` never tokenized as a comment close.
+      expect(texts('<!-- a <b --><p>')).toEqual([
+        [TokenType.HtmlCommentOpen, '<!--'],
+        [TokenType.Text, ' a <b '],
+        [TokenType.HtmlCommentClose, '-->'],
+        [TokenType.HtmlTagOpen, '<'],
+        [TokenType.Text, 'p'],
+        [TokenType.HtmlTagClose, '>'],
+      ]);
+    });
+
+    it("reads an unbalanced quote in a comment's body as text", () => {
+      expect(texts('<!-- <a title="x -->')).toEqual([
+        [TokenType.HtmlCommentOpen, '<!--'],
+        [TokenType.Text, ' <a title="x '],
+        [TokenType.HtmlCommentClose, '-->'],
+      ]);
+    });
+
+    it('reads close tags, doctypes, and a nested <!-- as text', () => {
+      expect(texts('<!-- </div> <!DOCTYPE html> <!-- x -->')).toEqual([
+        [TokenType.HtmlCommentOpen, '<!--'],
+        [TokenType.Text, ' </div> <!DOCTYPE html> <!-- x '],
+        [TokenType.HtmlCommentClose, '-->'],
+      ]);
+    });
+
+    it("still tokenizes Liquid in a comment's body", () => {
+      expect(texts('<!-- {{ x }} {%- if y -%} -->')).toEqual([
+        [TokenType.HtmlCommentOpen, '<!--'],
+        [TokenType.Text, ' '],
+        [TokenType.LiquidVariableOutputOpen, '{{'],
+        [TokenType.Text, ' x '],
+        [TokenType.LiquidVariableOutputClose, '}}'],
+        [TokenType.Text, ' '],
+        [TokenType.LiquidTagOpen, '{%-'],
+        [TokenType.Text, ' if y '],
+        [TokenType.LiquidTagClose, '-%}'],
+        [TokenType.Text, ' '],
+        [TokenType.HtmlCommentClose, '-->'],
+      ]);
+    });
+
+    it('does not close a comment on --> inside Liquid', () => {
+      expect(texts("<!-- {{ '-->' }} -->")).toEqual([
+        [TokenType.HtmlCommentOpen, '<!--'],
+        [TokenType.Text, ' '],
+        [TokenType.LiquidVariableOutputOpen, '{{'],
+        [TokenType.Text, " '-->' "],
+        [TokenType.LiquidVariableOutputClose, '}}'],
+        [TokenType.Text, ' '],
+        [TokenType.HtmlCommentClose, '-->'],
+      ]);
+    });
+
+    it('closes a comment on --!>', () => {
+      expect(texts('<!-- a --!> b')).toEqual([
+        [TokenType.HtmlCommentOpen, '<!--'],
+        [TokenType.Text, ' a '],
+        [TokenType.HtmlCommentClose, '--!>'],
+        [TokenType.Text, ' b'],
+      ]);
+    });
+
+    it('closes the empty comments <!--> and <!--->', () => {
+      expect(texts('<!-->a')).toEqual([
+        [TokenType.HtmlCommentOpen, '<!--'],
+        [TokenType.HtmlCommentClose, '>'],
+        [TokenType.Text, 'a'],
+      ]);
+      expect(texts('<!--->a')).toEqual([
+        [TokenType.HtmlCommentOpen, '<!--'],
+        [TokenType.HtmlCommentClose, '->'],
+        [TokenType.Text, 'a'],
+      ]);
+      expect(texts('<!---->')).toEqual([
+        [TokenType.HtmlCommentOpen, '<!--'],
+        [TokenType.HtmlCommentClose, '-->'],
+      ]);
+    });
+
+    it('reads > and -> as text anywhere but right after <!--', () => {
+      expect(texts('<!-- > -> --->')).toEqual([
+        [TokenType.HtmlCommentOpen, '<!--'],
+        [TokenType.Text, ' > -> -'],
+        [TokenType.HtmlCommentClose, '-->'],
+      ]);
+      // Liquid right after `<!--` means the `>` that follows is not `<!-->`.
+      expect(texts('<!--{{ x }}>-->')).toEqual([
+        [TokenType.HtmlCommentOpen, '<!--'],
+        [TokenType.LiquidVariableOutputOpen, '{{'],
+        [TokenType.Text, ' x '],
+        [TokenType.LiquidVariableOutputClose, '}}'],
+        [TokenType.Text, '>'],
+        [TokenType.HtmlCommentClose, '-->'],
+      ]);
+    });
+
+    it('opens no comment inside an <svg>', () => {
+      // The parser closes an `<svg>` raw body at the first `</svg>` token, so a
+      // `<!--` in SVG (in CDATA, a foreignObject script, or a comment that
+      // never closes) must not hide it. Inside SVG, `<!--` opens no mode, as
+      // before comment mode. An `<svg` glued to a Liquid attribute counts too.
+      for (const [open, body] of [
+        ['<svg>', '<text><![CDATA[x > </script> <!-- z]]></text>'],
+        ['<svg>', '<foreignObject><script>s = "<!--";</script></foreignObject>'],
+        ['<svg>', '<!-- icon'],
+        ['<svg{% if x %} class="x"{% endif %}>', '<text><![CDATA[x > <!-- z]]></text>'],
+        // The parser balances a nested `<svg>`, so the outer one is still open after it.
+        ['<svg>', '<svg></svg><text><![CDATA[x > <!-- z]]></text>'],
+        ['<svg>', '<svg/><!-- icon</svg>'],
+      ]) {
+        const result = texts(`${open}${body}</svg><p>`);
+        expect(result.slice(-6, -3)).toEqual([
+          [TokenType.HtmlCloseTagOpen, '</'],
+          [TokenType.Text, 'svg'],
+          [TokenType.HtmlTagClose, '>'],
+        ]);
+      }
+    });
+
+    it('opens comments again after the </svg>', () => {
+      expect(texts('<svg></svg><!-- a <b -->')).toContainEqual([TokenType.HtmlCommentOpen, '<!--']);
+      // A `<svg>` in a script body is text, so it doesn't turn comments off.
+      expect(texts('<script>s = "<svg>";</script><!-- a <b -->')).toContainEqual([
+        TokenType.HtmlCommentOpen,
+        '<!--',
+      ]);
+    });
+
+    it('reads a script or style body as raw text, but not one inside SVG', () => {
+      const types = (source: string) => texts(source).map(([type]) => type);
+      // Outside SVG the body is one Text token, closed by its own close tag.
+      expect(texts('<script>a<b; s = "<!--";</script>')[3]).toEqual([
+        TokenType.Text,
+        'a<b; s = "<!--";',
+      ]);
+      expect(texts('<style>a > b { }</STYLE >')[3]).toEqual([TokenType.Text, 'a > b { }']);
+      // In SVG a `<style>` is markup: its `<b>` is a tag.
+      expect(
+        types('<svg><style><b></b></style></svg>').filter((t) => t === TokenType.HtmlTagOpen),
+      ).toHaveLength(3);
+    });
+
+    it('reads a --> outside a comment as text', () => {
+      expect(texts('a --> b')).toEqual([[TokenType.Text, 'a --> b']]);
+    });
+
+    it("leaves an unclosed comment's body as text to the end", () => {
+      expect(texts('<!-- a <b')).toEqual([
+        [TokenType.HtmlCommentOpen, '<!--'],
+        [TokenType.Text, ' a <b'],
+      ]);
+    });
+  });
+
+  describe('Liquid raw tag bodies (rawBodyRule)', () => {
+    const rawBodyRule = rawBodyRuleLookup((name) => Environment.default().tagForName(name));
+
+    /** Each token as `[type, source text]`, without EndOfInput. */
+    function texts(source: string): [TokenType, string][] {
+      return tokenize(source, { rawBodyRule })
+        .slice(0, -1)
+        .map((t) => [t.type, source.slice(t.start, t.end)]);
+    }
+
+    it('keeps a <!-- in a comment body from opening a comment', () => {
+      expect(texts('{% comment %}<!-- old{% endcomment %}<p>')).toEqual([
+        [TokenType.LiquidTagOpen, '{%'],
+        [TokenType.Text, ' comment '],
+        [TokenType.LiquidTagClose, '%}'],
+        [TokenType.Text, '<!-- old'],
+        [TokenType.LiquidTagOpen, '{%'],
+        [TokenType.Text, ' endcomment '],
+        [TokenType.LiquidTagClose, '%}'],
+        [TokenType.HtmlTagOpen, '<'],
+        [TokenType.Text, 'p'],
+        [TokenType.HtmlTagClose, '>'],
+      ]);
+    });
+
+    it('resumes the mode the raw tag sits in after its end tag', () => {
+      // The `"` in the raw body does not close the attribute value.
+      const result = texts('<a title="{% raw %}"<b{% endraw %}">');
+      expect(result.slice(-3)).toEqual([
+        [TokenType.LiquidTagClose, '%}'],
+        [TokenType.HtmlQuoteClose, '"'],
+        [TokenType.HtmlTagClose, '>'],
+      ]);
+      expect(result).toContainEqual([TokenType.Text, '"<b']);
+    });
+
+    it('bounds a stray {{ in a raw body to the body', () => {
+      expect(texts('{% raw %}{{ a {% endraw %}{{ 1 }}').slice(3)).toEqual([
+        [TokenType.LiquidVariableOutputOpen, '{{'],
+        [TokenType.Text, ' a '],
+        [TokenType.LiquidTagOpen, '{%'],
+        [TokenType.Text, ' endraw '],
+        [TokenType.LiquidTagClose, '%}'],
+        [TokenType.LiquidVariableOutputOpen, '{{'],
+        [TokenType.Text, ' 1 '],
+        [TokenType.LiquidVariableOutputClose, '}}'],
+      ]);
+    });
+
+    it('ends a nested comment body by the comment rule', () => {
+      const source = '{% comment %}{% comment %}<!--{% endcomment %}<b{% endcomment %}<p>';
+      expect(texts(source).slice(-3)).toEqual([
+        [TokenType.HtmlTagOpen, '<'],
+        [TokenType.Text, 'p'],
+        [TokenType.HtmlTagClose, '>'],
+      ]);
+    });
+
+    it('tokenizes an unclosed raw body, and any body without a rule, as markup', () => {
+      expect(texts('{% raw %}<p>')[3]).toEqual([TokenType.HtmlTagOpen, '<']);
+      const withoutRule = tokenize('{% comment %}<p>{% endcomment %}');
+      expect(withoutRule[3]).toMatchObject({ type: TokenType.HtmlTagOpen });
+    });
+  });
+
   describe('HTML tag context (modal)', () => {
     // "<div class="foo">" len=17: 0:< 1:d 2:i 3:v 4:  5:c 6:l 7:a 8:s 9:s 10:= 11:" 12:f 13:o 14:o 15:" 16:>
     it('tokenizes <div class="foo">', () => {
@@ -582,14 +813,15 @@ describe('Unit: document-tokenizer', () => {
       assertTokenInvariants(source);
     });
 
-    it('finds --> and <!-- in the middle of text', () => {
-      const source = 'a-b-->c<!--d';
+    it("finds <!-- and the comment's close in the middle of text", () => {
+      // Outside a comment, `-->` is text.
+      const source = 'a-b-->c<!--d-e-->f';
       expect(tokens(source)).toMatchObject([
-        { type: TokenType.Text, start: 0, end: 3 },
-        { type: TokenType.HtmlCommentClose, start: 3, end: 6 },
-        { type: TokenType.Text, start: 6, end: 7 },
+        { type: TokenType.Text, start: 0, end: 7 },
         { type: TokenType.HtmlCommentOpen, start: 7, end: 11 },
-        { type: TokenType.Text, start: 11, end: 12 },
+        { type: TokenType.Text, start: 11, end: 14 },
+        { type: TokenType.HtmlCommentClose, start: 14, end: 17 },
+        { type: TokenType.Text, start: 17, end: 18 },
       ]);
       assertTokenInvariants(source);
     });
@@ -612,8 +844,10 @@ describe('Unit: document-tokenizer', () => {
         'Default',
         '',
         {},
-        ['{{', '{{-', '{%', '{%-', '<!--', '-->', '<!', '</a', '</Z', '</{', '<a', '<Z', '<{'],
+        ['{{', '{{-', '{%', '{%-', '<!--', '<!', '</a', '</Z', '</{', '<a', '<Z', '<{'],
       ],
+      ['HtmlComment', '<!--', {}, ['{{', '{{-', '{%', '{%-', '-->', '--!>']],
+      ['RawText script', '<script>', {}, ['{{', '{%', '</script>', '</SCRIPT >']],
       [
         'HtmlTag',
         '',
@@ -676,6 +910,9 @@ describe('Unit: document-tokenizer', () => {
           { insideQuotedAttribute: quote },
         ],
       ),
+      ['inside a comment', '<!--', {}],
+      ['inside a script', '<script>', {}],
+      ['inside an svg', '<svg>', {}],
       ['inside a Liquid tag', '{% ', {}],
       ['inside a Liquid output', '{{ ', {}],
     ];
@@ -715,6 +952,13 @@ describe('Unit: document-tokenizer', () => {
       '<br/>',
       '<br />',
       '<!-- comment -->',
+      '<!-- a <b -->',
+      '<!-- <a title="x -->',
+      '<!-- a --!>',
+      '<!-->',
+      '<!--->',
+      '<!-- {{ x }} -->',
+      '<!-- unclosed',
       '<!DOCTYPE html>',
       '<div class="foo">',
       "<div class='foo'>",
diff --git a/packages/liquid-html-parser/src/document/tokenizer.ts b/packages/liquid-html-parser/src/document/tokenizer.ts
index a236f1ea8..c5960e764 100644
--- a/packages/liquid-html-parser/src/document/tokenizer.ts
+++ b/packages/liquid-html-parser/src/document/tokenizer.ts
@@ -1,4 +1,6 @@
 import { assertNever } from '../utils';
+import { findRawBodyEnd, liquidTagTokenName } from './raw-body';
+import type { RawBodyRuleFor } from './raw-body';
 
 export enum TokenType {
   Text = 'Text',
@@ -68,6 +70,17 @@ export interface TokenizeOptions {
    * `ParserBase.retokenizeRawText`.
    */
   rawText?: boolean;
+
+  /**
+   * The body rule of each Liquid raw tag (`comment`, `raw`, `doc`, `schema`,
+   * …), from the tag registry. When set, a raw tag's body is opaque: it ends
+   * where `findRawBodyEnd` ends it, the same rule the parser uses, only
+   * Liquid delimiters are tokens inside it, and the mode before the tag holds
+   * again after it. So a `<!--`, a `<b` or a quote in `{% comment %}` can't
+   * open a mode that outlives the body. Without it, raw bodies are tokenized
+   * like any other markup.
+   */
+  rawBodyRule?: RawBodyRuleFor;
 }
 
 export function tokenize(source: string, options: TokenizeOptions = {}): Token[] {
@@ -118,6 +131,26 @@ export function createTokenizer(source: string, tokens: Token[], fastPath = true
   let textIsSpace = false;
   let quoteChar = '';
   let ended = false;
+  let rawBodyRule: RawBodyRuleFor | undefined;
+  // Where the current comment's body starts, for the spec's empty comments
+  // `<!-->` and `<!--->`, which close only right after `<!--`.
+  let commentBodyStart = -1;
+  // Where the `{%` of the Liquid tag being tokenized starts.
+  let liquidTagStart = -1;
+  // How many `<svg>` elements are open. The parser keeps an `<svg>` body raw
+  // and closes it at the `</svg>` token that balances it, so inside one the
+  // tokenizer opens no comment mode that could hide that token: SVG holds
+  // CDATA, `foreignObject` scripts and other text where a `<!--` is not a
+  // comment. There `<!--` and `-->` tokenize as they did before comment mode.
+  // Nested `<svg` open tags count as `scanForHtmlCloseTag` counts them,
+  // self-closing ones included.
+  let svgDepth = 0;
+  // The element whose open tag is being tokenized, when it is `svg`, `script`
+  // or `style`: the tag's `>` opens it.
+  let pendingElement: 'svg' | 'script' | 'style' | undefined;
+  // The `<script>` or `<style>` whose body is being tokenized in RawText mode,
+  // or "" when the input is a body passed with `rawText` (no close tag).
+  let rawTextTag = '';
   // The last search for `}}`: where it started, and where it found one (-1 for
   // nowhere). Restarts after raw tags can land inside the same unclosed `{{`
   // again and again, and this keeps each from searching the rest anew.
@@ -189,6 +222,12 @@ export function createTokenizer(source: string, tokens: Token[], fastPath = true
     pos = start;
     textStart = -1;
     ended = false;
+    rawBodyRule = options.rawBodyRule;
+    commentBodyStart = -1;
+    liquidTagStart = -1;
+    svgDepth = 0;
+    pendingElement = undefined;
+    rawTextTag = '';
 
     // Resume inside a quoted attribute value when reslicing a suffix that begins
     // mid-attribute (e.g. `...{% endraw %}">` straddled by a stray `{{`). The
@@ -222,7 +261,7 @@ export function createTokenizer(source: string, tokens: Token[], fastPath = true
     }
   }
 
-  // Liquid open check — reused in Default, HtmlTag, and QuotedValue modes
+  // Liquid open check — reused in every mode outside Liquid
   function scanLiquidOpen(): boolean {
     if (source.charCodeAt(pos) !== CHAR_OPEN_BRACE) return false;
     if (match('{{-')) {
@@ -236,11 +275,13 @@ export function createTokenizer(source: string, tokens: Token[], fastPath = true
       return true;
     }
     if (match('{%-')) {
+      liquidTagStart = pos;
       emit(TokenType.LiquidTagOpen, 3);
       pushMode(Mode.LiquidTag);
       return true;
     }
     if (match('{%')) {
+      liquidTagStart = pos;
       emit(TokenType.LiquidTagOpen, 2);
       pushMode(Mode.LiquidTag);
       return true;
@@ -248,6 +289,76 @@ export function createTokenizer(source: string, tokens: Token[], fastPath = true
     return false;
   }
 
+  // After the close of a Liquid tag, when the tag is a raw tag whose body
+  // closes: tokenize the body on its own, so nothing in it can change the mode
+  // the tag sits in, and resume at its end tag in that mode. A body Liquid
+  // reports as never closed is left to the parser, which throws on it.
+  function skipRawBody() {
+    if (!rawBodyRule) return;
+    const name = liquidTagTokenName(source.slice(liquidTagStart, pos));
+    const rule = name === undefined ? undefined : rawBodyRule(name);
+    if (name === undefined || rule === undefined) return;
+    const end = findRawBodyEnd(source, pos, name, rule, rawBodyRule);
+    if (!end || end.tagStart <= pos) return;
+
+    const bodyStart = pos;
+    const body = tokenizeToEnd(
+      source.slice(bodyStart, end.tagStart),
+      { skipFrontmatter: true, rawText: true, rawBodyRule },
+      fastPath,
+    );
+    for (const token of body) {
+      if (token.type === TokenType.EndOfInput) continue;
+      tokens.push({ type: token.type, start: token.start + bodyStart, end: token.end + bodyStart });
+    }
+    pos = end.tagStart;
+  }
+
+  // The lowercase name at `at` when it is `svg`, `script` or `style` followed by
+  // whitespace, `/` or `>` (or the end), as the parser names those elements.
+  function elementNameAt(at: number): 'svg' | 'script' | 'style' | undefined {
+    const match = /^(svg|script|style)(?=[\s/>]|$)/i.exec(source.slice(at, at + 7));
+    if (match) return match[1]!.toLowerCase() as 'svg' | 'script' | 'style';
+    // An `<svg` glued to Liquid, as in `<svg{% if x %} class="x"{% endif %}>`, may
+    // be the `svg` element with a Liquid attribute or a compound name such as
+    // `<svg{{ x }}-icon>`; only the parser can tell. Treat it as an `<svg>`: in
+    // one, comments tokenize as they did before comment mode, so a wrong guess
+    // costs nothing.
+    return /^svg\{/i.test(source.slice(at, at + 4)) ? 'svg' : undefined;
+  }
+
+  // Whether `</` at `at` begins a `</svg>` the parser closes an `<svg>` raw body
+  // on: the whole `</svg>`, whitespace allowed before `>`. `</svg marker>`
+  // doesn't close it, so it doesn't end the SVG body here either.
+  function closesSvg(at: number): boolean {
+    return /^<\/svg\s*>/i.test(source.slice(at, at + 64));
+  }
+
+  // Whether `</` at `at` begins the close tag of the current raw text element:
+  // the whole `</script>`, whitespace allowed before `>`.
+  function closesRawText(at: number): boolean {
+    if (rawTextTag === '') return false;
+    const name = source.slice(at + 2, at + 2 + rawTextTag.length);
+    if (name.toLowerCase() !== rawTextTag) return false;
+    let i = at + 2 + rawTextTag.length;
+    while (i < source.length && /\s/.test(source[i]!)) i++;
+    return source[i] === '>';
+  }
+
+  // At the `>` of an open tag: enter the element it named, if it matters. An
+  // `<svg>` starts an SVG body. A `<script>` or `<style>` outside SVG
+  // has a raw text body; inside SVG it is foreign content, read as markup.
+  function openPendingElement() {
+    const element = pendingElement;
+    pendingElement = undefined;
+    if (element === 'svg') {
+      if (svgDepth === 0) svgDepth = 1;
+    } else if (element !== undefined && svgDepth === 0 && mode === Mode.Default) {
+      rawTextTag = element;
+      pushMode(Mode.RawText);
+    }
+  }
+
   function fill(index: number): boolean {
     while (pos < source.length && tokens.length <= index) {
       switch (mode) {
@@ -255,9 +366,11 @@ export function createTokenizer(source: string, tokens: Token[], fastPath = true
           if (match('-%}')) {
             emit(TokenType.LiquidTagClose, 3);
             popMode();
+            skipRawBody();
           } else if (match('%}')) {
             emit(TokenType.LiquidTagClose, 2);
             popMode();
+            skipRawBody();
           } else {
             startText();
             skipText();
@@ -282,16 +395,25 @@ export function createTokenizer(source: string, tokens: Token[], fastPath = true
         case Mode.Default: {
           if (scanLiquidOpen()) continue;
 
-          if (match('<!--')) {
+          // Inside an `<svg>`, `<!--` and `-->` are the one-off tokens they were
+          // before comment mode, and open no mode.
+          if (match('<!--') && svgDepth > 0) {
             emit(TokenType.HtmlCommentOpen, 4);
             continue;
           }
 
-          if (match('-->')) {
+          if (match('-->') && svgDepth > 0) {
             emit(TokenType.HtmlCommentClose, 3);
             continue;
           }
 
+          if (match('<!--')) {
+            emit(TokenType.HtmlCommentOpen, 4);
+            pushMode(Mode.HtmlComment);
+            commentBodyStart = pos;
+            continue;
+          }
+
           if (match('<!')) {
             emit(TokenType.HtmlDoctypeOpen, 2);
             pushMode(Mode.HtmlTag);
@@ -300,6 +422,7 @@ export function createTokenizer(source: string, tokens: Token[], fastPath = true
 
           if (match('</')) {
             if (isTagNameStart(source.charCodeAt(pos + 2))) {
+              if (svgDepth > 0 && closesSvg(pos)) svgDepth--;
               emit(TokenType.HtmlCloseTagOpen, 2);
               pushMode(Mode.HtmlTag);
               continue;
@@ -308,6 +431,8 @@ export function createTokenizer(source: string, tokens: Token[], fastPath = true
 
           if (ch(0) === '<') {
             if (isTagNameStart(source.charCodeAt(pos + 1))) {
+              pendingElement = elementNameAt(pos + 1);
+              if (svgDepth > 0 && pendingElement === 'svg') svgDepth++;
               emit(TokenType.HtmlTagOpen, 1);
               pushMode(Mode.HtmlTag);
               continue;
@@ -325,12 +450,14 @@ export function createTokenizer(source: string, tokens: Token[], fastPath = true
           if (match('/>')) {
             emit(TokenType.HtmlSelfClose, 2);
             popMode();
+            pendingElement = undefined;
             continue;
           }
 
           if (ch(0) === '>') {
             emit(TokenType.HtmlTagClose, 1);
             popMode();
+            openPendingElement();
             continue;
           }
 
@@ -386,9 +513,61 @@ export function createTokenizer(source: string, tokens: Token[], fastPath = true
           break;
         }
 
+        case Mode.HtmlComment: {
+          // A comment's body is text, except for Liquid, which still renders
+          // inside it, and the comment's close. Markup in the body (`<b`, an
+          // unbalanced quote, a nested `<!--`) is text, as it is to a browser, so
+          // it can't open a tag that swallows the close.
+          if (scanLiquidOpen()) continue;
+
+          // The HTML spec closes `<!-->` and `<!--->` as empty comments
+          // ("abrupt-closing-of-empty-comment"). This applies only right after
+          // `<!--`; anywhere later, `>` and `->` are text.
+          if (pos === commentBodyStart) {
+            if (ch(0) === '>') {
+              emit(TokenType.HtmlCommentClose, 1);
+              popMode();
+              continue;
+            }
+            if (match('->')) {
+              emit(TokenType.HtmlCommentClose, 2);
+              popMode();
+              continue;
+            }
+          }
+
+          if (match('-->')) {
+            emit(TokenType.HtmlCommentClose, 3);
+            popMode();
+            continue;
+          }
+
+          // `--!>` closes a comment too ("incorrectly-closed-comment").
+          if (match('--!>')) {
+            emit(TokenType.HtmlCommentClose, 4);
+            popMode();
+            continue;
+          }
+
+          startText();
+          skipText();
+          break;
+        }
+
         case Mode.RawText: {
+          // A `<script>` or `<style>` body is text, except for Liquid, which
+          // still renders inside it, and the element's close tag. A `<!--`, a
+          // `<svg`, or a quote in the body is text, as it is to a browser.
           if (scanLiquidOpen()) continue;
 
+          if (match('</') && closesRawText(pos)) {
+            popMode();
+            rawTextTag = '';
+            emit(TokenType.HtmlCloseTagOpen, 2);
+            pushMode(Mode.HtmlTag);
+            continue;
+          }
+
           startText();
           skipText();
           break;
@@ -441,6 +620,8 @@ function nextTextCandidate(
       return nextLiquidTagCloseCandidate(source, from);
     case Mode.RawText:
       return nextRawTextCandidate(source, from);
+    case Mode.HtmlComment:
+      return nextHtmlCommentCandidate(source, from);
     default:
       return assertNever(mode);
   }
@@ -457,7 +638,7 @@ const CHAR_OPEN_BRACE = 0x7b; // {
 const CHAR_LEFT_SINGLE_CURLY_QUOTE = 0x2018; // ‘
 const CHAR_RIGHT_DOUBLE_CURLY_QUOTE = 0x201d; // ”
 
-/** Default mode tokens start with `{` (Liquid), `<` (HTML), or `-` (`-->`). */
+/** Default mode tokens start with `{` (Liquid), `<` (HTML), or `-` (`-->` in an `<svg>`). */
 function nextDefaultCandidate(source: string, from: number): number {
   for (let i = from; i < source.length; i++) {
     const c = source.charCodeAt(i);
@@ -466,10 +647,26 @@ function nextDefaultCandidate(source: string, from: number): number {
   return source.length;
 }
 
-/** RawText mode tokens start with `{` (Liquid). */
+/**
+ * HtmlComment mode tokens start with `{` (Liquid) or `-` (`-->`, `--!>`). The
+ * empty-comment closes `>` and `->` are checked only at the body's first
+ * character, before any text run starts.
+ */
+function nextHtmlCommentCandidate(source: string, from: number): number {
+  for (let i = from; i < source.length; i++) {
+    const c = source.charCodeAt(i);
+    if (c === CHAR_OPEN_BRACE || c === CHAR_DASH) return i;
+  }
+  return source.length;
+}
+
+/** RawText mode tokens start with `{` (Liquid) or `<` (the element's close tag). */
 function nextRawTextCandidate(source: string, from: number): number {
-  const i = source.indexOf('{', from);
-  return i === -1 ? source.length : i;
+  for (let i = from; i < source.length; i++) {
+    const c = source.charCodeAt(i);
+    if (c === CHAR_OPEN_BRACE || c === CHAR_LESS_THAN) return i;
+  }
+  return source.length;
 }
 
 /**
@@ -546,6 +743,7 @@ enum Mode {
   LiquidTag = 'LiquidTag',
   LiquidVariableOutput = 'LiquidVariableOutput',
   RawText = 'RawText',
+  HtmlComment = 'HtmlComment',
 }
 
 // Curly (smart) quotes come in directional pairs: a value opened with a left
diff --git a/packages/liquid-html-parser/src/tolerant.ts b/packages/liquid-html-parser/src/tolerant.ts
index 27de69e64..8ad7170a1 100644
--- a/packages/liquid-html-parser/src/tolerant.ts
+++ b/packages/liquid-html-parser/src/tolerant.ts
@@ -14,6 +14,7 @@ import type { ASTBuildOptions, DocumentNode, LiquidErrorNode, LiquidHtmlNode } f
 import { walk } from './ast';
 import { TolerantDocumentParser } from './document/tolerant-parser';
 import { tokenize } from './document/tokenizer';
+import { rawBodyRuleLookup } from './document/raw-body';
 import { Environment } from './environment';
 import { NodeTypes } from './types';
 
@@ -30,7 +31,9 @@ export function toTolerantLiquidAST(
   },
 ): DocumentNode {
   const env = options.environment ?? Environment.default();
-  const tokens = tokenize(source);
+  const tokens = tokenize(source, {
+    rawBodyRule: rawBodyRuleLookup((name) => env.tagForName(name)),
+  });
   const parser = new TolerantDocumentParser(
     tokens,
     source,
@@ -54,7 +57,9 @@ export function toTolerantLiquidHtmlAST(
   },
 ): DocumentNode {
   const env = options.environment ?? Environment.default();
-  const tokens = tokenize(source);
+  const tokens = tokenize(source, {
+    rawBodyRule: rawBodyRuleLookup((name) => env.tagForName(name)),
+  });
   const parser = new TolerantDocumentParser(
     tokens,
     source,
diff --git a/specs/parser/html.yml b/specs/parser/html.yml
index fa87bd545..3df32852c 100644
--- a/specs/parser/html.yml
+++ b/specs/parser/html.yml
@@ -5995,9 +5995,9 @@ cases:
     source: <script>if(i<n){}{% comment %}</script>
     parse: [html]
     error:
-      message: Attempting to end parsing before HtmlRawNode 'script' was closed
-      start: [0, 0]
-      text: <script>
+      message: Attempting to end parsing before LiquidRawTag 'comment' was closed
+      start: [0, 17]
+      text: "{% comment %}"
   - name: rejects a script with a < comparison that is never closed
     source: |
       <script>
@@ -6014,3 +6014,1149 @@ cases:
       message: Attempting to end parsing before HtmlRawNode 'script' was closed
       start: [0, 0]
       text: <script>
+  - name: parses an HTML comment holding a tag opener
+    source: <!-- a <b --><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <!-- a <b --><p>after</p> }
+      children:
+        - type: HtmlComment
+          body: a <b
+          position: { start: [0, 0], text: <!-- a <b --> }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 13], text: <p> }
+          blockEndPosition: { start: [0, 21], text: </p> }
+          position: { start: [0, 13], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 14], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 16], text: after }
+  - name: parses an HTML comment holding an unbalanced quote
+    source: <!-- <a title="x --><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <!-- <a title="x --><p>after</p> }
+      children:
+        - type: HtmlComment
+          body: <a title="x
+          position: { start: [0, 0], text: <!-- <a title="x --> }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 20], text: <p> }
+          blockEndPosition: { start: [0, 28], text: </p> }
+          position: { start: [0, 20], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 21], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 23], text: after }
+  - name: parses an HTML comment holding a close tag
+    source: <!-- </div> --><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <!-- </div> --><p>after</p> }
+      children:
+        - type: HtmlComment
+          body: </div>
+          position: { start: [0, 0], text: <!-- </div> --> }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 15], text: <p> }
+          blockEndPosition: { start: [0, 23], text: </p> }
+          position: { start: [0, 15], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 16], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 18], text: after }
+  - name: parses an HTML comment holding a nested <!--
+    source: <!-- <!-- x --><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <!-- <!-- x --><p>after</p> }
+      children:
+        - type: HtmlComment
+          body: <!-- x
+          position: { start: [0, 0], text: <!-- <!-- x --> }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 15], text: <p> }
+          blockEndPosition: { start: [0, 23], text: </p> }
+          position: { start: [0, 15], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 16], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 18], text: after }
+  - name: parses an HTML comment holding Liquid after a tag opener
+    source: <!-- <b {{ x }} --><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<!-- <b {{ x }} --><p>after</p>" }
+      children:
+        - type: HtmlComment
+          body: <b {{ x }}
+          position: { start: [0, 0], text: "<!-- <b {{ x }} -->" }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 19], text: <p> }
+          blockEndPosition: { start: [0, 27], text: </p> }
+          position: { start: [0, 19], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 20], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 22], text: after }
+  - name: closes an HTML comment on --!>
+    source: <!-- a --!><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <!-- a --!><p>after</p> }
+      children:
+        - type: HtmlComment
+          body: a
+          position: { start: [0, 0], text: <!-- a --!> }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 11], text: <p> }
+          blockEndPosition: { start: [0, 19], text: </p> }
+          position: { start: [0, 11], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 12], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 14], text: after }
+  - name: closes the empty HTML comment <!-->
+    source: <!--><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <!--><p>after</p> }
+      children:
+        - type: HtmlComment
+          body: ""
+          position: { start: [0, 0], text: <!--> }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 5], text: <p> }
+          blockEndPosition: { start: [0, 13], text: </p> }
+          position: { start: [0, 5], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 6], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 8], text: after }
+  - name: closes the empty HTML comment <!--->
+    source: <!---><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <!---><p>after</p> }
+      children:
+        - type: HtmlComment
+          body: ""
+          position: { start: [0, 0], text: <!---> }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 6], text: <p> }
+          blockEndPosition: { start: [0, 14], text: </p> }
+          position: { start: [0, 6], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 7], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 9], text: after }
+  - name: closes the empty HTML comment <!---->
+    source: <!----><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <!----><p>after</p> }
+      children:
+        - type: HtmlComment
+          body: ""
+          position: { start: [0, 0], text: <!----> }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 7], text: <p> }
+          blockEndPosition: { start: [0, 15], text: </p> }
+          position: { start: [0, 7], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 8], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 10], text: after }
+  - name: parses an IE conditional comment
+    source: <!--[if IE]><p>old</p><![endif]-->
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<!--[if IE]><p>old</p><![endif]-->" }
+      children:
+        - type: HtmlComment
+          body: "[if IE]><p>old</p><![endif]"
+          position: { start: [0, 0], text: "<!--[if IE]><p>old</p><![endif]-->" }
+  - name: parses a downlevel-revealed conditional comment
+    source: <!--[if !IE]><!--><p>modern</p><!--<![endif]-->
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<!--[if !IE]><!--><p>modern</p><!--<![endif]-->" }
+      children:
+        - type: HtmlComment
+          body: "[if !IE]><!"
+          position: { start: [0, 0], text: "<!--[if !IE]><!-->" }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 18], text: <p> }
+          blockEndPosition: { start: [0, 27], text: </p> }
+          position: { start: [0, 18], text: <p>modern</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 19], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: modern
+              position: { start: [0, 21], text: modern }
+        - type: HtmlComment
+          body: <![endif]
+          position: { start: [0, 31], text: "<!--<![endif]-->" }
+  - name: parses an HTML comment holding --
+    source: <!-- a -- b -->
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <!-- a -- b --> }
+      children:
+        - type: HtmlComment
+          body: a -- b
+          position: { start: [0, 0], text: <!-- a -- b --> }
+  - name: reads a --> outside an HTML comment as text
+    source: <p>a --> b</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <p>a --> b</p> }
+      children:
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 0], text: <p> }
+          blockEndPosition: { start: [0, 10], text: </p> }
+          position: { start: [0, 0], text: <p>a --> b</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 1], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: a --> b
+              position: { start: [0, 3], text: a --> b }
+  - name: parses an HTML comment inside a Liquid comment
+    source: "{% comment %}<!-- x -->{% endcomment %}<div>y</div>"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% comment %}<!-- x -->{% endcomment %}<div>y</div>" }
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition: { start: [0, 23], text: "{% endcomment %}" }
+          position: { start: [0, 0], text: "{% comment %}<!-- x -->{% endcomment %}" }
+          body:
+            type: RawMarkup
+            kind: text
+            value: <!-- x -->
+            position: { start: [0, 13], text: <!-- x --> }
+            nodes:
+              - type: TextNode
+                value: <!-- x -->
+                position: { start: [0, 13], text: <!-- x --> }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 39], text: <div> }
+          blockEndPosition: { start: [0, 45], text: </div> }
+          position: { start: [0, 39], text: <div>y</div> }
+          name:
+            - type: TextNode
+              value: div
+              position: { start: [0, 40], text: div }
+          attributes: []
+          children:
+            - type: TextNode
+              value: y
+              position: { start: [0, 44], text: y }
+  - name: keeps an HTML comment in a script body as text
+    source: <script><!-- alert(1) //--></script>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <script><!-- alert(1) //--></script> }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 27], text: </script> }
+          position: { start: [0, 0], text: <script><!-- alert(1) //--></script> }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: <!-- alert(1) //-->
+            position: { start: [0, 8], text: <!-- alert(1) //--> }
+            nodes:
+              - type: TextNode
+                value: <!-- alert(1) //-->
+                position: { start: [0, 8], text: <!-- alert(1) //--> }
+  - name: keeps an HTML comment in a style body as text
+    source: "<style><!-- body { color: red } --></style>"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<style><!-- body { color: red } --></style>" }
+      children:
+        - type: HtmlRawNode
+          name: style
+          blockStartPosition: { start: [0, 0], text: <style> }
+          blockEndPosition: { start: [0, 35], text: </style> }
+          position: { start: [0, 0], text: "<style><!-- body { color: red } --></style>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: css
+            value: "<!-- body { color: red } -->"
+            position: { start: [0, 7], text: "<!-- body { color: red } -->" }
+            nodes:
+              - type: TextNode
+                value: "<!-- body { color: red } -->"
+                position: { start: [0, 7], text: "<!-- body { color: red } -->" }
+  - name: keeps an HTML comment in an svg body as text
+    source: <svg><!-- icon --><path d="M0 0"/></svg>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <svg><!-- icon --><path d="M0 0"/></svg> }
+      children:
+        - type: HtmlRawNode
+          name: svg
+          blockStartPosition: { start: [0, 0], text: <svg> }
+          blockEndPosition: { start: [0, 34], text: </svg> }
+          position: { start: [0, 0], text: <svg><!-- icon --><path d="M0 0"/></svg> }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: text
+            value: <!-- icon --><path d="M0 0"/>
+            position: { start: [0, 5], text: <!-- icon --><path d="M0 0"/> }
+            nodes:
+              - type: TextNode
+                value: <!-- icon --><path d="M0 0"/>
+                position: { start: [0, 5], text: <!-- icon --><path d="M0 0"/> }
+  - name: closes a script whose body opens an HTML comment it never closes
+    source: <script>const s = "<!--";</script><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <script>const s = "<!--";</script><p>after</p> }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 25], text: </script> }
+          position: { start: [0, 0], text: <script>const s = "<!--";</script> }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: const s = "<!--";
+            position: { start: [0, 8], text: const s = "<!--"; }
+            nodes:
+              - type: TextNode
+                value: const s = "<!--";
+                position: { start: [0, 8], text: const s = "<!--"; }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 34], text: <p> }
+          blockEndPosition: { start: [0, 42], text: </p> }
+          position: { start: [0, 34], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 35], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 37], text: after }
+  - name: closes a script whose body opens a quoted attribute it never closes
+    source: <script>const s = "<a title='x";</script><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <script>const s = "<a title='x";</script><p>after</p> }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 32], text: </script> }
+          position: { start: [0, 0], text: <script>const s = "<a title='x";</script> }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: const s = "<a title='x";
+            position: { start: [0, 8], text: const s = "<a title='x"; }
+            nodes:
+              - type: TextNode
+                value: const s = "<a title='x";
+                position: { start: [0, 8], text: const s = "<a title='x"; }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 41], text: <p> }
+          blockEndPosition: { start: [0, 49], text: </p> }
+          position: { start: [0, 41], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 42], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 44], text: after }
+  - name: closes a style whose body opens an HTML comment it never closes
+    source: '<style>.x::after { content: "<!--"; }</style><p>after</p>'
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: '<style>.x::after { content: "<!--"; }</style><p>after</p>' }
+      children:
+        - type: HtmlRawNode
+          name: style
+          blockStartPosition: { start: [0, 0], text: <style> }
+          blockEndPosition: { start: [0, 37], text: </style> }
+          position: { start: [0, 0], text: '<style>.x::after { content: "<!--"; }</style>' }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: css
+            value: '.x::after { content: "<!--"; }'
+            position: { start: [0, 7], text: '.x::after { content: "<!--"; }' }
+            nodes:
+              - type: TextNode
+                value: '.x::after { content: "<!--"; }'
+                position: { start: [0, 7], text: '.x::after { content: "<!--"; }' }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 45], text: <p> }
+          blockEndPosition: { start: [0, 53], text: </p> }
+          position: { start: [0, 45], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 46], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 48], text: after }
+  - name: closes an svg holding a <!-- in CDATA
+    source: <svg><text><![CDATA[x > y <!-- z]]></text></svg><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<svg><text><![CDATA[x > y <!-- z]]></text></svg><p>after</p>" }
+      children:
+        - type: HtmlRawNode
+          name: svg
+          blockStartPosition: { start: [0, 0], text: <svg> }
+          blockEndPosition: { start: [0, 42], text: </svg> }
+          position: { start: [0, 0], text: "<svg><text><![CDATA[x > y <!-- z]]></text></svg>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: text
+            value: <text><![CDATA[x > y <!-- z]]></text>
+            position: { start: [0, 5], text: "<text><![CDATA[x > y <!-- z]]></text>" }
+            nodes:
+              - type: TextNode
+                value: <text><![CDATA[x > y <!-- z]]></text>
+                position: { start: [0, 5], text: "<text><![CDATA[x > y <!-- z]]></text>" }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 48], text: <p> }
+          blockEndPosition: { start: [0, 56], text: </p> }
+          position: { start: [0, 48], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 49], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 51], text: after }
+  - name: closes an svg holding a <!-- in a CDATA style
+    source: '<svg><style><![CDATA[a > b { content: "<!--" }]]></style></svg><p>after</p>'
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: '<svg><style><![CDATA[a > b { content: "<!--" }]]></style></svg><p>after</p>' }
+      children:
+        - type: HtmlRawNode
+          name: svg
+          blockStartPosition: { start: [0, 0], text: <svg> }
+          blockEndPosition: { start: [0, 57], text: </svg> }
+          position: { start: [0, 0], text: '<svg><style><![CDATA[a > b { content: "<!--" }]]></style></svg>' }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: text
+            value: '<style><![CDATA[a > b { content: "<!--" }]]></style>'
+            position: { start: [0, 5], text: '<style><![CDATA[a > b { content: "<!--" }]]></style>' }
+            nodes:
+              - type: TextNode
+                value: '<style><![CDATA[a > b { content: "<!--" }]]></style>'
+                position: { start: [0, 5], text: '<style><![CDATA[a > b { content: "<!--" }]]></style>' }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 63], text: <p> }
+          blockEndPosition: { start: [0, 71], text: </p> }
+          position: { start: [0, 63], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 64], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 66], text: after }
+  - name: closes an svg holding a <!-- in CDATA, after a ]]> inside a Liquid comment
+    source: <svg><text><![CDATA[x > {% comment %}]]>{% endcomment %} <!-- z]]></text></svg><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<svg><text><![CDATA[x > {% comment %}]]>{% endcomment %} <!-- z]]></text></svg><p>after</p>" }
+      children:
+        - type: HtmlRawNode
+          name: svg
+          blockStartPosition: { start: [0, 0], text: <svg> }
+          blockEndPosition: { start: [0, 73], text: </svg> }
+          position: { start: [0, 0], text: "<svg><text><![CDATA[x > {% comment %}]]>{% endcomment %} <!-- z]]></text></svg>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: text
+            value: <text><![CDATA[x > {% comment %}]]>{% endcomment %} <!-- z]]></text>
+            position: { start: [0, 5], text: "<text><![CDATA[x > {% comment %}]]>{% endcomment %} <!-- z]]></text>" }
+            nodes:
+              - type: TextNode
+                value: <text><![CDATA[x >
+                position: { start: [0, 5], text: "<text><![CDATA[x >" }
+              - type: LiquidRawTag
+                name: comment
+                markup: ""
+                markupPosition: { start: [0, 35], text: "" }
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                delimiterWhitespaceStart: ""
+                delimiterWhitespaceEnd: ""
+                blockStartPosition: { start: [0, 24], text: "{% comment %}" }
+                blockEndPosition: { start: [0, 40], text: "{% endcomment %}" }
+                position: { start: [0, 24], text: "{% comment %}]]>{% endcomment %}" }
+                body:
+                  type: RawMarkup
+                  kind: text
+                  value: "]]>"
+                  position: { start: [0, 37], text: "]]>" }
+                  nodes:
+                    - type: TextNode
+                      value: "]]>"
+                      position: { start: [0, 37], text: "]]>" }
+              - type: TextNode
+                value: <!-- z]]></text>
+                position: { start: [0, 57], text: "<!-- z]]></text>" }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 79], text: <p> }
+          blockEndPosition: { start: [0, 87], text: </p> }
+          position: { start: [0, 79], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 80], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 82], text: after }
+  - name: closes an svg holding a <!-- in CDATA, after a </script>
+    source: <svg><text><![CDATA[x > </script> <!-- z]]></text></svg><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<svg><text><![CDATA[x > </script> <!-- z]]></text></svg><p>after</p>" }
+      children:
+        - type: HtmlRawNode
+          name: svg
+          blockStartPosition: { start: [0, 0], text: <svg> }
+          blockEndPosition: { start: [0, 50], text: </svg> }
+          position: { start: [0, 0], text: "<svg><text><![CDATA[x > </script> <!-- z]]></text></svg>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: text
+            value: <text><![CDATA[x > </script> <!-- z]]></text>
+            position: { start: [0, 5], text: "<text><![CDATA[x > </script> <!-- z]]></text>" }
+            nodes:
+              - type: TextNode
+                value: <text><![CDATA[x > </script> <!-- z]]></text>
+                position: { start: [0, 5], text: "<text><![CDATA[x > </script> <!-- z]]></text>" }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 56], text: <p> }
+          blockEndPosition: { start: [0, 64], text: </p> }
+          position: { start: [0, 56], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 57], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 59], text: after }
+  - name: closes an svg holding a <!-- in a CDATA script, after a </style>
+    source: <svg><script><![CDATA[if (a < b) s = '</style> <!--';]]></script></svg><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<svg><script><![CDATA[if (a < b) s = '</style> <!--';]]></script></svg><p>after</p>" }
+      children:
+        - type: HtmlRawNode
+          name: svg
+          blockStartPosition: { start: [0, 0], text: <svg> }
+          blockEndPosition: { start: [0, 65], text: </svg> }
+          position: { start: [0, 0], text: "<svg><script><![CDATA[if (a < b) s = '</style> <!--';]]></script></svg>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: text
+            value: <script><![CDATA[if (a < b) s = '</style> <!--';]]></script>
+            position: { start: [0, 5], text: "<script><![CDATA[if (a < b) s = '</style> <!--';]]></script>" }
+            nodes:
+              - type: TextNode
+                value: <script><![CDATA[if (a < b) s = '</style> <!--';]]></script>
+                position: { start: [0, 5], text: "<script><![CDATA[if (a < b) s = '</style> <!--';]]></script>" }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 71], text: <p> }
+          blockEndPosition: { start: [0, 79], text: </p> }
+          position: { start: [0, 71], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 72], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 74], text: after }
+  - name: closes an svg holding a <!-- in a foreignObject script
+    source: <svg><foreignObject><script>const s = "<!--";</script></foreignObject></svg><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <svg><foreignObject><script>const s = "<!--";</script></foreignObject></svg><p>after</p> }
+      children:
+        - type: HtmlRawNode
+          name: svg
+          blockStartPosition: { start: [0, 0], text: <svg> }
+          blockEndPosition: { start: [0, 70], text: </svg> }
+          position: { start: [0, 0], text: <svg><foreignObject><script>const s = "<!--";</script></foreignObject></svg> }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: text
+            value: <foreignObject><script>const s = "<!--";</script></foreignObject>
+            position: { start: [0, 5], text: <foreignObject><script>const s = "<!--";</script></foreignObject> }
+            nodes:
+              - type: TextNode
+                value: <foreignObject><script>const s = "<!--";</script></foreignObject>
+                position: { start: [0, 5], text: <foreignObject><script>const s = "<!--";</script></foreignObject> }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 76], text: <p> }
+          blockEndPosition: { start: [0, 84], text: </p> }
+          position: { start: [0, 76], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 77], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 79], text: after }
+  - name: closes an svg holding a <!-- in a foreignObject style
+    source: '<svg><foreignObject><style>a::after { content: "<!--" }</style></foreignObject></svg><p>after</p>'
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: '<svg><foreignObject><style>a::after { content: "<!--" }</style></foreignObject></svg><p>after</p>' }
+      children:
+        - type: HtmlRawNode
+          name: svg
+          blockStartPosition: { start: [0, 0], text: <svg> }
+          blockEndPosition: { start: [0, 79], text: </svg> }
+          position: { start: [0, 0], text: '<svg><foreignObject><style>a::after { content: "<!--" }</style></foreignObject></svg>' }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: text
+            value: '<foreignObject><style>a::after { content: "<!--" }</style></foreignObject>'
+            position: { start: [0, 5], text: '<foreignObject><style>a::after { content: "<!--" }</style></foreignObject>' }
+            nodes:
+              - type: TextNode
+                value: '<foreignObject><style>a::after { content: "<!--" }</style></foreignObject>'
+                position: { start: [0, 5], text: '<foreignObject><style>a::after { content: "<!--" }</style></foreignObject>' }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 85], text: <p> }
+          blockEndPosition: { start: [0, 93], text: </p> }
+          position: { start: [0, 85], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 86], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 88], text: after }
+  - name: closes an svg holding an HTML comment that never closes
+    source: <svg><!-- icon</svg><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <svg><!-- icon</svg><p>after</p> }
+      children:
+        - type: HtmlRawNode
+          name: svg
+          blockStartPosition: { start: [0, 0], text: <svg> }
+          blockEndPosition: { start: [0, 14], text: </svg> }
+          position: { start: [0, 0], text: <svg><!-- icon</svg> }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: text
+            value: <!-- icon
+            position: { start: [0, 5], text: <!-- icon }
+            nodes:
+              - type: TextNode
+                value: <!-- icon
+                position: { start: [0, 5], text: <!-- icon }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 20], text: <p> }
+          blockEndPosition: { start: [0, 28], text: </p> }
+          position: { start: [0, 20], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 21], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 23], text: after }
+  - name: closes an svg holding a <!-- in CDATA, after a </svg marker>
+    source: <svg><text><![CDATA[a > </svg marker> <!-- z]]></text></svg><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<svg><text><![CDATA[a > </svg marker> <!-- z]]></text></svg><p>after</p>" }
+      children:
+        - type: HtmlRawNode
+          name: svg
+          blockStartPosition: { start: [0, 0], text: <svg> }
+          blockEndPosition: { start: [0, 54], text: </svg> }
+          position: { start: [0, 0], text: "<svg><text><![CDATA[a > </svg marker> <!-- z]]></text></svg>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: text
+            value: <text><![CDATA[a > </svg marker> <!-- z]]></text>
+            position: { start: [0, 5], text: "<text><![CDATA[a > </svg marker> <!-- z]]></text>" }
+            nodes:
+              - type: TextNode
+                value: <text><![CDATA[a > </svg marker> <!-- z]]></text>
+                position: { start: [0, 5], text: "<text><![CDATA[a > </svg marker> <!-- z]]></text>" }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 60], text: <p> }
+          blockEndPosition: { start: [0, 68], text: </p> }
+          position: { start: [0, 60], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 61], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 63], text: after }
+  - name: parses an HTML comment after a script whose body holds an unpaired <![CDATA[
+    source: <script>/* <![CDATA[ */ if (x > y) {}</script><!-- </div> --><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<script>/* <![CDATA[ */ if (x > y) {}</script><!-- </div> --><p>after</p>" }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 37], text: </script> }
+          position: { start: [0, 0], text: "<script>/* <![CDATA[ */ if (x > y) {}</script>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: /* <![CDATA[ */ if (x > y) {}
+            position: { start: [0, 8], text: "/* <![CDATA[ */ if (x > y) {}" }
+            nodes:
+              - type: TextNode
+                value: /* <![CDATA[ */ if (x > y) {}
+                position: { start: [0, 8], text: "/* <![CDATA[ */ if (x > y) {}" }
+        - type: HtmlComment
+          body: </div>
+          position: { start: [0, 46], text: <!-- </div> --> }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 61], text: <p> }
+          blockEndPosition: { start: [0, 69], text: </p> }
+          position: { start: [0, 61], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 62], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 64], text: after }
+  - name: parses an HTML comment after a style whose body holds an unpaired <![CDATA[
+    source: <style>/* <![CDATA[ */ a > b {}</style><!-- </div> --><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<style>/* <![CDATA[ */ a > b {}</style><!-- </div> --><p>after</p>" }
+      children:
+        - type: HtmlRawNode
+          name: style
+          blockStartPosition: { start: [0, 0], text: <style> }
+          blockEndPosition: { start: [0, 31], text: </style> }
+          position: { start: [0, 0], text: "<style>/* <![CDATA[ */ a > b {}</style>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: css
+            value: /* <![CDATA[ */ a > b {}
+            position: { start: [0, 7], text: "/* <![CDATA[ */ a > b {}" }
+            nodes:
+              - type: TextNode
+                value: /* <![CDATA[ */ a > b {}
+                position: { start: [0, 7], text: "/* <![CDATA[ */ a > b {}" }
+        - type: HtmlComment
+          body: </div>
+          position: { start: [0, 39], text: <!-- </div> --> }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 54], text: <p> }
+          blockEndPosition: { start: [0, 62], text: </p> }
+          position: { start: [0, 54], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 55], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 57], text: after }
+  - name: closes an svg whose open tag has a glued Liquid attribute
+    source: <svg{% if x %} class="x"{% endif %}><text><![CDATA[x > <!-- z]]></text></svg><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: '<svg{% if x %} class="x"{% endif %}><text><![CDATA[x > <!-- z]]></text></svg><p>after</p>' }
+      children:
+        - type: HtmlRawNode
+          name: svg
+          blockStartPosition: { start: [0, 0], text: '<svg{% if x %} class="x"{% endif %}>' }
+          blockEndPosition: { start: [0, 71], text: </svg> }
+          position: { start: [0, 0], text: '<svg{% if x %} class="x"{% endif %}><text><![CDATA[x > <!-- z]]></text></svg>' }
+          attributes:
+            - type: LiquidTag
+              name: if
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              delimiterWhitespaceStart: ""
+              delimiterWhitespaceEnd: ""
+              blockStartPosition: { start: [0, 4], text: "{% if x %}" }
+              blockEndPosition: { start: [0, 24], text: "{% endif %}" }
+              markupPosition: { start: [0, 10], text: "x " }
+              position: { start: [0, 4], text: '{% if x %} class="x"{% endif %}' }
+              markup:
+                type: VariableLookup
+                name: x
+                position: { start: [0, 10], text: x }
+                lookups: []
+                lookupModes: []
+              children:
+                - type: LiquidBranch
+                  name: null
+                  markup: ""
+                  whitespaceStart: ""
+                  whitespaceEnd: ""
+                  markupPosition: { start: [0, 14], text: "" }
+                  blockStartPosition: { start: [0, 14], text: "" }
+                  blockEndPosition: { start: [0, 24], text: "" }
+                  position: { start: [0, 14], text: ' class="x"' }
+                  children:
+                    - type: AttrDoubleQuoted
+                      attributePosition: { start: [0, 22], text: x }
+                      position: { start: [0, 15], text: class="x" }
+                      name:
+                        - type: TextNode
+                          value: class
+                          position: { start: [0, 15], text: class }
+                      value:
+                        - type: TextNode
+                          value: x
+                          position: { start: [0, 22], text: x }
+          body:
+            type: RawMarkup
+            kind: text
+            value: <text><![CDATA[x > <!-- z]]></text>
+            position: { start: [0, 36], text: "<text><![CDATA[x > <!-- z]]></text>" }
+            nodes:
+              - type: TextNode
+                value: <text><![CDATA[x > <!-- z]]></text>
+                position: { start: [0, 36], text: "<text><![CDATA[x > <!-- z]]></text>" }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 77], text: <p> }
+          blockEndPosition: { start: [0, 85], text: </p> }
+          position: { start: [0, 77], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 78], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 80], text: after }
+  - name: does not close a script body on a close tag inside a drop before a <!--
+    source: <script>{{ '</script>' }}<!--</script>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<script>{{ '</script>' }}<!--</script>" }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 29], text: </script> }
+          position: { start: [0, 0], text: "<script>{{ '</script>' }}<!--</script>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: "{{ '</script>' }}<!--"
+            position: { start: [0, 8], text: "{{ '</script>' }}<!--" }
+            nodes:
+              - type: LiquidVariableOutput
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                markupPosition: { start: [0, 10], text: " '</script>' " }
+                position: { start: [0, 8], text: "{{ '</script>' }}" }
+                markup:
+                  type: LiquidVariable
+                  rawSource: "'</script>'"
+                  position: { start: [0, 11], text: "'</script>' " }
+                  expression:
+                    type: String
+                    single: true
+                    value: </script>
+                    position: { start: [0, 11], text: "'</script>'" }
+                  filters: []
+              - type: TextNode
+                value: <!--
+                position: { start: [0, 25], text: <!-- }
+  - name: parses Liquid in an HTML comment holding an unbalanced quote
+    source: <!-- <a title="{{ x }} -->
+    parse: [liquid]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: '<!-- <a title="{{ x }} -->' }
+      children:
+        - type: TextNode
+          value: <!-- <a title="
+          position: { start: [0, 0], text: <!-- <a title=" }
+        - type: LiquidVariableOutput
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          markupPosition: { start: [0, 17], text: " x " }
+          position: { start: [0, 15], text: "{{ x }}" }
+          markup:
+            type: LiquidVariable
+            rawSource: x
+            position: { start: [0, 18], text: "x " }
+            expression:
+              type: VariableLookup
+              name: x
+              position: { start: [0, 18], text: x }
+              lookups: []
+              lookupModes: []
+            filters: []
+        - type: TextNode
+          value: -->
+          position: { start: [0, 23], text: --> }
+  - name: closes a nested svg at its outer </svg> when CDATA after the inner one holds a <!--
+    source: <svg><svg></svg><text><![CDATA[a > <!-- z]]></text></svg><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<svg><svg></svg><text><![CDATA[a > <!-- z]]></text></svg><p>after</p>" }
+      children:
+        - type: HtmlRawNode
+          name: svg
+          blockStartPosition: { start: [0, 0], text: <svg> }
+          blockEndPosition: { start: [0, 51], text: </svg> }
+          position: { start: [0, 0], text: "<svg><svg></svg><text><![CDATA[a > <!-- z]]></text></svg>" }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: text
+            value: <svg></svg><text><![CDATA[a > <!-- z]]></text>
+            position: { start: [0, 5], text: "<svg></svg><text><![CDATA[a > <!-- z]]></text>" }
+            nodes:
+              - type: TextNode
+                value: <svg></svg><text><![CDATA[a > <!-- z]]></text>
+                position: { start: [0, 5], text: "<svg></svg><text><![CDATA[a > <!-- z]]></text>" }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 57], text: <p> }
+          blockEndPosition: { start: [0, 65], text: </p> }
+          position: { start: [0, 57], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 58], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 60], text: after }
+  - name: parses an HTML comment right after a nested svg
+    source: <svg><svg></svg></svg><!-- </div> --><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <svg><svg></svg></svg><!-- </div> --><p>after</p> }
+      children:
+        - type: HtmlRawNode
+          name: svg
+          blockStartPosition: { start: [0, 0], text: <svg> }
+          blockEndPosition: { start: [0, 16], text: </svg> }
+          position: { start: [0, 0], text: <svg><svg></svg></svg> }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: text
+            value: <svg></svg>
+            position: { start: [0, 5], text: <svg></svg> }
+            nodes:
+              - type: TextNode
+                value: <svg></svg>
+                position: { start: [0, 5], text: <svg></svg> }
+        - type: HtmlComment
+          body: </div>
+          position: { start: [0, 22], text: <!-- </div> --> }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 37], text: <p> }
+          blockEndPosition: { start: [0, 45], text: </p> }
+          position: { start: [0, 37], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 38], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 40], text: after }
diff --git a/specs/parser/liquid-raw.yml b/specs/parser/liquid-raw.yml
index e2d29988f..33acdff5c 100644
--- a/specs/parser/liquid-raw.yml
+++ b/specs/parser/liquid-raw.yml
@@ -2858,3 +2858,545 @@ cases:
                   lookups: []
                   lookupModes: []
                 filters: []
+  - name: parses the markup after a comment whose body opens a tag
+    source: "{% comment %} a<b {% endcomment %}<div>x</div>"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% comment %} a<b {% endcomment %}<div>x</div>" }
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition: { start: [0, 18], text: "{% endcomment %}" }
+          position: { start: [0, 0], text: "{% comment %} a<b {% endcomment %}" }
+          body:
+            type: RawMarkup
+            kind: text
+            value: " a<b "
+            position: { start: [0, 13], text: " a<b " }
+            nodes:
+              - type: TextNode
+                value: a<b
+                position: { start: [0, 14], text: a<b }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 34], text: <div> }
+          blockEndPosition: { start: [0, 40], text: </div> }
+          position: { start: [0, 34], text: <div>x</div> }
+          name:
+            - type: TextNode
+              value: div
+              position: { start: [0, 35], text: div }
+          attributes: []
+          children:
+            - type: TextNode
+              value: x
+              position: { start: [0, 39], text: x }
+  - name: parses the markup after a comment whose body opens a quoted attribute
+    source: '{% comment %} <a title="x {% endcomment %}<div>x</div>'
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: '{% comment %} <a title="x {% endcomment %}<div>x</div>' }
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition: { start: [0, 26], text: "{% endcomment %}" }
+          position: { start: [0, 0], text: '{% comment %} <a title="x {% endcomment %}' }
+          body:
+            type: RawMarkup
+            kind: text
+            value: ' <a title="x '
+            position: { start: [0, 13], text: ' <a title="x ' }
+            nodes:
+              - type: TextNode
+                value: <a title="x
+                position: { start: [0, 14], text: <a title="x }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 42], text: <div> }
+          blockEndPosition: { start: [0, 48], text: </div> }
+          position: { start: [0, 42], text: <div>x</div> }
+          name:
+            - type: TextNode
+              value: div
+              position: { start: [0, 43], text: div }
+          attributes: []
+          children:
+            - type: TextNode
+              value: x
+              position: { start: [0, 47], text: x }
+  - name: parses the markup after a comment whose body opens an HTML comment
+    source: "{% comment %}<!-- old {% endcomment %}<div>x</div>"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% comment %}<!-- old {% endcomment %}<div>x</div>" }
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition: { start: [0, 22], text: "{% endcomment %}" }
+          position: { start: [0, 0], text: "{% comment %}<!-- old {% endcomment %}" }
+          body:
+            type: RawMarkup
+            kind: text
+            value: "<!-- old "
+            position: { start: [0, 13], text: "<!-- old " }
+            nodes:
+              - type: TextNode
+                value: <!-- old
+                position: { start: [0, 13], text: <!-- old }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 38], text: <div> }
+          blockEndPosition: { start: [0, 44], text: </div> }
+          position: { start: [0, 38], text: <div>x</div> }
+          name:
+            - type: TextNode
+              value: div
+              position: { start: [0, 39], text: div }
+          attributes: []
+          children:
+            - type: TextNode
+              value: x
+              position: { start: [0, 43], text: x }
+  - name: parses the markup after a raw whose body opens an HTML comment
+    source: "{% raw %}<!--{% endraw %}<div>x</div>"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% raw %}<!--{% endraw %}<div>x</div>" }
+      children:
+        - type: LiquidRawTag
+          name: raw
+          markup: ""
+          markupPosition: { start: [0, 7], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% raw %}" }
+          blockEndPosition: { start: [0, 13], text: "{% endraw %}" }
+          position: { start: [0, 0], text: "{% raw %}<!--{% endraw %}" }
+          body:
+            type: RawMarkup
+            kind: text
+            value: <!--
+            position: { start: [0, 9], text: <!-- }
+            nodes:
+              - type: TextNode
+                value: <!--
+                position: { start: [0, 9], text: <!-- }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 25], text: <div> }
+          blockEndPosition: { start: [0, 31], text: </div> }
+          position: { start: [0, 25], text: <div>x</div> }
+          name:
+            - type: TextNode
+              value: div
+              position: { start: [0, 26], text: div }
+          attributes: []
+          children:
+            - type: TextNode
+              value: x
+              position: { start: [0, 30], text: x }
+  - name: parses the markup after two scripts whose bodies open an HTML comment
+    source: <script>var a = "<!--";</script><script>var b = "<!--";</script><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: <script>var a = "<!--";</script><script>var b = "<!--";</script><p>after</p> }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 23], text: </script> }
+          position: { start: [0, 0], text: <script>var a = "<!--";</script> }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: var a = "<!--";
+            position: { start: [0, 8], text: var a = "<!--"; }
+            nodes:
+              - type: TextNode
+                value: var a = "<!--";
+                position: { start: [0, 8], text: var a = "<!--"; }
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 32], text: <script> }
+          blockEndPosition: { start: [0, 55], text: </script> }
+          position: { start: [0, 32], text: <script>var b = "<!--";</script> }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: var b = "<!--";
+            position: { start: [0, 40], text: var b = "<!--"; }
+            nodes:
+              - type: TextNode
+                value: var b = "<!--";
+                position: { start: [0, 40], text: var b = "<!--"; }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 64], text: <p> }
+          blockEndPosition: { start: [0, 72], text: </p> }
+          position: { start: [0, 64], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 65], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 67], text: after }
+  - name: parses the markup after a script, then a raw, whose bodies open an HTML comment
+    source: <script>var a = "<!--";</script>{% raw %}{{{% endraw %}<p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: '<script>var a = "<!--";</script>{% raw %}{{{% endraw %}<p>after</p>' }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 23], text: </script> }
+          position: { start: [0, 0], text: <script>var a = "<!--";</script> }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: var a = "<!--";
+            position: { start: [0, 8], text: var a = "<!--"; }
+            nodes:
+              - type: TextNode
+                value: var a = "<!--";
+                position: { start: [0, 8], text: var a = "<!--"; }
+        - type: LiquidRawTag
+          name: raw
+          markup: ""
+          markupPosition: { start: [0, 39], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 32], text: "{% raw %}" }
+          blockEndPosition: { start: [0, 43], text: "{% endraw %}" }
+          position: { start: [0, 32], text: "{% raw %}{{{% endraw %}" }
+          body:
+            type: RawMarkup
+            kind: text
+            value: "{{"
+            position: { start: [0, 41], text: "{{" }
+            nodes:
+              - type: TextNode
+                value: "{{"
+                position: { start: [0, 41], text: "{{" }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 55], text: <p> }
+          blockEndPosition: { start: [0, 63], text: </p> }
+          position: { start: [0, 55], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 56], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 58], text: after }
+  - name: parses the markup after a comment, then a script, whose bodies open an HTML comment
+    source: '{% comment %}<!--{% endcomment %}<script>var b = "<!--";</script><p>after</p>'
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: '{% comment %}<!--{% endcomment %}<script>var b = "<!--";</script><p>after</p>' }
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition: { start: [0, 17], text: "{% endcomment %}" }
+          position: { start: [0, 0], text: "{% comment %}<!--{% endcomment %}" }
+          body:
+            type: RawMarkup
+            kind: text
+            value: <!--
+            position: { start: [0, 13], text: <!-- }
+            nodes:
+              - type: TextNode
+                value: <!--
+                position: { start: [0, 13], text: <!-- }
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 33], text: <script> }
+          blockEndPosition: { start: [0, 56], text: </script> }
+          position: { start: [0, 33], text: <script>var b = "<!--";</script> }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: var b = "<!--";
+            position: { start: [0, 41], text: var b = "<!--"; }
+            nodes:
+              - type: TextNode
+                value: var b = "<!--";
+                position: { start: [0, 41], text: var b = "<!--"; }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 65], text: <p> }
+          blockEndPosition: { start: [0, 73], text: </p> }
+          position: { start: [0, 65], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 66], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 68], text: after }
+  - name: parses the markup after a comment, then a raw, whose bodies open markup
+    source: "{% comment %}<!--{% endcomment %}{% raw %}<a{% endraw %}<p>after</p>"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% comment %}<!--{% endcomment %}{% raw %}<a{% endraw %}<p>after</p>" }
+      children:
+        - type: LiquidRawTag
+          name: comment
+          markup: ""
+          markupPosition: { start: [0, 11], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% comment %}" }
+          blockEndPosition: { start: [0, 17], text: "{% endcomment %}" }
+          position: { start: [0, 0], text: "{% comment %}<!--{% endcomment %}" }
+          body:
+            type: RawMarkup
+            kind: text
+            value: <!--
+            position: { start: [0, 13], text: <!-- }
+            nodes:
+              - type: TextNode
+                value: <!--
+                position: { start: [0, 13], text: <!-- }
+        - type: LiquidRawTag
+          name: raw
+          markup: ""
+          markupPosition: { start: [0, 40], text: "" }
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 33], text: "{% raw %}" }
+          blockEndPosition: { start: [0, 44], text: "{% endraw %}" }
+          position: { start: [0, 33], text: "{% raw %}<a{% endraw %}" }
+          body:
+            type: RawMarkup
+            kind: text
+            value: <a
+            position: { start: [0, 42], text: <a }
+            nodes:
+              - type: TextNode
+                value: <a
+                position: { start: [0, 42], text: <a }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 56], text: <p> }
+          blockEndPosition: { start: [0, 64], text: </p> }
+          position: { start: [0, 56], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 57], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 59], text: after }
+  - name: resumes inside a script body after a raw tag in it
+    source: <script>{% raw %}{{{% endraw %} s = "<!--"; t = "}}";</script><p>after</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: '<script>{% raw %}{{{% endraw %} s = "<!--"; t = "}}";</script><p>after</p>' }
+      children:
+        - type: HtmlRawNode
+          name: script
+          blockStartPosition: { start: [0, 0], text: <script> }
+          blockEndPosition: { start: [0, 53], text: </script> }
+          position: { start: [0, 0], text: '<script>{% raw %}{{{% endraw %} s = "<!--"; t = "}}";</script>' }
+          attributes: []
+          body:
+            type: RawMarkup
+            kind: javascript
+            value: '{% raw %}{{{% endraw %} s = "<!--"; t = "}}";'
+            position: { start: [0, 8], text: '{% raw %}{{{% endraw %} s = "<!--"; t = "}}";' }
+            nodes:
+              - type: LiquidRawTag
+                name: raw
+                markup: ""
+                markupPosition: { start: [0, 15], text: "" }
+                whitespaceStart: ""
+                whitespaceEnd: ""
+                delimiterWhitespaceStart: ""
+                delimiterWhitespaceEnd: ""
+                blockStartPosition: { start: [0, 8], text: "{% raw %}" }
+                blockEndPosition: { start: [0, 19], text: "{% endraw %}" }
+                position: { start: [0, 8], text: "{% raw %}{{{% endraw %}" }
+                body:
+                  type: RawMarkup
+                  kind: text
+                  value: "{{"
+                  position: { start: [0, 17], text: "{{" }
+                  nodes:
+                    - type: TextNode
+                      value: "{{"
+                      position: { start: [0, 17], text: "{{" }
+              - type: TextNode
+                value: s = "<!--"; t = "}}";
+                position: { start: [0, 32], text: 's = "<!--"; t = "}}";' }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 62], text: <p> }
+          blockEndPosition: { start: [0, 70], text: </p> }
+          position: { start: [0, 62], text: <p>after</p> }
+          name:
+            - type: TextNode
+              value: p
+              position: { start: [0, 63], text: p }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 65], text: after }
+  - name: keeps a quote in a raw body from closing the attribute value it sits in
+    source: <a title="{% raw %}"{% endraw %}">x</a>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: '<a title="{% raw %}"{% endraw %}">x</a>' }
+      children:
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 0], text: '<a title="{% raw %}"{% endraw %}">' }
+          blockEndPosition: { start: [0, 35], text: </a> }
+          position: { start: [0, 0], text: '<a title="{% raw %}"{% endraw %}">x</a>' }
+          name:
+            - type: TextNode
+              value: a
+              position: { start: [0, 1], text: a }
+          attributes:
+            - type: AttrDoubleQuoted
+              attributePosition: { start: [0, 10], text: '{% raw %}"{% endraw %}' }
+              position: { start: [0, 3], text: 'title="{% raw %}"{% endraw %}"' }
+              name:
+                - type: TextNode
+                  value: title
+                  position: { start: [0, 3], text: title }
+              value:
+                - type: LiquidRawTag
+                  name: raw
+                  markup: ""
+                  markupPosition: { start: [0, 17], text: "" }
+                  whitespaceStart: ""
+                  whitespaceEnd: ""
+                  delimiterWhitespaceStart: ""
+                  delimiterWhitespaceEnd: ""
+                  blockStartPosition: { start: [0, 10], text: "{% raw %}" }
+                  blockEndPosition: { start: [0, 20], text: "{% endraw %}" }
+                  position: { start: [0, 10], text: '{% raw %}"{% endraw %}' }
+                  body:
+                    type: RawMarkup
+                    kind: text
+                    value: '"'
+                    position: { start: [0, 19], text: '"' }
+                    nodes:
+                      - type: TextNode
+                        value: '"'
+                        position: { start: [0, 19], text: '"' }
+          children:
+            - type: TextNode
+              value: x
+              position: { start: [0, 34], text: x }
+  - name: resumes inside the quoted attribute a raw tag sits in when its body opens an HTML comment
+    source: <div data="{% raw %}<!--{% endraw %}">x</div>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: '<div data="{% raw %}<!--{% endraw %}">x</div>' }
+      children:
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 0], text: '<div data="{% raw %}<!--{% endraw %}">' }
+          blockEndPosition: { start: [0, 39], text: </div> }
+          position: { start: [0, 0], text: '<div data="{% raw %}<!--{% endraw %}">x</div>' }
+          name:
+            - type: TextNode
+              value: div
+              position: { start: [0, 1], text: div }
+          attributes:
+            - type: AttrDoubleQuoted
+              attributePosition: { start: [0, 11], text: "{% raw %}<!--{% endraw %}" }
+              position: { start: [0, 5], text: 'data="{% raw %}<!--{% endraw %}"' }
+              name:
+                - type: TextNode
+                  value: data
+                  position: { start: [0, 5], text: data }
+              value:
+                - type: LiquidRawTag
+                  name: raw
+                  markup: ""
+                  markupPosition: { start: [0, 18], text: "" }
+                  whitespaceStart: ""
+                  whitespaceEnd: ""
+                  delimiterWhitespaceStart: ""
+                  delimiterWhitespaceEnd: ""
+                  blockStartPosition: { start: [0, 11], text: "{% raw %}" }
+                  blockEndPosition: { start: [0, 24], text: "{% endraw %}" }
+                  position: { start: [0, 11], text: "{% raw %}<!--{% endraw %}" }
+                  body:
+                    type: RawMarkup
+                    kind: text
+                    value: <!--
+                    position: { start: [0, 20], text: <!-- }
+                    nodes:
+                      - type: TextNode
+                        value: <!--
+                        position: { start: [0, 20], text: <!-- }
+          children:
+            - type: TextNode
+              value: x
+              position: { start: [0, 38], text: x }

From 31f66557e1de13243bcd4e6047eb9524f2a72442 Mon Sep 17 00:00:00 2001
From: Philippe Collin <philippe.collin@shopify.com>
Date: Fri, 30 Oct 2026 11:49:25 -0400
Subject: [PATCH 16/20] Parse the Liquid inside HTML comments

Liquid treats <!-- and --> as text, so the Liquid inside an HTML comment
renders, and its tags still open, branch and close blocks. The parser
read a comment's body as opaque, so {% if a %}<!-- {% endif %} --> failed
with an unclosed if, and checks never saw the Liquid in a comment.

HtmlComment now has children (text and Liquid, never markup) and
blockStartPosition/blockEndPosition for its delimiters:
- A comment that crosses a Liquid block boundary is split there, and the
  part on the split side has an empty delimiter range.
- A comment whose --> sits in a block opened inside it ends with that
  block.
- A comment that never closes ends at the end of the source, as in a
  browser.
- An end tag in a comment that matches no open block fails, as in Liquid.
- opaqueHtmlComments keeps comment bodies opaque, for HTML that is data
  rather than a template.

Consumers:
- Prettier prints a split or unclosed comment as written, trimming the
  whitespace on its delimiter-less side so formatting stays idempotent.
- Completions descend into a comment's children.
- After an error inside a comment, tolerant recovery resumes at the
  comment's --> instead of skipping it, so the markup after it stays
  HTML.

Co-Authored-By: River <river@shopify.com>
Co-Authored-By: Martin Morissette <martin.morissette@shopify.com>
Co-Authored-By: Mbarak Bujra <mbarak.bujra@shopify.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../liquid-html-parser/specs/architecture.md  |   2 +-
 .../specs/recursive-descent.md                |   6 +-
 packages/liquid-html-parser/src/ast.test.ts   |  22 +
 packages/liquid-html-parser/src/ast.ts        |  38 +-
 .../src/document/factories.ts                 |  13 +-
 .../liquid-html-parser/src/document/html.ts   |  90 ++-
 .../src/document/node-dispatch.ts             |  18 +-
 .../liquid-html-parser/src/document/parser.ts |  24 +
 .../src/document/tolerant-parser.ts           |  10 +-
 .../liquid-html-parser/src/tolerant.test.ts   |  13 +
 packages/liquid-html-parser/src/tolerant.ts   |   1 +
 .../src/printer/printer-liquid-html.ts        |  14 +-
 .../src/test/html-comment/fixed.liquid        |  15 +
 .../src/test/html-comment/index.liquid        |   9 +
 .../params/LiquidCompletionParams.ts          |   6 +-
 .../ObjectCompletionProvider.spec.ts          |   7 +
 .../src/css/CSSLanguageService.ts             |   5 +-
 specs/checks/liquid-html-syntax-error.yml     |  13 +
 specs/checks/undefined-object.yml             |   9 +
 specs/parser/html.yml                         | 612 ++++++++++++++++++
 20 files changed, 894 insertions(+), 33 deletions(-)

diff --git a/packages/liquid-html-parser/specs/architecture.md b/packages/liquid-html-parser/specs/architecture.md
index 2a956d3fa..b68d85af6 100644
--- a/packages/liquid-html-parser/specs/architecture.md
+++ b/packages/liquid-html-parser/specs/architecture.md
@@ -432,7 +432,7 @@ function makeHtmlRawNode(
   blockEndPosition,
   source,
 ): HtmlRawNode;
-function makeHtmlComment(body, start, end, source): HtmlComment;
+function makeHtmlComment(children, blockStartPosition, blockEndPosition, source): HtmlComment;
 function makeHtmlDoctype(legacyDoctypeString, start, end, source): HtmlDoctype;
 function makeAttrDoubleQuoted(name, value, attributePosition, position, source): AttrDoubleQuoted;
 function makeAttrSingleQuoted(name, value, attributePosition, position, source): AttrSingleQuoted;
diff --git a/packages/liquid-html-parser/specs/recursive-descent.md b/packages/liquid-html-parser/specs/recursive-descent.md
index de3e0537d..e83e3c066 100644
--- a/packages/liquid-html-parser/specs/recursive-descent.md
+++ b/packages/liquid-html-parser/specs/recursive-descent.md
@@ -78,7 +78,7 @@ LiquidHtmlNode (discriminated union of all traversable nodes)
   ├── TextNode                    { value: string }
   ├── YAMLFrontmatter             { body: string }
   ├── HtmlDoctype                 { legacyDoctypeString: string | null }
-  ├── HtmlComment                 { body: string }
+  ├── HtmlComment                 { body: string, children: (LiquidNode|TextNode)[] }
   │
   ├── LiquidVariableOutput        { markup: string | LiquidVariable, whitespace }
   │
@@ -307,9 +307,11 @@ htmlVoid     := '<' voidTagName attributes '>'
 htmlSelfClosing := '<' tagName attributes '/>'
 htmlRawNode  := '<' rawTagName attributes '>' rawBody '</' rawTagName '>'
 htmlDoctype  := '<!doctype' ... '>'
-htmlComment  := '<!--' ... ('-->' | '--!>') | '<!-->' | '<!--->'
+htmlComment  := '<!--' (text | liquidNode)* ('-->' | '--!>') | '<!-->' | '<!--->'
 ```
 
+**HTML comments hold Liquid.** Liquid renders the Liquid inside `<!-- -->`, so a comment's body is parsed into `children` as text and Liquid, never markup. A comment that crosses a Liquid block boundary is split there: one `HtmlComment` ends before the tag that ends or branches the enclosing block, and the next starts after it, with an empty `blockEndPosition` or `blockStartPosition` on the split side. When a block opened inside a comment holds the `-->`, the comment ends with that block. A comment that never closes ends at the end of the source, as in a browser. An end or branch tag inside a comment that matches no open block fails, as in Liquid. `opaqueHtmlComments` keeps comment bodies opaque, for HTML that is data rather than a template.
+
 **Tag names can be compound** — they may contain Liquid variable outputs: `<{{ header_type }}--header>`.
 
 **Void elements:** `area`, `base`, `br`, `col`, `command`, `embed`, `hr`, `img`, `input`, `keygen`, `link`, `meta`, `param`, `source`, `track`, `wbr` (case-insensitive).
diff --git a/packages/liquid-html-parser/src/ast.test.ts b/packages/liquid-html-parser/src/ast.test.ts
index 1aac72c37..32452e0f6 100644
--- a/packages/liquid-html-parser/src/ast.test.ts
+++ b/packages/liquid-html-parser/src/ast.test.ts
@@ -65,6 +65,28 @@ describe('Unit: Stage 2 (AST)', () => {
     });
   });
 
+  describe('toLiquidHtmlAST(source, { opaqueHtmlComments: true })', () => {
+    const options = {
+      mode: 'strict',
+      allowUnclosedDocumentNode: false,
+      opaqueHtmlComments: true,
+    } as const;
+    const expectPath = makeExpectPath('opaqueHtmlComments');
+
+    it('should keep an HTML comment body opaque', () => {
+      ast = toLiquidHtmlAST('<p>a</p><!-- {% endif %} {% raw %} {{ b }} -->', options);
+      expectPath(ast, 'children.1.type').to.eql('HtmlComment');
+      expectPath(ast, 'children.1.children').to.eql([]);
+      expectPath(ast, 'children.1.body').to.eql('{% endif %} {% raw %} {{ b }}');
+    });
+
+    it('should reject an unclosed HTML comment', () => {
+      expect(() => toLiquidHtmlAST('<!-- {{ b }}', options)).to.throw(
+        /Attempting to end parsing before HtmlComment '<!--' was closed/,
+      );
+    });
+  });
+
   function makeExpectPath(message: string) {
     return function expectPath(ast: LiquidHtmlNode, path: string) {
       return expect(deepGet(path.split('.'), ast), message);
diff --git a/packages/liquid-html-parser/src/ast.ts b/packages/liquid-html-parser/src/ast.ts
index dbf19e874..d7b5bceac 100644
--- a/packages/liquid-html-parser/src/ast.ts
+++ b/packages/liquid-html-parser/src/ast.ts
@@ -778,9 +778,29 @@ export interface HtmlDoctype extends ASTNode<NodeTypes.HtmlDoctype> {
   legacyDoctypeString: string | null;
 }
 
-/** Represents `<!-- comments -->` */
+/**
+ * Represents `<!-- comments -->`.
+ *
+ * Liquid treats `<!--` and `-->` as plain text, so the Liquid inside a comment
+ * still renders and can close a block opened before the comment.
+ *
+ * This node describes the source, not the rendered page. The parser knows where
+ * each delimiter is written, not which `-->` closes which `<!--` once branches
+ * are chosen: depending on conditionals, a comment can close more than once, or
+ * never. So a comment that crosses a Liquid block boundary is split at that
+ * boundary, and a comment whose `-->` sits inside a block it opened ends with
+ * that block. Liquid outputs every delimiter as written, so only the rendered
+ * output shows which comments are open.
+ */
 export interface HtmlComment extends ASTNode<NodeTypes.HtmlComment> {
+  /** The source between the delimiters, trimmed. */
   body: string;
+  /** The text and Liquid between the delimiters. */
+  children: (LiquidNode | TextNode)[];
+  /** The range covered by this node's `<!--`, empty when the node starts at a block boundary. */
+  blockStartPosition: Position;
+  /** The range covered by this node's `-->`, empty when the node ends at a block boundary. */
+  blockEndPosition: Position;
 }
 
 export interface HtmlNodeBase<T> extends ASTNode<T> {
@@ -953,6 +973,13 @@ export interface ASTBuildOptions {
    * element. Off by default: it accepts templates the strict grammar rejects.
    */
   pairDanglingCloseTags?: boolean;
+
+  /**
+   * Keep each HTML comment's body as opaque text instead of parsing the Liquid
+   * inside it. For HTML that is data rather than a template, such as a rendered
+   * setting value or a translation, where `{% ... %}` inside a comment is not a tag.
+   */
+  opaqueHtmlComments?: boolean;
 }
 
 export function isBranchedTag(node: LiquidHtmlNode) {
@@ -985,7 +1012,14 @@ export function toLiquidHtmlAST(
   const tokens = tokenize(source, {
     rawBodyRule: rawBodyRuleLookup((name) => env.tagForName(name)),
   });
-  const parser = new DocumentParser(tokens, source, env, true, options.allowUnclosedDocumentNode);
+  const parser = new DocumentParser(
+    tokens,
+    source,
+    env,
+    true,
+    options.allowUnclosedDocumentNode,
+    options.opaqueHtmlComments,
+  );
   parser.pairDanglingCloseTags = options.pairDanglingCloseTags ?? false;
   return parser.parseDocument();
 }
diff --git a/packages/liquid-html-parser/src/document/factories.ts b/packages/liquid-html-parser/src/document/factories.ts
index 1640e6f5b..9e4c00a7c 100644
--- a/packages/liquid-html-parser/src/document/factories.ts
+++ b/packages/liquid-html-parser/src/document/factories.ts
@@ -353,15 +353,18 @@ export function makeHtmlRawNode(
 }
 
 export function makeHtmlComment(
-  body: string,
-  start: number,
-  end: number,
+  children: (LiquidNode | TextNode)[],
+  blockStartPosition: Position,
+  blockEndPosition: Position,
   source: string,
 ): HtmlComment {
   return {
     type: NodeTypes.HtmlComment,
-    body,
-    position: { start, end },
+    body: source.slice(blockStartPosition.end, blockEndPosition.start).trim(),
+    children,
+    blockStartPosition,
+    blockEndPosition,
+    position: { start: blockStartPosition.start, end: blockEndPosition.end },
     source,
   };
 }
diff --git a/packages/liquid-html-parser/src/document/html.ts b/packages/liquid-html-parser/src/document/html.ts
index 6d06459d0..0c43b9ad9 100644
--- a/packages/liquid-html-parser/src/document/html.ts
+++ b/packages/liquid-html-parser/src/document/html.ts
@@ -53,12 +53,16 @@ import type { TagDefinition } from '../environment';
  * the coupling explicit and narrow.
  */
 export interface HtmlParserDelegate extends ParserBase {
-  readonly htmlParseHtml: boolean;
+  htmlParseHtml: boolean;
   htmlAllowUnclosedHtml: boolean;
   /** See `ASTBuildOptions.pairDanglingCloseTags`. */
   readonly htmlPairDanglingCloseTags: boolean;
   htmlInAttributeContext: boolean;
   htmlInAttributeValueContext: boolean;
+  /** The `<!--` of the comment the parser is inside, or `null` outside a comment. */
+  htmlOpenComment: Position | null;
+  /** Keep comment bodies as opaque text (`ASTBuildOptions.opaqueHtmlComments`). */
+  readonly htmlOpaqueComments: boolean;
 
   parseNode(): LiquidHtmlNode;
   parseLiquidVariableOutput(): LiquidVariableOutput;
@@ -239,30 +243,82 @@ export function parseHtmlRawBody(
   return makeHtmlRawNode(plainName, attributes, body, blockStartPosition, blockEndPosition, source);
 }
 
-// htmlComment := "<!--" text* "-->"
+// htmlComment := "<!--"? (text | liquidVariableOutput | liquidTag)* "-->"?
+//
+// The body is parsed as text and Liquid, never as markup. When the body reaches
+// a tag that ends or branches an enclosing block, the comment stops before that
+// tag and `parseNode` resumes it after the tag. When a block opened inside the
+// comment consumes the `-->`, the comment ends with that block.
 export function parseHtmlComment(parser: HtmlParserDelegate): HtmlComment {
-  const source = parser.getSource();
-  const openToken = parser.consume(TokenType.HtmlCommentOpen);
-  const bodyStart = openToken.end;
+  if (parser.htmlOpaqueComments) return parseOpaqueHtmlComment(parser);
 
-  while (!parser.isAtEnd() && !parser.check(TokenType.HtmlCommentClose)) {
-    parser.advance();
+  const source = parser.getSource();
+  const start = parser.peek().start;
+  let blockStartPosition: Position = { start, end: start };
+  if (parser.check(TokenType.HtmlCommentOpen)) {
+    const openToken = parser.consume(TokenType.HtmlCommentOpen);
+    blockStartPosition = { start: openToken.start, end: openToken.end };
+    parser.htmlOpenComment = blockStartPosition;
   }
 
-  if (parser.isAtEnd()) {
-    throw new LiquidHTMLASTParsingError(
-      `Attempting to end parsing before HtmlComment '<!--' was closed`,
-      source,
-      openToken.start,
-      openToken.end,
-    );
+  const children: LiquidHtmlNode[] = [];
+  let blockEndPosition: Position | null = null;
+  const savedParseHtml = parser.htmlParseHtml;
+  parser.htmlParseHtml = false;
+  try {
+    while (parser.htmlOpenComment !== null) {
+      // A browser ends an unclosed comment at the end of the input.
+      if (parser.isAtEnd()) {
+        parser.htmlOpenComment = null;
+        break;
+      }
+      if (parser.check(TokenType.HtmlCommentClose)) {
+        const closeToken = parser.consume(TokenType.HtmlCommentClose);
+        blockEndPosition = { start: closeToken.start, end: closeToken.end };
+        parser.htmlOpenComment = null;
+        break;
+      }
+      if (parser.isBlockTerminator()) break;
+      children.push(parser.parseNode());
+    }
+  } finally {
+    parser.htmlParseHtml = savedParseHtml;
   }
 
-  const bodyEnd = parser.peek().start;
+  const end = parser.peek().start;
+  return makeHtmlComment(
+    filterChildren(ChildFilterMode.Syntactic, children, source) as (LiquidNode | TextNode)[],
+    blockStartPosition,
+    blockEndPosition ?? { start: end, end },
+    source,
+  );
+}
+
+// opaqueHtmlComment := "<!--" token* "-->"
+function parseOpaqueHtmlComment(parser: HtmlParserDelegate): HtmlComment {
+  const source = parser.getSource();
+  const openToken = parser.consume(TokenType.HtmlCommentOpen);
+  while (!parser.isAtEnd() && !parser.check(TokenType.HtmlCommentClose)) parser.advance();
+  if (parser.isAtEnd()) throw unclosedHtmlCommentError(source, openToken);
   const closeToken = parser.consume(TokenType.HtmlCommentClose);
-  const body = source.slice(bodyStart, bodyEnd).trim();
+  return makeHtmlComment(
+    [],
+    { start: openToken.start, end: openToken.end },
+    { start: closeToken.start, end: closeToken.end },
+    source,
+  );
+}
 
-  return makeHtmlComment(body, openToken.start, closeToken.end, source);
+function unclosedHtmlCommentError(
+  source: string,
+  openComment: Position,
+): LiquidHTMLASTParsingError {
+  return new LiquidHTMLASTParsingError(
+    `Attempting to end parsing before HtmlComment '<!--' was closed`,
+    source,
+    openComment.start,
+    openComment.end,
+  );
 }
 
 // htmlDoctype := "<!" text ">"
diff --git a/packages/liquid-html-parser/src/document/node-dispatch.ts b/packages/liquid-html-parser/src/document/node-dispatch.ts
index 83185d12b..c750e41ef 100644
--- a/packages/liquid-html-parser/src/document/node-dispatch.ts
+++ b/packages/liquid-html-parser/src/document/node-dispatch.ts
@@ -16,13 +16,17 @@ import type {
   HtmlDanglingMarkerClose,
   YAMLFrontmatter,
 } from '../ast';
+import type { Position } from '../types';
 import { LiquidHTMLASTParsingError } from '../errors';
 import { assertNever } from '../utils';
 
 export interface NodeDispatchDelegate extends ParserBase {
   readonly dispatchParseHtml: boolean;
   readonly dispatchAllowUnclosedHtml: boolean;
+  /** The `<!--` of the comment the parser is inside, or `null` outside a comment. */
+  dispatchOpenHtmlComment: Position | null;
 
+  isBlockTerminator(): boolean;
   parseLiquidVariableOutput(): LiquidVariableOutput;
   parseLiquidTag(): LiquidTag | LiquidRawTag;
   parseHtmlElement(): HtmlElement | HtmlVoidElement | HtmlSelfClosingElement | HtmlRawNode;
@@ -34,6 +38,11 @@ export interface NodeDispatchDelegate extends ParserBase {
 
 // node := text | yamlFrontmatter | liquidVariableOutput | liquidTag | htmlElement | htmlComment | htmlDoctype
 export function parseNode(p: NodeDispatchDelegate): LiquidHtmlNode {
+  // A comment split by a block boundary resumes after the boundary tag.
+  if (p.dispatchParseHtml && p.dispatchOpenHtmlComment !== null && !p.isBlockTerminator()) {
+    return p.parseHtmlComment();
+  }
+
   const token = p.peek();
 
   switch (token.type) {
@@ -80,15 +89,22 @@ export function parseNode(p: NodeDispatchDelegate): LiquidHtmlNode {
 
     case TokenType.HtmlCommentOpen:
       if (p.dispatchParseHtml) return p.parseHtmlComment();
+      if (p.dispatchOpenHtmlComment === null) {
+        p.dispatchOpenHtmlComment = { start: token.start, end: token.end };
+      }
       return advanceAsText(p);
 
     case TokenType.HtmlDoctypeOpen:
       if (p.dispatchParseHtml) return p.parseHtmlDoctype();
       return advanceAsText(p);
 
+    case TokenType.HtmlCommentClose:
+      // A block opened inside a comment ran past the comment's `-->`.
+      p.dispatchOpenHtmlComment = null;
+      return advanceAsText(p);
+
     case TokenType.HtmlTagClose:
     case TokenType.HtmlSelfClose:
-    case TokenType.HtmlCommentClose:
     case TokenType.HtmlEquals:
     case TokenType.HtmlQuoteOpen:
     case TokenType.HtmlQuoteClose:
diff --git a/packages/liquid-html-parser/src/document/parser.ts b/packages/liquid-html-parser/src/document/parser.ts
index dac39383e..5a950b5c5 100644
--- a/packages/liquid-html-parser/src/document/parser.ts
+++ b/packages/liquid-html-parser/src/document/parser.ts
@@ -69,6 +69,8 @@ export class DocumentParser
   private _pairDanglingCloseTags: boolean = false;
   private _inAttributeContext: boolean = false;
   private _inAttributeValueContext: boolean = false;
+  private _openHtmlComment: Position | null = null;
+  private readonly _opaqueHtmlComments: boolean;
 
   constructor(
     tokens: Token[],
@@ -76,6 +78,7 @@ export class DocumentParser
     env: Environment,
     parseHtml: boolean,
     allowUnclosedDocumentNode: boolean = false,
+    opaqueHtmlComments: boolean = false,
   ) {
     super(tokens, source);
     this.env = env;
@@ -83,6 +86,7 @@ export class DocumentParser
     this._parseHtml = parseHtml;
     this._allowUnclosedHtml = allowUnclosedDocumentNode;
     this._allowUnclosedDocumentNode = allowUnclosedDocumentNode;
+    this._opaqueHtmlComments = opaqueHtmlComments;
   }
 
   get rawParseHtml(): boolean {
@@ -118,6 +122,18 @@ export class DocumentParser
   get htmlParseHtml(): boolean {
     return this._parseHtml;
   }
+  set htmlParseHtml(v: boolean) {
+    this._parseHtml = v;
+  }
+  get htmlOpenComment(): Position | null {
+    return this._openHtmlComment;
+  }
+  set htmlOpenComment(v: Position | null) {
+    this._openHtmlComment = v;
+  }
+  get htmlOpaqueComments(): boolean {
+    return this._opaqueHtmlComments;
+  }
   get htmlAllowUnclosedHtml(): boolean {
     return this._allowUnclosedHtml;
   }
@@ -158,6 +174,12 @@ export class DocumentParser
   get dispatchAllowUnclosedHtml(): boolean {
     return this._allowUnclosedHtml;
   }
+  get dispatchOpenHtmlComment(): Position | null {
+    return this._openHtmlComment;
+  }
+  set dispatchOpenHtmlComment(v: Position | null) {
+    this._openHtmlComment = v;
+  }
 
   tagForName(name: string) {
     return this.env.tagForName(name);
@@ -168,6 +190,8 @@ export class DocumentParser
     const children: LiquidHtmlNode[] = [];
     if (this.check(TokenType.YamlFrontmatter)) children.push(parseNodeFn(this));
     while (!this.isAtEnd()) children.push(this.parseNodeInScope(children));
+    // A comment still open at the end of the input ends there, as in a browser.
+    this._openHtmlComment = null;
     return makeDocumentNode(
       filterChildren(ChildFilterMode.Syntactic, children, this.source),
       this.source,
diff --git a/packages/liquid-html-parser/src/document/tolerant-parser.ts b/packages/liquid-html-parser/src/document/tolerant-parser.ts
index f942cd61f..58175864f 100644
--- a/packages/liquid-html-parser/src/document/tolerant-parser.ts
+++ b/packages/liquid-html-parser/src/document/tolerant-parser.ts
@@ -103,9 +103,17 @@ export class TolerantDocumentParser extends DocumentParser {
        * construct. isResyncToken includes EndOfInput, so this also stops
        * cleanly at the end of the source.
        */
-      while (!this.isAtEnd() && !isResyncToken(this.peek().type)) this.advance();
+      while (!this.isAtEnd() && !this.isResyncPoint()) this.advance();
       const end = this.peek().start;
       return makeLiquidErrorNode(startTok.start, end, source, e.message, found);
     }
   }
+
+  private isResyncPoint(): boolean {
+    const type = this.peek().type;
+    // Skipping the open comment's `-->` would make the rest of the document comment text.
+    return (
+      isResyncToken(type) || (type === TokenType.HtmlCommentClose && this.htmlOpenComment !== null)
+    );
+  }
 }
diff --git a/packages/liquid-html-parser/src/tolerant.test.ts b/packages/liquid-html-parser/src/tolerant.test.ts
index 9a0f42750..62d104587 100644
--- a/packages/liquid-html-parser/src/tolerant.test.ts
+++ b/packages/liquid-html-parser/src/tolerant.test.ts
@@ -189,6 +189,19 @@ describe('tolerant mode resynchronizes after an error (panic mode)', () => {
     expect(ast.children[0].position).toEqual({ start: 0, end: 12 });
     expect(ast.children[2].position).toEqual({ start: 22, end: 33 });
   });
+
+  it('resumes an interrupted HTML comment at its close, so the markup after it is HTML', () => {
+    const source = '<!-- {% endfor %} --><p>a</p>';
+    const ast = toTolerantLiquidHtmlAST(source);
+
+    expect(ast.children.map((child) => child.type)).toEqual([
+      NodeTypes.HtmlComment,
+      NodeTypes.LiquidErrorNode,
+      NodeTypes.HtmlComment,
+      NodeTypes.HtmlElement,
+    ]);
+    expect(source.slice(ast.children[2].position.start, ast.children[2].position.end)).toBe('-->');
+  });
 });
 
 describe('findErrorNodeAtOffset', () => {
diff --git a/packages/liquid-html-parser/src/tolerant.ts b/packages/liquid-html-parser/src/tolerant.ts
index 8ad7170a1..885e803bc 100644
--- a/packages/liquid-html-parser/src/tolerant.ts
+++ b/packages/liquid-html-parser/src/tolerant.ts
@@ -66,6 +66,7 @@ export function toTolerantLiquidHtmlAST(
     env,
     true,
     options.allowUnclosedDocumentNode,
+    options.opaqueHtmlComments,
   );
   return parser.parseDocument();
 }
diff --git a/packages/prettier-plugin-liquid/src/printer/printer-liquid-html.ts b/packages/prettier-plugin-liquid/src/printer/printer-liquid-html.ts
index 1eabbaa38..ee7c83b59 100644
--- a/packages/prettier-plugin-liquid/src/printer/printer-liquid-html.ts
+++ b/packages/prettier-plugin-liquid/src/printer/printer-liquid-html.ts
@@ -253,7 +253,7 @@ function printNode(
     }
 
     case NodeTypes.RawMarkup: {
-      if (node.parentNode?.name === 'doc') {
+      if (node.parentNode?.type === NodeTypes.LiquidRawTag && node.parentNode.name === 'doc') {
         return printLiquidDoc(path as AstPath<RawMarkup>, options, print, args);
       }
 
@@ -332,6 +332,18 @@ function printNode(
     }
 
     case NodeTypes.HtmlComment: {
+      const { blockStartPosition: open, blockEndPosition: close } = node;
+      // Part of a comment split at a Liquid block boundary, or one that never
+      // closes: adding the missing delimiter would change the output. On a side
+      // without one, the next parse reads the line break printed there as part
+      // of this node, so trim it to keep formatting idempotent.
+      if (open.start === open.end || close.start === close.end) {
+        let text = node.source.slice(node.position.start, node.position.end);
+        if (open.start === open.end) text = text.trimStart();
+        if (close.start === close.end) text = text.trimEnd();
+        return text;
+      }
+
       const conditionalComment = getConditionalComment(
         node.source.slice(node.position.start, node.position.end),
       );
diff --git a/packages/prettier-plugin-liquid/src/test/html-comment/fixed.liquid b/packages/prettier-plugin-liquid/src/test/html-comment/fixed.liquid
index c69c34c87..89db02420 100644
--- a/packages/prettier-plugin-liquid/src/test/html-comment/fixed.liquid
+++ b/packages/prettier-plugin-liquid/src/test/html-comment/fixed.liquid
@@ -69,3 +69,18 @@ It should support and indend the bodies of all IE comment variations
 <!--[if gt IE 6]>
   According to the conditional comment this is IE greater than 6<br />
 <![endif]-->
+
+It should print the parts of a comment split at a Liquid block boundary as written
+{% if a %}
+  <!-- x
+{% else %}
+  y -->
+{% endif %}
+
+It should print a comment as written when a block opened inside it holds its close
+<!-- {% if x %} --> a {% endif %}
+<b>c</b>
+
+It should print a comment that never closes as written
+<p>a</p>
+<!-- b <p>c</p>
diff --git a/packages/prettier-plugin-liquid/src/test/html-comment/index.liquid b/packages/prettier-plugin-liquid/src/test/html-comment/index.liquid
index 607d5e15b..e64be9d28 100644
--- a/packages/prettier-plugin-liquid/src/test/html-comment/index.liquid
+++ b/packages/prettier-plugin-liquid/src/test/html-comment/index.liquid
@@ -66,3 +66,12 @@ According to the conditional comment this is IE lower or equal to 7<br />
 <!--[if gt IE 6]>
 According to the conditional comment this is IE greater than 6<br />
 <![endif]-->
+
+It should print the parts of a comment split at a Liquid block boundary as written
+{% if a %}<!-- x {% else %} y -->{% endif %}
+
+It should print a comment as written when a block opened inside it holds its close
+<!-- {% if x %} --> a {% endif %}<b>c</b>
+
+It should print a comment that never closes as written
+<p>a</p><!-- b <p>c</p>
diff --git a/packages/theme-language-server-common/src/completions/params/LiquidCompletionParams.ts b/packages/theme-language-server-common/src/completions/params/LiquidCompletionParams.ts
index e0bcc5f3c..84d7308c0 100644
--- a/packages/theme-language-server-common/src/completions/params/LiquidCompletionParams.ts
+++ b/packages/theme-language-server-common/src/completions/params/LiquidCompletionParams.ts
@@ -469,9 +469,13 @@ function findCompletionNode(
         break;
       }
 
+      case NodeTypes.HtmlComment: {
+        finder.current = covering(current.children, cursor);
+        break;
+      }
+
       case NodeTypes.YAMLFrontmatter:
       case NodeTypes.HtmlDoctype:
-      case NodeTypes.HtmlComment:
       case NodeTypes.RawMarkup: {
         break;
       }
diff --git a/packages/theme-language-server-common/src/completions/providers/ObjectCompletionProvider.spec.ts b/packages/theme-language-server-common/src/completions/providers/ObjectCompletionProvider.spec.ts
index f5581f043..0bd94b617 100644
--- a/packages/theme-language-server-common/src/completions/providers/ObjectCompletionProvider.spec.ts
+++ b/packages/theme-language-server-common/src/completions/providers/ObjectCompletionProvider.spec.ts
@@ -172,6 +172,13 @@ describe('Module: ObjectCompletionProvider', async () => {
     );
   });
 
+  it('should complete variable lookups inside HTML comments, since Liquid renders them', async () => {
+    const contexts = [`<!-- {{ a█ }} -->`, `<!-- {% if a█ %}{% endif %} -->`, `<p><!-- {{ a█`];
+    await Promise.all(
+      contexts.map((context) => expect(provider, context).to.complete(context, ['all_products'])),
+    );
+  });
+
   it('should complete variable lookups (placeholder mode)', async () => {
     const contexts = [
       `{{ █`,
diff --git a/packages/theme-language-server-common/src/css/CSSLanguageService.ts b/packages/theme-language-server-common/src/css/CSSLanguageService.ts
index 00db110ed..d8846f204 100644
--- a/packages/theme-language-server-common/src/css/CSSLanguageService.ts
+++ b/packages/theme-language-server-common/src/css/CSSLanguageService.ts
@@ -1,4 +1,4 @@
-import { LiquidRawTag, NodeTypes } from '@shopify/liquid-html-parser';
+import { LiquidHtmlNode, LiquidRawTag, NodeTypes } from '@shopify/liquid-html-parser';
 import { Mode, Modes, SourceCodeType, findCurrentNode } from '@shopify/theme-check-common';
 import { LanguageService, Stylesheet, getCSSLanguageService } from 'vscode-css-languageservice';
 import {
@@ -81,7 +81,8 @@ export class CSSLanguageService {
             node.type === NodeTypes.LiquidRawTag && node.name === 'stylesheet',
         );
         if (isDiagnostics && 'children' in node && node.children) {
-          stylesheetTag = node.children.find(
+          const children: LiquidHtmlNode[] = node.children;
+          stylesheetTag = children.find(
             (node): node is LiquidRawTag =>
               node.type === NodeTypes.LiquidRawTag && node.name === 'stylesheet',
           );
diff --git a/specs/checks/liquid-html-syntax-error.yml b/specs/checks/liquid-html-syntax-error.yml
index 248eed2ca..35e264254 100644
--- a/specs/checks/liquid-html-syntax-error.yml
+++ b/specs/checks/liquid-html-syntax-error.yml
@@ -1712,3 +1712,16 @@ cases:
         start: [0, 3]
         highlight: bool and cond
         fix: "{{ bool }}"
+  - name: accepts a Liquid block that closes inside an HTML comment, since Liquid renders the comment's Liquid
+    files:
+      file.liquid: "{% if a %}<!-- {% endif %} -->"
+    docset: default
+  - name: should report an end tag inside an HTML comment that closes no block
+    files:
+      file.liquid: "<!-- {% endif %} -->"
+    docset: default
+    offenses:
+      - file: file.liquid
+        message: "Attempting to close LiquidTag 'if' before it was opened without a matching 'if'"
+        start: [0, 5]
+        highlight: "{% endif %}"
diff --git a/specs/checks/undefined-object.yml b/specs/checks/undefined-object.yml
index 4122443ec..480c67271 100644
--- a/specs/checks/undefined-object.yml
+++ b/specs/checks/undefined-object.yml
@@ -756,3 +756,12 @@ cases:
         }
         {% endschema %}
     docset: default
+  - name: reports an undefined object inside an HTML comment, which Liquid renders
+    files:
+      file.liquid: "<!-- {{ my_var }} -->"
+    docset: default
+    offenses:
+      - file: file.liquid
+        message: "Unknown object 'my_var' used."
+        start: [0, 8]
+        highlight: my_var
diff --git a/specs/parser/html.yml b/specs/parser/html.yml
index 3df32852c..817f73af4 100644
--- a/specs/parser/html.yml
+++ b/specs/parser/html.yml
@@ -2558,12 +2558,37 @@ cases:
       children:
         - type: HtmlComment
           body: hello {{ product.name }}
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [2, 0], text: --> }
           position:
             start: [0, 0]
             text: |-
               <!--
                 hello {{ product.name }}
               -->
+          children:
+            - type: TextNode
+              value: hello
+              position: { start: [1, 2], text: hello }
+            - type: LiquidVariableOutput
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              markupPosition: { start: [1, 10], text: " product.name " }
+              position: { start: [1, 8], text: "{{ product.name }}" }
+              markup:
+                type: LiquidVariable
+                rawSource: product.name
+                position: { start: [1, 11], text: "product.name " }
+                expression:
+                  type: VariableLookup
+                  name: product
+                  position: { start: [1, 11], text: product.name }
+                  lookups:
+                    - type: String
+                      value: name
+                      position: { start: [1, 19], text: name }
+                  lookupModes: [bareword]
+                filters: []
   - name: should parse script tags as raw
     source: |-
       <script>
@@ -4507,7 +4532,13 @@ cases:
       children:
         - type: HtmlComment
           body: hello
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 11], text: --> }
           position: { start: [0, 0], text: <!-- hello --> }
+          children:
+            - type: TextNode
+              value: hello
+              position: { start: [0, 5], text: hello }
   - name: should parse style tags as HtmlRawNode
     source: "<style>.x { color: red; }</style>"
     parse: [html]
@@ -4938,7 +4969,13 @@ cases:
       children:
         - type: HtmlComment
           body: a
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 5], text: --> }
           position: { start: [0, 0], text: <!--a--> }
+          children:
+            - type: TextNode
+              value: a
+              position: { start: [0, 4], text: a }
         - type: HtmlRawNode
           name: script
           blockStartPosition: { start: [0, 8], text: <script> }
@@ -4956,7 +4993,13 @@ cases:
                 position: { start: [0, 16], text: b }
         - type: HtmlComment
           body: c
+          blockStartPosition: { start: [0, 26], text: <!-- }
+          blockEndPosition: { start: [0, 31], text: --> }
           position: { start: [0, 26], text: <!--c--> }
+          children:
+            - type: TextNode
+              value: c
+              position: { start: [0, 30], text: c }
         - type: HtmlRawNode
           name: style
           blockStartPosition: { start: [0, 34], text: <style> }
@@ -6024,7 +6067,13 @@ cases:
       children:
         - type: HtmlComment
           body: a <b
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 10], text: --> }
           position: { start: [0, 0], text: <!-- a <b --> }
+          children:
+            - type: TextNode
+              value: a <b
+              position: { start: [0, 5], text: a <b }
         - type: HtmlElement
           blockStartPosition: { start: [0, 13], text: <p> }
           blockEndPosition: { start: [0, 21], text: </p> }
@@ -6048,7 +6097,13 @@ cases:
       children:
         - type: HtmlComment
           body: <a title="x
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 17], text: --> }
           position: { start: [0, 0], text: <!-- <a title="x --> }
+          children:
+            - type: TextNode
+              value: <a title="x
+              position: { start: [0, 5], text: <a title="x }
         - type: HtmlElement
           blockStartPosition: { start: [0, 20], text: <p> }
           blockEndPosition: { start: [0, 28], text: </p> }
@@ -6072,7 +6127,13 @@ cases:
       children:
         - type: HtmlComment
           body: </div>
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 12], text: --> }
           position: { start: [0, 0], text: <!-- </div> --> }
+          children:
+            - type: TextNode
+              value: </div>
+              position: { start: [0, 5], text: </div> }
         - type: HtmlElement
           blockStartPosition: { start: [0, 15], text: <p> }
           blockEndPosition: { start: [0, 23], text: </p> }
@@ -6096,7 +6157,13 @@ cases:
       children:
         - type: HtmlComment
           body: <!-- x
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 12], text: --> }
           position: { start: [0, 0], text: <!-- <!-- x --> }
+          children:
+            - type: TextNode
+              value: <!-- x
+              position: { start: [0, 5], text: <!-- x }
         - type: HtmlElement
           blockStartPosition: { start: [0, 15], text: <p> }
           blockEndPosition: { start: [0, 23], text: </p> }
@@ -6120,7 +6187,29 @@ cases:
       children:
         - type: HtmlComment
           body: <b {{ x }}
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 16], text: --> }
           position: { start: [0, 0], text: "<!-- <b {{ x }} -->" }
+          children:
+            - type: TextNode
+              value: <b
+              position: { start: [0, 5], text: <b }
+            - type: LiquidVariableOutput
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              markupPosition: { start: [0, 10], text: " x " }
+              position: { start: [0, 8], text: "{{ x }}" }
+              markup:
+                type: LiquidVariable
+                rawSource: x
+                position: { start: [0, 11], text: "x " }
+                expression:
+                  type: VariableLookup
+                  name: x
+                  position: { start: [0, 11], text: x }
+                  lookups: []
+                  lookupModes: []
+                filters: []
         - type: HtmlElement
           blockStartPosition: { start: [0, 19], text: <p> }
           blockEndPosition: { start: [0, 27], text: </p> }
@@ -6144,7 +6233,13 @@ cases:
       children:
         - type: HtmlComment
           body: a
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 7], text: --!> }
           position: { start: [0, 0], text: <!-- a --!> }
+          children:
+            - type: TextNode
+              value: a
+              position: { start: [0, 5], text: a }
         - type: HtmlElement
           blockStartPosition: { start: [0, 11], text: <p> }
           blockEndPosition: { start: [0, 19], text: </p> }
@@ -6168,7 +6263,10 @@ cases:
       children:
         - type: HtmlComment
           body: ""
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 4], text: ">" }
           position: { start: [0, 0], text: <!--> }
+          children: []
         - type: HtmlElement
           blockStartPosition: { start: [0, 5], text: <p> }
           blockEndPosition: { start: [0, 13], text: </p> }
@@ -6192,7 +6290,10 @@ cases:
       children:
         - type: HtmlComment
           body: ""
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 4], text: -> }
           position: { start: [0, 0], text: <!---> }
+          children: []
         - type: HtmlElement
           blockStartPosition: { start: [0, 6], text: <p> }
           blockEndPosition: { start: [0, 14], text: </p> }
@@ -6216,7 +6317,10 @@ cases:
       children:
         - type: HtmlComment
           body: ""
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 4], text: --> }
           position: { start: [0, 0], text: <!----> }
+          children: []
         - type: HtmlElement
           blockStartPosition: { start: [0, 7], text: <p> }
           blockEndPosition: { start: [0, 15], text: </p> }
@@ -6240,7 +6344,13 @@ cases:
       children:
         - type: HtmlComment
           body: "[if IE]><p>old</p><![endif]"
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 31], text: --> }
           position: { start: [0, 0], text: "<!--[if IE]><p>old</p><![endif]-->" }
+          children:
+            - type: TextNode
+              value: "[if IE]><p>old</p><![endif]"
+              position: { start: [0, 4], text: "[if IE]><p>old</p><![endif]" }
   - name: parses a downlevel-revealed conditional comment
     source: <!--[if !IE]><!--><p>modern</p><!--<![endif]-->
     parse: [html]
@@ -6251,7 +6361,13 @@ cases:
       children:
         - type: HtmlComment
           body: "[if !IE]><!"
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 15], text: --> }
           position: { start: [0, 0], text: "<!--[if !IE]><!-->" }
+          children:
+            - type: TextNode
+              value: "[if !IE]><!"
+              position: { start: [0, 4], text: "[if !IE]><!" }
         - type: HtmlElement
           blockStartPosition: { start: [0, 18], text: <p> }
           blockEndPosition: { start: [0, 27], text: </p> }
@@ -6267,7 +6383,13 @@ cases:
               position: { start: [0, 21], text: modern }
         - type: HtmlComment
           body: <![endif]
+          blockStartPosition: { start: [0, 31], text: <!-- }
+          blockEndPosition: { start: [0, 44], text: --> }
           position: { start: [0, 31], text: "<!--<![endif]-->" }
+          children:
+            - type: TextNode
+              value: <![endif]
+              position: { start: [0, 35], text: "<![endif]" }
   - name: parses an HTML comment holding --
     source: <!-- a -- b -->
     parse: [html]
@@ -6278,7 +6400,13 @@ cases:
       children:
         - type: HtmlComment
           body: a -- b
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 12], text: --> }
           position: { start: [0, 0], text: <!-- a -- b --> }
+          children:
+            - type: TextNode
+              value: a -- b
+              position: { start: [0, 5], text: a -- b }
   - name: reads a --> outside an HTML comment as text
     source: <p>a --> b</p>
     parse: [html]
@@ -6890,7 +7018,13 @@ cases:
                 position: { start: [0, 8], text: "/* <![CDATA[ */ if (x > y) {}" }
         - type: HtmlComment
           body: </div>
+          blockStartPosition: { start: [0, 46], text: <!-- }
+          blockEndPosition: { start: [0, 58], text: --> }
           position: { start: [0, 46], text: <!-- </div> --> }
+          children:
+            - type: TextNode
+              value: </div>
+              position: { start: [0, 51], text: </div> }
         - type: HtmlElement
           blockStartPosition: { start: [0, 61], text: <p> }
           blockEndPosition: { start: [0, 69], text: </p> }
@@ -6929,7 +7063,13 @@ cases:
                 position: { start: [0, 7], text: "/* <![CDATA[ */ a > b {}" }
         - type: HtmlComment
           body: </div>
+          blockStartPosition: { start: [0, 39], text: <!-- }
+          blockEndPosition: { start: [0, 51], text: --> }
           position: { start: [0, 39], text: <!-- </div> --> }
+          children:
+            - type: TextNode
+              value: </div>
+              position: { start: [0, 44], text: </div> }
         - type: HtmlElement
           blockStartPosition: { start: [0, 54], text: <p> }
           blockEndPosition: { start: [0, 62], text: </p> }
@@ -7146,7 +7286,13 @@ cases:
                 position: { start: [0, 5], text: <svg></svg> }
         - type: HtmlComment
           body: </div>
+          blockStartPosition: { start: [0, 22], text: <!-- }
+          blockEndPosition: { start: [0, 34], text: --> }
           position: { start: [0, 22], text: <!-- </div> --> }
+          children:
+            - type: TextNode
+              value: </div>
+              position: { start: [0, 27], text: </div> }
         - type: HtmlElement
           blockStartPosition: { start: [0, 37], text: <p> }
           blockEndPosition: { start: [0, 45], text: </p> }
@@ -7160,3 +7306,469 @@ cases:
             - type: TextNode
               value: after
               position: { start: [0, 40], text: after }
+  - name: parses the Liquid inside an HTML comment as text and Liquid
+    source: <!-- a {{ b }} <p> -->
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<!-- a {{ b }} <p> -->" }
+      children:
+        - type: HtmlComment
+          body: a {{ b }} <p>
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 19], text: --> }
+          position: { start: [0, 0], text: "<!-- a {{ b }} <p> -->" }
+          children:
+            - type: TextNode
+              value: a
+              position: { start: [0, 5], text: a }
+            - type: LiquidVariableOutput
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              markupPosition: { start: [0, 9], text: " b " }
+              position: { start: [0, 7], text: "{{ b }}" }
+              markup:
+                type: LiquidVariable
+                rawSource: b
+                position: { start: [0, 10], text: "b " }
+                expression:
+                  type: VariableLookup
+                  name: b
+                  position: { start: [0, 10], text: b }
+                  lookups: []
+                  lookupModes: []
+                filters: []
+            - type: TextNode
+              value: <p>
+              position: { start: [0, 15], text: <p> }
+  - name: splits an HTML comment at the tag that closes an enclosing block
+    source: "{% for x in xs %}{% if x %}<!-- a {% endif %} b -->{% endfor %}"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% for x in xs %}{% if x %}<!-- a {% endif %} b -->{% endfor %}" }
+      children:
+        - type: LiquidTag
+          name: for
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% for x in xs %}" }
+          blockEndPosition: { start: [0, 51], text: "{% endfor %}" }
+          markupPosition: { start: [0, 7], text: "x in xs " }
+          position: { start: [0, 0], text: "{% for x in xs %}{% if x %}<!-- a {% endif %} b -->{% endfor %}" }
+          markup:
+            type: ForMarkup
+            variableName: x
+            reversed: false
+            position: { start: [0, 7], text: "x in xs " }
+            collection:
+              type: VariableLookup
+              name: xs
+              position: { start: [0, 12], text: xs }
+              lookups: []
+              lookupModes: []
+            args: []
+          children:
+            - type: LiquidBranch
+              name: null
+              markup: ""
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              markupPosition: { start: [0, 17], text: "" }
+              blockStartPosition: { start: [0, 17], text: "" }
+              blockEndPosition: { start: [0, 51], text: "" }
+              position: { start: [0, 17], text: "{% if x %}<!-- a {% endif %} b -->" }
+              children:
+                - type: LiquidTag
+                  name: if
+                  whitespaceStart: ""
+                  whitespaceEnd: ""
+                  delimiterWhitespaceStart: ""
+                  delimiterWhitespaceEnd: ""
+                  blockStartPosition: { start: [0, 17], text: "{% if x %}" }
+                  blockEndPosition: { start: [0, 34], text: "{% endif %}" }
+                  markupPosition: { start: [0, 23], text: "x " }
+                  position: { start: [0, 17], text: "{% if x %}<!-- a {% endif %}" }
+                  markup:
+                    type: VariableLookup
+                    name: x
+                    position: { start: [0, 23], text: x }
+                    lookups: []
+                    lookupModes: []
+                  children:
+                    - type: LiquidBranch
+                      name: null
+                      markup: ""
+                      whitespaceStart: ""
+                      whitespaceEnd: ""
+                      markupPosition: { start: [0, 27], text: "" }
+                      blockStartPosition: { start: [0, 27], text: "" }
+                      blockEndPosition: { start: [0, 34], text: "" }
+                      position: { start: [0, 27], text: "<!-- a " }
+                      children:
+                        - type: HtmlComment
+                          body: a
+                          blockStartPosition: { start: [0, 27], text: <!-- }
+                          blockEndPosition: { start: [0, 34], text: "" }
+                          position: { start: [0, 27], text: "<!-- a " }
+                          children:
+                            - type: TextNode
+                              value: a
+                              position: { start: [0, 32], text: a }
+                - type: HtmlComment
+                  body: b
+                  blockStartPosition: { start: [0, 45], text: "" }
+                  blockEndPosition: { start: [0, 48], text: --> }
+                  position: { start: [0, 45], text: " b -->" }
+                  children:
+                    - type: TextNode
+                      value: b
+                      position: { start: [0, 46], text: b }
+  - name: ends an HTML comment with a block opened inside it that closes after it
+    source: <!-- {% if x %} --> a {% endif %}<b>c</b>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<!-- {% if x %} --> a {% endif %}<b>c</b>" }
+      children:
+        - type: HtmlComment
+          body: "{% if x %} --> a {% endif %}"
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 33], text: "" }
+          position: { start: [0, 0], text: "<!-- {% if x %} --> a {% endif %}" }
+          children:
+            - type: LiquidTag
+              name: if
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              delimiterWhitespaceStart: ""
+              delimiterWhitespaceEnd: ""
+              blockStartPosition: { start: [0, 5], text: "{% if x %}" }
+              blockEndPosition: { start: [0, 22], text: "{% endif %}" }
+              markupPosition: { start: [0, 11], text: "x " }
+              position: { start: [0, 5], text: "{% if x %} --> a {% endif %}" }
+              markup:
+                type: VariableLookup
+                name: x
+                position: { start: [0, 11], text: x }
+                lookups: []
+                lookupModes: []
+              children:
+                - type: LiquidBranch
+                  name: null
+                  markup: ""
+                  whitespaceStart: ""
+                  whitespaceEnd: ""
+                  markupPosition: { start: [0, 15], text: "" }
+                  blockStartPosition: { start: [0, 15], text: "" }
+                  blockEndPosition: { start: [0, 22], text: "" }
+                  position: { start: [0, 15], text: " --> a " }
+                  children:
+                    - type: TextNode
+                      value: --> a
+                      position: { start: [0, 16], text: --> a }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 33], text: <b> }
+          blockEndPosition: { start: [0, 37], text: </b> }
+          position: { start: [0, 33], text: <b>c</b> }
+          name:
+            - type: TextNode
+              value: b
+              position: { start: [0, 34], text: b }
+          attributes: []
+          children:
+            - type: TextNode
+              value: c
+              position: { start: [0, 36], text: c }
+  - name: ends an HTML comment that never closes at the end of the source, as a browser does
+    source: a <!-- b <p>c</p>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: a <!-- b <p>c</p> }
+      children:
+        - type: TextNode
+          value: a
+          position: { start: [0, 0], text: a }
+        - type: HtmlComment
+          body: b <p>c</p>
+          blockStartPosition: { start: [0, 2], text: <!-- }
+          blockEndPosition: { start: [0, 17], text: "" }
+          position: { start: [0, 2], text: <!-- b <p>c</p> }
+          children:
+            - type: TextNode
+              value: b <p>c</p>
+              position: { start: [0, 7], text: b <p>c</p> }
+  - name: ends the rest of a split HTML comment that never closes at the end of the source
+    source: "{% if x %}<!-- a {% endif %} b"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% if x %}<!-- a {% endif %} b" }
+      children:
+        - type: LiquidTag
+          name: if
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% if x %}" }
+          blockEndPosition: { start: [0, 17], text: "{% endif %}" }
+          markupPosition: { start: [0, 6], text: "x " }
+          position: { start: [0, 0], text: "{% if x %}<!-- a {% endif %}" }
+          markup:
+            type: VariableLookup
+            name: x
+            position: { start: [0, 6], text: x }
+            lookups: []
+            lookupModes: []
+          children:
+            - type: LiquidBranch
+              name: null
+              markup: ""
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              markupPosition: { start: [0, 10], text: "" }
+              blockStartPosition: { start: [0, 10], text: "" }
+              blockEndPosition: { start: [0, 17], text: "" }
+              position: { start: [0, 10], text: "<!-- a " }
+              children:
+                - type: HtmlComment
+                  body: a
+                  blockStartPosition: { start: [0, 10], text: <!-- }
+                  blockEndPosition: { start: [0, 17], text: "" }
+                  position: { start: [0, 10], text: "<!-- a " }
+                  children:
+                    - type: TextNode
+                      value: a
+                      position: { start: [0, 15], text: a }
+        - type: HtmlComment
+          body: b
+          blockStartPosition: { start: [0, 28], text: "" }
+          blockEndPosition: { start: [0, 30], text: "" }
+          position: { start: [0, 28], text: " b" }
+          children:
+            - type: TextNode
+              value: b
+              position: { start: [0, 29], text: b }
+  - name: ends a split HTML comment at a block that closes at the end of the source
+    source: "{% if x %}<!-- a {% endif %}"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% if x %}<!-- a {% endif %}" }
+      children:
+        - type: LiquidTag
+          name: if
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% if x %}" }
+          blockEndPosition: { start: [0, 17], text: "{% endif %}" }
+          markupPosition: { start: [0, 6], text: "x " }
+          position: { start: [0, 0], text: "{% if x %}<!-- a {% endif %}" }
+          markup:
+            type: VariableLookup
+            name: x
+            position: { start: [0, 6], text: x }
+            lookups: []
+            lookupModes: []
+          children:
+            - type: LiquidBranch
+              name: null
+              markup: ""
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              markupPosition: { start: [0, 10], text: "" }
+              blockStartPosition: { start: [0, 10], text: "" }
+              blockEndPosition: { start: [0, 17], text: "" }
+              position: { start: [0, 10], text: "<!-- a " }
+              children:
+                - type: HtmlComment
+                  body: a
+                  blockStartPosition: { start: [0, 10], text: <!-- }
+                  blockEndPosition: { start: [0, 17], text: "" }
+                  position: { start: [0, 10], text: "<!-- a " }
+                  children:
+                    - type: TextNode
+                      value: a
+                      position: { start: [0, 15], text: a }
+  - name: tracks an HTML comment reopened inside a block before the block's end tag
+    source: <!--{% if true %}--><!--{% endif %}x--><b>after</b>
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<!--{% if true %}--><!--{% endif %}x--><b>after</b>" }
+      children:
+        - type: HtmlComment
+          body: "{% if true %}--><!--{% endif %}x"
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 36], text: --> }
+          position: { start: [0, 0], text: "<!--{% if true %}--><!--{% endif %}x-->" }
+          children:
+            - type: LiquidTag
+              name: if
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              delimiterWhitespaceStart: ""
+              delimiterWhitespaceEnd: ""
+              blockStartPosition: { start: [0, 4], text: "{% if true %}" }
+              blockEndPosition: { start: [0, 24], text: "{% endif %}" }
+              markupPosition: { start: [0, 10], text: "true " }
+              position: { start: [0, 4], text: "{% if true %}--><!--{% endif %}" }
+              markup:
+                type: LiquidLiteral
+                keyword: "true"
+                value: true
+                position: { start: [0, 10], text: "true" }
+              children:
+                - type: LiquidBranch
+                  name: null
+                  markup: ""
+                  whitespaceStart: ""
+                  whitespaceEnd: ""
+                  markupPosition: { start: [0, 17], text: "" }
+                  blockStartPosition: { start: [0, 17], text: "" }
+                  blockEndPosition: { start: [0, 24], text: "" }
+                  position: { start: [0, 17], text: --><!-- }
+                  children:
+                    - type: TextNode
+                      value: --><!--
+                      position: { start: [0, 17], text: --><!-- }
+            - type: TextNode
+              value: x
+              position: { start: [0, 35], text: x }
+        - type: HtmlElement
+          blockStartPosition: { start: [0, 39], text: <b> }
+          blockEndPosition: { start: [0, 47], text: </b> }
+          position: { start: [0, 39], text: <b>after</b> }
+          name:
+            - type: TextNode
+              value: b
+              position: { start: [0, 40], text: b }
+          attributes: []
+          children:
+            - type: TextNode
+              value: after
+              position: { start: [0, 42], text: after }
+  - name: splits an HTML comment at each branch of an enclosing block
+    source: "{% if a %}<!-- x {% else %} y -->{% endif %}"
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "{% if a %}<!-- x {% else %} y -->{% endif %}" }
+      children:
+        - type: LiquidTag
+          name: if
+          whitespaceStart: ""
+          whitespaceEnd: ""
+          delimiterWhitespaceStart: ""
+          delimiterWhitespaceEnd: ""
+          blockStartPosition: { start: [0, 0], text: "{% if a %}" }
+          blockEndPosition: { start: [0, 33], text: "{% endif %}" }
+          markupPosition: { start: [0, 6], text: "a " }
+          position: { start: [0, 0], text: "{% if a %}<!-- x {% else %} y -->{% endif %}" }
+          markup:
+            type: VariableLookup
+            name: a
+            position: { start: [0, 6], text: a }
+            lookups: []
+            lookupModes: []
+          children:
+            - type: LiquidBranch
+              name: null
+              markup: ""
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              markupPosition: { start: [0, 10], text: "" }
+              blockStartPosition: { start: [0, 10], text: "" }
+              blockEndPosition: { start: [0, 17], text: "" }
+              position: { start: [0, 10], text: "<!-- x " }
+              children:
+                - type: HtmlComment
+                  body: x
+                  blockStartPosition: { start: [0, 10], text: <!-- }
+                  blockEndPosition: { start: [0, 17], text: "" }
+                  position: { start: [0, 10], text: "<!-- x " }
+                  children:
+                    - type: TextNode
+                      value: x
+                      position: { start: [0, 15], text: x }
+            - type: LiquidBranch
+              name: else
+              markup: ""
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              markupPosition: { start: [0, 25], text: "" }
+              blockStartPosition: { start: [0, 17], text: "{% else %}" }
+              blockEndPosition: { start: [0, 33], text: "" }
+              position: { start: [0, 17], text: "{% else %} y -->" }
+              children:
+                - type: HtmlComment
+                  body: y
+                  blockStartPosition: { start: [0, 27], text: "" }
+                  blockEndPosition: { start: [0, 30], text: --> }
+                  position: { start: [0, 27], text: " y -->" }
+                  children:
+                    - type: TextNode
+                      value: y
+                      position: { start: [0, 28], text: y }
+  - name: rejects an orphan end tag inside an HTML comment, as Liquid does
+    source: <!-- {% endif %} -->
+    parse: [html]
+    error:
+      message: Attempting to close LiquidTag 'if' before it was opened without a matching 'if'
+      start: [0, 5]
+      text: "{% endif %}"
+  - name: rejects an unclosed block inside an HTML comment, as Liquid does
+    source: <!-- {% if a %} -->
+    parse: [html]
+    error:
+      message: Attempting to end parsing before LiquidTag 'if' was closed
+      start: [0, 5]
+      text: "{% if a %}"
+  - name: parses a raw tag inside an HTML comment as a raw tag
+    source: <!-- {% raw %}{{ a }} -->{% endraw %} -->
+    parse: [html]
+    ast:
+      type: Document
+      name: "#document"
+      position: { start: [0, 0], text: "<!-- {% raw %}{{ a }} -->{% endraw %} -->" }
+      children:
+        - type: HtmlComment
+          body: "{% raw %}{{ a }} -->{% endraw %}"
+          blockStartPosition: { start: [0, 0], text: <!-- }
+          blockEndPosition: { start: [0, 38], text: --> }
+          position: { start: [0, 0], text: "<!-- {% raw %}{{ a }} -->{% endraw %} -->" }
+          children:
+            - type: LiquidRawTag
+              name: raw
+              markup: ""
+              markupPosition: { start: [0, 12], text: "" }
+              whitespaceStart: ""
+              whitespaceEnd: ""
+              delimiterWhitespaceStart: ""
+              delimiterWhitespaceEnd: ""
+              blockStartPosition: { start: [0, 5], text: "{% raw %}" }
+              blockEndPosition: { start: [0, 25], text: "{% endraw %}" }
+              position: { start: [0, 5], text: "{% raw %}{{ a }} -->{% endraw %}" }
+              body:
+                type: RawMarkup
+                kind: text
+                value: "{{ a }} -->"
+                position: { start: [0, 14], text: "{{ a }} -->" }
+                nodes:
+                  - type: TextNode
+                    value: "{{ a }} -->"
+                    position: { start: [0, 14], text: "{{ a }} -->" }

From 7cb4970d8a273276dd542223e34c65c8697c3b67 Mon Sep 17 00:00:00 2001
From: Philippe Collin <philippe.collin@shopify.com>
Date: Fri, 30 Oct 2026 11:51:14 -0400
Subject: [PATCH 17/20] Add changesets for the parser sync

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .changeset/block-argument-type.md      |  6 ++++++
 .changeset/html-comment-children.md    | 16 ++++++++++++++++
 .changeset/html-comment-mode.md        |  5 +++++
 .changeset/pair-dangling-close-tags.md |  5 +++++
 .changeset/raw-tag-body-rules.md       | 12 ++++++++++++
 .changeset/script-style-raw-text.md    |  5 +++++
 6 files changed, 49 insertions(+)
 create mode 100644 .changeset/block-argument-type.md
 create mode 100644 .changeset/html-comment-children.md
 create mode 100644 .changeset/html-comment-mode.md
 create mode 100644 .changeset/pair-dangling-close-tags.md
 create mode 100644 .changeset/raw-tag-body-rules.md
 create mode 100644 .changeset/script-style-raw-text.md

diff --git a/.changeset/block-argument-type.md b/.changeset/block-argument-type.md
new file mode 100644
index 000000000..a92e859f4
--- /dev/null
+++ b/.changeset/block-argument-type.md
@@ -0,0 +1,6 @@
+---
+'@shopify/liquid-html-parser': minor
+'@shopify/theme-language-server-common': patch
+---
+
+Type `{% block %}` and `{% section %}` arguments as one `BlockArgument`, whose value is a scalar or a single-level array literal, instead of a `LiquidNamedArgument | BlockArrayArgument` union. Completions narrow on the argument's value.
diff --git a/.changeset/html-comment-children.md b/.changeset/html-comment-children.md
new file mode 100644
index 000000000..757c256ef
--- /dev/null
+++ b/.changeset/html-comment-children.md
@@ -0,0 +1,16 @@
+---
+'@shopify/liquid-html-parser': minor
+'@shopify/prettier-plugin-liquid': patch
+'@shopify/theme-check-common': patch
+'@shopify/theme-language-server-common': patch
+---
+
+Parse the Liquid inside HTML comments. Liquid renders it, and its tags can open, branch and close blocks, so `{% if a %}<!-- {% endif %} -->` no longer fails with an unclosed `if`.
+
+- `HtmlComment` has `children` (text and Liquid) and `blockStartPosition`/`blockEndPosition` for its delimiters.
+- A comment that crosses a Liquid block boundary is split there, and each part has an empty delimiter range on the split side.
+- A comment that never closes ends at the end of the file, as in a browser.
+- An end tag in a comment that closes no block is a parse error, as in Liquid.
+- The `opaqueHtmlComments` option keeps comment bodies opaque.
+
+Checks now see the Liquid in HTML comments, completions work inside them, and prettier prints split and unclosed comments as written.
diff --git a/.changeset/html-comment-mode.md b/.changeset/html-comment-mode.md
new file mode 100644
index 000000000..d47f699a5
--- /dev/null
+++ b/.changeset/html-comment-mode.md
@@ -0,0 +1,5 @@
+---
+'@shopify/liquid-html-parser': patch
+---
+
+Tokenize HTML comments as a browser does. In a comment only Liquid and the comment's close count, so a `<b`, an unbalanced quote or a nested `<!--` can no longer hide the `-->`. A comment closes on `-->` or `--!>`, and `<!-->` and `<!--->` are empty comments. Outside a comment, `-->` is text. The bodies of Liquid raw tags like `{% comment %}` are opaque to the tokenizer too, so a `<!--` or a quote in one no longer affects the rest of the file.
diff --git a/.changeset/pair-dangling-close-tags.md b/.changeset/pair-dangling-close-tags.md
new file mode 100644
index 000000000..f854f4618
--- /dev/null
+++ b/.changeset/pair-dangling-close-tags.md
@@ -0,0 +1,5 @@
+---
+'@shopify/liquid-html-parser': minor
+---
+
+Add a `pairDanglingCloseTags` option, off by default. Themes often open an element in each branch of a conditional and close it once after it (`{% if a %}<div class="x">{% else %}<div class="y">{% endif %}…</div>`). With the option, such a close tag becomes an `HtmlDanglingMarkerClose` when an earlier `if`, `unless` or `case` in the same scope leaves an element of that name open on every path, instead of a parse error. It pairs only with the innermost such element.
diff --git a/.changeset/raw-tag-body-rules.md b/.changeset/raw-tag-body-rules.md
new file mode 100644
index 000000000..49b77003f
--- /dev/null
+++ b/.changeset/raw-tag-body-rules.md
@@ -0,0 +1,12 @@
+---
+'@shopify/liquid-html-parser': patch
+---
+
+End each raw tag's body by the rule of the Liquid class that parses it, in templates and in `{% liquid %}`:
+
+- `{% comment %}` nests, skips the bodies of raw tags inside it, and closes on any tag named `endcomment`, so `{% endcomment xyz %}` closes it.
+- `{% raw %}`, `{% javascript %}`, `{% schema %}` and `{% stylesheet %}` close at their first end tag, extra markup included, so `{% endraw xyz %}` closes `{% raw %}`.
+- `{% doc %}` reads like `{% raw %}` but rejects a nested `{% doc %}`.
+- `{% style %}` is a block, so it nests.
+
+Templates that Liquid reports as never closed now fail to parse too, such as a comment whose body Liquid's tokenizer runs past the `{% endcomment %}`.
diff --git a/.changeset/script-style-raw-text.md b/.changeset/script-style-raw-text.md
new file mode 100644
index 000000000..97b7cf5ca
--- /dev/null
+++ b/.changeset/script-style-raw-text.md
@@ -0,0 +1,5 @@
+---
+'@shopify/liquid-html-parser': patch
+---
+
+Read `<script>` and `<style>` bodies as raw text, as a browser does: a `<` in them is JavaScript or CSS, not an HTML tag, and the element closes at its first close tag outside Liquid. So `<script>a<script>b</script>c</script>` now ends the script at the first `</script>` and reports the second as an unmatched close tag. `<svg>` still pairs nested `<svg>` elements.

From 2fd0edf53ba41b9d04dfd73a0dec41f4499c3cb1 Mon Sep 17 00:00:00 2001
From: Philippe Collin <philippe.collin@shopify.com>
Date: Tue, 3 Nov 2026 15:33:28 -0500
Subject: [PATCH 18/20] Test that a trailing reversed doesn't reverse a for
 loop

Liquid only accepts `reversed` right after the collection, so
`{% for x in c limit: 5 reversed %}` is a syntax error. The parser leaves
the tag as string markup and prettier prints it as written. Reading it as
reversed would make prettier move it before `limit:`, which reverses the
loop.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 packages/liquid-html-parser/src/tags/for.test.ts            | 6 ++++++
 packages/liquid-html-parser/src/tags/for.ts                 | 1 +
 .../src/test/liquid-tag-for/fixed.liquid                    | 6 ++++++
 .../src/test/liquid-tag-for/index.liquid                    | 6 ++++++
 4 files changed, 19 insertions(+)

diff --git a/packages/liquid-html-parser/src/tags/for.test.ts b/packages/liquid-html-parser/src/tags/for.test.ts
index 2b894aabf..4522de628 100644
--- a/packages/liquid-html-parser/src/tags/for.test.ts
+++ b/packages/liquid-html-parser/src/tags/for.test.ts
@@ -85,6 +85,12 @@ describe('forTag', () => {
     expect(result.args).toHaveLength(2);
   });
 
+  it('rejects reversed after named args', () => {
+    expect(() =>
+      forTag.parse('for', parser('item in collection limit:5 reversed'), stubParser),
+    ).toThrow();
+  });
+
   it('parses for loop with comma-separated named args', () => {
     const result = forTag.parse('for', parser('item in collection limit:5, offset:2'), stubParser);
     expect(result).toMatchObject({
diff --git a/packages/liquid-html-parser/src/tags/for.ts b/packages/liquid-html-parser/src/tags/for.ts
index 32d8cf65f..86ee7f58f 100644
--- a/packages/liquid-html-parser/src/tags/for.ts
+++ b/packages/liquid-html-parser/src/tags/for.ts
@@ -10,6 +10,7 @@ function parseForMarkup(_name: string, markup: MarkupParser, _parser: Parser): F
     throw new Error("Expected 'in'");
   }
   const collection = markup.valueExpression();
+  // Liquid only accepts `reversed` here, before any named argument.
   const reversed = markup.id('reversed');
 
   // Named args in for/tablerow accept optional commas between args
diff --git a/packages/prettier-plugin-liquid/src/test/liquid-tag-for/fixed.liquid b/packages/prettier-plugin-liquid/src/test/liquid-tag-for/fixed.liquid
index 8f0306c88..a9182d34a 100644
--- a/packages/prettier-plugin-liquid/src/test/liquid-tag-for/fixed.liquid
+++ b/packages/prettier-plugin-liquid/src/test/liquid-tag-for/fixed.liquid
@@ -39,3 +39,9 @@ printWidth: 80
 {% for element in collection reversed limit: 10 %}
   {{ element }}
 {% endfor %}
+
+It keeps a reversed after tag arguments where it is, since Liquid ignores it there
+printWidth: 1
+{% for element in collection limit: 10 reversed %}
+  {{ element }}
+{% endfor %}
diff --git a/packages/prettier-plugin-liquid/src/test/liquid-tag-for/index.liquid b/packages/prettier-plugin-liquid/src/test/liquid-tag-for/index.liquid
index 9035b17b7..24d3cc50f 100644
--- a/packages/prettier-plugin-liquid/src/test/liquid-tag-for/index.liquid
+++ b/packages/prettier-plugin-liquid/src/test/liquid-tag-for/index.liquid
@@ -30,3 +30,9 @@ printWidth: 80
 {% for element in collection reversed limit: 10 %}
   {{ element }}
 {% endfor %}
+
+It keeps a reversed after tag arguments where it is, since Liquid ignores it there
+printWidth: 1
+{% for element in collection limit: 10 reversed %}
+  {{ element }}
+{% endfor %}

From 713066d77eae37a68d4c65cd52f94eddd35bf621 Mon Sep 17 00:00:00 2001
From: Philippe Collin <philippe.collin@shopify.com>
Date: Wed, 4 Nov 2026 17:31:30 -0500
Subject: [PATCH 19/20] Release the HTML comment and script/style changes as
 major

Liquid in HTML comments, the browser-style comment tokenizer and raw
`<script>`/`<style>` bodies change the tree for some templates, and some
templates that parsed now fail. The 2.0.0 release made the same kind of
change as a major. Each changeset now lists what breaks, and points to
`opaqueHtmlComments` for the comment tree.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .changeset/html-comment-children.md | 13 +++++++++++--
 .changeset/html-comment-mode.md     |  9 ++++++++-
 .changeset/script-style-raw-text.md |  6 +++++-
 3 files changed, 24 insertions(+), 4 deletions(-)

diff --git a/.changeset/html-comment-children.md b/.changeset/html-comment-children.md
index 757c256ef..e36f398f9 100644
--- a/.changeset/html-comment-children.md
+++ b/.changeset/html-comment-children.md
@@ -1,5 +1,5 @@
 ---
-'@shopify/liquid-html-parser': minor
+'@shopify/liquid-html-parser': major
 '@shopify/prettier-plugin-liquid': patch
 '@shopify/theme-check-common': patch
 '@shopify/theme-language-server-common': patch
@@ -13,4 +13,13 @@ Parse the Liquid inside HTML comments. Liquid renders it, and its tags can open,
 - An end tag in a comment that closes no block is a parse error, as in Liquid.
 - The `opaqueHtmlComments` option keeps comment bodies opaque.
 
-Checks now see the Liquid in HTML comments, completions work inside them, and prettier prints split and unclosed comments as written.
+**Breaking changes**
+
+- Code that walks `children` now visits the Liquid and text inside HTML comments.
+- `<!-- {% if a %} --><p>x</p><!-- {% endif %} -->` is one comment whose `if` holds `<p>x</p>` as text, not two comments around a `<p>` element.
+- `<!-- {% endif %} -->` with no open `if` no longer parses. An unclosed `<!--` and `{% if a %}<!-- {% endif %} -->` now parse.
+- Code that creates `HtmlComment` nodes must set `children`, `blockStartPosition` and `blockEndPosition`.
+
+Pass `opaqueHtmlComments: true` to get the 2.x tree for these templates.
+
+Checks now see the Liquid in HTML comments, and completions work inside them. Prettier prints an unclosed comment as written, and can move whitespace and line breaks inside a comment that holds a Liquid block or is split by one.
diff --git a/.changeset/html-comment-mode.md b/.changeset/html-comment-mode.md
index d47f699a5..2a3d9b4e6 100644
--- a/.changeset/html-comment-mode.md
+++ b/.changeset/html-comment-mode.md
@@ -1,5 +1,12 @@
 ---
-'@shopify/liquid-html-parser': patch
+'@shopify/liquid-html-parser': major
 ---
 
 Tokenize HTML comments as a browser does. In a comment only Liquid and the comment's close count, so a `<b`, an unbalanced quote or a nested `<!--` can no longer hide the `-->`. A comment closes on `-->` or `--!>`, and `<!-->` and `<!--->` are empty comments. Outside a comment, `-->` is text. The bodies of Liquid raw tags like `{% comment %}` are opaque to the tokenizer too, so a `<!--` or a quote in one no longer affects the rest of the file.
+
+**Breaking changes**
+
+- `<!--><div>shown</div>-->` is an empty comment, a `<div>` element and the text `-->`. It used to be one comment.
+- `<!-- a --!><p>b</p>` closes the comment at `--!>` instead of failing to parse.
+
+`opaqueHtmlComments` doesn't change these.
diff --git a/.changeset/script-style-raw-text.md b/.changeset/script-style-raw-text.md
index 97b7cf5ca..48f77166f 100644
--- a/.changeset/script-style-raw-text.md
+++ b/.changeset/script-style-raw-text.md
@@ -1,5 +1,9 @@
 ---
-'@shopify/liquid-html-parser': patch
+'@shopify/liquid-html-parser': major
 ---
 
 Read `<script>` and `<style>` bodies as raw text, as a browser does: a `<` in them is JavaScript or CSS, not an HTML tag, and the element closes at its first close tag outside Liquid. So `<script>a<script>b</script>c</script>` now ends the script at the first `</script>` and reports the second as an unmatched close tag. `<svg>` still pairs nested `<svg>` elements.
+
+**Breaking changes**
+
+- A `<script>` inside a script body no longer pairs with a `</script>`. `<script>document.write('<script src="a.js"></script>');</script>` and `<script type="text/template"><script>x</script></script>` now fail to parse in `strict` mode with "Attempting to close HtmlElement 'script' before it was opened".

From 1438b50c7e0aab94b9cb50c0e3eb22a8d6b62f09 Mon Sep 17 00:00:00 2001
From: Philippe Collin <philippe.collin@shopify.com>
Date: Thu, 5 Nov 2026 11:08:32 -0500
Subject: [PATCH 20/20] Release the HTML comment and script/style changes as
 minor

This undoes the major bump from 713066d7. The three changesets keep
their lists of what changes for existing templates, now headed
"Behavior changes". `opaqueHtmlComments` is described as giving the
previous tree rather than the 2.x tree, since the release stays on 2.x.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .changeset/html-comment-children.md | 6 +++---
 .changeset/html-comment-mode.md     | 4 ++--
 .changeset/script-style-raw-text.md | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.changeset/html-comment-children.md b/.changeset/html-comment-children.md
index e36f398f9..e9ebe2782 100644
--- a/.changeset/html-comment-children.md
+++ b/.changeset/html-comment-children.md
@@ -1,5 +1,5 @@
 ---
-'@shopify/liquid-html-parser': major
+'@shopify/liquid-html-parser': minor
 '@shopify/prettier-plugin-liquid': patch
 '@shopify/theme-check-common': patch
 '@shopify/theme-language-server-common': patch
@@ -13,13 +13,13 @@ Parse the Liquid inside HTML comments. Liquid renders it, and its tags can open,
 - An end tag in a comment that closes no block is a parse error, as in Liquid.
 - The `opaqueHtmlComments` option keeps comment bodies opaque.
 
-**Breaking changes**
+**Behavior changes**
 
 - Code that walks `children` now visits the Liquid and text inside HTML comments.
 - `<!-- {% if a %} --><p>x</p><!-- {% endif %} -->` is one comment whose `if` holds `<p>x</p>` as text, not two comments around a `<p>` element.
 - `<!-- {% endif %} -->` with no open `if` no longer parses. An unclosed `<!--` and `{% if a %}<!-- {% endif %} -->` now parse.
 - Code that creates `HtmlComment` nodes must set `children`, `blockStartPosition` and `blockEndPosition`.
 
-Pass `opaqueHtmlComments: true` to get the 2.x tree for these templates.
+Pass `opaqueHtmlComments: true` to get the previous tree for these templates.
 
 Checks now see the Liquid in HTML comments, and completions work inside them. Prettier prints an unclosed comment as written, and can move whitespace and line breaks inside a comment that holds a Liquid block or is split by one.
diff --git a/.changeset/html-comment-mode.md b/.changeset/html-comment-mode.md
index 2a3d9b4e6..45689b679 100644
--- a/.changeset/html-comment-mode.md
+++ b/.changeset/html-comment-mode.md
@@ -1,10 +1,10 @@
 ---
-'@shopify/liquid-html-parser': major
+'@shopify/liquid-html-parser': minor
 ---
 
 Tokenize HTML comments as a browser does. In a comment only Liquid and the comment's close count, so a `<b`, an unbalanced quote or a nested `<!--` can no longer hide the `-->`. A comment closes on `-->` or `--!>`, and `<!-->` and `<!--->` are empty comments. Outside a comment, `-->` is text. The bodies of Liquid raw tags like `{% comment %}` are opaque to the tokenizer too, so a `<!--` or a quote in one no longer affects the rest of the file.
 
-**Breaking changes**
+**Behavior changes**
 
 - `<!--><div>shown</div>-->` is an empty comment, a `<div>` element and the text `-->`. It used to be one comment.
 - `<!-- a --!><p>b</p>` closes the comment at `--!>` instead of failing to parse.
diff --git a/.changeset/script-style-raw-text.md b/.changeset/script-style-raw-text.md
index 48f77166f..f79c97b31 100644
--- a/.changeset/script-style-raw-text.md
+++ b/.changeset/script-style-raw-text.md
@@ -1,9 +1,9 @@
 ---
-'@shopify/liquid-html-parser': major
+'@shopify/liquid-html-parser': minor
 ---
 
 Read `<script>` and `<style>` bodies as raw text, as a browser does: a `<` in them is JavaScript or CSS, not an HTML tag, and the element closes at its first close tag outside Liquid. So `<script>a<script>b</script>c</script>` now ends the script at the first `</script>` and reports the second as an unmatched close tag. `<svg>` still pairs nested `<svg>` elements.
 
-**Breaking changes**
+**Behavior changes**
 
 - A `<script>` inside a script body no longer pairs with a `</script>`. `<script>document.write('<script src="a.js"></script>');</script>` and `<script type="text/template"><script>x</script></script>` now fail to parse in `strict` mode with "Attempting to close HtmlElement 'script' before it was opened".