@falsefalse/prettier-plugin-handlebars 0.0.2 → 0.0.5

package/dist/parse/lex.js

@@ -0,0 +1,274 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tagNameTerminator = exports.attributeNameCharacter = exports.leadingWhitespace = exports.parseMustacheToken = exports.isEscapedOpen = exports.openDelimiter = void 0;
+exports.startsTemplateTag = startsTemplateTag;
+exports.skipTemplateTag = skipTemplateTag;
+exports.scanTag = scanTag;
+exports.sameTag = sameTag;
+exports.startsCloseTag = startsCloseTag;
+exports.readCloseTagSource = readCloseTagSource;
+exports.trimTrailingWhitespace = trimTrailingWhitespace;
+exports.isTagStart = isTagStart;
+exports.readAttributeValue = readAttributeValue;
+exports.skipWhitespace = skipWhitespace;
+exports.readAttributeName = readAttributeName;
+exports.readName = readName;
+exports.consumeTagLikeChunk = consumeTagLikeChunk;
+/* Character-level readers: where a tag, a name or a value ends. Nothing here builds a node or
+ * knows what a block is, so everything above can be read without this file open. */
+const html_1 = require("../core/html");
+const scan_1 = require("../core/scan");
+const whitespace = __importStar(require("../core/whitespace"));
+const tokens_1 = require("../dialects/handlebars/tokens");
+({ openDelimiter: exports.openDelimiter, isEscapedOpen: exports.isEscapedOpen, parseToken: exports.parseMustacheToken } = tokens_1.handlebarsDialect);
+/* Built from the shared class so the character list stays written in one place. */
+exports.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. */
+exports.attributeNameCharacter = new RegExp(`[^${whitespace.htmlCharacters}"'<>/=]`, 'u');
+/** What ends a tag name. HTML's tag-name state leaves on whitespace, `/` or `>`, and nothing else. */
+exports.tagNameTerminator = new RegExp(`[${whitespace.htmlCharacters}/>]`, 'u');
+function startsTemplateTag(text, position) {
+    return text.startsWith(exports.openDelimiter, position) && !(0, exports.isEscapedOpen)(text, position);
+}
+/**
+ * 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.
+ */
+/**
+ * Past the mustache at `position`. A token reporting an end at or before where it started would
+ * leave the caller's loop standing still, so the opening delimiter is the smallest step taken.
+ */
+function skipTemplateTag(text, position) {
+    return Math.max((0, exports.parseMustacheToken)(text, position).end, position + 2);
+}
+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 || (0, html_1.isVoidElement)(tag) ? '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)) {
+            pos = skipTemplateTag(text, pos);
+            continue;
+        }
+        const char = text[pos];
+        if (whitespace.html.test(char)) {
+            pos += 1;
+            continue;
+        }
+        if (char === '=') {
+            afterEquals = true;
+            pos += 1;
+            continue;
+        }
+        if (afterEquals && char !== '>') {
+            pos = readAttributeValue(text, pos).end;
+            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 };
+}
+/* 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 || exports.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)) {
+            pos = skipTemplateTag(text, pos);
+            continue;
+        }
+        pos += 1;
+    }
+    return pos;
+}
+/**
+ * An attribute value's extent and its text, whichever way it was written. The quotes are not
+ * part of the value, so `start` is inside them - getting that `+ 1` wrong shifts every range a
+ * mustache inside the value reports.
+ */
+function readAttributeValue(text, position) {
+    const quote = text[position];
+    if (quote === '"' || quote === "'") {
+        const quoted = readQuotedAttributeValue(text, position + 1, quote);
+        return { raw: quoted.value, start: position + 1, end: quoted.position };
+    }
+    const end = readUnquotedValueEnd(text, position);
+    return { raw: text.slice(position, end), start: position, end };
+}
+function readQuotedAttributeValue(text, position, quote) {
+    let pos = position;
+    while (pos < text.length) {
+        if (startsTemplateTag(text, pos)) {
+            pos = skipTemplateTag(text, pos);
+            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 && exports.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] === '>';
+}
+/** 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;
+}

package/dist/parse/lookahead.d.ts

@@ -0,0 +1,35 @@
+import type { HandlebarsToken as MustacheToken } from '../dialects/handlebars/tokens';
+export declare const openDelimiter: string, parseMustacheToken: (text: string, position: number) => MustacheToken, findNextHandlebarsOpen: (text: string, position: number) => number, isDynamicTagStart: (text: string, position: number) => boolean, consumeRawBlock: (text: string, position: number) => number | null;
+export declare function consumeTerminatedRawBlock(text: string, position: number, rangeOffset: number): number | null;
+export declare function hasMatchingBlockEnd(text: string, token: MustacheToken): boolean;
+/**
+ * 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}}`.
+ */
+export declare function mustachesFrom(text: string, from: number): Generator<MustacheToken>;
+/** Where the block opened by `token` closes, or null if it never does. */
+export declare function findMatchingBlockEnd(text: string, token: MustacheToken): number | 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".
+ */
+export declare function consumeNextNode(text: string, position: number): number;
+export declare function findNextMarkup(text: string, position: number): number;
+export declare function findCurrentBlockBoundary(text: string, position: number, endBlock: string): number;
+export declare function findMatchingTagClose(text: string, tag: string, position: number, limit?: number): number | 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.
+ */
+export declare function findRawTextClose(text: string, position: number, tag: string): number;
+export declare function consumeDynamicElement(text: string, position: number): number | null;

package/dist/parse/lookahead.js

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consumeRawBlock = exports.isDynamicTagStart = exports.findNextHandlebarsOpen = exports.parseMustacheToken = exports.openDelimiter = void 0;
+exports.consumeTerminatedRawBlock = consumeTerminatedRawBlock;
+exports.hasMatchingBlockEnd = hasMatchingBlockEnd;
+exports.mustachesFrom = mustachesFrom;
+exports.findMatchingBlockEnd = findMatchingBlockEnd;
+exports.consumeNextNode = consumeNextNode;
+exports.findNextMarkup = findNextMarkup;
+exports.findCurrentBlockBoundary = findCurrentBlockBoundary;
+exports.findMatchingTagClose = findMatchingTagClose;
+exports.findRawTextClose = findRawTextClose;
+exports.consumeDynamicElement = consumeDynamicElement;
+/* Lookahead: where a construct ends, without building anything. Every answer is an index, so
+ * the tree builder can decide whether to refuse before it has committed to a node. */
+const html_1 = require("../core/html");
+const errors_1 = require("../core/errors");
+const tokens_1 = require("../dialects/handlebars/tokens");
+const lex_1 = require("./lex");
+({ openDelimiter: exports.openDelimiter, parseToken: exports.parseMustacheToken, findNextOpen: exports.findNextHandlebarsOpen, isDynamicElementStart: exports.isDynamicTagStart, consumeRawBlock: exports.consumeRawBlock } = tokens_1.handlebarsDialect);
+/* 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 = (0, exports.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))) {
+        (0, errors_1.fail)(`unterminated raw block: expected ${(0, tokens_1.handlebarsRawBlockCloser)(name)}`, rangeOffset + position, rangeOffset + end);
+    }
+    return end;
+}
+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 = (0, exports.findNextHandlebarsOpen)(text, pos);
+        if (next === -1) {
+            return;
+        }
+        const rawBlockEnd = (0, exports.consumeRawBlock)(text, next);
+        if (rawBlockEnd !== null && rawBlockEnd > next) {
+            pos = rawBlockEnd;
+            continue;
+        }
+        const token = (0, exports.parseMustacheToken)(text, next);
+        yield token;
+        pos = token.end > next ? token.end : next + 2;
+    }
+}
+/** Where the block opened by `token` closes, or null if it never does. */
+function findMatchingBlockEnd(text, token) {
+    if (!token.name) {
+        return null;
+    }
+    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;
+            }
+            depth -= 1;
+        }
+    }
+    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 ((0, lex_1.startsTemplateTag)(text, position)) {
+        const token = (0, exports.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 = (0, lex_1.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 findNextMarkup(text, position) {
+    let next = text.length;
+    let searchPos = position;
+    while (searchPos < text.length) {
+        const candidate = text.indexOf('<', searchPos);
+        if (candidate === -1) {
+            break;
+        }
+        if ((0, exports.isDynamicTagStart)(text, candidate)) {
+            next = candidate;
+            break;
+        }
+        if ((0, lex_1.isTagStart)(text, candidate)) {
+            next = candidate;
+            break;
+        }
+        searchPos = candidate + 1;
+    }
+    const hb = (0, exports.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 = (0, exports.consumeRawBlock)(text, position);
+    if (rawBlockEnd !== null && rawBlockEnd > position) {
+        return rawBlockEnd;
+    }
+    return (0, lex_1.skipTemplateTag)(text, position);
+}
+function findMatchingTagClose(text, tag, position, limit = -1) {
+    if ((0, html_1.isRawTextElement)(tag)) {
+        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 = (0, exports.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 (!(0, lex_1.isTagStart)(text, next)) {
+            pos = next + 1;
+            continue;
+        }
+        const tagResult = (0, lex_1.scanTag)(text, next);
+        if (tagResult.kind === 'close') {
+            if ((0, lex_1.sameTag)(tagResult.tag, tag)) {
+                if (depth === 0) {
+                    return next;
+                }
+                depth -= 1;
+            }
+            pos = tagResult.end;
+            continue;
+        }
+        if (tagResult.kind === 'open' && (0, html_1.isRawTextElement)(tagResult.tag)) {
+            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' && (0, lex_1.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 && lex_1.tagNameTerminator.test(text[index + needle.length] ?? '>')) {
+            return index;
+        }
+    }
+    return -1;
+}
+function consumeDynamicElement(text, position) {
+    if (!(0, exports.isDynamicTagStart)(text, position)) {
+        return null;
+    }
+    const dynamicOpen = `<${exports.openDelimiter}`;
+    const dynamicClose = `</${exports.openDelimiter}`;
+    if (text.startsWith(dynamicClose, position)) {
+        return (0, lex_1.consumeTagLikeChunk)(text, position);
+    }
+    const openEnd = (0, lex_1.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 (0, lex_1.consumeTagLikeChunk)(text, nextClose);
+            }
+            depth -= 1;
+            pos = (0, lex_1.consumeTagLikeChunk)(text, nextClose);
+            continue;
+        }
+        depth += 1;
+        pos = (0, lex_1.consumeTagLikeChunk)(text, nextOpen);
+    }
+    return openEnd;
+}

package/dist/parse/nodes.d.ts

@@ -0,0 +1,38 @@
+import type { HandlebarsToken as MustacheToken } from '../dialects/handlebars/tokens';
+import type { CommentStatement, DecoratorStatement, MustacheStatement, PartialStatement, TextNode, UnmatchedNode } from '../types';
+type PrettierIgnoreDirective = 'next' | 'start' | 'end' | null;
+/**
+ * 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.
+ */
+export declare function getPrettierIgnoreDirective(rawContent: string): PrettierIgnoreDirective;
+export declare function findPrettierIgnoreEnd(text: string, position: number): number | null;
+/** A run of source kept as text. `verbatim` means the printer reproduces it rather than reflowing. */
+export declare function textNode(text: string, start: number, end: number, rangeOffset: number, verbatim?: boolean): TextNode;
+export declare function createUnmatchedNode(text: string, start: number, end: number, rangeOffset: number): UnmatchedNode;
+/** Where `content` begins inside the tag spanning [tagStart, tagEnd), for absolute expression ranges. */
+export declare function contentOffset(text: string, tagStart: number, tagEnd: number, content: string): number;
+/**
+ * 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.
+ */
+export declare function createMustache(text: string, token: MustacheToken, position: number, rangeOffset: number): MustacheStatement;
+/**
+ * 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.
+ */
+export declare function createStatement(text: string, token: MustacheToken, position: number, rangeOffset: number): MustacheStatement | PartialStatement | DecoratorStatement | CommentStatement | 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.
+ */
+export declare function commentBody(token: MustacheToken): string;
+export declare function createComment(token: MustacheToken, start?: number, end?: number): CommentStatement;
+export {};