prettier-plugin-sfmc 0.6.0 → 1.0.0

package/README.md

@@ -1,6 +1,6 @@
 # prettier-plugin-sfmc
 
-Unified Prettier plugin for **Salesforce Marketing Cloud** — formats **AMPscript** (`.ampscript`, `.amp`, `.html`), registers **SSJS** (`.ssjs`) with Prettier’s JavaScript formatter, and formats **SQL** (`.sql`) via embedded [prettier-plugin-sql](https://www.npmjs.com/package/prettier-plugin-sql).
+Unified Prettier plugin for **Salesforce Marketing Cloud** — formats **AMPscript** (`.ampscript`, `.amp`, `.html`), normalizes **Marketing Cloud Next Handlebars** (`.hbs` and `{{…}}` inside `.html`), registers **SSJS** (`.ssjs`) with Prettier’s JavaScript formatter, and formats **SQL** (`.sql`) via embedded [prettier-plugin-sql](https://www.npmjs.com/package/prettier-plugin-sql).
 
 ## Installation
 
@@ -26,11 +26,11 @@ To use explicitly in `.prettierrc`:
 
 ## Options
 
-All options use the `ampscript` prefix — they control AMPscript formatting behavior.
+AMPscript options use the `ampscript` prefix; Handlebars options use the `handlebars` prefix.
 
 | Option                                                                                        | Type                                                                         | Default         | Description                                    |
 | --------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | --------------- | ---------------------------------------------- |
-| [`ampscriptSpacing`](docs/options/ampscript-spacing.md)                                       | boolean                                                                      | `true`          | Spacing in inline expressions: `%%= V(@x) =%%` |
+| [`ampscriptSpacing`](docs/options/ampscript-spacing.md)                                       | boolean                                                                      | `true`          | Spacing in inline expressions: `%%= v(@x) =%%` |
 | [`ampscriptEnforceVariableCasing`](docs/options/ampscript-enforce-variable-casing.md)         | boolean                                                                      | `true`          | Normalize variable casing to first occurrence  |
 | [`ampscriptRemoveUnnecessaryBrackets`](docs/options/ampscript-remove-unnecessary-brackets.md) | boolean                                                                      | `true`          | Remove needless parentheses                    |
 | [`ampscriptQuoteStyle`](docs/options/ampscript-quote-style.md)                                | `"single"` \| `"double"`                                                     | `"single"`      | String quote style                             |
@@ -38,6 +38,8 @@ All options use the `ampscript` prefix — they control AMPscript formatting beh
 | [`ampscriptFunctionCase`](docs/options/ampscript-function-case.md)                            | `"upper-camel"` \| `"lower-camel"` \| `"upper"` \| `"lower"` \| `"preserve"` | `"upper-camel"` | Function name casing                           |
 | [`ampscriptBlockLineBreaks`](docs/options/ampscript-block-line-breaks.md)                     | boolean                                                                      | `false`         | Optional line breaks around `%%[ ]%%` when not already at a line boundary |
 | [`ampscriptVarDeclarationStyle`](docs/options/ampscript-var-declaration-style.md)             | `"auto"` \| `"single-line"` \| `"multi-line"`                                | `"multi-line"`  | Var declaration formatting                     |
+| [`handlebarsSpacing`](docs/options/handlebars-spacing.md)                                     | boolean                                                                      | `false`         | Pad simple/triple `{{…}}`; sigil mustaches stay tight |
+| [`handlebarsHelperCase`](docs/options/handlebars-helper-case.md)                              | `"upper-camel"` \| `"lower-camel"` \| `"upper"` \| `"lower"` \| `"preserve"` | `"lower-camel"` | Casing of known MCN Handlebars helper names    |
 
 ### Example `.prettierrc`
 
@@ -56,7 +58,8 @@ All options use the `ampscript` prefix — they control AMPscript formatting beh
 | ------------ | ------------------- | ------------------ | ------------------------------------------------------------------------------- |
 | `.ampscript` | `ampscript`         | `ampscript-parse`  | Full AMPscript formatting                                                       |
 | `.amp`       | `ampscript`         | `ampscript-parse`  | Full AMPscript formatting                                                       |
-| `.html`      | `sfmc`              | `ampscript-parse`  | AMPscript formatted; HTML and `<script runat="server">` delegated to Prettier's built-in HTML formatter |
+| `.html`      | `sfmc`              | `ampscript-parse`  | AMPscript formatted; HTML and `<script runat="server">` delegated to Prettier; MCN `{{…}}` Handlebars normalized (see [Handlebars](#handlebars-marketing-cloud-next)) |
+| `.hbs`       | `handlebars`        | `ampscript-parse`  | Marketing Cloud Next Handlebars normalized (see [Handlebars](#handlebars-marketing-cloud-next)); embedded HTML delegated to Prettier |
 | `.ssjs`      | `ssjs`              | `babel` (built-in) | Standard JavaScript formatting                                                  |
 | `.sql`       | —                   | `sql`              | SQL via composed `prettier-plugin-sql`                                          |
 
@@ -106,9 +109,29 @@ When formatting `.html` files, the plugin:
 1. Parses AMPscript regions (`%%[ ]%%`, `%%= =%%`, `<script language="ampscript">`)
 2. Delegates HTML content to Prettier's built-in HTML formatter
 3. Prettier's HTML formatter handles `<script runat="server">` SSJS blocks as JavaScript
+4. Normalizes Marketing Cloud Next `{{…}}` Handlebars expressions (see [Handlebars](#handlebars-marketing-cloud-next))
 
 This means a single plugin handles all SFMC formatting in HTML email templates.
 
+## Handlebars (Marketing Cloud Next)
+
+Marketing Cloud Next templates use [Handlebars](https://developer.salesforce.com/docs/marketing/handlebars-for-marketing-cloud-next) `{{…}}` expressions. These can co-exist with classic AMPscript and HTML in a single `.html` file, or stand alone in a dedicated `.hbs` file. The plugin normalizes each Handlebars expression it finds in both file types.
+
+Normalization is driven by two options:
+
+- [`handlebarsSpacing`](docs/options/handlebars-spacing.md) (default `false`) — internal whitespace runs always collapse to a single space (`{{ formatCurrency   x }}` becomes `{{formatCurrency x}}`). When `true`, simple mustaches and triple-stache also get one space of padding (`{{ formatCurrency x }}`, `{{{ raw }}}`); sigil mustaches (`{{#each}}`, `{{/each}}`, `{{^x}}`, `{{>p}}`, `{{&x}}`) always stay tight.
+- [`handlebarsHelperCase`](docs/options/handlebars-helper-case.md) (default `"lower-camel"`) — recases **known** MCN Handlebars helper names (from the [`handlebars-data`](https://www.npmjs.com/package/handlebars-data) catalog) at the mustache head, block open/close, and subexpression heads. Unknown paths such as `{{firstName}}` or `{{item.Title}}` are always preserved.
+
+Everything else is left exactly as written:
+
+- **String literals are preserved byte-for-byte**, including their whitespace and quote character: `{{concat "a   b"}}` and `{{concat 'x   y'}}` are unchanged.
+- **Handlebars comments are preserved verbatim**: `{{! … }}` and `{{!-- … --}}` keep their inner spacing.
+- **Malformed or unbalanced expressions are left untouched** (for example a `{{#if}}` with no matching `{{/if}}` in the fragment) and never cause a formatting error.
+- **`{!$…}` merge-field bindings are never touched** — these are SFMC personalization bindings, not Handlebars syntax, and pass through byte-for-byte.
+- Formatting is **idempotent**: running it a second time produces identical output.
+
+AMPscript delimiters (`%%[`, `]%%`, `%%=`, `=%%`) and their contents are unaffected.
+
 ## Ignoring Code
 
 Prettier provides two ways to exclude code from formatting: ignore comments for specific code sections, and `.prettierignore` for entire files.

package/docs/options/handlebars-helper-case.md

@@ -0,0 +1,102 @@
+# `handlebarsHelperCase`
+
+> Control the casing of Marketing Cloud Next Handlebars helper names.
+
+| | |
+|---|---|
+| **Type** | `"upper-camel"` \| `"lower-camel"` \| `"upper"` \| `"lower"` \| `"preserve"` |
+| **Default** | `"lower-camel"` |
+| **Applied by** | `prettier --write` · VS Code format-on-save (requires the [Prettier extension](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode)) |
+
+## What It Controls
+
+Normalises the casing of every **known** Marketing Cloud Next Handlebars helper name. MCN Handlebars helper names are case-insensitive at runtime; this option chooses a consistent form for the formatted output. The canonical names come from the [`handlebars-data`](https://www.npmjs.com/package/handlebars-data) catalog (e.g. `formatCurrency`, `getContentBlock`, `each`).
+
+Recasing is applied at every head position of an expression:
+
+- the mustache head — `{{formatCurrency …}}`
+- a block open — `{{#each …}}`
+- a block close — `{{/each}}`
+- a subexpression head — `{{iif (isEmpty x) a b}}`
+
+**Only names present in the catalog are recased.** Unknown paths — data fields, personalization strings, and dotted property access such as `{{firstName}}` or `{{item.Title}}` — are always preserved exactly as written, in every mode (including their casing).
+
+## Settings
+
+| Value | Effect (for the known helper `getContentBlock`) |
+|-------|--------|
+| `"lower-camel"` (default) | camelCase: `getContentBlock` |
+| `"upper-camel"` | Canonical PascalCase: `GetContentBlock` |
+| `"upper"` | ALL CAPS: `GETCONTENTBLOCK` |
+| `"lower"` | all lowercase: `getcontentblock` |
+| `"preserve"` | Helper casing is left exactly as written |
+
+### `"lower-camel"` (default)
+
+**Input:**
+
+```handlebars
+{{GetContentBlock key="my-block"}}
+{{#EACH items}}{{firstName}}{{/EACH}}
+```
+
+**Output:**
+
+```handlebars
+{{getContentBlock key="my-block"}}
+{{#each items}}{{firstName}}{{/each}}
+```
+
+Note that `firstName` is not a catalog helper, so its casing is left untouched.
+
+### `"upper-camel"`
+
+**Output:**
+
+```handlebars
+{{GetContentBlock key="my-block"}}
+{{#Each items}}{{firstName}}{{/Each}}
+```
+
+### `"upper"`
+
+**Output:**
+
+```handlebars
+{{GETCONTENTBLOCK key="my-block"}}
+{{#EACH items}}{{firstName}}{{/EACH}}
+```
+
+### `"lower"`
+
+**Output:**
+
+```handlebars
+{{getcontentblock key="my-block"}}
+{{#each items}}{{firstName}}{{/each}}
+```
+
+### `"preserve"`
+
+Helper names are emitted exactly as they appeared in the source. Whitespace is still normalised.
+
+## Unknown paths are never touched
+
+In every mode, a path that is not a known helper keeps its exact casing:
+
+```handlebars
+{{firstName}}
+{{item.Title}}
+{{Contact.EmailAddress}}
+```
+
+These are personalization fields, not helpers, so recasing them would change their meaning. They pass through unchanged.
+
+## Configuration Example
+
+```json
+{
+    "plugins": ["prettier-plugin-sfmc"],
+    "handlebarsHelperCase": "upper-camel"
+}
+```

package/docs/options/handlebars-spacing.md

@@ -0,0 +1,69 @@
+# `handlebarsSpacing`
+
+> Pad the inside of Marketing Cloud Next `{{…}}` expressions.
+
+| | |
+|---|---|
+| **Type** | `boolean` |
+| **Default** | `false` |
+| **Applied by** | `prettier --write` · VS Code format-on-save (requires the [Prettier extension](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode)) |
+
+## What It Controls
+
+Controls whether one space of padding is emitted just inside the delimiters of a Marketing Cloud Next Handlebars expression. When `true`, simple mustaches (`{{ … }}`) and triple-stache (`{{{ … }}}`) are padded. Sigil mustaches — block open (`{{#each}}`), block close (`{{/each}}`), inverse (`{{^x}}`), partial (`{{>p}}`), and unescaped (`{{&x}}`) — always stay tight regardless of this option.
+
+Internal runs of whitespace are collapsed to a single space either way, and the contents of quoted string literals are preserved byte-for-byte.
+
+## Settings
+
+| Value | Effect |
+|-------|--------|
+| `false` (default) | Tight: `{{foo bar}}`, `{{{raw}}}` |
+| `true` | Padded simple/triple, tight sigils: `{{ foo bar }}`, `{{{ raw }}}`, `{{#each items}}` |
+
+### `false` (default)
+
+**Input:**
+
+```handlebars
+{{ foo   bar }}
+{{{  raw  }}}
+{{#each items}}{{ item.title }}{{/each}}
+```
+
+**Output:**
+
+```handlebars
+{{foo bar}}
+{{{raw}}}
+{{#each items}}{{item.title}}{{/each}}
+```
+
+### `true`
+
+**Input:**
+
+```handlebars
+{{foo bar}}
+{{{raw}}}
+{{#each items}}{{item.title}}{{/each}}
+```
+
+**Output:**
+
+```handlebars
+{{ foo bar }}
+{{{ raw }}}
+{{#each items}}{{ item.title }}{{/each}}
+```
+
+Note how the block open/close (`{{#each}}` / `{{/each}}`) remain tight while the simple mustache (`{{ item.title }}`) is padded.
+
+## Configuration Example
+
+```json
+{
+    "plugins": ["prettier-plugin-sfmc"],
+    "handlebarsSpacing": true
+}
+```

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "prettier-plugin-sfmc",
-    "version": "0.6.0",
-    "description": "Prettier plugin for Salesforce Marketing Cloud — AMPscript, SSJS, and SQL formatting",
+    "version": "1.0.0",
+    "description": "Prettier plugin for Salesforce Marketing Cloud - AMPscript, Marketing Cloud Next Handlebars, SSJS, and SQL formatting",
     "type": "module",
     "main": "src/index.js",
     "exports": {
@@ -35,6 +35,7 @@
         "prettier",
         "ampscript",
         "ssjs",
+        "handlebars",
         "sql",
         "tsql",
         "transact-sql",
@@ -48,6 +49,7 @@
     "dependencies": {
         "ampscript-data": "^2.0.3",
         "ampscript-parser": "^0.1.3",
+        "handlebars-data": "^0.3.0",
         "prettier-plugin-sql": "^0.20.0",
         "ssjs-data": "^0.5.0"
     },
@@ -69,7 +71,7 @@
         "prettier": ">=3.7.0"
     },
     "engines": {
-        "node": ">=18.0.0"
+        "node": ">=22.0.0"
     },
     "lint-staged": {
         "*.{js,mjs,cjs}": [

package/src/index.js

@@ -11,6 +11,7 @@
  */
 
 import { parse } from 'ampscript-parser';
+import { getHelper } from 'handlebars-data';
 import sqlPlugin from 'prettier-plugin-sql';
 import { printers as prettierEstreePrinters } from 'prettier/plugins/estree';
 import { printAmpscriptNode, collectVariableMap } from './printer.js';
@@ -43,6 +44,292 @@ function mergeSqlOptionsWithSfmcDefaults(sqlOptions) {
     return merged;
 }
 
+// ── Handlebars (MCN) inner normalization ─────────────────────────────────────
+
+/**
+ * Recase a Handlebars helper name using the `handlebars-data` catalog.
+ *
+ * Only names that exist in the catalog (via `getHelper`) are recased; unknown
+ * paths (`firstName`, `item.title`) are returned unchanged in every mode. MCN
+ * Handlebars is case-insensitive at runtime, so recasing a known helper is safe.
+ * Catalog names are lower-camel canonical (e.g. `formatDate`), so `upper-camel`
+ * simply capitalizes the first character of the canonical form.
+ *
+ * @param {string} name Head token as written in the source.
+ * @param {'upper-camel'|'lower-camel'|'upper'|'lower'|'preserve'} mode Casing mode.
+ * @returns {string} Recased name, or the original `name` when not a known helper.
+ */
+function applyHelperCase(name, mode) {
+    if (mode === 'preserve') {
+        return name;
+    }
+    const helper = getHelper(name);
+    if (!helper) {
+        return name;
+    }
+    const canonical = helper.name;
+    if (mode === 'upper') {
+        return canonical.toUpperCase();
+    }
+    if (mode === 'lower') {
+        return canonical.toLowerCase();
+    }
+    if (mode === 'lower-camel') {
+        return canonical[0].toLowerCase() + canonical.slice(1);
+    }
+    // upper-camel
+    return canonical[0].toUpperCase() + canonical.slice(1);
+}
+
+/** Leading sigils that may precede the head token of a mustache. */
+const MUSTACHE_SIGILS = new Set(['#', '/', '^', '>', '&']);
+
+/**
+ * A head token is eligible for recasing only when it is a bare helper name:
+ * a single identifier segment with no path separators (`.` / `/`), no `@`
+ * data-variable prefix, and no `=` (hash key). This keeps `item.title`,
+ * `@index`, and `key=value` untouched while still recasing `formatDate`.
+ *
+ * @param {string} token Candidate head token.
+ * @returns {boolean} True when the token is a bare, recasable name.
+ */
+function isBareName(token) {
+    return /^[A-Za-z_]\w*$/.test(token);
+}
+
+/**
+ * Normalize the inner text of a single Handlebars expression.
+ *
+ * Whitespace outside quoted string literals is collapsed to a single space and
+ * trimmed. When `helperCase` is not `preserve`, the head token (the first token
+ * after an optional leading sigil) and the head token of every subexpression
+ * (first token after each `(`) are recased via {@link applyHelperCase} — but
+ * only when they are known catalog helpers. String literals, paths, hash keys,
+ * block params (`as |x y|`), and unknown names are preserved byte-for-byte.
+ *
+ * Padding of the outer expression (per `handlebarsSpacing`) is applied by the
+ * caller, not here.
+ *
+ * @param {string} inner Raw inner text of a mustache expression.
+ * @param {{ helperCase?: 'upper-camel'|'lower-camel'|'upper'|'lower'|'preserve' }} [opts] Options.
+ * @returns {string} Normalized inner text (collapsed whitespace, recased heads).
+ */
+function normalizeMustacheInner(inner, opts = {}) {
+    const helperCase = opts.helperCase || 'lower-camel';
+
+    // First pass: collapse whitespace outside string literals, preserving quotes.
+    let collapsed = '';
+    /** @type {string|null} */
+    let quote = null;
+    for (const ch of inner) {
+        if (quote) {
+            collapsed += ch;
+            if (ch === quote) {
+                quote = null;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            collapsed += ch;
+            continue;
+        }
+        if (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r' || ch === '\f' || ch === '\v') {
+            if (collapsed.length > 0 && collapsed.at(-1) !== ' ') {
+                collapsed += ' ';
+            }
+            continue;
+        }
+        collapsed += ch;
+    }
+    collapsed = collapsed.trim();
+
+    if (helperCase === 'preserve' || collapsed.length === 0) {
+        return collapsed;
+    }
+
+    // Second pass: recase the head token and each subexpression head token.
+    // A head is expected at the very start (after an optional sigil) and
+    // immediately after each `(`. We walk the collapsed string, tracking string
+    // literals so `(` / heads inside quotes are ignored.
+    let result = '';
+    quote = null;
+    let expectHead = true;
+    let leadingSigilConsumed = false;
+    let i = 0;
+    const n = collapsed.length;
+    while (i < n) {
+        const ch = collapsed[i];
+        if (quote) {
+            result += ch;
+            if (ch === quote) {
+                quote = null;
+            }
+            i++;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            result += ch;
+            expectHead = false;
+            i++;
+            continue;
+        }
+        // At the outermost head position, skip a single leading sigil.
+        if (expectHead && !leadingSigilConsumed && result.length === 0 && MUSTACHE_SIGILS.has(ch)) {
+            result += ch;
+            leadingSigilConsumed = true;
+            i++;
+            continue;
+        }
+        if (ch === '(') {
+            result += ch;
+            expectHead = true;
+            i++;
+            continue;
+        }
+        if (ch === ' ') {
+            result += ch;
+            i++;
+            continue;
+        }
+        if (expectHead) {
+            // Read the head token up to the next whitespace, `(`, `)`, or quote.
+            let j = i;
+            while (j < n && !/[\s()'"]/.test(collapsed[j])) {
+                j++;
+            }
+            const token = collapsed.slice(i, j);
+            result += isBareName(token) ? applyHelperCase(token, helperCase) : token;
+            expectHead = false;
+            i = j;
+            continue;
+        }
+        result += ch;
+        i++;
+    }
+    return result;
+}
+
+/**
+ * Token placeholder prefix used to shield MCN Handlebars `{{…}}` regions from
+ * Prettier's HTML parser (which would otherwise collapse whitespace inside string
+ * literals and reflow mustaches). Mirrors the `AMPSCRIPTPH…END` scheme.
+ */
+const HANDLEBARS_PH = 'HANDLEBARSPH';
+
+/**
+ * Extract every well-formed MCN Handlebars `{{…}}` region from a string, replacing
+ * each with a `HANDLEBARSPH<n>END` placeholder and recording the normalized
+ * replacement text. The HTML parser then never sees mustache internals, so it
+ * cannot corrupt string literals or reflow them; normalization happens here.
+ *
+ * Guarantees:
+ * - `{!$…}` merge-field bindings are never matched (they use single braces).
+ * - AMPscript delimiters and `AMPSCRIPTPH…END` placeholders are never matched
+ *   (they contain no `{{`).
+ * - Handlebars comments (`{{! … }}`, `{{!-- … --}}`) are recorded verbatim.
+ * - Triple-stache (`{{{ … }}}`) and the `&` sigil are preserved (not rewritten).
+ * - String literals inside an expression keep their exact bytes and quote style.
+ * - Unbalanced/never-closed mustaches are left verbatim in the returned string
+ *   (no throw, no change), so the HTML parser passes them through untouched.
+ *
+ * @param {string} text Joined HTML/text (AMPscript already placeholdered).
+ * @param {{ spacing?: boolean, helperCase?: 'upper-camel'|'lower-camel'|'upper'|'lower'|'preserve' }} [opts]
+ * Formatting options: `spacing` pads simple/triple mustaches (sigil mustaches stay
+ * tight); `helperCase` recases known catalog helpers at head positions.
+ * @returns {{ html: string, tokens: string[] }} Text with Handlebars placeholders
+ * and the ordered list of normalized mustache replacements.
+ */
+function extractHandlebarsRegions(text, opts = {}) {
+    const spacing = opts.spacing === true;
+    const helperCase = opts.helperCase || 'lower-camel';
+    /** @type {string[]} */
+    const tokens = [];
+    if (typeof text !== 'string' || !text.includes('{{')) {
+        return { html: text, tokens };
+    }
+
+    let out = '';
+    let i = 0;
+    const n = text.length;
+    while (i < n) {
+        const open = text.indexOf('{{', i);
+        if (open === -1) {
+            out += text.slice(i);
+            break;
+        }
+        out += text.slice(i, open);
+
+        const isTriple = text[open + 2] === '{';
+        const openLen = isTriple ? 3 : 2;
+        const afterOpen = text.slice(open + openLen);
+
+        // Comments: record verbatim, never normalize their contents.
+        if (!isTriple && afterOpen.startsWith('!')) {
+            const isBlock = afterOpen.startsWith('!--');
+            const closeStr = isBlock ? '--}}' : '}}';
+            const close = text.indexOf(closeStr, open + openLen);
+            if (close === -1) {
+                out += text.slice(open);
+                break;
+            }
+            const end = close + closeStr.length;
+            tokens.push(text.slice(open, end));
+            out += `${HANDLEBARS_PH}${tokens.length - 1}END`;
+            i = end;
+            continue;
+        }
+
+        // Scan for the closing delimiter, ignoring `}}` inside string literals.
+        const closeDelim = isTriple ? '}}}' : '}}';
+        /** @type {string|null} */
+        let quote = null;
+        let j = open + openLen;
+        let foundClose = -1;
+        while (j < n) {
+            const ch = text[j];
+            if (quote) {
+                if (ch === quote) {
+                    quote = null;
+                }
+                j++;
+                continue;
+            }
+            if (ch === '"' || ch === "'") {
+                quote = ch;
+                j++;
+                continue;
+            }
+            if (text.startsWith(closeDelim, j)) {
+                foundClose = j;
+                break;
+            }
+            j++;
+        }
+
+        if (foundClose === -1) {
+            // Unbalanced — leave the remainder exactly as-is for the HTML parser.
+            out += text.slice(open);
+            break;
+        }
+
+        const inner = text.slice(open + openLen, foundClose);
+        const opener = text.slice(open, open + openLen);
+        const normalized = normalizeMustacheInner(inner, { helperCase });
+        // Pad simple mustaches (`{{ … }}`) and triple-stache (`{{{ … }}}`) when
+        // `spacing` is enabled; sigil mustaches (`{{#…}}`, `{{/…}}`, `{{^…}}`,
+        // `{{>…}}`, `{{&…}}`) always stay tight.
+        const hasSigil = MUSTACHE_SIGILS.has(normalized[0]);
+        const pad = spacing && !hasSigil && normalized.length > 0 ? ' ' : '';
+        tokens.push(`${opener}${pad}${normalized}${pad}${closeDelim}`);
+        out += `${HANDLEBARS_PH}${tokens.length - 1}END`;
+        i = foundClose + closeDelim.length;
+    }
+
+    return { html: out, tokens };
+}
+
 // ── Languages ────────────────────────────────────────────────────────────────
 
 export const languages = [
@@ -58,6 +345,12 @@ export const languages = [
         extensions: ['.html'],
         vscodeLanguageIds: ['sfmc'],
     },
+    {
+        name: 'Handlebars (MCN)',
+        parsers: ['ampscript-parse'],
+        extensions: ['.hbs'],
+        vscodeLanguageIds: ['handlebars'],
+    },
     {
         name: 'SSJS',
         parsers: ['babel'],
@@ -125,7 +418,12 @@ export const printers = {
             const hasHtml = node.children.some(
                 (c) => c.type === 'Content' && /<[a-zA-Z!/]/.test(c.value),
             );
-            if (!hasHtml) {
+            // Pure `.hbs` documents may contain no HTML tags at all — still run
+            // the embed path so `{{…}}` mustaches are normalized.
+            const hasHandlebars = node.children.some(
+                (c) => c.type === 'Content' && c.value.includes('{{'),
+            );
+            if (!hasHtml && !hasHandlebars) {
                 return;
             }
 
@@ -146,7 +444,17 @@ export const printers = {
                     }
                 }
 
-                const html = htmlParts.join('');
+                // Shield MCN Handlebars {{…}} from the HTML parser (which would
+                // otherwise collapse whitespace inside string literals). The
+                // mustache text is normalized (whitespace, helper casing, and
+                // optional padding) during extraction.
+                const { html, tokens: handlebarsTokens } = extractHandlebarsRegions(
+                    htmlParts.join(''),
+                    {
+                        spacing: options.handlebarsSpacing === true,
+                        helperCase: options.handlebarsHelperCase || 'lower-camel',
+                    },
+                );
 
                 let htmlDocument;
                 try {
@@ -155,12 +463,12 @@ export const printers = {
                     return;
                 }
 
-                const re = new RegExp(String.raw`${PH}(\d+)END`, 'g');
+                const re = new RegExp(String.raw`(?:${PH}(\d+)END|${HANDLEBARS_PH}(\d+)END)`, 'g');
                 return prettier.doc.utils.mapDoc(htmlDocument, (d) => {
                     if (typeof d !== 'string') {
                         return d;
                     }
-                    if (!d.includes(PH)) {
+                    if (!d.includes(PH) && !d.includes(HANDLEBARS_PH)) {
                         return d;
                     }
 
@@ -172,7 +480,11 @@ export const printers = {
                         if (m.index > last) {
                             parts.push(d.slice(last, m.index));
                         }
-                        parts.push(print(['children', Number.parseInt(m[1], 10)]));
+                        if (m[1] === undefined) {
+                            parts.push(handlebarsTokens[Number.parseInt(m[2], 10)]);
+                        } else {
+                            parts.push(print(['children', Number.parseInt(m[1], 10)]));
+                        }
                         last = m.index + m[0].length;
                     }
                     if (last < d.length) {
@@ -368,6 +680,41 @@ const sfmcOptions = {
         ],
         description: 'Control how var declarations with multiple variables are formatted.',
     },
+    handlebarsSpacing: {
+        type: 'boolean',
+        category: 'Handlebars',
+        default: false,
+        description:
+            'Pad the inside of Marketing Cloud Next `{{…}}` expressions. ' +
+            'When true, simple mustaches and triple-stache get one space of padding ' +
+            '(`{{ foo bar }}`, `{{{ raw }}}`); sigil mustaches (`{{#each}}`, `{{/each}}`, ' +
+            '`{{^x}}`, `{{>p}}`, `{{&x}}`) always stay tight. When false (default), all ' +
+            'mustaches are tight. Internal runs of whitespace collapse to a single space ' +
+            'either way, and string literals are preserved.',
+    },
+    handlebarsHelperCase: {
+        type: 'choice',
+        category: 'Handlebars',
+        default: 'lower-camel',
+        choices: [
+            {
+                value: 'upper-camel',
+                description: 'Canonical PascalCase: FormatDate, TruncateWords',
+            },
+            {
+                value: 'lower-camel',
+                description: 'camelCase: formatDate, truncateWords',
+            },
+            { value: 'upper', description: 'UPPERCASE: FORMATDATE, TRUNCATEWORDS' },
+            { value: 'lower', description: 'lowercase: formatdate, truncatewords' },
+            { value: 'preserve', description: 'Keep original helper casing' },
+        ],
+        description:
+            'Control the casing of Marketing Cloud Next Handlebars helper names. ' +
+            'Only names found in the handlebars-data catalog are recased, at the ' +
+            'mustache head, block open/close, and subexpression heads. Unknown paths ' +
+            '(e.g. `firstName`, `item.title`) are always preserved.',
+    },
 };
 
 export const options = {