@falsefalse/prettier-plugin-handlebars 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Poliklot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,149 @@
+# @falsefalse/prettier-plugin-handlebars
+
+A Prettier plugin for classic Handlebars templates with mixed HTML markup.
+
+This started as a fork of another plugin — see [Prior work](#prior-work). It is **opinionated**:
+it exposes no options of its own, only Prettier's core `printWidth`, `tabWidth`, `useTabs` and
+`singleQuote`. Everything else is a decision the formatter has already made.
+
+## The rule everything follows
+
+> Whitespace that renders belongs to the author. Whitespace that does not belongs to the
+> formatter.
+
+Between two siblings, whitespace reaches the page, so it is reproduced exactly — a space stays a
+space, a newline stays a newline, a run of blank lines collapses to one. The formatter never
+invents a gap the author did not write, and never drops one they did.
+
+Inside a tag or a mustache, whitespace never reaches the page, so it is the formatter's: it is
+normalised, and driven by width, all-or-nothing.
+
+Two consequences worth stating plainly:
+
+- **A one-liner stays a one-liner.** `{{#if a}}x{{else}}y{{/if}}` is one line because the author
+  wrote it as one line, not because it happens to fit.
+- **Anything the author broke stays broken.** Reflowing it would move rendered whitespace.
+
+## Install
+
+```bash
+npm install --save-dev prettier github:falsefalse/prettier-plugin-handlebars
+```
+
+```js
+/** @type {import("prettier").Config} */
+module.exports = {
+  plugins: ['@falsefalse/prettier-plugin-handlebars'],
+  overrides: [{ files: ['*.hbs', '*.handlebars'], options: { parser: 'handlebars' } }],
+};
+```
+
+The `overrides` entry is what makes Prettier pick this parser; without it `.hbs` files are either
+skipped or handed to the HTML parser. See [docs/EDITOR_SETUP.md](./docs/EDITOR_SETUP.md).
+
+## What it formats
+
+- HTML elements, void elements, custom elements, comments, `pre` / `textarea` / `script` / `style`
+- `{{mustache}}`, `{{{triple}}}`, `{{! comments }}`, `{{!-- block comments --}}`
+- block helpers, `{{else}}`, `{{else if …}}`, inverted `{{^…}}`
+- partials `{{> name}}`, dynamic partials `{{> (lookup . "n")}}`, block partials `{{#> layout}}`
+- inline partials `{{#*inline "name"}}`, decorators `{{*log}}`
+- Mustache inheritance — `{{< layout}}`, `{{$block}}`
+- raw blocks `{{{{raw}}}}…{{{{/raw}}}}`
+- whitespace control markers, `{{~v~}}`, `{{~#if a~}}`
+- Handlebars inside attribute values, and blocks in attribute position
+- hash params written `k=v`, `k= v` or `k = v`, printed consistently
+- subexpressions to any depth, broken by width all the way down
+- `prettier-ignore`, `prettier-ignore-start` / `-end`
+
+## Unclosed input is rejected
+
+Everything that opens must close. There is no recovery: a formatter that guesses at a missing
+`}}` prints markup the author did not write, and one that passes a mismatched tag through leaves
+the rest of the file unformatted with nothing to show for it.
+
+```
+$ prettier --write page.hbs
+[error] page.hbs: SyntaxError: unclosed tag: expected </span> (3:3)
+[error]   1 | <div>
+[error]   2 |   <p>x</p>
+[error] > 3 |   <span>y
+[error]     |   ^^^^^^
+[error]   4 | </div>
+```
+
+The error carries a source range, so editors can put the cursor on it.
+
+This includes the HTML spec's optional end tags: `<ul><li>a<li>b</ul>` is rejected. One rule with
+no list of exceptions beats a list of exceptions that has to be kept in step with the spec.
+
+What is checked is structure: delimiters balance, tags nest, a block matches its own closer —
+not Handlebars' expression grammar. `{{}}`, `{{{x}}}}` and `{{foo xa"y}}` are all
+delimiter-balanced, so they pass through unchanged for Handlebars itself to reject at compile
+time. The formatter does not make them worse, and it is not a second implementation of the
+language.
+
+### When the markup only balances at render time
+
+Two escape hatches, in order of preference.
+
+Hide the markup behind a call, so the parser sees balanced source and the browser still gets what
+you meant:
+
+```hbs
+{{#if twoColumns}}{{{concat '<div class="row">'}}}{{/if}}
+  …
+{{#if twoColumns}}{{{concat '</div>'}}}{{/if}}
+```
+
+Or fence the region off entirely. Nothing inside is parsed, so nothing inside can be rejected:
+
+```hbs
+{{! prettier-ignore-start }}
+<div>deliberately unbalanced
+{{! prettier-ignore-end }}
+```
+
+## Options
+
+None. `printWidth`, `tabWidth`, `useTabs` and `singleQuote` are read from Prettier's core config;
+this plugin adds nothing.
+
+## Development
+
+```bash
+npm ci
+npm run check   # build + tests + both fuzz gates
+```
+
+`npm run check` runs the test suite plus two fuzz gates, each two-sided: every generated case
+must format idempotently, without losing source, and **without changing what the template
+renders** — compiled with the real Handlebars runtime, not approximated. Every malformed case
+must be refused with a location.
+
+`scripts/run-property-gate.mjs` checks the same properties over a real corpus:
+
+```bash
+npm run corpus:gate -- --git ../your-repo --width 95 path/to/templates
+```
+
+The last gate is a person reading the diff the formatter would produce. The property gates prove
+correctness; they cannot see bad taste, which is the failure mode that actually matters here.
+
+[docs/REWRITE-PLAN.md](./docs/REWRITE-PLAN.md) is the design record — why the printer looks like
+this, and what the previous one got wrong.
+
+## Prior work
+
+This plugin began as a fork of
+[Poliklot/prettier-plugin-handlebars](https://github.com/Poliklot/prettier-plugin-handlebars),
+published as `@poliklot/prettier-plugin-handlebars` and MIT-licensed, © Poliklot. The parser and
+printer have since been rewritten — [docs/REWRITE-PLAN.md](./docs/REWRITE-PLAN.md) is that record
+— and the package now ships under its own name, but the shape of the project, a Handlebars-aware
+`.hbs` formatter with no options of its own, starts there.
+
+## Docs
+
+- [Editor setup](./docs/EDITOR_SETUP.md)
+- [Troubleshooting](./docs/TROUBLESHOOTING.md)
+- [Printer rewrite plan](./docs/REWRITE-PLAN.md) — the design record

package/dist/dialects/handlebars/tokens.d.ts

@@ -0,0 +1,54 @@
+import type { TemplateBlockPrefix, TemplateToken } from 'template-format-core';
+export interface HandlebarsToken extends TemplateToken {
+    /**
+     * Whether the tokenizer found a closing delimiter, rather than running to the end of the
+     * input. Recorded by the one place that knows: re-deriving it by string-matching the token's
+     * tail reports true for any unterminated token running to a text end that already ends in
+     * `}}`, letting `{{foo "bar}}` past the malformed guard to print as `{{foo "bar}}}}`.
+     */
+    terminated: boolean;
+}
+export declare const handlebarsDialect: {
+    openDelimiter: string;
+    parseToken: typeof parseHandlebarsToken;
+    findNextOpen: typeof findNextHandlebarsOpen;
+    isEscapedOpen: typeof isEscapedHandlebarsOpen;
+    isDynamicElementStart: typeof isDynamicHandlebarsElementStart;
+    consumeRawBlock: typeof consumeHandlebarsRawBlock;
+    getBlockExpression: typeof getHandlebarsBlockExpression;
+    getBlockPrefix: typeof getHandlebarsBlockPrefix;
+    getPrintedBlockPrefix: typeof getPrintedHandlebarsBlockPrefix;
+    getElseKeyword: typeof getHandlebarsElseKeyword;
+    getBlockClosePrefix: typeof getHandlebarsBlockClosePrefix;
+    shouldPreserveTokenVerbatim: typeof shouldPreserveHandlebarsTokenVerbatim;
+};
+declare function parseHandlebarsToken(text: string, position: number): HandlebarsToken;
+/**
+ * Whether a comment at `position` is written in block form. `{{~!-- x --~}}` is one as much as
+ * `{{!-- x --}}`, so the `~` is skipped: anchoring on a literal `{{!--` reads the
+ * whitespace-control form as a line comment and demotes it to `{{! !-- x -- }}`.
+ */
+export declare function isHandlebarsBlockComment(text: string, position: number): boolean;
+declare function isEscapedHandlebarsOpen(text: string, position: number): boolean;
+declare function findNextHandlebarsOpen(text: string, position: number): number;
+declare function isDynamicHandlebarsElementStart(text: string, position: number): boolean;
+/**
+ * The name a raw block opens with, or `''` if `position` is not one. Tildes are tolerated on the
+ * open because the lexer takes them there; the closer below is stricter for the same reason.
+ */
+export declare function handlebarsRawBlockName(text: string, position: number, openEnd: number): string;
+/**
+ * The only closer Handlebars accepts: no whitespace inside it and no tilde on either side -
+ * `{{{{~/raw}}}}` and `{{{{ / raw }}}}` are both lexical errors. One literal, so there is nothing
+ * to escape and nothing to drift - the two hand-written patterns this replaces disagreed about
+ * exactly that whitespace.
+ */
+export declare function handlebarsRawBlockCloser(name: string): string;
+declare function consumeHandlebarsRawBlock(text: string, position: number): number | null;
+declare function getHandlebarsBlockExpression(token: TemplateToken): string;
+declare function getHandlebarsBlockPrefix(token: TemplateToken): TemplateBlockPrefix;
+declare function getPrintedHandlebarsBlockPrefix(prefix: TemplateBlockPrefix): string;
+declare function getHandlebarsElseKeyword(): string;
+declare function getHandlebarsBlockClosePrefix(path: string): string;
+declare function shouldPreserveHandlebarsTokenVerbatim(token: TemplateToken): boolean;
+export {};

package/dist/dialects/handlebars/tokens.js

@@ -0,0 +1,296 @@
+"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.handlebarsDialect = void 0;
+exports.isHandlebarsBlockComment = isHandlebarsBlockComment;
+exports.handlebarsRawBlockName = handlebarsRawBlockName;
+exports.handlebarsRawBlockCloser = handlebarsRawBlockCloser;
+const template_format_core_1 = require("template-format-core");
+const scan_1 = require("../../scan");
+const whitespace = __importStar(require("../../whitespace"));
+/* Deliberately not typed `: TemplateDialect`. That interface demands nine more members than the
+ * parser and printer ever ask for, each a second copy of Handlebars syntax to keep in step by
+ * hand - `getLineCommentTag` and `printComment` disagree about the same thing. */
+exports.handlebarsDialect = {
+    openDelimiter: '{{',
+    parseToken: parseHandlebarsToken,
+    findNextOpen: findNextHandlebarsOpen,
+    isEscapedOpen: isEscapedHandlebarsOpen,
+    isDynamicElementStart: isDynamicHandlebarsElementStart,
+    consumeRawBlock: consumeHandlebarsRawBlock,
+    getBlockExpression: getHandlebarsBlockExpression,
+    getBlockPrefix: getHandlebarsBlockPrefix,
+    getPrintedBlockPrefix: getPrintedHandlebarsBlockPrefix,
+    getElseKeyword: getHandlebarsElseKeyword,
+    getBlockClosePrefix: getHandlebarsBlockClosePrefix,
+    shouldPreserveTokenVerbatim: shouldPreserveHandlebarsTokenVerbatim,
+};
+/**
+ * The path a block opens on, which is where its name ends. A plain whitespace split cut
+ * `{{#[my block]}}` down to `[my`, and that never matched the `[my block]` the block's own
+ * `{{/[my block]}}` reports - a Handlebars path segment may hold spaces inside `[...]`.
+ */
+function readPathName(inner) {
+    const text = inner.trim();
+    let brackets = false;
+    for (let pos = 0; pos < text.length; pos += 1) {
+        const char = text[pos];
+        if (char === '[') {
+            brackets = true;
+        }
+        else if (char === ']') {
+            brackets = false;
+        }
+        else if (!brackets && whitespace.handlebars.test(char)) {
+            return text.slice(0, pos);
+        }
+    }
+    return text;
+}
+function parseHandlebarsToken(text, position) {
+    const triple = text.startsWith('{{{', position);
+    const openLength = triple ? 3 : 2;
+    const close = triple ? '}}}' : '}}';
+    const isBlockComment = isHandlebarsBlockComment(text, position);
+    const blockClose = isBlockComment ? findHandlebarsBlockCommentClose(text, position + openLength, close) : null;
+    /* A comment body is text, not an expression: Handlebars ends a line comment at the first close
+     * delimiter, full stop. The quote-aware scanner lets an unbalanced quote run the token past
+     * its real `}}`, so `{{! "q }}\n{{#if a}}y{{/if}}` swallows the block and renders nothing -
+     * stable across passes, and invisible to every gate. */
+    const isLineComment = !isBlockComment && /^~?!/u.test(text.slice(position + openLength, position + openLength + 2));
+    const closeIdx = isBlockComment
+        ? blockClose?.index ?? -1
+        : isLineComment
+            ? text.indexOf(close, position + openLength)
+            : findHandlebarsClose(text, position + openLength, close);
+    const end = isBlockComment
+        ? blockClose?.end ?? text.length
+        : closeIdx >= 0
+            ? closeIdx + close.length
+            : text.length;
+    const rawContent = text.slice(position + openLength, closeIdx >= 0 ? closeIdx : undefined);
+    const rawInner = rawContent.trim();
+    const trimOpen = rawInner.startsWith('~');
+    /* A block comment's closing `~` sits after the `--`, so it is outside `rawContent`. */
+    const trimClose = blockClose ? blockClose.trimClose : rawInner.endsWith('~');
+    const inner = rawInner.replace(/^~/, '').replace(/~$/, '').trim();
+    const baseToken = {
+        rawContent,
+        rawInner,
+        start: position,
+        end,
+        triple,
+        trimOpen,
+        trimClose,
+        terminated: isBlockComment ? blockClose !== null : closeIdx >= 0,
+    };
+    if (inner.startsWith('!')) {
+        return { kind: 'comment', content: inner, name: undefined, ...baseToken };
+    }
+    if (inner.startsWith('>')) {
+        return { kind: 'partial', content: inner.slice(1).trim(), name: undefined, ...baseToken };
+    }
+    if (inner.startsWith('<')) {
+        const name = readPathName(inner.slice(1));
+        return { kind: 'blockStart', content: inner, name, specialForm: 'parent', ...baseToken };
+    }
+    if (inner.startsWith('#>')) {
+        const name = readPathName(inner.slice(2));
+        return { kind: 'blockStart', content: inner, name, specialForm: 'blockPartial', ...baseToken };
+    }
+    if (inner.startsWith('#*')) {
+        const name = readPathName(inner.slice(2));
+        return { kind: 'blockStart', content: inner, name, specialForm: 'decoratorBlock', ...baseToken };
+    }
+    if (inner.startsWith('*')) {
+        return { kind: 'mustache', content: inner, name: undefined, specialForm: 'decorator', ...baseToken };
+    }
+    if (inner.startsWith('#')) {
+        const name = readPathName(inner.slice(1));
+        return { kind: 'blockStart', content: inner, name, ...baseToken };
+    }
+    if (inner.startsWith('^')) {
+        const name = readPathName(inner.slice(1));
+        /* Bare `{{^}}` is the shorthand for `{{else}}`; only `{{^name}}` opens an inverted block. */
+        if (!name) {
+            return { kind: 'else', content: inner, name: 'else', ...baseToken };
+        }
+        return { kind: 'blockStart', content: inner, name, specialForm: 'inverseBlock', ...baseToken };
+    }
+    if (inner.startsWith('$')) {
+        const name = readPathName(inner.slice(1));
+        return { kind: 'blockStart', content: inner, name, specialForm: 'mustacheBlock', ...baseToken };
+    }
+    if (inner.startsWith('/')) {
+        const name = inner.slice(1).trim();
+        return { kind: 'blockEnd', content: inner, name, ...baseToken };
+    }
+    if (inner === 'else' || inner.startsWith('else ')) {
+        return {
+            kind: 'else',
+            content: inner,
+            name: 'else',
+            specialForm: inner === 'else' ? undefined : 'elseIf',
+            ...baseToken,
+        };
+    }
+    return { kind: 'mustache', content: inner, name: undefined, ...baseToken };
+}
+/**
+ * Whether a comment at `position` is written in block form. `{{~!-- x --~}}` is one as much as
+ * `{{!-- x --}}`, so the `~` is skipped: anchoring on a literal `{{!--` reads the
+ * whitespace-control form as a line comment and demotes it to `{{! !-- x -- }}`.
+ */
+function isHandlebarsBlockComment(text, position) {
+    const openLength = text.startsWith('{{{', position) ? 3 : 2;
+    return /^~?!--/u.test(text.slice(position + openLength, position + openLength + 4));
+}
+/** The first `--}}` or `--~}}`, whichever comes first. */
+function findHandlebarsBlockCommentClose(text, position, close) {
+    const plain = text.indexOf(`--${close}`, position);
+    const trimmed = text.indexOf(`--~${close}`, position);
+    if (trimmed >= 0 && (plain < 0 || trimmed < plain)) {
+        return { index: trimmed, end: trimmed + close.length + 3, trimClose: true };
+    }
+    return plain < 0 ? null : { index: plain, end: plain + close.length + 2, trimClose: false };
+}
+function findHandlebarsClose(text, position, closeDelimiter) {
+    return (0, scan_1.scanPastQuotes)(text, position, {
+        stopsAt: (index) => text.startsWith(closeDelimiter, index),
+        opensQuote: (index) => (0, template_format_core_1.isTemplateExpressionQuoteStart)(text, index, position),
+    });
+}
+function isEscapedHandlebarsOpen(text, position) {
+    if (!text.startsWith('{{', position)) {
+        return false;
+    }
+    let slashCount = 0;
+    for (let index = position - 1; index >= 0 && text[index] === '\\'; index -= 1) {
+        slashCount += 1;
+    }
+    return slashCount % 2 === 1;
+}
+function findNextHandlebarsOpen(text, position) {
+    let searchPos = position;
+    while (searchPos < text.length) {
+        const candidate = text.indexOf('{{', searchPos);
+        if (candidate === -1) {
+            return -1;
+        }
+        if (!isEscapedHandlebarsOpen(text, candidate)) {
+            return candidate;
+        }
+        searchPos = candidate + 2;
+    }
+    return -1;
+}
+function isDynamicHandlebarsElementStart(text, position) {
+    return text.startsWith('<{{', position) || text.startsWith('</{{', position);
+}
+/**
+ * The name a raw block opens with, or `''` if `position` is not one. Tildes are tolerated on the
+ * open because the lexer takes them there; the closer below is stricter for the same reason.
+ */
+function handlebarsRawBlockName(text, position, openEnd) {
+    const inner = text.slice(position + 4, openEnd).trim().replace(/^~/u, '').replace(/~$/u, '').trim();
+    return inner.startsWith('/') ? '' : (inner.split(whitespace.handlebarsRun)[0] ?? '');
+}
+/**
+ * The only closer Handlebars accepts: no whitespace inside it and no tilde on either side -
+ * `{{{{~/raw}}}}` and `{{{{ / raw }}}}` are both lexical errors. One literal, so there is nothing
+ * to escape and nothing to drift - the two hand-written patterns this replaces disagreed about
+ * exactly that whitespace.
+ */
+function handlebarsRawBlockCloser(name) {
+    return `{{{{/${name}}}}}`;
+}
+function consumeHandlebarsRawBlock(text, position) {
+    if (!text.startsWith('{{{{', position)) {
+        return null;
+    }
+    const openIdx = text.indexOf('}}}}', position + 4);
+    if (openIdx === -1) {
+        return text.length;
+    }
+    const name = handlebarsRawBlockName(text, position, openIdx);
+    if (!name) {
+        return null;
+    }
+    const closer = handlebarsRawBlockCloser(name);
+    const closeIdx = text.indexOf(closer, openIdx + 4);
+    if (closeIdx === -1) {
+        return text.length;
+    }
+    return closeIdx + closer.length;
+}
+function getHandlebarsBlockExpression(token) {
+    if (token.specialForm === 'blockPartial' || token.specialForm === 'decoratorBlock') {
+        return token.content.slice(2).trim();
+    }
+    return token.content.slice(1).trim();
+}
+function getHandlebarsBlockPrefix(token) {
+    if (token.specialForm === 'blockPartial') {
+        return '#>';
+    }
+    if (token.specialForm === 'decoratorBlock') {
+        return '#*';
+    }
+    if (token.specialForm === 'inverseBlock') {
+        return '^';
+    }
+    if (token.specialForm === 'parent') {
+        return '<';
+    }
+    if (token.specialForm === 'mustacheBlock') {
+        return '$';
+    }
+    return '#';
+}
+function getPrintedHandlebarsBlockPrefix(prefix) {
+    if (prefix === '#>' || prefix === '<') {
+        return `${prefix} `;
+    }
+    return prefix;
+}
+function getHandlebarsElseKeyword() {
+    return 'else';
+}
+function getHandlebarsBlockClosePrefix(path) {
+    return `/${path}`;
+}
+function shouldPreserveHandlebarsTokenVerbatim(token) {
+    return token.specialForm === 'elseIf';
+}

package/dist/errors.d.ts

@@ -0,0 +1,24 @@
+interface Position {
+    line: number;
+    column: number;
+}
+/**
+ * A construct the template opened and never closed, or closed with the wrong thing.
+ *
+ * The formatter refuses rather than guessing: guessing at a missing `}}` means printing markup
+ * the author did not write, and quietly passing a mismatched tag through means the rest of the
+ * file goes unformatted with nothing to show for it.
+ */
+export declare class TemplateSyntaxError extends SyntaxError {
+    readonly start: number;
+    readonly end: number;
+    /** Prettier renders a code frame from this, and editors put the cursor on it. */
+    loc?: {
+        start: Position;
+        end: Position;
+    };
+    constructor(message: string, start: number, end: number);
+    /** Offsets are all the parser knows; line and column need the whole text. */
+    locate(text: string): this;
+}
+export {};

package/dist/errors.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateSyntaxError = void 0;
+function positionAt(text, offset) {
+    const upTo = text.slice(0, Math.max(0, Math.min(offset, text.length)));
+    return { line: upTo.split('\n').length, column: upTo.length - (upTo.lastIndexOf('\n') + 1) + 1 };
+}
+/**
+ * A construct the template opened and never closed, or closed with the wrong thing.
+ *
+ * The formatter refuses rather than guessing: guessing at a missing `}}` means printing markup
+ * the author did not write, and quietly passing a mismatched tag through means the rest of the
+ * file goes unformatted with nothing to show for it.
+ */
+class TemplateSyntaxError extends SyntaxError {
+    constructor(message, start, end) {
+        super(message);
+        this.start = start;
+        this.end = end;
+        /* Editor integrations grep stderr for `: SyntaxError: <message> (line:col)` to place the
+         * cursor -- JsPrettier for Sublime Text does, and a subclass name misses that pattern. */
+        this.name = 'SyntaxError';
+    }
+    /** Offsets are all the parser knows; line and column need the whole text. */
+    locate(text) {
+        const start = positionAt(text, this.start);
+        this.loc = { start, end: positionAt(text, this.end) };
+        this.message = `${this.message} (${start.line}:${start.column})`;
+        return this;
+    }
+}
+exports.TemplateSyntaxError = TemplateSyntaxError;

package/dist/expression.d.ts

@@ -0,0 +1,8 @@
+import type { Call } from './types';
+/**
+ * Parses one call's source into structured parts whose ranges are absolute in the template.
+ *
+ * `offset` is where `source` begins in the template, so a subexpression buried in a hash value
+ * can still be located exactly.
+ */
+export declare function parseCall(source: string, offset?: number): Call;