@falsefalse/prettier-plugin-handlebars 0.0.1

package/dist/plugin.d.ts

@@ -0,0 +1,22 @@
+import { locEnd, locStart, parse } from './parser';
+export declare const languages: {
+    name: string;
+    type: string;
+    parsers: string[];
+    extensions: string[];
+    aliases: string[];
+    vscodeLanguageIds: string[];
+}[];
+export declare const parsers: {
+    handlebars: {
+        parse: typeof parse;
+        astFormat: string;
+        locStart: typeof locStart;
+        locEnd: typeof locEnd;
+    };
+};
+export declare const printers: {
+    'handlebars-ast': import("prettier").Printer<import("./types").Node>;
+};
+export declare const options: {};
+export declare const defaultOptions: {};

package/dist/plugin.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOptions = exports.options = exports.printers = exports.parsers = exports.languages = void 0;
+const parser_1 = require("./parser");
+const printer_1 = require("./printer");
+exports.languages = [
+    {
+        name: 'Handlebars',
+        type: 'markup',
+        parsers: ['handlebars'],
+        extensions: ['.hbs', '.handlebars'],
+        aliases: ['hbs', 'htmlbars', 'classic-handlebars'],
+        vscodeLanguageIds: ['handlebars'],
+    },
+];
+exports.parsers = {
+    'handlebars': {
+        parse: parser_1.parse,
+        astFormat: 'handlebars-ast',
+        locStart: parser_1.locStart,
+        locEnd: parser_1.locEnd,
+    },
+};
+exports.printers = {
+    'handlebars-ast': printer_1.printer,
+};
+/* Opinionated formatter - prettier's core options only. */
+exports.options = {};
+exports.defaultOptions = {};

package/dist/printer.d.ts

@@ -0,0 +1,8 @@
+import type { ParserOptions, Printer } from 'prettier';
+import type { Node } from './types';
+/** Only prettier's core options reach the printer; this formatter is opinionated. */
+export type PrintOptions = Pick<ParserOptions<Node>, 'singleQuote'> & {
+    /** Quote holding the value being printed into. Unusable by anything nested in it. */
+    enclosingQuote?: '"' | "'";
+};
+export declare const printer: Printer<Node>;

package/dist/printer.js

