@falsefalse/prettier-plugin-handlebars 0.0.2 → 0.0.3

package/LICENSE

@@ -1,6 +1,7 @@
 MIT License
 
-Copyright (c) 2026 Poliklot
+Copyright (c) 2026 Illia Furman
+Portions 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

package/README.md

@@ -2,9 +2,9 @@
 
 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.
+It is **opinionated**: it exposes no options of its own, only Prettier's core `printWidth`,
+`tabWidth` and `useTabs`. Everything else is a decision the formatter has already
+made.
 
 ## The rule everything follows
 
@@ -27,7 +27,7 @@ Two consequences worth stating plainly:
 ## Install
 
 ```bash
-npm install --save-dev prettier github:falsefalse/prettier-plugin-handlebars
+npm install --save-dev prettier @falsefalse/prettier-plugin-handlebars
 ```
 
 ```js
@@ -106,8 +106,21 @@ Or fence the region off entirely. Nothing inside is parsed, so nothing inside ca
 
 ## Options
 
-None. `printWidth`, `tabWidth`, `useTabs` and `singleQuote` are read from Prettier's core config;
-this plugin adds nothing.
+None. `printWidth`, `tabWidth` and `useTabs` are read from Prettier's core config; this plugin
+adds nothing. `singleQuote` is **ignored** - quoting is part of the opinion.
+
+Quotes are `"` around an HTML attribute value and `'` around a string literal in a mustache:
+
+```hbs
+<div class="card" title="{{t 'card.title'}}">{{t 'card.body' count=n}}</div>
+```
+
+The two are complementary, so a literal inside an attribute already wears the quote the attribute
+did not and neither has to give way. Both still yield to the quote they sit inside and to
+whichever one needs no escaping, so `{{t "it's"}}` keeps its double quote. A literal inside a
+block in attribute position, `<img {{#if m}}alt="{{t 'k'}}"{{/if}}>`, keeps the quote the author
+gave it: there the enclosing quote is only half of a text node, so no reader downstream can tell
+what it is.
 
 ## Development
 
@@ -133,15 +146,6 @@ correctness; they cannot see bad taste, which is the failure mode that actually
 [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)

package/dist/{errors.d.ts → core/errors.d.ts}

@@ -21,4 +21,11 @@ export declare class TemplateSyntaxError extends SyntaxError {
     /** Offsets are all the parser knows; line and column need the whole text. */
     locate(text: string): this;
 }
+/**
+ * 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.
+ */
+export declare function fail(message: string, start: number, end: number): never;
 export {};

package/dist/{errors.js → core/errors.js}

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateSyntaxError = void 0;
+exports.fail = fail;
 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 };
@@ -30,3 +31,12 @@ class TemplateSyntaxError extends SyntaxError {
     }
 }
 exports.TemplateSyntaxError = TemplateSyntaxError;
+/**
+ * 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 TemplateSyntaxError(message, start, end);
+}

package/dist/core/html.d.ts

@@ -0,0 +1,2 @@
+export declare function isVoidElement(tag: string): boolean;
+export declare function isRawTextElement(tag: string): boolean;

package/dist/core/html.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVoidElement = isVoidElement;
+exports.isRawTextElement = isRawTextElement;
+/** Elements with no closing tag. Writing one is an error, not a shorthand. */
+const voidElements = new Set([
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'keygen',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
+]);
+/** Elements whose content is text, not markup: a `<` inside one opens nothing. */
+const rawTextElements = new Set(['script', 'style', 'textarea', 'pre']);
+/* Both sets are keyed lowercase and a tag name is not: `<BR>` is a `br`. Asking through these
+ * rather than reaching for the set is what keeps the fold from being forgotten at a call site. */
+function isVoidElement(tag) {
+    return voidElements.has(tag.toLowerCase());
+}
+function isRawTextElement(tag) {
+    return rawTextElements.has(tag.toLowerCase());
+}

package/dist/core/source.d.ts

