@falsefalse/prettier-plugin-handlebars 0.0.1 → 0.0.3

package/dist/parser.js

@@ -33,350 +33,272 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.locStart = exports.locEnd = void 0;
 exports.parse = parse;
-const template_format_core_1 = require("template-format-core");
-const template_format_core_2 = require("template-format-core");
-Object.defineProperty(exports, "locEnd", { enumerable: true, get: function () { return template_format_core_2.locEnd; } });
-Object.defineProperty(exports, "locStart", { enumerable: true, get: function () { return template_format_core_2.locStart; } });
+const html_1 = require("./core/html");
+const source_1 = require("./core/source");
+const errors_1 = require("./core/errors");
+const whitespace = __importStar(require("./core/whitespace"));
+const lex_1 = require("./parse/lex");
+const lookahead_1 = require("./parse/lookahead");
+const nodes_1 = require("./parse/nodes");
 const expression_1 = require("./expression");
-const scan_1 = require("./scan");
-const errors_1 = require("./errors");
-const whitespace = __importStar(require("./whitespace"));
 const tokens_1 = require("./dialects/handlebars/tokens");
-/* Built from the shared class so the character list stays written in one place. */
-const leadingWhitespace = new RegExp(`^${whitespace.htmlRun.source}`, 'u');
-/* HTML's lexical classes, composed from the whitespace list rather than repeating it - both
- * embed it, and a second hand-written copy is what `whitespace.ts` exists to prevent. They
- * live here because the tokenizer below is the only thing that reads them. */
-/** What an attribute name is made of: anything but whitespace and the characters that end one. */
-const attributeNameCharacter = new RegExp(`[^${whitespace.htmlCharacters}"'<>/=]`, 'u');
-/** What ends a tag name. HTML's tag-name state leaves on whitespace, `/` or `>`, and nothing else. */
-const tagNameTerminator = new RegExp(`[${whitespace.htmlCharacters}/>]`, 'u');
 /* Destructured rather than wrapped: seven of these had a one-line function around them whose
  * only job was to give the dialect member a local name. */
-const { openDelimiter, isEscapedOpen, parseToken: parseMustacheToken, findNextOpen: findNextHandlebarsOpen, isDynamicElementStart: isDynamicTagStart, consumeRawBlock, getBlockExpression, getBlockPrefix, shouldPreserveTokenVerbatim: shouldPreserveMustacheVerbatim, } = tokens_1.handlebarsDialect;
+const { parseToken: parseMustacheToken, findNextOpen: findNextHandlebarsOpen, getBlockExpression, getBlockPrefix, shouldPreserveTokenVerbatim: shouldPreserveMustacheVerbatim, } = tokens_1.handlebarsDialect;
 function parse(text) {
-    const normalizedText = (0, template_format_core_2.normalizeInput)(text);
+    const normalizedText = (0, source_1.normalizeInput)(text);
     try {
         const { nodes } = parseChildren(normalizedText, 0, null, null);
-        return (0, template_format_core_2.withRange)({ type: 'Program', body: nodes }, 0, normalizedText.length);
+        return (0, source_1.withRange)({ type: 'Program', body: nodes }, 0, normalizedText.length);
     }
     catch (error) {
         /* Offsets become line and column here, where the whole text is still in hand. */
         throw error instanceof errors_1.TemplateSyntaxError ? error.locate(normalizedText) : error;
     }
 }
-/**
- * Every malformed construct ends here. A formatter that guesses at a missing delimiter prints
- * markup the author did not write; one that passes a mismatched tag through leaves the rest of
- * the file unformatted with nothing to show for it. Refusing is the only honest option, and the
- * offsets let an editor put the cursor on the offending place.
- */
-function fail(message, start, end) {
-    throw new errors_1.TemplateSyntaxError(message, start, end);
-}
 /* The dialect reports an unterminated token as one that ends at EOF, which is also what a token
  * ending the file looks like; the closing delimiter is what tells them apart. */