@@ -0,0 +1,526 @@
+"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.printer = void 0;
+const doc_1 = require("prettier/doc");
+const template_format_core_1 = require("template-format-core");
+const tokens_1 = require("./dialects/handlebars/tokens");
+const whitespace = __importStar(require("./whitespace"));
+const { dedent, fill, group, hardline, ifBreak, indent, join, line, literalline, softline } = doc_1.builders;
+const { removeLines } = doc_1.utils;
+/* A run of blank lines collapses to one, which is two hardlines. */
+const MAX_HARDLINES = 2;
+/** The `~` of `{{~foo~}}`, which strips the whitespace next to the delimiter it sits on. */
+const trim = (marker) => (marker ? '~' : '');
+const hardlines = (count) => Array.from({ length: count }, () => hardline);
+/**
+ * A child that can take its container's closing marker inside it.
+ *
+ * Lazy rather than memoised: `withCloser` replaces the piece, so `doc` is never read on a child
+ * that got a tail. The getter buys not caching but never building the untailed doc at all,
+ * which on a deep chain of single children would double the work per level.
+ */
+function tailable(build) {
+    return {
+        kind: 'doc',
+        get doc() {
+            return build([]);
+        },
+        withTail: build,
+    };
+}
+const isGap = (piece) => piece.kind !== 'doc';
+/* Built from the shared class so the character list stays written in one place, and hoisted so
+ * `textPieces` is not compiling a pattern per text run. */
+const whitespaceGap = new RegExp(`(${whitespace.htmlRun.source})`, 'u');
+const trailingWhitespace = new RegExp(`${whitespace.htmlRun.source}$`, 'u');
+/**
+ * The governing rule: whitespace between siblings renders, so it is reproduced, never invented.
+ * A run holding a newline stays a newline, which keeps apart what the author put on separate
+ * lines. A run of plain spaces becomes a `line`, free to collapse or wrap by width.
+ */
+function whitespacePiece(text) {
+    const newlines = text.split('\n').length - 1;
+    return newlines === 0 ? { kind: 'space' } : { kind: 'break', count: Math.min(newlines, MAX_HARDLINES) };
+}
+/**
+ * A text run decomposes into the same pieces as a sibling list: words, and the gaps between
+ * them. Treating a run's interior differently from the gaps between nodes would make layout
+ * depend on where the parser happened to put a node boundary, collapsing a newline the author
+ * wrote inside a text run to a space.
+ */
+function textPieces(node) {
+    /* Raw text and ignored regions are copied through; literalline keeps them off the indent. */
+    if (node.verbatim || node.preserveWhitespace) {
+        return [{ kind: 'doc', doc: join(literalline, node.chars.split('\n')) }];
+    }
+    /* ASCII whitespace only. A non-breaking space is content the author chose - it suppresses a
+     * line break on the page - so it travels inside a word rather than becoming a gap. */
+    /* Splitting on a capture group already alternates word, gap, word, so the odd slots are the
+     * gaps - no second pattern to keep in step with the first. */
+    return node.chars
+        .split(whitespaceGap)
+        .flatMap((part, index) => part === '' ? [] : [index % 2 === 1 ? whitespacePiece(part) : { kind: 'doc', doc: part }]);
+}
+/* Recovered text is copied through, but its trailing whitespace belongs to the surrounding
+ * program: left inside the raw it would be reprinted *and* re-added as a line ending, growing
+ * the file by a newline on every pass. */
+function unmatchedPieces(node) {
+    /* In a value the trailing gap is content, not somewhere to break: split off as one it let the
+     * block around it break, and the printer indented the closing marker into a value the author
+     * owns - a space appeared on the page. */
+    if (node.preserveWhitespace) {
+        return [{ kind: 'doc', doc: join(literalline, node.raw.split('\n')) }];
+    }
+    /* ASCII only, as everywhere else: `\s` matches U+00A0, so on `\s` a non-breaking space ending
+     * an ignored region is rewritten as a plain one, and a run of them as a single space. */
+    const trailing = trailingWhitespace.exec(node.raw)?.[0] ?? '';
+    const body = trailing ? node.raw.slice(0, -trailing.length) : node.raw;
+    const pieces = [];
+    if (body) {
+        pieces.push({ kind: 'doc', doc: join(literalline, body.split('\n')) });
+    }
+    if (trailing) {
+        pieces.push(whitespacePiece(trailing));
+    }
+    return pieces;
+}
+/**
+ * Each run between hard breaks wraps on its own. `fill` rather than `group`, so a run that does
+ * not fit breaks only where it must - all-or-nothing is for attributes and call params, where
+ * the whitespace is the formatter's; content wraps like prose. Adjacent pieces with no gap are
+ * glued in the source and merge into one fill item.
+ */
+function assemble(pieces) {
+    const docs = [];
+    const run = [];
+    let glued = [];
+    /* A group, not a bare array: `propagateBreaks` marks a group holding a hard line as broken,
+     * and `fits` then refuses it, so `fill` prints the item in break mode and the groups inside it
+     * get measured one by one. Left as an array it measured as "fits" - `fits` stops at the first
+     * hard line - and everything after that line printed flat, over width, until the next pass. */
+    const flushGlued = () => {
+        if (glued.length > 0) {
+            run.push(glued.length === 1 ? glued[0] : group([...glued]));
+            glued = [];
+        }
+    };
+    const flushRun = () => {
+        flushGlued();
+        if (run.length === 0) {
+            return;
+        }
+        /* `fill` only means anything with separators to wrap at. Wrapping a lone item in one hides
+         * its own groups from the width check, so a call that should break stays long. */
+        docs.push(run.length === 1 ? run[0] : fill([...run]));
+        run.length = 0;
+    };
+    for (const piece of pieces) {
+        if (piece.kind === 'break') {
+            flushRun();
+            docs.push(...hardlines(piece.count));
+            continue;
+        }
+        if (piece.kind === 'space') {
+            flushGlued();
+            /* fill reads even positions as content; keep separators on the odd ones. A space that must
+             * not become a line break is still a separator - printing it as one keeps its neighbours
+             * as separate items that `fill` can measure. Gluing it to them makes everything downstream
+             * of a standalone-sensitive statement one unbreakable blob, holding a long tag after a
+             * `prettier-ignore` region over width until a second pass moves it. */
+            if (run.length % 2 === 0)
+                run.push('');
+            run.push(spaceDoc(piece));
+            continue;
+        }
+        glued.push(piece.doc);
+    }
+    flushRun();
+    return docs;
+}
+/** A space the printer may wrap at, or one it may not. */
+const spaceDoc = (piece) => (piece.hard ? ' ' : line);
+/** Every space in the run becomes one the printer may not wrap at. */
+const harden = (pieces) => pieces.map((piece) => (piece.kind === 'space' ? { kind: 'space', hard: true } : piece));
+/** Gaps outside a content run have nothing to wrap, so they print as themselves. */
+function gapDocs(gaps) {
+    return gaps.flatMap((gap) => {
+        if (gap.kind === 'break')
+            return hardlines(gap.count);
+        return gap.kind === 'space' ? [spaceDoc(gap)] : [];
+    });
+}
+/** The half-open span of `pieces` with the whitespace at either end excluded. */
+function contentSpan(pieces) {
+    let start = 0;
+    let end = pieces.length;
+    while (start < end && isGap(pieces[start]))
+        start += 1;
+    while (end > start && isGap(pieces[end - 1]))
+        end -= 1;
+    return [start, end];
+}
+function printExpression(expression, breakable) {
+    return expression.type === 'SubExpression' ? printCall(expression, '(', ')', breakable) : expression.source;
+}
+function printCallParts(call, breakable) {
+    const parts = call.params.map((param) => printExpression(param, breakable));
+    for (const pair of call.hash) {
+        parts.push([pair.key, '=', printExpression(pair.value, breakable)]);
+    }
+    if (call.blockParams && call.blockParams.length > 0) {
+        parts.push(['as |', call.blockParams.join(' '), '|']);
+    }
+    return parts;
+}
+/** Whitespace inside a mustache does not render, so it is the formatter's: all-or-nothing. */
+function printCall(call, open, close, breakable = true) {
+    const parts = printCallParts(call, breakable);
+    if (parts.length === 0) {
+        return [open, printExpression(call.path, breakable), close];
+    }
+    if (!breakable) {
+        return [open, printExpression(call.path, false), ' ', join(' ', parts), close];
+    }
+    /* One group, so a call that does not fit breaks every one of its parts. */
+    return group([open, indent([printExpression(call.path, true), line, join(line, parts)]), softline, close]);
+}
+/* The three inline statements are one call in different delimiters: a mustache in `{{}}` (or
+ * `{{{}}}` when unescaped), a partial in `{{> }}`, a decorator in `{{*}}`. */
+function printStatement(node, prefix) {
+    const triple = node.type === 'MustacheStatement' && node.triple;
+    return printCall(node, [triple ? '{{{' : '{{', trim(node.trimOpen), prefix], [trim(node.trimClose), triple ? '}}}' : '}}']);
+}
+function printComment(node) {
+    /* `block` already covers a multiline body - the parser sets it for either - so re-testing
+     * `multiline` here only invited the two to be kept in step by hand. */
+    const [open, close] = node.block
+        ? [`{{${trim(node.trimOpen)}!--`, `--${trim(node.trimClose)}}}`]
+        : [`{{${trim(node.trimOpen)}!`, `${trim(node.trimClose)}}}`];
+    const body = node.value;
+    /* express-hbs' layout directive is not prose: padding `{{!< layout}}` to `{{! < layout }}`
+     * stops it being recognised and the layout silently stops being applied. The parser decides,
+     * from the source - the body alone cannot tell the directive from a comment about one. */
+    if (node.layout) {
+        return [open, body, close];
+    }
+    /* A body the author started on its own line is re-indented under the comment, so it follows
+     * the surrounding structure instead of staying frozen at the column it was written at.
+     * Common indentation is stripped and re-applied, which keeps the body's *relative* shape. */
+    if (/^\n/u.test(body)) {
+        const lines = (0, template_format_core_1.stripCommonIndent)(body.replace(/^\n/u, '').replace(trailingWhitespace, '').split('\n'));
+        return lines.every((line) => line === '')
+            ? [open, hardline, close]
+            : [open, indent([hardline, join(hardline, lines)]), hardline, close];
+    }
+    /* Otherwise pad only where the body is not already spaced away from the delimiter: padding
+     * regardless puts trailing whitespace on the opening line, which re-parses differently on the
+     * next pass. Continuation lines keep their own indentation, having nothing to hang from. */
+    /* An empty block comment still gets its spacing: `{{!----}}` reads as a typo, and it is what
+     * the formatter would otherwise write over every `{{!-- --}}` in a file. A line comment has no
+     * such problem - `{{!}}` is already what an empty one looks like. */
+    if (body === '') {
+        return node.block ? [open, ' ', close] : [open, close];
+    }
+    /* ASCII whitespace, not `\s`: a non-breaking space is content the author put there. Trimming
+     * on `\s` deleted one off the end of a block comment's body, and reading one as the pad it
+     * already had left a line comment unpadded. */
+    const lead = whitespace.html.test(body[0] ?? '') ? '' : ' ';
+    const tail = whitespace.html.test(body[body.length - 1] ?? '') ? '' : ' ';
+    return [open, lead, join(literalline, body.split('\n')), tail, close];
+}
+/**
+ * The quote that needs no escaping; `singleQuote` decides only when either would do.
+ *
+ * Against the value's raw text, not just its TextNode parts: a quote inside a mustache is printed
+ * too, so `class='{{t "x"}}'` cannot be re-quoted with `"` without ending the attribute early.
+ */
+/* A quote ends the value holding it, so a nested element cannot reuse the outer one. */
+function chooseQuote(value, options) {
+    const preferred = options.singleQuote === true ? "'" : '"';
+    const candidates = [preferred, preferred === '"' ? "'" : '"'];
+    return candidates.find((q) => q !== options.enclosingQuote && !value.raw.includes(q)) ?? preferred;
+}
+function printAttribute(attribute, options) {
+    if (attribute.type === 'RawAttribute') {
+        return attribute.raw;
+    }
+    if (attribute.type === 'AttributeBlock') {
+        return printAny(attribute.block, options);
+    }
+    if (!attribute.value) {
+        return attribute.name;
+    }
+    /* An attribute value is content: every space in it renders, so it is reproduced exactly. Only
+     * the calls inside it may be reflowed, since whitespace within a mustache never reaches the
+     * rendered value. The parser marks the value's text as whitespace-significant, which is what
+     * keeps a block's body from being laid out at the printer's indent level instead of the
+     * author's - and what lets prettier see where the value's own lines end. */
+    const { parts } = attribute.value;
+    const quote = chooseQuote(attribute.value, options);
+    const nested = { ...options, enclosingQuote: quote };
+    return [attribute.name, '=', quote, ...parts.map((part) => printAny(part, nested)), quote];
+}
+/**
+ * One group for the whole tag, with no inner group around the attributes. Grouping them
+ * separately lets the attributes fit while the `>` alone drops to the next line, which reads as
+ * a stray bracket rather than a break.
+ */
+function printOpenTag(node, options) {
+    const marker = node.selfClosing && !template_format_core_1.voidElements.has(node.tag.toLowerCase()) ? ' />' : '>';
+    if (node.attributes.length === 0) {
+        return ['<', node.tag, marker];
+    }
+    /* A gap between attributes is normally the formatter's - it never reaches the page. But a
+     * mustache or block in attribute position emits content, so two the author glued together
+     * have to stay glued: `{{a}}{{b}}` is one attribute, `{{a}} {{b}}` is two. */
+    const attributes = node.attributes.flatMap((attribute, index) => {
+        const printed = printAttribute(attribute, options);
+        return index === 0 || attribute.glued ? [printed] : [line, printed];
+    });
+    /* Same rule against the tag name itself: a first attribute the author glued on stays glued,
+     * or `<h{{level}}>` prints as `<h {{level}}>` and stops being a heading. */
+    const head = node.attributes[0].glued ? attributes : [line, ...attributes];
+    return group(['<', node.tag, indent(head), ifBreak([softline, marker.trimStart()], marker)]);
+}
+/**
+ * The content between two markers - a tag's brackets, or a block's open and close - together
+ * with the marker that ends it.
+ *
+ * The trailing gap sits inside the indent, so the dedent lands the closer at the container's
+ * own level; dedenting outside overshoots, and the overshoot compounds with depth.
+ *
+ * With no trailing gap the closer is glued onto the last piece: `fill` measures its last item
+ * blind to what follows, so a `</p>` left outside would not count towards its line's width.
+ */
+function printBody(pieces, closer) {
+    if (pieces.length === 0) {
+        return [closer];
+    }
+    const [start, end] = contentSpan(pieces);
+    /* Nothing but whitespace inside: emit it once rather than as both edges. */
+    if (start >= end) {
+        return [...gapDocs(pieces.slice(0, 1)), closer];
+    }
+    const leading = gapDocs(pieces.slice(0, start));
+    const trailing = gapDocs(pieces.slice(end)).map(dedent);
+    const content = pieces.slice(start, end);
+    if (trailing.length === 0) {
+        return [indent([...leading, ...assemble(withCloser(content, closer))])];
+    }
+    return [indent([...leading, ...assemble(content), ...trailing]), closer];
+}
+/**
+ * The closer goes *inside* the last child when that child has a body to put it in. `fill`
+ * measures its last item against an empty rest-stack, so a marker appended after the child is
+ * invisible to the width check one level down as well as at this one: the line came out over
+ * width, and the next pass - now seeing a real break there - printed it differently.
+ */
+function withCloser(content, closer) {
+    const last = content[content.length - 1];
+    if (last?.kind === 'doc' && last.withTail) {
+        return [...content.slice(0, -1), { kind: 'doc', doc: last.withTail(closer) }];
+    }
+    return [...content, { kind: 'doc', doc: closer }];
+}
+/* Containers thread the marker into their body; everything else just carries it along. */
+function printWithTail(node, options, tail) {
+    if (node.type === 'ElementNode') {
+        return printElement(node, options, tail);
+    }
+    if (node.type === 'BlockStatement') {
+        return printBlock(node, options, tail);
+    }
+    return [printAny(node, options), tail];
+}
+function printElement(node, options, tail = []) {
+    const openTag = printOpenTag(node, options);
+    const closer = ['</', node.closeTag ?? node.tag, '>', tail];
+    const doc = node.selfClosing
+        ? [openTag, tail]
+        : group([openTag, ...printBody(childPieces(node.children, options), closer)]);
+    /* Inside an attribute value every character renders, so the tag may not be broken across
+     * lines - that would put the printer's newlines and indent inside a value the author owns,
+     * changing the page. Only calls may still be reflowed: `{{ }}` never reaches the page. */
+    return node.preserveWhitespace ? removeLines(doc) : doc;
+}
+function printBlock(node, options, tail = []) {
+    const prefix = tokens_1.handlebarsDialect.getPrintedBlockPrefix(node.blockPrefix ?? '#');
+    const elseKeyword = tokens_1.handlebarsDialect.getElseKeyword();
+    const sections = [
+        {
+            program: node.program,
+            open: (breakable) => printCall(node, ['{{', trim(node.trimOpen), prefix], [trim(node.trimClose), '}}'], breakable),
+        },
+        ...(node.inverseChain ?? []).map((branch) => ({
+            program: branch.program,
+            open: (breakable) => printCall(branch, ['{{', trim(branch.trimOpen), `${elseKeyword} `], [trim(branch.trimClose), '}}'], breakable),
+        })),
+    ];
+    /* An empty `{{else}}` prints nothing - unless it carries `~`, which strips whitespace that
+     * would otherwise render. */
+    if (node.inverse.body.length > 0 || node.inverseTrimOpen || node.inverseTrimClose) {
+        sections.push({
+            program: node.inverse,
+            open: () => ['{{', trim(node.inverseTrimOpen), elseKeyword, trim(node.inverseTrimClose), '}}'],
+        });
+    }
+    const close = [
+        '{{',
+        trim(node.closeTrimOpen),
+        tokens_1.handlebarsDialect.getBlockClosePrefix(node.path.source),
+        trim(node.closeTrimClose),
+        '}}',
+        tail,
+    ];
+    const pieces = sections.map((section) => childPieces(section.program.body, options));
+    /* A section the author kept on one line is an atom: wrapping its body would leave a marker
+     * alone on its line, where Handlebars strips the whitespace around it and the page changes.
+     * Per section, not per block - read whole-block, a newline in one branch unwrapped the rest.
+     * Markers stay a whole-block decision; splitting `{{else if` from its condition never helps. */
+    const sectionBreaks = pieces.map((body) => body.some((piece) => piece.kind === 'break'));
+    const breakable = sectionBreaks.some(Boolean);
+    const opens = sections.map((section) => section.open(breakable));
+    /* Each body carries the marker that closes it, so `fill` can see it when measuring. */
+    return group([
+        opens[0],
+        ...pieces.flatMap((body, index) => printBody(sectionBreaks[index] ? body : harden(body), opens[index + 1] ?? close)),
+    ]);
+}
+/* Handlebars strips the whitespace around a partial, comment or block left alone on its line -
+ * a mustache is not - so a space next to one has to stay a space: wrapping there would start or
+ * stop that stripping. `UnmatchedNode` is in the set because its verbatim text may begin or end
+ * with any of them. */
+const standaloneStatements = new Set([
+    'PartialStatement',
+    'CommentStatement',
+    'BlockStatement',
+    'DecoratorStatement',
+    'UnmatchedNode',
+]);
+/**
+ * Children need no separators: the whitespace between them is already in the tree, so the
+ * printer cannot add a gap the author did not write, nor drop one they did.
+ */
+function childPieces(nodes, options) {
+    const pieces = [];
+    const sensitive = [];
+    for (const child of nodes) {
+        if (child.type === 'TextNode') {
+            pieces.push(...textPieces(child));
+            continue;
+        }
+        if (child.type === 'UnmatchedNode') {
+            const verbatim = unmatchedPieces(child);
+            /* Both edges: the text is opaque, so either end may be a standalone statement. */
+            sensitive.push(pieces.length, pieces.length + verbatim.length - 1);
+            pieces.push(...verbatim);
+            continue;
+        }
+        if (standaloneStatements.has(child.type)) {
+            sensitive.push(pieces.length);
+        }
+        pieces.push(tailable((tail) => printWithTail(child, options, tail)));
+    }
+    for (const at of sensitive) {
+        for (const neighbour of [at - 1, at + 1]) {
+            if (pieces[neighbour]?.kind === 'space') {
+                pieces[neighbour] = { kind: 'space', hard: true };
+            }
+        }
+    }
+    return pieces;
+}
+/**
+ * A template's own leading and trailing whitespace is not content: the file ends in exactly one
+ * newline whatever the author left behind.
+ */
+function printRoot(nodes, options) {
+    const pieces = childPieces(nodes, options);
+    const [start, end] = contentSpan(pieces);
+    return start >= end ? '' : [...assemble(pieces.slice(start, end)), hardline];
+}
+/**
+ * The printer recurses over nodes directly rather than through prettier's AstPath. It makes no
+ * parent-dependent decisions - a node's shape is a function of the node alone - so the path
+ * buys nothing, and dropping it keeps every signature free of casts.
+ */
+function printAny(node, options) {
+    switch (node.type) {
+        case 'Program':
+            return assemble(childPieces(node.body, options));
+        case 'TextNode':
+            return assemble(textPieces(node));
+        case 'MustacheStatement':
+            return printStatement(node, '');
+        case 'PartialStatement':
+            return printStatement(node, '> ');
+        case 'DecoratorStatement':
+            return printStatement(node, '*');
+        case 'CommentStatement':
+            return printComment(node);
+        /* `childPieces` intercepts these, so this arm only keeps the switch exhaustive. It goes
+         * through `unmatchedPieces` all the same, rather than repeating it: a second copy drifts,
+         * and one missing the trailing-whitespace split grows the file by a newline every pass. */
+        case 'UnmatchedNode':
+            return assemble(unmatchedPieces(node));
+        case 'ElementNode':
+            return printElement(node, options);
+        case 'BlockStatement':
+            return printBlock(node, options);
+    }
+}
+/* Prettier walks the tree itself to track a cursor offset; the printer's own recursion does not
+ * use these. */
+const visitorKeys = {
+    Program: ['body'],
+    ElementNode: ['attributes', 'children'],
+    Attribute: ['value'],
+    AttributeValue: ['parts'],
+    AttributeBlock: ['block'],
+    BlockStatement: ['program', 'inverseChain', 'inverse'],
+    ElseBranch: ['program'],
+};
+exports.printer = {
+    /* Only the root reaches this: everything below recurses through printAny. */
+    print(path, options) {
+        const node = path.node;
+        return node.type === 'Program' && path.parent === null ? printRoot(node.body, options) : printAny(node, options);
+    },
+    getVisitorKeys(node, nonTraversableKeys) {
+        const type = typeof node === 'object' && node !== null && 'type' in node ? String(node.type) : '';
+        return (visitorKeys[type] ?? []).filter((key) => !nonTraversableKeys.has(key));
+    },
+};