@@ -0,0 +1,11 @@
+/** Where a node came from. Optional: a node built rather than read has no source to point at. */
+export interface SourceRange {
+    range?: [number, number];
+}
+/** A BOM and a CRLF are not content. Every offset the parser records counts the result. */
+export declare function normalizeInput(text: string): string;
+export declare function locStart(node: SourceRange): number;
+export declare function locEnd(node: SourceRange): number;
+export declare function withRange<T extends object>(node: T, start: number, end: number): T;
+/** For a node whose span is only sometimes known - an attribute value outside a template. */
+export declare function withOptionalRange<T extends object>(node: T, start?: number, end?: number): T;

package/dist/core/source.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeInput = normalizeInput;
+exports.locStart = locStart;
+exports.locEnd = locEnd;
+exports.withRange = withRange;
+exports.withOptionalRange = withOptionalRange;
+/** A BOM and a CRLF are not content. Every offset the parser records counts the result. */
+function normalizeInput(text) {
+    return text.replace(/^\uFEFF/u, '').replace(/\r\n?/gu, '\n');
+}
+function locStart(node) {
+    return node.range?.[0] ?? 0;
+}
+function locEnd(node) {
+    return node.range?.[1] ?? 0;
+}
+/* Non-enumerable, so a range never reaches a snapshot, a `JSON.stringify` or a structural
+ * comparison between an expected node and a parsed one. */
+function withRange(node, start, end) {
+    Object.defineProperty(node, 'range', { value: [start, end], enumerable: false, configurable: true });
+    return node;
+}
+/** For a node whose span is only sometimes known - an attribute value outside a template. */
+function withOptionalRange(node, start, end) {
+    return typeof start === 'number' && typeof end === 'number' ? withRange(node, start, end) : node;
+}

package/dist/{whitespace.d.ts → core/whitespace.d.ts}

@@ -26,3 +26,8 @@ export declare const htmlRunGlobal: RegExp;
 export declare const handlebars: RegExp;
 /** `/\s+/u` - splitting a mustache's inner text into words. */
 export declare const handlebarsRun: RegExp;
+/**
+ * Every line shifted left by the smallest indent any non-blank line carries, trailing spaces
+ * and tabs dropped. Keeps a block's relative shape while letting the printer own its column.
+ */
+export declare function stripCommonIndent(lines: string[]): string[];

package/dist/{whitespace.js → core/whitespace.js}

@@ -8,6 +8,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handlebarsRun = exports.handlebars = exports.htmlRunGlobal = exports.htmlRun = exports.html = exports.htmlCharacters = void 0;
+exports.stripCommonIndent = stripCommonIndent;
 /**
  * HTML's set. Not `\s`, which also matches U+00A0 - a non-breaking space is content, so
  * `<div title=a b>` is one attribute holding one and `<div a b>` is one attribute named `a b`.
@@ -29,3 +30,20 @@ exports.htmlRunGlobal = new RegExp(`[${exports.htmlCharacters}]+`, 'gu');
 exports.handlebars = /\s/u;
 /** `/\s+/u` - splitting a mustache's inner text into words. */
 exports.handlebarsRun = /\s+/u;
+/** How many spaces or tabs a line opens with. Not `trimStart`, which also eats a U+00A0. */
+function indentOf(line) {
+    let at = 0;
+    while (line[at] === ' ' || line[at] === '\t')
+        at += 1;
+    return at;
+}
+/**
+ * Every line shifted left by the smallest indent any non-blank line carries, trailing spaces
+ * and tabs dropped. Keeps a block's relative shape while letting the printer own its column.
+ */
+function stripCommonIndent(lines) {
+    const common = lines
+        .filter((line) => line.trim() !== '')
+        .reduce((least, line) => Math.min(least, indentOf(line)), Infinity);
+    return lines.map((line) => line.trim() === '' ? '' : line.slice(Math.min(common, indentOf(line))).replace(/[ \t]+$/u, ''));
+}

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