-/* Where a raw block at `position` ends, or null if there is not one there. A body Handlebars
- * emits literally is copied through wherever it appears; one that never closes is rejected
- * wherever it appears too. */
-function consumeTerminatedRawBlock(text, position, rangeOffset) {
-    const end = consumeRawBlock(text, position);
-    if (end === null) {
-        return null;
-    }
-    /* Same as for a mustache, except the closer carries the block's own name - and the name is
-     * read once here rather than once to decide and again to name it in the message. */
-    const openEnd = text.indexOf('}}}}', position + 4);
-    const name = openEnd === -1 ? '' : (0, tokens_1.handlebarsRawBlockName)(text, position, openEnd);
-    if (name === '' || !text.slice(position, end).endsWith((0, tokens_1.handlebarsRawBlockCloser)(name))) {
-        fail(`unterminated raw block: expected ${(0, tokens_1.handlebarsRawBlockCloser)(name)}`, rangeOffset + position, rangeOffset + end);
-    }
-    return end;
-}
-function startsTemplateTag(text, position) {
-    return text.startsWith(openDelimiter, position) && !isEscapedOpen(text, position);
-}
 function parseChildren(text, position, endTag, endBlock, rangeOffset = 0) {
     const nodes = [];
     let pos = position;
-    if (endTag && template_format_core_1.rawTextElements.has(endTag.toLowerCase())) {
-        const closeStart = findRawTextClose(text, pos, endTag);
-        const contentEnd = closeStart >= 0 ? closeStart : text.length;
-        const rawContent = text.slice(pos, contentEnd);
-        if (rawContent.length > 0) {
-            nodes.push((0, template_format_core_2.withRange)({
-                type: 'TextNode',
-                chars: rawContent,
-                verbatim: true,
-            }, rangeOffset + pos, rangeOffset + contentEnd));
-        }
-        const closeIdx = closeStart >= 0 ? text.indexOf('>', closeStart) : -1;
-        if (closeStart >= 0 && closeIdx < 0) {
-            fail("unterminated tag: expected '>'", rangeOffset + closeStart, rangeOffset + text.length);
-        }
-        const nextPos = closeIdx >= 0 ? closeIdx + 1 : contentEnd;
-        const closeTag = closeStart >= 0 ? readCloseTagSource(text, closeStart, closeIdx) : undefined;
-        return { nodes, position: nextPos, endReason: closeStart >= 0 ? 'tagClose' : null, contentEnd, closeTag };
+    if (endTag && (0, html_1.isRawTextElement)(endTag)) {
+        return parseRawTextChildren(text, pos, endTag, rangeOffset);
     }
     /* The current block's terminator does not move while this call runs, and every position the
      * loop reaches is at depth 0 inside it, so it is hoisted: recomputing it per open tag is
      * quadratic in the number of mustaches in the block's body. */
-    const blockBoundary = endBlock ? findCurrentBlockBoundary(text, pos, endBlock) : -1;
+    const blockBoundary = endBlock ? (0, lookahead_1.findCurrentBlockBoundary)(text, pos, endBlock) : -1;
     while (pos < text.length) {
-        const rawBlockEnd = consumeTerminatedRawBlock(text, pos, rangeOffset);
+        const rawBlockEnd = (0, lookahead_1.consumeTerminatedRawBlock)(text, pos, rangeOffset);
         if (rawBlockEnd !== null) {
-            nodes.push(createUnmatchedNode(text, pos, rawBlockEnd, rangeOffset));
+            nodes.push((0, nodes_1.createUnmatchedNode)(text, pos, rawBlockEnd, rangeOffset));
             pos = rawBlockEnd;
             continue;
         }
-        const dynamicElementEnd = consumeDynamicElement(text, pos);
+        const dynamicElementEnd = (0, lookahead_1.consumeDynamicElement)(text, pos);
         if (dynamicElementEnd !== null) {
-            nodes.push(createUnmatchedNode(text, pos, dynamicElementEnd, rangeOffset));
+            nodes.push((0, nodes_1.createUnmatchedNode)(text, pos, dynamicElementEnd, rangeOffset));
             pos = dynamicElementEnd;
             continue;
         }
-        if (endTag && startsCloseTag(text, pos, endTag)) {
+        if (endTag && (0, lex_1.startsCloseTag)(text, pos, endTag)) {
             const contentEnd = pos;
             const closeIdx = text.indexOf('>', pos);
             if (closeIdx < 0) {
-                fail("unterminated tag: expected '>'", rangeOffset + pos, rangeOffset + text.length);
+                (0, errors_1.fail)("unterminated tag: expected '>'", rangeOffset + pos, rangeOffset + text.length);
             }
-            const closeTag = readCloseTagSource(text, pos, closeIdx);
+            const closeTag = (0, lex_1.readCloseTagSource)(text, pos, closeIdx);
             pos = closeIdx + 1;
             return { nodes, position: pos, endReason: 'tagClose', contentEnd, closeTag };
         }
-        if (startsTemplateTag(text, pos)) {
-            const token = parseMustacheToken(text, pos);
-            if (!token.terminated) {
-                const [open, close] = (0, tokens_1.isHandlebarsBlockComment)(text, pos)
-                    ? ['{{!--', '--}}']
-                    : token.triple
-                        ? ['{{{', '}}}']
-                        : [text.startsWith('{{!', pos) ? '{{!' : '{{', '}}'];
-                fail(`unterminated ${open}: expected ${close}`, rangeOffset + pos, rangeOffset + token.end);
-            }
-            if (shouldPreserveMustacheVerbatim(token) && !(endBlock && token.kind === 'else')) {
-                nodes.push(createUnmatchedNode(text, pos, token.end, rangeOffset));
-                pos = token.end;
-                continue;
-            }
-            if (token.kind === 'comment') {
-                const ignoreDirective = getPrettierIgnoreDirective(commentBody(token));
-                if (ignoreDirective === 'start') {
-                    const ignoreStart = pos;
-                    const ignoreEnd = findPrettierIgnoreEnd(text, token.end);
-                    if (ignoreEnd === null) {
-                        fail('unterminated prettier-ignore region: expected {{! prettier-ignore-end }}', rangeOffset + ignoreStart, rangeOffset + token.end);
-                    }
-                    nodes.push(createUnmatchedNode(text, ignoreStart, ignoreEnd, rangeOffset));
-                    pos = ignoreEnd;
-                    continue;
-                }
-                if (ignoreDirective === 'next') {
-                    const ignoredEnd = consumeNextNode(text, token.end);
-                    /* Nothing follows to ignore, so the directive is only a comment. */
-                    if (ignoredEnd <= token.end) {
-                        nodes.push(createComment(token, rangeOffset + pos, rangeOffset + token.end));
-                        pos = token.end;
-                        continue;
-                    }
-                    nodes.push(createUnmatchedNode(text, pos, ignoredEnd, rangeOffset));
-                    pos = ignoredEnd;
-                    continue;
-                }
-            }
-            if (endBlock && token.kind === 'blockEnd' && token.name === endBlock) {
-                return { nodes, position: token.end, endReason: 'blockEnd', endToken: token };
-            }
-            if (endBlock && token.kind === 'else') {
-                return { nodes, position: token.end, endReason: 'else', endToken: token };
-            }
-            if (token.kind === 'blockStart') {
-                if (!hasMatchingBlockEnd(text, token)) {
-                    fail(`unclosed block: expected {{/${token.name ?? ''}}}`, rangeOffset + pos, rangeOffset + token.end);
-                }
-                const { node, next, closed } = parseBlock(text, token, rangeOffset);
-                if (!closed) {
-                    fail(`unclosed block: expected {{/${token.name ?? ''}}}`, rangeOffset + pos, rangeOffset + token.end);
-                }
-                nodes.push(node);
-                pos = next;
-                continue;
-            }
-            if (token.kind === 'blockEnd') {
-                fail(endBlock
-                    ? `unexpected {{/${token.name ?? ''}}}: expected {{/${endBlock}}}`
-                    : `unexpected {{/${token.name ?? ''}}}: no block is open`, rangeOffset + pos, rangeOffset + token.end);
-            }
-            /* Blocks and terminators are handled above, so the only kind left that `createStatement`
-             * declines is a stray `{{else}}` with nothing open - kept as a mustache. */
-            nodes.push(createStatement(text, token, pos, rangeOffset) ?? createMustache(text, token, pos, rangeOffset));
-            pos = token.end;
+        if ((0, lex_1.startsTemplateTag)(text, pos)) {
+            const step = parseMustacheChild(text, pos, endBlock, rangeOffset, nodes);
+            if (typeof step !== 'number')
+                return step;
+            pos = step;
             continue;
         }
         if (text[pos] === '<') {
-            if (text.startsWith('<!', pos) && !text.startsWith('<!--', pos)) {
-                const closeIdx = text.indexOf('>', pos + 2);
-                /* Unterminated, so the declaration runs to the end of the input - but its trailing
-                 * whitespace is still the author's. Folding that into the verbatim run makes the
-                 * printer's own final newline additive, and the file grows a line on every format. */
-                const end = closeIdx >= 0 ? closeIdx + 1 : trimTrailingWhitespace(text, pos);
-                nodes.push((0, template_format_core_2.withRange)({ type: 'TextNode', chars: text.slice(pos, end), verbatim: true }, rangeOffset + pos, rangeOffset + end));
-                pos = end;
-                continue;
-            }
-            if (!isTagStart(text, pos)) {
-                const nextMarkup = findNextMarkup(text, pos + 1);
-                nodes.push((0, template_format_core_2.withRange)({ type: 'TextNode', chars: text.slice(pos, nextMarkup) }, rangeOffset + pos, rangeOffset + nextMarkup));
-                pos = nextMarkup;
-                continue;
-            }
-            if (text.startsWith('<!--', pos)) {
-                const closeIdx = text.indexOf('-->', pos + 4);
-                if (closeIdx < 0) {
-                    fail("unterminated HTML comment: expected '-->'", rangeOffset + pos, rangeOffset + text.length);
-                }
-                const end = closeIdx + 3;
-                nodes.push((0, template_format_core_2.withRange)({ type: 'TextNode', chars: text.slice(pos, end), verbatim: true }, rangeOffset + pos, rangeOffset + end));
-                pos = end;
-                continue;
-            }
-            const tagResult = parseTag(text, pos, rangeOffset);
-            if (!tagResult.terminated) {
-                fail("unterminated tag: expected '>'", rangeOffset + pos, rangeOffset + tagResult.end);
-            }
-            if (tagResult.kind === 'close') {
-                if (endTag && sameTag(tagResult.tag, endTag)) {
-                    const contentEnd = pos;
-                    pos = tagResult.end;
-                    return { nodes, position: pos, endReason: 'tagClose', contentEnd, closeTag: tagResult.source };
-                }
-                fail(endTag
-                    ? `unexpected </${tagResult.tag}>: expected </${endTag}>`
-                    : `unexpected </${tagResult.tag}>: no tag is open`, rangeOffset + pos, rangeOffset + tagResult.end);
-            }
-            if (tagResult.kind === 'selfClosing') {
-                const invalidVoidCloseEnd = consumeInvalidVoidElementClose(text, tagResult.end, tagResult.tag);
-                if (invalidVoidCloseEnd !== null) {
-                    fail(`<${tagResult.tag}> is a void element and cannot be closed`, rangeOffset + tagResult.end, rangeOffset + invalidVoidCloseEnd);
-                }
-                nodes.push((0, template_format_core_2.withRange)({
-                    type: 'ElementNode',
-                    tag: tagResult.tag,
-                    attributes: tagResult.attributes,
-                    children: [],
-                    selfClosing: true,
-                    attributesRange: tagResult.attributesRange,
-                }, rangeOffset + pos, rangeOffset + tagResult.end));
-                pos = tagResult.end;
-                continue;
-            }
-            if (findMatchingTagClose(text, tagResult.tag, tagResult.end, blockBoundary) === null) {
-                fail(`unclosed tag: expected </${tagResult.tag}>`, rangeOffset + pos, rangeOffset + tagResult.end);
-            }
-            const { nodes: children, position: newPos, endReason: childEndReason, contentEnd, closeTag, } = parseChildren(text, tagResult.end, tagResult.tag, null, rangeOffset);
-            if (childEndReason !== 'tagClose') {
-                fail(`unclosed tag: expected </${tagResult.tag}>`, rangeOffset + pos, rangeOffset + tagResult.end);
-            }
-            nodes.push((0, template_format_core_2.withRange)({
-                type: 'ElementNode',
-                tag: tagResult.tag,
-                attributes: tagResult.attributes,
-                children,
-                selfClosing: false,
-                ...(closeTag && closeTag !== tagResult.tag ? { closeTag } : {}),
-                attributesRange: tagResult.attributesRange,
-                contentRange: [rangeOffset + tagResult.end, rangeOffset + (contentEnd ?? newPos)],
-            }, rangeOffset + pos, rangeOffset + newPos));
-            pos = newPos;
+            const step = parseElementChild(text, pos, endTag, blockBoundary, rangeOffset, nodes);
+            if (typeof step !== 'number')
+                return step;
+            pos = step;
             continue;
         }
         /* Text node until the next markup. The run is kept verbatim, whitespace-only runs
          * included: what renders is the printer's to decide, not the parser's to discard. */
-        const nextMarkup = findNextMarkup(text, pos);
+        const nextMarkup = (0, lookahead_1.findNextMarkup)(text, pos);
         if (nextMarkup > pos) {
-            nodes.push((0, template_format_core_2.withRange)({ type: 'TextNode', chars: text.slice(pos, nextMarkup) }, rangeOffset + pos, rangeOffset + nextMarkup));
+            nodes.push((0, nodes_1.textNode)(text, pos, nextMarkup, rangeOffset));
         }
         pos = nextMarkup;
     }
     return { nodes, position: pos, endReason: null };
 }
-function hasMatchingBlockEnd(text, token) {
-    return findMatchingBlockEnd(text, token) !== null;
-}
-/**
- * The mustaches in `text` from `from` onwards, minus those inside a `{{{{raw}}}}` body:
- * Handlebars does not parse one, so a `{{#if}}` in there opens nothing.
- *
- * Deliberately does *not* skip HTML comments or `<script>`: Handlebars has no idea what HTML is
- * and rejects `{{#if a}}<!-- {{#if b}} -->{{/if}}`, so these scans must see that `{{#if b}}`.
- */
-function* mustachesFrom(text, from) {
-    let pos = from;
-    while (pos < text.length) {
-        const next = findNextHandlebarsOpen(text, pos);
-        if (next === -1) {
-            return;
-        }
-        const rawBlockEnd = consumeRawBlock(text, next);
-        if (rawBlockEnd !== null && rawBlockEnd > next) {
-            pos = rawBlockEnd;
-            continue;
-        }
-        const token = parseMustacheToken(text, next);
-        yield token;
-        pos = token.end > next ? token.end : next + 2;
+/* A raw text element has no children: `<` inside one is text, so the whole body is one run and
+ * the only thing to find is the closing tag. */
+function parseRawTextChildren(text, position, endTag, rangeOffset) {
+    const closeStart = (0, lookahead_1.findRawTextClose)(text, position, endTag);
+    const contentEnd = closeStart >= 0 ? closeStart : text.length;
+    const nodes = contentEnd > position ? [(0, nodes_1.textNode)(text, position, contentEnd, rangeOffset, true)] : [];
+    const closeIdx = closeStart >= 0 ? text.indexOf('>', closeStart) : -1;
+    if (closeStart >= 0 && closeIdx < 0) {
+        (0, errors_1.fail)("unterminated tag: expected '>'", rangeOffset + closeStart, rangeOffset + text.length);
     }
+    return {
+        nodes,
+        position: closeIdx >= 0 ? closeIdx + 1 : contentEnd,
+        endReason: closeStart >= 0 ? 'tagClose' : null,
+        contentEnd,
+        closeTag: closeStart >= 0 ? (0, lex_1.readCloseTagSource)(text, closeStart, closeIdx) : undefined,
+    };
 }
-/** Where the block opened by `token` closes, or null if it never does. */
-function findMatchingBlockEnd(text, token) {
-    if (!token.name) {
-        return null;
+/* Split out of `parseChildren` only for size; both read `nodes` as the list being built. */
+function parseMustacheChild(text, pos, endBlock, rangeOffset, nodes) {
+    const token = parseMustacheToken(text, pos);
+    if (!token.terminated) {
+        const [open, close] = (0, tokens_1.isHandlebarsBlockComment)(text, pos)
+            ? ['{{!--', '--}}']
+            : token.triple
+                ? ['{{{', '}}}']
+                : [text.startsWith('{{!', pos) ? '{{!' : '{{', '}}'];
+        (0, errors_1.fail)(`unterminated ${open}: expected ${close}`, rangeOffset + pos, rangeOffset + token.end);
+    }
+    if (shouldPreserveMustacheVerbatim(token) && !(endBlock && token.kind === 'else')) {
+        nodes.push((0, nodes_1.createUnmatchedNode)(text, pos, token.end, rangeOffset));
+        return token.end;
     }
-    let depth = 0;
-    /* From the end of the opening tag, which the token already knows - a caller passing a start
-     * position instead would have `findNextHandlebarsOpen` land on a `{{` inside the tag's own
-     * string literal, reading `{{#if (eq a "{{")}}` as a mustache that never closes. */
-    for (const candidate of mustachesFrom(text, token.end)) {
-        if (candidate.kind === 'blockStart' && candidate.name === token.name) {
-            depth += 1;
-        }
-        else if (candidate.kind === 'blockEnd' && candidate.name === token.name) {
-            if (depth === 0) {
-                return candidate.end;
+    if (token.kind === 'comment') {
+        const ignoreDirective = (0, nodes_1.getPrettierIgnoreDirective)((0, nodes_1.commentBody)(token));
+        if (ignoreDirective === 'start') {
+            const ignoreStart = pos;
+            const ignoreEnd = (0, nodes_1.findPrettierIgnoreEnd)(text, token.end);
+            if (ignoreEnd === null) {
+                (0, errors_1.fail)('unterminated prettier-ignore region: expected {{! prettier-ignore-end }}', rangeOffset + ignoreStart, rangeOffset + token.end);
             }
-            depth -= 1;
-        }
+            nodes.push((0, nodes_1.createUnmatchedNode)(text, ignoreStart, ignoreEnd, rangeOffset));
+            return ignoreEnd;
+        }
+        if (ignoreDirective === 'next') {
+            const ignoredEnd = (0, lookahead_1.consumeNextNode)(text, token.end);
+            /* Nothing follows to ignore, so the directive is only a comment. */
+            if (ignoredEnd <= token.end) {
+                nodes.push((0, nodes_1.createComment)(token, rangeOffset + pos, rangeOffset + token.end));
+                return token.end;
+            }
+            nodes.push((0, nodes_1.createUnmatchedNode)(text, pos, ignoredEnd, rangeOffset));
+            return ignoredEnd;
+        }
+    }
+    if (endBlock && token.kind === 'blockEnd' && token.name === endBlock) {
+        return { nodes, position: token.end, endReason: 'blockEnd', endToken: token };
+    }
+    if (endBlock && token.kind === 'else') {
+        return { nodes, position: token.end, endReason: 'else', endToken: token };
+    }
+    if (token.kind === 'blockStart') {
+        if (!(0, lookahead_1.hasMatchingBlockEnd)(text, token)) {
+            (0, errors_1.fail)(`unclosed block: expected {{/${token.name ?? ''}}}`, rangeOffset + pos, rangeOffset + token.end);
+        }
+        const { node, next, closed } = parseBlock(text, token, rangeOffset);
+        if (!closed) {
+            (0, errors_1.fail)(`unclosed block: expected {{/${token.name ?? ''}}}`, rangeOffset + pos, rangeOffset + token.end);
+        }
+        nodes.push(node);
+        return next;
+    }
+    if (token.kind === 'blockEnd') {
+        (0, errors_1.fail)(endBlock
+            ? `unexpected {{/${token.name ?? ''}}}: expected {{/${endBlock}}}`
+            : `unexpected {{/${token.name ?? ''}}}: no block is open`, rangeOffset + pos, rangeOffset + token.end);
+    }
+    /* Blocks and terminators are handled above, so the only kind left that `createStatement`
+     * declines is a stray `{{else}}` with nothing open - kept as a mustache. */
+    nodes.push((0, nodes_1.createStatement)(text, token, pos, rangeOffset) ?? (0, nodes_1.createMustache)(text, token, pos, rangeOffset));
+    return token.end;
+}
+function parseElementChild(text, pos, endTag, blockBoundary, rangeOffset, nodes) {
+    if (text.startsWith('<!', pos) && !text.startsWith('<!--', pos)) {
+        const closeIdx = text.indexOf('>', pos + 2);
+        /* Unterminated, so the declaration runs to the end of the input - but its trailing
+         * whitespace is still the author's. Folding that into the verbatim run makes the
+         * printer's own final newline additive, and the file grows a line on every format. */
+        const end = closeIdx >= 0 ? closeIdx + 1 : (0, lex_1.trimTrailingWhitespace)(text, pos);
+        nodes.push((0, nodes_1.textNode)(text, pos, end, rangeOffset, true));
+        return end;
+    }
+    if (!(0, lex_1.isTagStart)(text, pos)) {
+        const nextMarkup = (0, lookahead_1.findNextMarkup)(text, pos + 1);
+        nodes.push((0, nodes_1.textNode)(text, pos, nextMarkup, rangeOffset));
+        return nextMarkup;
     }
-    return null;
-}
-function parseBlock(text, token, rangeOffset = 0) {
-    const blockExpression = getBlockExpression(token);
-    const openInfo = (0, expression_1.parseCall)(blockExpression, rangeOffset + contentOffset(text, token.start, token.end, blockExpression));
+    if (text.startsWith('<!--', pos)) {
+        const closeIdx = text.indexOf('-->', pos + 4);
+        if (closeIdx < 0) {
+            (0, errors_1.fail)("unterminated HTML comment: expected '-->'", rangeOffset + pos, rangeOffset + text.length);
+        }
+        const end = closeIdx + 3;
+        nodes.push((0, nodes_1.textNode)(text, pos, end, rangeOffset, true));
+        return end;
+    }
+    return parseElement(text, pos, endTag, blockBoundary, rangeOffset, nodes);
+}
+/* Split from `parseElementChild` so the three things that open with `<` and are not an element -
+ * a declaration, a comment, a bare `<` - stay out of the way of the one that is. */
+function parseElement(text, pos, endTag, blockBoundary, rangeOffset, nodes) {
+    const tagResult = parseTag(text, pos, rangeOffset);
+    if (!tagResult.terminated) {
+        (0, errors_1.fail)("unterminated tag: expected '>'", rangeOffset + pos, rangeOffset + tagResult.end);
+    }
+    if (tagResult.kind === 'close') {
+        if (endTag && (0, lex_1.sameTag)(tagResult.tag, endTag)) {
+            return { nodes, position: tagResult.end, endReason: 'tagClose', contentEnd: pos, closeTag: tagResult.source };
+        }
+        (0, errors_1.fail)(endTag
+            ? `unexpected </${tagResult.tag}>: expected </${endTag}>`
+            : `unexpected </${tagResult.tag}>: no tag is open`, rangeOffset + pos, rangeOffset + tagResult.end);
+    }
+    if (tagResult.kind === 'selfClosing') {
+        const invalidVoidCloseEnd = consumeInvalidVoidElementClose(text, tagResult.end, tagResult.tag);
+        if (invalidVoidCloseEnd !== null) {
+            (0, errors_1.fail)(`<${tagResult.tag}> is a void element and cannot be closed`, rangeOffset + tagResult.end, rangeOffset + invalidVoidCloseEnd);
+        }
+        nodes.push((0, source_1.withRange)({
+            type: 'ElementNode',
+            tag: tagResult.tag,
+            attributes: tagResult.attributes,
+            children: [],
+            selfClosing: true,
+            attributesRange: tagResult.attributesRange,
+        }, rangeOffset + pos, rangeOffset + tagResult.end));
+        return tagResult.end;
+    }
+    if ((0, lookahead_1.findMatchingTagClose)(text, tagResult.tag, tagResult.end, blockBoundary) === null) {
+        (0, errors_1.fail)(`unclosed tag: expected </${tagResult.tag}>`, rangeOffset + pos, rangeOffset + tagResult.end);
+    }
+    const { nodes: children, position: newPos, endReason: childEndReason, contentEnd, closeTag, } = parseChildren(text, tagResult.end, tagResult.tag, null, rangeOffset);
+    if (childEndReason !== 'tagClose') {
+        (0, errors_1.fail)(`unclosed tag: expected </${tagResult.tag}>`, rangeOffset + pos, rangeOffset + tagResult.end);
+    }
+    nodes.push((0, source_1.withRange)({
+        type: 'ElementNode',
+        tag: tagResult.tag,
+        attributes: tagResult.attributes,
+        children,
+        selfClosing: false,
+        ...(closeTag && closeTag !== tagResult.tag ? { closeTag } : {}),
+        attributesRange: tagResult.attributesRange,
+        contentRange: [rangeOffset + tagResult.end, rangeOffset + (contentEnd ?? newPos)],
+    }, rangeOffset + pos, rangeOffset + newPos));
+    return newPos;
+}
+function parseBlock(text, token, rangeOffset) {
+    /* A call's source is a slice of its own token, so its parts locate against the template. */
+    const callAt = (at, source) => (0, expression_1.parseCall)(source, rangeOffset + (0, nodes_1.contentOffset)(text, at.start, at.end, source));
+    const openInfo = callAt(token, getBlockExpression(token));
     const blockPrefix = getBlockPrefix(token);
-    const { nodes: program, position: afterProgram, endReason, endToken } = parseChildren(text, token.end, null, openInfo.path.source, rangeOffset);
-    const buildProgram = (nodes, start, end) => (0, template_format_core_2.withRange)({ type: 'Program', body: nodes }, rangeOffset + start, rangeOffset + end);
+    /* Every branch reads to the same terminator - this block's own closer - so they differ only
+     * in where they start. */
+    const parseBranch = (from) => parseChildren(text, from, null, openInfo.path.source, rangeOffset);
+    const { nodes: program, position: afterProgram, endReason, endToken } = parseBranch(token.end);
+    const buildProgram = (nodes, start, end) => (0, source_1.withRange)({ type: 'Program', body: nodes }, rangeOffset + start, rangeOffset + end);
     /* A program ends where its terminator begins, not after it, so the body tiles the range. */
     const programBody = buildProgram(program, token.end, endToken?.start ?? afterProgram);
     /* Set only when the author wrote a bare `{{else}}`; otherwise the empty inverse is built at
      * the end, once the closer's position is known. Anchoring it at `afterProgram` up here put it
      * inside the else-if chain - a point belonging to a different section of the block. */
-    let inverseBody;
+    let inverse;
     const inverseChain = [];
     let finalPos = afterProgram;
     let closeToken = endReason === 'blockEnd' ? endToken : undefined;
-    let inverseTrimOpen = false;
-    let inverseTrimClose = false;
     if (endReason === 'else' && endToken) {
         let currentElseToken = endToken;
         let currentPosition = afterProgram;
         while (currentElseToken?.specialForm === 'elseIf') {
-            const branchExpressionText = currentElseToken.content.replace(/^else\s+/, '');
-            const branchExpression = (0, expression_1.parseCall)(branchExpressionText, rangeOffset + contentOffset(text, currentElseToken.start, currentElseToken.end, branchExpressionText));
-            const { nodes: branchNodes, position: afterBranch, endReason: branchEndReason, endToken: branchEndToken, } = parseChildren(text, currentPosition, null, openInfo.path.source, rangeOffset);
-            inverseChain.push((0, template_format_core_2.withRange)({
+            const branchExpression = callAt(currentElseToken, currentElseToken.content.replace(/^else\s+/, ''));
+            const { nodes: branchNodes, position: afterBranch, endReason: branchEndReason, endToken: branchEndToken, } = parseBranch(currentPosition);
+            inverseChain.push((0, source_1.withRange)({
                 type: 'ElseBranch',
                 program: buildProgram(branchNodes, currentElseToken.end, branchEndToken?.start ?? afterBranch),
                 trimOpen: currentElseToken.trimOpen,
@@ -393,25 +315,27 @@ function parseBlock(text, token, rangeOffset = 0) {
             currentElseToken = undefined;
         }
         if (currentElseToken) {
-            inverseTrimOpen = currentElseToken.trimOpen;
-            inverseTrimClose = currentElseToken.trimClose;
-            const { nodes: inverseNodes, position: afterInverse, endReason: inverseEndReason, endToken: inverseEndToken, } = parseChildren(text, currentPosition, null, openInfo.path.source, rangeOffset);
-            inverseBody = buildProgram(inverseNodes, currentElseToken.end, inverseEndToken?.start ?? afterInverse);
+            const { nodes: inverseNodes, position: afterInverse, endReason: inverseEndReason, endToken: inverseEndToken, } = parseBranch(currentPosition);
+            inverse = {
+                program: buildProgram(inverseNodes, currentElseToken.end, inverseEndToken?.start ?? afterInverse),
+                trimOpen: currentElseToken.trimOpen,
+                trimClose: currentElseToken.trimClose,
+            };
             finalPos = afterInverse;
             closeToken = inverseEndReason === 'blockEnd' ? inverseEndToken : undefined;
         }
     }
     const closerAnchor = closeToken?.start ?? finalPos;
-    const node = (0, template_format_core_2.withRange)({
+    const node = (0, source_1.withRange)({
         type: 'BlockStatement',
         program: programBody,
         ...(inverseChain.length > 0 ? { inverseChain } : {}),
         /* An empty inverse sits where the block's closer starts: after every branch, before
          * `{{/if}}`. It is a zero-width point, so it has to be a position the block actually
          * owns. */
-        inverse: inverseBody ?? buildProgram([], closerAnchor, closerAnchor),
-        ...(inverseTrimOpen ? { inverseTrimOpen } : {}),
-        ...(inverseTrimClose ? { inverseTrimClose } : {}),
+        inverse: inverse?.program ?? buildProgram([], closerAnchor, closerAnchor),
+        ...(inverse?.trimOpen ? { inverseTrimOpen: true } : {}),
+        ...(inverse?.trimClose ? { inverseTrimClose: true } : {}),
         blockPrefix,
         trimOpen: token.trimOpen,
         trimClose: token.trimClose,
@@ -422,161 +346,42 @@ function parseBlock(text, token, rangeOffset = 0) {
     return { node, next: finalPos, closed: Boolean(closeToken) };
 }
 /**
- * The directive has to *be* the comment, not appear somewhere inside it: on `includes`, a
- * comment merely mentioning `prettier-ignore` would silently suppress the next node, and one
- * mentioning `prettier-ignore-start` would open a region.
+ * The node a mustache stands for and where it ends, or null when it stands for nothing on its
+ * own: a block that never closes, a stray `{{else}}` or `{{/if}}`. Recovering from that is the
+ * caller's, and the two callers disagree - in attribute position it stays a mustache, inside a
+ * value it goes back to being text.
  */
-function getPrettierIgnoreDirective(rawContent) {
-    switch (rawContent.toLowerCase().replace(/^\s*!(?:-{2})?/u, '').trim()) {
-        case 'prettier-ignore-start':
-            return 'start';
-        case 'prettier-ignore-end':
-            return 'end';
-        case 'prettier-ignore':
-            return 'next';
-        default:
-            return null;
+function readTemplateNode(text, token, position, rangeOffset) {
+    const statement = (0, nodes_1.createStatement)(text, token, position, rangeOffset);
+    if (statement) {
+        return { node: statement, next: token.end };
     }
-}
-function findPrettierIgnoreEnd(text, position) {
-    for (const token of mustachesFrom(text, position)) {
-        /* Kind first: `commentBody` and the directive lookup are wasted on every mustache, block and
-         * partial the scan walks past on the way. */
-        if (token.kind === 'comment' && getPrettierIgnoreDirective(commentBody(token)) === 'end') {
-            return token.end;
-        }
+    if (token.kind === 'blockStart' && (0, lookahead_1.hasMatchingBlockEnd)(text, token)) {
+        return parseBlock(text, token, rangeOffset);
     }
     return null;
 }
-/**
- * How far `{{! prettier-ignore }}` reaches: to the end of the one node that follows it, or
- * nowhere if that node's extent cannot be determined.
- *
- * It scans rather than parses: a nested `parseChildren` would run past the enclosing container,
- * handing an element its own `</div>`, and could `fail()` - leaving a directive meant to
- * suppress formatting able to reject the file. `position` means "nothing to ignore".
- */
-function consumeNextNode(text, position) {
-    if (position >= text.length) {
-        return position;
-    }
-    if (startsTemplateTag(text, position)) {
-        const token = parseMustacheToken(text, position);
-        /* A terminator belongs to whatever opened it, never to the node being skipped. */
-        if (token.kind === 'blockEnd' || token.kind === 'else') {
-            return position;
-        }
-        return token.kind === 'blockStart' ? findMatchingBlockEnd(text, token) ?? position : token.end;
-    }
-    if (text[position] === '<') {
-        const tagResult = scanTag(text, position);
-        if (!tagResult.terminated || tagResult.kind === 'close') {
-            return position;
-        }
-        if (tagResult.kind === 'selfClosing') {
-            return tagResult.end;
-        }
-        const closeStart = findMatchingTagClose(text, tagResult.tag, tagResult.end);
-        if (closeStart === null) {
-            return position;
-        }
-        const closeEnd = text.indexOf('>', closeStart);
-        return closeEnd < 0 ? position : closeEnd + 1;
-    }
-    const nextMarkup = findNextMarkup(text, position);
-    if (nextMarkup <= position) {
-        return nextMarkup;
-    }
-    /* Only whitespace is stepped over on the way to the node being ignored - a run of text is a
-     * node in its own right, and is the thing to ignore. */
-    if (text.slice(position, nextMarkup).trim() !== '' || nextMarkup >= text.length) {
-        return nextMarkup;
-    }
-    return consumeNextNode(text, nextMarkup);
-}
-function createUnmatchedNode(text, start, end, rangeOffset) {
-    return (0, template_format_core_2.withRange)({ type: 'UnmatchedNode', raw: text.slice(start, end) }, rangeOffset + start, rangeOffset + end);
-}
-/**
- * Where a tag ends, what it is called and whether it closed - without building a single node and
- * without rejecting anything.
- *
- * Lookahead has to be total: callers scan regions they may go on to skip, including a
- * `{{! prettier-ignore }}` body, so a `parseTag` here let the directive reject the very file it
- * was written to protect. `terminated` is false when the tag ran to EOF, which is also how an
- * unterminated attribute value shows up.
- */
-function scanTag(text, position) {
-    let pos = position + 1;
-    const closing = text[pos] === '/';
-    if (closing) {
-        pos += 1;
-    }
-    const { value: tag, next } = readName(text, pos);
-    pos = next;
-    const kindAt = (selfClosed) => {
-        if (closing) {
-            return 'close';
-        }
-        return selfClosed || template_format_core_1.voidElements.has(tag.toLowerCase()) ? 'selfClosing' : 'open';
-    };
-    /* A quote only delimits a value directly after `=`, whitespace aside. Treating every quote as
-     * a delimiter would make `title=a"b'c>` swallow the rest of the file hunting a closing `"`. */
-    let afterEquals = false;
-    while (pos < text.length) {
-        if (startsTemplateTag(text, pos)) {
-            const token = parseMustacheToken(text, pos);
-            pos = token.end > pos ? token.end : pos + 2;
-            continue;
-        }
-        const char = text[pos];
-        if (whitespace.html.test(char)) {
-            pos += 1;
-            continue;
-        }
-        if (char === '=') {
-            afterEquals = true;
-            pos += 1;
-            continue;
-        }
-        if (afterEquals && char !== '>') {
-            pos =
-                char === '"' || char === "'"
-                    ? readQuotedAttributeValue(text, pos + 1, char).position
-                    : readUnquotedValueEnd(text, pos);
-            afterEquals = false;
-            continue;
-        }
-        if (isSelfClosingSlash(text, pos)) {
-            return { kind: kindAt(true), tag, end: pos + 2, terminated: true };
-        }
-        if (char === '>') {
-            return { kind: kindAt(false), tag, end: pos + 1, terminated: true };
-        }
-        afterEquals = false;
-        pos += 1;
-    }
-    return { kind: kindAt(false), tag, end: pos, terminated: false };
-}
-function parseTag(text, position, rangeOffset = 0) {
+function parseTag(text, position, rangeOffset) {
     let pos = position + 1; // skip '<'
     if (text[pos] === '/') {
         pos += 1;
-        const { value: tag, next } = readName(text, pos);
+        const { value: tag, next } = (0, lex_1.readName)(text, pos);
         const closeIdx = text.indexOf('>', next);
         return {
             kind: 'close',
             tag,
-            source: readCloseTagSource(text, position, closeIdx),
+            source: (0, lex_1.readCloseTagSource)(text, position, closeIdx),
             end: closeIdx >= 0 ? closeIdx + 1 : text.length,
             terminated: closeIdx >= 0,
         };
     }
-    const { value: tag, next } = readName(text, pos);
+    const { value: tag, next } = (0, lex_1.readName)(text, pos);
     pos = next;
     const attributes = [];
     const headStart = pos;
     const span = (headEnd) => [rangeOffset + headStart, rangeOffset + headEnd];
+    /* A void element is self-closing however it was written, so `<br>` and `<br/>` agree. */
+    const kindOf = (selfClosed) => selfClosed || (0, html_1.isVoidElement)(tag) ? 'selfClosing' : 'open';
     let glued = false;
     let attrStart = pos;
     /* `glued` is whether the author left a space before this attribute. That includes the first
@@ -585,10 +390,10 @@ function parseTag(text, position, rangeOffset = 0) {
      * accounts for all of the source it was read from. */
     const add = (attribute, end) => {
         const marked = glued ? { ...attribute, glued: true } : attribute;
-        attributes.push((0, template_format_core_2.withRange)(marked, rangeOffset + attrStart, rangeOffset + end));
+        attributes.push((0, source_1.withRange)(marked, rangeOffset + attrStart, rangeOffset + end));
     };
     while (pos < text.length) {
-        pos = skipWhitespace(text, pos);
+        pos = (0, lex_1.skipWhitespace)(text, pos);
         /* Trailing whitespace can run out the input. Falling through would ask `parseAttribute` to
          * read past the end and report `unexpected undefined`, when the tag is simply unterminated. */
         if (pos >= text.length) {
@@ -604,179 +409,88 @@ function parseTag(text, position, rangeOffset = 0) {
             pos = dynamicAttribute.position;
             continue;
         }
-        if (startsTemplateTag(text, pos)) {
+        if ((0, lex_1.startsTemplateTag)(text, pos)) {
             const token = parseMustacheToken(text, pos);
-            const statement = createStatement(text, token, pos, rangeOffset);
-            if (statement) {
-                add({ type: 'AttributeBlock', block: statement }, token.end);
-                pos = token.end;
-                continue;
-            }
-            if (token.kind === 'blockStart' && hasMatchingBlockEnd(text, token)) {
-                const { node, next } = parseBlock(text, token, rangeOffset);
-                add({ type: 'AttributeBlock', block: node }, next);
-                pos = next;
-                continue;
-            }
-            /* A block that never closes, or a stray `{{else}}` / `{{/if}}`. Being unbalanced is not
-             * itself grounds to reject here - the tag's own extent is already fixed - so they are kept
-             * as a mustache. `createMustache` still parses the call, so what is *inside* one can be
-             * rejected the same as anywhere else. */
-            add({ type: 'AttributeBlock', block: createMustache(text, token, pos, rangeOffset) }, token.end);
-            pos = token.end;
+            /* Unbalanced is not itself grounds to reject here - the tag's own extent is already fixed
+             * - so it stays a mustache. `createMustache` still parses the call, so what is *inside*
+             * one can be rejected the same as anywhere else. */
+            const read = readTemplateNode(text, token, pos, rangeOffset) ?? {
+                node: (0, nodes_1.createMustache)(text, token, pos, rangeOffset),
+                next: token.end,
+            };
+            add({ type: 'AttributeBlock', block: read.node }, read.next);
+            pos = read.next;
             continue;
         }
-        if (text[pos] === '/' && text[pos + 1] === '>') {
+        const selfClosed = text[pos] === '/' && text[pos + 1] === '>';
+        if (selfClosed || text[pos] === '>') {
             const headEnd = pos;
-            pos += 2;
-            return { kind: 'selfClosing', tag, attributes, attributesRange: span(headEnd), end: pos, terminated: true };
-        }
-        if (text[pos] === '>') {
-            const headEnd = pos;
-            pos += 1;
-            const kind = template_format_core_1.voidElements.has(tag.toLowerCase()) ? 'selfClosing' : 'open';
-            return { kind, tag, attributes, attributesRange: span(headEnd), end: pos, terminated: true };
+            pos += selfClosed ? 2 : 1;
+            return { kind: kindOf(selfClosed), tag, attributes, attributesRange: span(headEnd), end: pos, terminated: true };
         }
         const attr = parseAttribute(text, pos, rangeOffset);
         /* Every remaining character is one an attribute name may start with, so there is nothing
          * left to skip over - and skipping is what quietly deleted the author's markup. */
         if (!attr) {
-            fail(`unexpected ${text[pos]} in <${tag}>: expected an attribute name or '>'`, rangeOffset + pos, rangeOffset + pos + 1);
+            (0, errors_1.fail)(`unexpected ${text[pos]} in <${tag}>: expected an attribute name or '>'`, rangeOffset + pos, rangeOffset + pos + 1);
         }
         add(attr.attribute, attr.position);
         pos = attr.position;
     }
-    const kind = template_format_core_1.voidElements.has(tag.toLowerCase()) ? 'selfClosing' : 'open';
-    return { kind, tag, attributes, attributesRange: span(pos), end: pos, terminated: false };
+    return { kind: kindOf(false), tag, attributes, attributesRange: span(pos), end: pos, terminated: false };
 }
 function consumeInvalidVoidElementClose(text, position, tag) {
-    if (!template_format_core_1.voidElements.has(tag.toLowerCase())) {
+    if (!(0, html_1.isVoidElement)(tag)) {
         return null;
     }
-    const afterGap = skipWhitespace(text, position);
+    const afterGap = (0, lex_1.skipWhitespace)(text, position);
     if (!text.startsWith('</', afterGap)) {
         return null;
     }
-    const { value, next } = readName(text, afterGap + 2);
-    const end = skipWhitespace(text, next);
-    return sameTag(value, tag) && text[end] === '>' ? end + 1 : null;
-}
-/* HTML tag names are case-insensitive, so `<DIV>x</div>` is one element. Comparing them
- * verbatim rejected it as unclosed, while the `voidElements` and `rawTextElements` lookups two
- * lines away had been lowercasing all along. */
-function sameTag(one, other) {
-    return one.toLowerCase() === other.toLowerCase();
-}
-/**
- * Whether a close tag for exactly `tag` starts here.
- *
- * The name has to end where `tag` does. On a prefix comparison `</bdi>` would close a `<b>`,
- * deleting `di` from the source and pointing any error at the next, well-formed close tag.
- */
-function startsCloseTag(text, position, tag) {
-    if (!text.startsWith('</', position)) {
-        return false;
-    }
-    const { value: name, next } = readName(text, position + 2);
-    return sameTag(name, tag) && (next >= text.length || tagNameTerminator.test(text[next]));
-}
-/* Everything between `</` and `>`. HTML keeps only the name and throws the rest away, but it is
- * still the author's source: `</h{{level}}>` has to come back out spelled that way. Whitespace
- * runs collapse so a close tag can never put a raw newline into a doc. */
-function readCloseTagSource(text, position, closeIdx) {
-    return text
-        .slice(position + 2, closeIdx >= 0 ? closeIdx : text.length)
-        .trim()
-        .replace(whitespace.htmlRunGlobal, ' ');
-}
-/* One past the last non-whitespace character, leaving the author's trailing whitespace to the
- * caller instead of burying it inside a node that prints verbatim. */
-function trimTrailingWhitespace(text, from) {
-    let end = text.length;
-    while (end > from && whitespace.html.test(text[end - 1])) {
-        end -= 1;
-    }
-    return end;
-}
-function isTagStart(text, position) {
-    if (text[position] !== '<') {
-        return false;
-    }
-    return /[A-Za-z!/]/u.test(text[position + 1] ?? '');
-}
-/**
- * Where an unquoted attribute value ends. HTML's unquoted-value state ends at whitespace or `>`
- * and nowhere else, so a `/` is content: breaking on it would drop the trailing slash of
- * `src=/a/b/` and make `<a href=/path/>t</a>` a self-closing `<a>` that rejects its own `</a>`.
- * `scanTag` reads values with this too, so its idea of where a tag ends matches the parser's;
- * were they to disagree, a `{{! prettier-ignore }}` region could stop mid-tag.
- */
-function readUnquotedValueEnd(text, position) {
-    let pos = position;
-    while (pos < text.length && text[pos] !== '>' && !whitespace.html.test(text[pos])) {
-        if (startsTemplateTag(text, pos)) {
-            const token = parseMustacheToken(text, pos);
-            pos = token.end > pos ? token.end : pos + 2;
-            continue;
-        }
-        pos += 1;
-    }
-    return pos;
+    const { value, next } = (0, lex_1.readName)(text, afterGap + 2);
+    const end = (0, lex_1.skipWhitespace)(text, next);
+    return (0, lex_1.sameTag)(value, tag) && text[end] === '>' ? end + 1 : null;
 }
-function parseAttribute(text, position, rangeOffset = 0) {
+function parseAttribute(text, position, rangeOffset) {
     let pos = position;
-    pos = skipWhitespace(text, pos);
-    const { value: name, next } = readAttributeName(text, pos);
+    pos = (0, lex_1.skipWhitespace)(text, pos);
+    const { value: name, next } = (0, lex_1.readAttributeName)(text, pos);
     pos = next;
     if (!name) {
         return null;
     }
-    pos = skipWhitespace(text, pos);
+    pos = (0, lex_1.skipWhitespace)(text, pos);
     // a boolean attribute: no "="
     if (text[pos] !== '=') {
         return { attribute: createAttribute(name, null), position: pos };
     }
     pos += 1;
-    pos = skipWhitespace(text, pos);
-    let rawValue = '';
-    let valueStart = pos;
-    if (text[pos] === '"' || text[pos] === "'") {
-        const quote = text[pos];
-        pos += 1;
-        valueStart = pos;
-        const quoted = readQuotedAttributeValue(text, pos, quote);
-        rawValue = quoted.value;
-        pos = quoted.position;
-    }
-    else {
-        const start = pos;
-        valueStart = start;
-        pos = readUnquotedValueEnd(text, pos);
-        rawValue = text.slice(start, pos);
-    }
+    pos = (0, lex_1.skipWhitespace)(text, pos);
+    const { raw: rawValue, start: valueStart, end } = (0, lex_1.readAttributeValue)(text, pos);
+    pos = end;
     /* A value holding both quote characters cannot be printed: whichever one the printer wraps it
      * in ends the attribute early: `title=a"b'c` would print as `title='a"b'c'`, which HTML reads
      * as two attributes. The reader skips over mustaches to find the closing quote, so it accepts
      * values like `class="{{t 'a' "b"}}"` that a browser would cut short. */
     if (rawValue.includes('"') && rawValue.includes("'")) {
-        fail('attribute value cannot contain both quote characters', rangeOffset + valueStart, rangeOffset + pos);
+        (0, errors_1.fail)('attribute value cannot contain both quote characters', rangeOffset + valueStart, rangeOffset + pos);
     }
     return { attribute: createAttribute(name, rawValue, rangeOffset + valueStart), position: pos };
 }
 function parseDynamicAttribute(text, position) {
     let pos = position;
-    pos = skipWhitespace(text, pos);
+    pos = (0, lex_1.skipWhitespace)(text, pos);
     const start = pos;
     let hasDynamicPart = false;
     let hasStaticPart = false;
     while (pos < text.length) {
-        if (startsTemplateTag(text, pos)) {
+        if ((0, lex_1.startsTemplateTag)(text, pos)) {
             const token = parseMustacheToken(text, pos);
             /* A block in the middle of a name is part of the name, so it is consumed whole rather
              * than refused. Unbalanced it is not a name at all, and the caller's error is better
              * than a guess at where it ends. */
             if (token.kind === 'blockStart') {
-                const blockEnd = findMatchingBlockEnd(text, token);
+                const blockEnd = (0, lookahead_1.findMatchingBlockEnd)(text, token);
                 if (blockEnd === null) {
                     return null;
                 }
@@ -791,7 +505,7 @@ function parseDynamicAttribute(text, position) {
             pos = token.end;
             continue;
         }
-        if (attributeNameCharacter.test(text[pos])) {
+        if (lex_1.attributeNameCharacter.test(text[pos])) {
             hasStaticPart = true;
             pos += 1;
             continue;
@@ -802,7 +516,7 @@ function parseDynamicAttribute(text, position) {
         return null;
     }
     const nameEnd = pos;
-    const afterName = skipWhitespace(text, pos);
+    const afterName = (0, lex_1.skipWhitespace)(text, pos);
     if (text[afterName] !== '=') {
         /* A static part is what makes this a name with a mustache in it rather than a mustache
          * standing alone. Without one the caller's model is the better fit - `{{attrs}}` is an
@@ -818,38 +532,23 @@ function parseDynamicAttribute(text, position) {
     }
     /* A value overrides that: it attaches to the composite name, and once the name is split
      * there is nothing left to attach it to. */
-    pos = skipWhitespace(text, afterName + 1);
-    if (text[pos] === '"' || text[pos] === "'") {
-        const quote = text[pos];
-        pos += 1;
-        pos = readQuotedAttributeValue(text, pos, quote).position;
-    }
-    else {
-        pos = readUnquotedValueEnd(text, pos);
-    }
+    pos = (0, lex_1.readAttributeValue)(text, (0, lex_1.skipWhitespace)(text, afterName + 1)).end;
     return {
         attribute: createRawAttribute(text.slice(start, pos)),
         position: pos,
     };
 }
 function createAttribute(name, rawValue, valueStart) {
-    if (rawValue == null) {
-        return {
-            type: 'Attribute',
-            name,
-            value: null,
-        };
+    if (rawValue === null) {
+        return { type: 'Attribute', name, value: null };
     }
     const value = {
         type: 'AttributeValue',
         parts: parseAttributeValueParts(rawValue, valueStart ?? 0),
         raw: rawValue,
     };
-    return {
-        type: 'Attribute',
-        name,
-        value: (0, template_format_core_2.withOptionalRange)(value, valueStart, typeof valueStart === 'number' ? valueStart + rawValue.length : undefined),
-    };
+    const valueEnd = valueStart === undefined ? undefined : valueStart + rawValue.length;
+    return { type: 'Attribute', name, value: (0, source_1.withOptionalRange)(value, valueStart, valueEnd) };
 }
 function createRawAttribute(raw) {
     return {
@@ -857,44 +556,33 @@ function createRawAttribute(raw) {
         raw,
     };
 }
-function parseAttributeValueParts(value, rangeOffset = 0) {
+function parseAttributeValueParts(value, rangeOffset) {
     const parts = [];
     let pos = 0;
     while (pos < value.length) {
         /* A raw block's body is emitted literally by Handlebars, so it is copied through here for
          * the same reason it is between siblings: reformatting the `{{ x }}` inside one changes
          * what the value renders. Only the sibling list guarded this. */
-        const rawBlockEnd = consumeTerminatedRawBlock(value, pos, rangeOffset);
+        const rawBlockEnd = (0, lookahead_1.consumeTerminatedRawBlock)(value, pos, rangeOffset);
         if (rawBlockEnd !== null) {
-            parts.push((0, template_format_core_2.withRange)({ type: 'TextNode', chars: value.slice(pos, rawBlockEnd) }, rangeOffset + pos, rangeOffset + rawBlockEnd));
+            parts.push((0, nodes_1.textNode)(value, pos, rawBlockEnd, rangeOffset));
             pos = rawBlockEnd;
             continue;
         }
-        if (startsTemplateTag(value, pos)) {
+        if ((0, lex_1.startsTemplateTag)(value, pos)) {
             const token = parseMustacheToken(value, pos);
-            const statement = createStatement(value, token, pos, rangeOffset);
-            if (statement) {
-                parts.push(statement);
-                pos = token.end;
-                continue;
-            }
-            if (token.kind === 'blockStart' && hasMatchingBlockEnd(value, token)) {
-                const { node, next } = parseBlock(value, token, rangeOffset);
-                parts.push(node);
-                pos = next;
-                continue;
-            }
             /* A value is a string, so the recovery here keeps the source as text rather than as a
              * node - unlike attribute position, where an unreadable token stays a mustache. */
-            parts.push((0, template_format_core_2.withRange)({ type: 'TextNode', chars: value.slice(pos, token.end) }, rangeOffset + pos, rangeOffset + token.end));
-            pos = token.end;
+            const read = readTemplateNode(value, token, pos, rangeOffset);
+            parts.push(read?.node ?? (0, nodes_1.textNode)(value, pos, token.end, rangeOffset));
+            pos = read?.next ?? token.end;
             continue;
         }
         const next = findNextHandlebarsOpen(value, pos);
         const end = next === -1 ? value.length : next;
         const rawText = value.slice(pos, end);
         if (rawText.length > 0) {
-            parts.push((0, template_format_core_2.withRange)({ type: 'TextNode', chars: rawText }, rangeOffset + pos, rangeOffset + end));
+            parts.push((0, nodes_1.textNode)(value, pos, end, rangeOffset));
         }
         pos = end;
     }
@@ -925,351 +613,3 @@ function preserveValueWhitespace(nodes) {
         }
     }
 }
-function readQuotedAttributeValue(text, position, quote) {
-    let pos = position;
-    while (pos < text.length) {
-        if (startsTemplateTag(text, pos)) {
-            const token = parseMustacheToken(text, pos);
-            pos = token.end > pos ? token.end : pos + 2;
-            continue;
-        }
-        if (text[pos] === quote) {
-            return { value: text.slice(position, pos), position: pos + 1 };
-        }
-        pos += 1;
-    }
-    return { value: text.slice(position), position: text.length };
-}
-/* One past the whitespace run starting at `position`. Every caller wants an index, and taking
- * one instead of a pair of closures is what let the open-coded copies of this loop go. */
-function skipWhitespace(text, position) {
-    let pos = position;
-    while (pos < text.length && whitespace.html.test(text[pos])) {
-        pos += 1;
-    }
-    return pos;
-}
-/**
- * HTML's attribute-name state ends at whitespace, `/`, `>` or `=`, and nowhere else.
- *
- * Matching a tag-name charset instead stepped over one character and carried on: `@click` came
- * back as `click` and `(click)="go()"` as two boolean attributes, value gone, silently.
- */
-/* Stops at a mustache as well as at the characters HTML ends a name on. `parseDynamicAttribute`
- * has already had its go by the time this runs, so what is left is a block or a partial glued to
- * the name - `<div data-{{#if a}}x{{/if}}>`. Reading `data-{{#if` as the name desynchronised the
- * tag loop, which then reported the `/` of `{{/if}}` as an unexpected character. Left here, the
- * tag loop takes the block as its own glued attribute and the two print back together. */
-function readAttributeName(text, position) {
-    let pos = position;
-    while (pos < text.length && attributeNameCharacter.test(text[pos]) && !startsTemplateTag(text, pos)) {
-        pos += 1;
-    }
-    return { value: text.slice(position, pos), next: pos };
-}
-function readName(text, position) {
-    let pos = position;
-    while (pos < text.length && /[A-Za-z0-9_:-]/.test(text[pos])) {
-        pos += 1;
-    }
-    return { value: text.slice(position, pos), next: pos };
-}
-function isSelfClosingSlash(text, position) {
-    return text[position] === '/' && text[position + 1] === '>';
-}
-function findNextMarkup(text, position) {
-    let next = text.length;
-    let searchPos = position;
-    while (searchPos < text.length) {
-        const candidate = text.indexOf('<', searchPos);
-        if (candidate === -1) {
-            break;
-        }
-        if (isDynamicTagStart(text, candidate)) {
-            next = candidate;
-            break;
-        }
-        if (isTagStart(text, candidate)) {
-            next = candidate;
-            break;
-        }
-        searchPos = candidate + 1;
-    }
-    const hb = findNextHandlebarsOpen(text, position);
-    if (hb !== -1 && hb < next) {
-        next = hb;
-    }
-    return next;
-}
-function findCurrentBlockBoundary(text, position, endBlock) {
-    let depth = 0;
-    for (const token of mustachesFrom(text, position)) {
-        if (token.kind === 'blockStart') {
-            depth += 1;
-        }
-        else if (token.kind === 'blockEnd') {
-            if (depth === 0 && token.name === endBlock) {
-                return token.start;
-            }
-            if (depth > 0) {
-                depth -= 1;
-            }
-        }
-        else if (token.kind === 'else' && depth === 0) {
-            return token.start;
-        }
-    }
-    return -1;
-}
-/* Past one mustache, or past a whole raw block: a raw block's body is emitted literally, so the
- * markup inside it is not markup either. Never returns `position`, so callers cannot spin. */
-function skipMustache(text, position) {
-    const rawBlockEnd = consumeRawBlock(text, position);
-    if (rawBlockEnd !== null && rawBlockEnd > position) {
-        return rawBlockEnd;
-    }
-    return Math.max(parseMustacheToken(text, position).end, position + 2);
-}
-function findMatchingTagClose(text, tag, position, limit = -1) {
-    if (template_format_core_1.rawTextElements.has(tag.toLowerCase())) {
-        const closeStart = findRawTextClose(text, position, tag);
-        if (closeStart === -1 || (limit >= 0 && closeStart >= limit)) {
-            return null;
-        }
-        return closeStart;
-    }
-    let depth = 0;
-    let pos = position;
-    while (pos < text.length) {
-        const next = text.indexOf('<', pos);
-        if (next === -1 || (limit >= 0 && next >= limit)) {
-            return null;
-        }
-        /* A `<` inside a mustache is not markup, so the dialect is consulted first, as every other
-         * scanner here does. Otherwise `{{t "<div>"}}` reads as an open tag, leaving the scan a level
-         * too deep and the real `</div>` closing it - refusing the file as unclosed. */
-        const mustache = findNextHandlebarsOpen(text, pos);
-        if (mustache !== -1 && mustache < next) {
-            pos = skipMustache(text, mustache);
-            continue;
-        }
-        if (text.startsWith('<!--', next)) {
-            const closeIdx = text.indexOf('-->', next + 4);
-            pos = closeIdx >= 0 ? closeIdx + 3 : text.length;
-            continue;
-        }
-        if (text.startsWith('<!', next) && !text.startsWith('<!--', next)) {
-            const closeIdx = text.indexOf('>', next + 2);
-            pos = closeIdx >= 0 ? closeIdx + 1 : text.length;
-            continue;
-        }
-        const dynamicEnd = consumeDynamicElement(text, next);
-        if (dynamicEnd !== null) {
-            pos = dynamicEnd;
-            continue;
-        }
-        if (!isTagStart(text, next)) {
-            pos = next + 1;
-            continue;
-        }
-        const tagResult = scanTag(text, next);
-        if (tagResult.kind === 'close') {
-            if (sameTag(tagResult.tag, tag)) {
-                if (depth === 0) {
-                    return next;
-                }
-                depth -= 1;
-            }
-            pos = tagResult.end;
-            continue;
-        }
-        if (tagResult.kind === 'open' && template_format_core_1.rawTextElements.has(tagResult.tag.toLowerCase())) {
-            const closeStart = findRawTextClose(text, tagResult.end, tagResult.tag);
-            const closeIdx = closeStart >= 0 ? text.indexOf('>', closeStart) : -1;
-            pos = closeIdx >= 0 ? closeIdx + 1 : text.length;
-            continue;
-        }
-        if (tagResult.kind === 'open' && sameTag(tagResult.tag, tag)) {
-            depth += 1;
-        }
-        pos = tagResult.end;
-    }
-    return null;
-}
-/**
- * Raw text ends at the first `</tag`, whatever it appears to sit inside.
- *
- * A browser's tokenizer does not parse the script or style body looking for string literals -
- * that is exactly why `"<\\/script>"` has to be escaped in JS. Tracking quotes here instead would
- * let an apostrophe in a comment hide the closing tag.
- */
-function findRawTextClose(text, position, tag) {
-    const needle = `</${tag.toLowerCase()}`;
-    /* The name has to end there: HTML's script-data end-tag state needs whitespace, `/` or `>`
-     * after it, so `"</scriptx>"` inside a script body does not close the element. */
-    /* Scanning case-insensitively rather than lowercasing the whole template: this runs once per
-     * raw-text element and again inside every close-tag scan, so a copy of the file each time
-     * turns a page of `<script>`s into quadratic work. */
-    for (let index = text.indexOf('<', position); index !== -1; index = text.indexOf('<', index + 1)) {
-        if (text.slice(index, index + needle.length).toLowerCase() === needle && tagNameTerminator.test(text[index + needle.length] ?? '>')) {
-            return index;
-        }
-    }
-    return -1;
-}
-/** Whether the character before `index`, whitespace aside, is `=`. */
-function follows(text, index, char) {
-    let at = index - 1;
-    while (at >= 0 && whitespace.html.test(text[at]))
-        at -= 1;
-    return text[at] === char;
-}
-function consumeTagLikeChunk(text, position) {
-    /* Same rule as a real tag head: a quote delimits a value only after `=`. `<{{t}} a=it's>`
-     * otherwise runs to EOF and swallows the rest of the file into one verbatim node. */
-    const end = (0, scan_1.scanPastQuotes)(text, position + 1, {
-        stopsAt: (index) => text[index] === '>',
-        opensQuote: (index) => follows(text, index, '='),
-    });
-    return end === -1 ? text.length : end + 1;
-}
-function consumeDynamicElement(text, position) {
-    if (!isDynamicTagStart(text, position)) {
-        return null;
-    }
-    const dynamicOpen = `<${openDelimiter}`;
-    const dynamicClose = `</${openDelimiter}`;
-    if (text.startsWith(dynamicClose, position)) {
-        return consumeTagLikeChunk(text, position);
-    }
-    const openEnd = consumeTagLikeChunk(text, position);
-    let depth = 0;
-    let pos = openEnd;
-    while (pos < text.length) {
-        const nextOpen = text.indexOf(dynamicOpen, pos);
-        const nextClose = text.indexOf(dynamicClose, pos);
-        const candidates = [nextOpen, nextClose].filter((value) => value !== -1);
-        const next = candidates.length > 0 ? Math.min(...candidates) : -1;
-        if (next === -1) {
-            return openEnd;
-        }
-        if (next === nextClose) {
-            if (depth === 0) {
-                return consumeTagLikeChunk(text, nextClose);
-            }
-            depth -= 1;
-            pos = consumeTagLikeChunk(text, nextClose);
-            continue;
-        }
-        depth += 1;
-        pos = consumeTagLikeChunk(text, nextOpen);
-    }
-    return openEnd;
-}
-/** Where `content` begins inside the tag spanning [tagStart, tagEnd), for absolute expression ranges. */
-function contentOffset(text, tagStart, tagEnd, content) {
-    const at = text.slice(tagStart, tagEnd).indexOf(content);
-    return at === -1 ? tagStart : tagStart + at;
-}
-/* The parts every inline statement shares: its call, and the `~` markers on its delimiters. */
-function statementBase(text, token, position, rangeOffset, content) {
-    return {
-        ...(0, expression_1.parseCall)(content, rangeOffset + contentOffset(text, position, token.end, content)),
-        ...(token.trimOpen ? { trimOpen: true } : {}),
-        ...(token.trimClose ? { trimClose: true } : {}),
-    };
-}
-/**
- * A mustache built from whatever token is in hand, whether or not it reads as one.
- *
- * The recovery paths use it for a block that never closes and for a stray `{{else}}` or
- * `{{/if}}` in a position that cannot reject them.
- */
-function createMustache(text, token, position, rangeOffset) {
-    /* Annotated, not inferred: `withOptionalRange` is generic, so an unannotated literal widens
-     * `type` to `string` and stops matching the node union. */
-    const node = {
-        type: 'MustacheStatement',
-        triple: token.triple,
-        ...statementBase(text, token, position, rangeOffset, token.content),
-    };
-    return (0, template_format_core_2.withOptionalRange)(node, rangeOffset + position, rangeOffset + token.end);
-}
-/**
- * The node for a token that stands on its own, or null for the three kinds - a block and the two
- * terminators - whose handling depends on where they appear.
- *
- * Every context that reads a mustache needs this dispatch: a program body, an attribute list,
- * the inside of a value. Written out three times, they had drifted at the recovery arms.
- */
-function createStatement(text, token, position, rangeOffset) {
-    const start = rangeOffset + position;
-    const end = rangeOffset + token.end;
-    if (token.kind === 'comment') {
-        return createComment(token, start, end);
-    }
-    if (token.kind === 'partial') {
-        const node = {
-            type: 'PartialStatement',
-            ...statementBase(text, token, position, rangeOffset, token.content),
-        };
-        return (0, template_format_core_2.withOptionalRange)(node, start, end);
-    }
-    /* Before the mustache arm: a decorator is a mustache token carrying a `*`. */
-    if (token.specialForm === 'decorator') {
-        const node = {
-            type: 'DecoratorStatement',
-            ...statementBase(text, token, position, rangeOffset, token.content.slice(1).trim()),
-        };
-        return (0, template_format_core_2.withOptionalRange)(node, start, end);
-    }
-    return token.kind === 'mustache' ? createMustache(text, token, position, rangeOffset) : null;
-}
-/**
- * A comment's body, with the tag's own `~` markers taken off. They are whitespace control, not
- * text: printing `rawContent` straight through emits them as body, turning `{{~! x ~}}` into
- * `{{! ~! x ~ }}` and dropping the stripping the author asked for.
- */
-function commentBody(token) {
-    let content = token.rawContent;
-    if (token.trimOpen) {
-        content = content.replace(/^([\t ]*)~/u, '$1');
-    }
-    /* A block comment's closing `~` follows the `--`, so it never reached `rawContent`. */
-    if (token.trimClose) {
-        content = content.replace(/~([\t ]*)$/u, '$1');
-    }
-    return content;
-}
-function createComment(token, start, end) {
-    const content = commentBody(token);
-    const isBlockStyle = /^\s*!-{2}/.test(content);
-    /* express-hbs' layout directive is `{{!< name}}`, with nothing between the `!` and the `<`, so
-     * the gap is what distinguishes it. Recognising it by body alone would print the ordinary
-     * comment `{{! < name}}` as a directive, silently wrapping the page in a layout. */
-    const isLayout = /^!<\s*\S/u.test(content.trim());
-    /* Only a block comment's `--` is a marker. Stripping up to two dashes regardless cannot tell
-     * it from a body that opens with one, which turns `{{!-foo}}` into `{{! foo }}`.
-     *
-     * Nothing is stripped from the end: the tokenizer stops before the closing delimiter already,
-     * so doing it again would delete a `--` the author wrote. */
-    const body = content.replace(isBlockStyle ? /^[\t ]*!--/u : /^[\t ]*!/u, '');
-    /* Trailing whitespace comes off first. A space between `{{!--` and the newline is invisible in
-     * the source and left the body not *starting* with one, which silently turned off the
-     * re-indent below - so `{{!-- \n  x\n--}}` and `{{!--\n  x\n--}}` printed differently. */
-    const trimmed = body.replace(/[ \t]+$/gm, '');
-    /* A body the author started on its own line keeps its leading newline; the printer reads that
-     * to decide whether to re-indent it. ASCII whitespace, not `\s`: a non-breaking space is
-     * content the author put there, and `\s` deleted one off the front of a comment body. */
-    const value = trimmed.startsWith('\n') ? trimmed : trimmed.replace(leadingWhitespace, '');
-    const isMultiline = /\n/.test(content);
-    return (0, template_format_core_2.withOptionalRange)({
-        type: 'CommentStatement',
-        value,
-        multiline: isMultiline,
-        block: isBlockStyle || isMultiline,
-        ...(isLayout ? { layout: true } : {}),
-        ...(token.trimOpen ? { trimOpen: true } : {}),
-        ...(token.trimClose ? { trimClose: true } : {}),
-    }, start, end);
-}