package/dist/scan.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The first index at or after `from` where `stopsAt` holds, skipping quoted runs so a delimiter
+ * inside a string literal does not end the scan. Backslash escapes are honoured inside a quote
+ * and nowhere else. Returns -1 if the scan reaches the end without stopping.
+ *
+ * `opensQuote` is the one thing a caller must decide: inside a tag a quote only delimits a
+ * value after `=`, and treating every quote as one makes `title=a"b'c>` swallow the file.
+ */
+export declare function scanPastQuotes(text: string, from: number, { stopsAt, opensQuote }: {
+    stopsAt: (index: number) => boolean;
+    opensQuote: (index: number) => boolean;
+}): number;

package/dist/scan.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanPastQuotes = scanPastQuotes;
+/**
+ * The first index at or after `from` where `stopsAt` holds, skipping quoted runs so a delimiter
+ * inside a string literal does not end the scan. Backslash escapes are honoured inside a quote
+ * and nowhere else. Returns -1 if the scan reaches the end without stopping.
+ *
+ * `opensQuote` is the one thing a caller must decide: inside a tag a quote only delimits a
+ * value after `=`, and treating every quote as one makes `title=a"b'c>` swallow the file.
+ */
+function scanPastQuotes(text, from, { stopsAt, opensQuote }) {
+    let quote = null;
+    let escaped = false;
+    for (let index = from; index < text.length; index += 1) {
+        const char = text[index];
+        if (quote) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (char === quote) {
+                quote = null;
+            }
+            continue;
+        }
+        if ((char === '"' || char === "'" || char === '`') && opensQuote(index)) {
+            quote = char;
+            continue;
+        }
+        if (stopsAt(index)) {
+            return index;
+        }
+    }
+    return -1;
+}