@@ -1,5 +1,22 @@
-import type { TemplateBlockPrefix, TemplateToken } from 'template-format-core';
-export interface HandlebarsToken extends TemplateToken {
+type TokenKind = 'blockStart' | 'blockEnd' | 'partial' | 'comment' | 'mustache' | 'else';
+/** How a block opens, which is also how its closer and its `{{else}}` are spelled. */
+type BlockPrefix = '#' | '#>' | '#*' | '^' | '<' | '$';
+/** A form the printer reproduces but the parser treats as its plain counterpart. */
+type SpecialForm = 'blockPartial' | 'decoratorBlock' | 'decorator' | 'elseIf' | 'inverseBlock' | 'parent' | 'mustacheBlock';
+export interface HandlebarsToken {
+    kind: TokenKind;
+    /** The inner text, whitespace control and the leading sigil stripped. */
+    content: string;
+    /** The inner text exactly as written, delimiters aside. */
+    rawContent: string;
+    start: number;
+    end: number;
+    triple: boolean;
+    /** The path a block opens or closes on. Absent on everything that opens nothing. */
+    name?: string;
+    trimOpen: boolean;
+    trimClose: boolean;
+    specialForm?: SpecialForm;
     /**
      * 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
@@ -45,10 +62,10 @@ export declare function handlebarsRawBlockName(text: string, position: number, o
  */
 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 getHandlebarsBlockExpression(token: HandlebarsToken): string;
+declare function getHandlebarsBlockPrefix(token: HandlebarsToken): BlockPrefix;
+declare function getPrintedHandlebarsBlockPrefix(prefix: BlockPrefix): string;
 declare function getHandlebarsElseKeyword(): string;
 declare function getHandlebarsBlockClosePrefix(path: string): string;
-declare function shouldPreserveHandlebarsTokenVerbatim(token: TemplateToken): boolean;
+declare function shouldPreserveHandlebarsTokenVerbatim(token: HandlebarsToken): boolean;
 export {};

package/dist/dialects/handlebars/tokens.js

@@ -37,12 +37,11 @@ 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. */
+const scan_1 = require("../../core/scan");
+const whitespace = __importStar(require("../../core/whitespace"));
+/* Deliberately untyped. An interface here would fix a member for every piece of Handlebars
+ * syntax, each a second copy to keep in step with the printer by hand; the inferred shape is
+ * exactly what the parser and printer ask for. */
 exports.handlebarsDialect = {
     openDelimiter: '{{',
     parseToken: parseHandlebarsToken,
@@ -108,7 +107,6 @@ function parseHandlebarsToken(text, position) {
     const inner = rawInner.replace(/^~/, '').replace(/~$/, '').trim();
     const baseToken = {
         rawContent,
-        rawInner,
         start: position,
         end,
         triple,
@@ -186,10 +184,19 @@ function findHandlebarsBlockCommentClose(text, position, close) {
     }
     return plain < 0 ? null : { index: plain, end: plain + close.length + 2, trimClose: false };
 }
+/* A quote opens a string only where a value can start. Mid-token - `it's` in `{{t it's}}` -
+ * it is an apostrophe, and treating it as an opening quote runs the scan past the real `}}`. */
+function opensQuote(text, index, expressionStart) {
+    if (index <= expressionStart) {
+        return true;
+    }
+    const previous = text[index - 1];
+    return !previous || whitespace.handlebars.test(previous) || /[([{=,:~|]/u.test(previous);
+}
 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),
+        opensQuote: (index) => opensQuote(text, index, position),
     });
 }
 function isEscapedHandlebarsOpen(text, position) {

package/dist/expression.js

@@ -34,9 +34,9 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCall = parseCall;
-const template_format_core_1 = require("template-format-core");
-const errors_1 = require("./errors");
-const whitespace = __importStar(require("./whitespace"));
+const source_1 = require("./core/source");
+const errors_1 = require("./core/errors");
+const whitespace = __importStar(require("./core/whitespace"));
 const quoteCharacters = new Set(['"', "'", '`']);
 const numberPattern = /^-?(?:\d+\.?\d*|\.\d+)$/u;
 function literalTypeOf(source) {
@@ -120,7 +120,7 @@ class CallReader {
     /** A leaf is its own source text and the span it came from; only the label differs. */
     leaf(type, start) {
         const node = { type, source: this.source.slice(start, this.index) };
-        return (0, template_format_core_1.withRange)(node, ...this.span(start, this.index));
+        return (0, source_1.withRange)(node, ...this.span(start, this.index));
     }
     readSubExpression() {
         const start = this.index;
@@ -140,7 +140,7 @@ class CallReader {
             params: inner.params,
             hash: inner.hash,
         };
-        return (0, template_format_core_1.withRange)(node, ...this.span(start, this.index));
+        return (0, source_1.withRange)(node, ...this.span(start, this.index));
     }
     readValue() {
         if (this.peek() === '(') {
@@ -165,7 +165,7 @@ class CallReader {
             return value;
         }
         const node = { type: 'PathExpression', source: value.source };
-        return value.range ? (0, template_format_core_1.withRange)(node, ...value.range) : node;
+        return value.range ? (0, source_1.withRange)(node, ...value.range) : node;
     }
     readCall(nested = false) {
         this.skipWhitespace();
@@ -193,7 +193,7 @@ class CallReader {
                 this.index += 1;
                 this.skipWhitespace();
                 const pairValue = this.readValue();
-                hash.push((0, template_format_core_1.withRange)({ key: value.source, value: pairValue }, ...this.span(start, this.index)));
+                hash.push((0, source_1.withRange)({ key: value.source, value: pairValue }, ...this.span(start, this.index)));
                 continue;
             }
             this.index = afterValue;
@@ -208,7 +208,7 @@ class CallReader {
     }
     emptyPath() {
         const node = { type: 'PathExpression', source: '' };
-        return (0, template_format_core_1.withRange)(node, ...this.span(this.index, this.index));
+        return (0, source_1.withRange)(node, ...this.span(this.index, this.index));
     }
 }
 /**

package/dist/parse/lex.d.ts

@@ -0,0 +1,86 @@
+import type { ElementAttribute } from '../types';
+export declare const openDelimiter: string, isEscapedOpen: (text: string, position: number) => boolean, parseMustacheToken: (text: string, position: number) => import("../dialects/handlebars/tokens").HandlebarsToken;
+export declare const leadingWhitespace: RegExp;
+/** What an attribute name is made of: anything but whitespace and the characters that end one. */
+export declare const attributeNameCharacter: RegExp;
+/** What ends a tag name. HTML's tag-name state leaves on whitespace, `/` or `>`, and nothing else. */
+export declare const tagNameTerminator: RegExp;
+export declare function startsTemplateTag(text: string, position: number): boolean;
+/**
+ * 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.
+ */
+export declare function skipTemplateTag(text: string, position: number): number;
+export declare function scanTag(text: string, position: number): {
+    kind: 'open' | 'selfClosing' | 'close';
+    tag: string;
+    end: number;
+    terminated: boolean;
+};
+export type ParsedTag = {
+    kind: 'open';
+    tag: string;
+    attributes: ElementAttribute[];
+    attributesRange: [number, number];
+    end: number;
+    terminated: boolean;
+} | {
+    kind: 'selfClosing';
+    tag: string;
+    attributes: ElementAttribute[];
+    attributesRange: [number, number];
+    end: number;
+    terminated: boolean;
+} | {
+    kind: 'close';
+    tag: string;
+    source: string;
+    end: number;
+    terminated: boolean;
+};
+export declare function sameTag(one: string, other: string): boolean;
+/**
+ * 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.
+ */
+export declare function startsCloseTag(text: string, position: number, tag: string): boolean;
+export declare function readCloseTagSource(text: string, position: number, closeIdx: number): string;
+export declare function trimTrailingWhitespace(text: string, from: number): number;
+export declare function isTagStart(text: string, position: number): boolean;
+/**
+ * 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.
+ */
+export declare function readAttributeValue(text: string, position: number): {
+    raw: string;
+    start: number;
+    end: number;
+};
+export declare function skipWhitespace(text: string, position: number): number;
+/**
+ * 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.
+ */
+export declare function readAttributeName(text: string, position: number): {
+    value: string;
+    next: number;
+};
+export declare function readName(text: string, position: number): {
+    value: string;
+    next: number;
+};
+export declare function consumeTagLikeChunk(text: string, position: number): number;