@maizzle/framework 6.0.0-rc.9 → 6.0.0

package/dist/transformers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/transformers/index.ts"],"sourcesContent":["import { parse, serialize } from '../utils/ast/index.ts'\nimport { inlineLinkDom } from './inlineLink.ts'\nimport { tailwindComponent } from './tailwindComponent.ts'\nimport { tailwindcss } from './tailwindcss.ts'\nimport { safeSelectorsDom } from './safeSelectors.ts'\nimport { attributeToStyleDom } from './attributeToStyle.ts'\nimport { inlineCssDom } from './inlineCss.ts'\nimport { msoPlaceholders } from './msoPlaceholders.ts'\nimport { columnWidth } from './columnWidth.ts'\nimport { imgWidthDom } from './imgWidth.ts'\nimport { removeAttributesDom } from './removeAttributes.ts'\nimport { shorthandCssDom } from './shorthandCss.ts'\nimport { sixHexDom } from './sixHex.ts'\nimport { addAttributesDom } from './addAttributes.ts'\nimport { filtersDom } from './filters/index.ts'\nimport { baseDom } from './base.ts'\nimport { entitiesDom } from './entities.ts'\nimport { urlQueryDom } from './urlQuery.ts'\nimport { purgeCssDom } from './purgeCss.ts'\nimport { replaceStrings } from './replaceStrings.ts'\nimport { format } from './format.ts'\nimport { minifyCodeInline } from './minifyCodeInline.ts'\nimport { minify } from './minify.ts'\nimport type { MaizzleConfig } from '../types/config.ts'\nimport type { TailwindBlock } from '../composables/renderContext.ts'\n\n/**\n * Run all Maizzle transformers on the rendered HTML.\n *\n * The HTML is parsed into a DOM once at the start and passed through all\n * DOM-based transformers as a shared `ChildNode[]`. After all DOM transformers\n * complete, the DOM is serialized back to a string exactly once.\n *\n * String-only transformers (those that rely on external tools that require a\n * raw HTML string) then run on the serialized output.\n *\n * Transformers run in a specific order:\n * 0.  Inline link stylesheets — replace `<link rel=\"stylesheet\">` with `<style>` tags\n * 1.  Tailwind CSS — compile CSS, lower syntax, optimize (cleanup + merge media queries)\n * 2.  Safe class names\n * 3.  Attribute to style\n * 4.  CSS inliner\n * 5.  Remove attributes\n * 6.  Shorthand CSS\n * 7.  Six-digit HEX\n * 8.  Add attributes\n * 9.  Filters\n * 10. Base URL\n * 11. URL query\n * 12. Purge CSS (serializes/parses internally around email-comb)\n * 13. Entities\n * + Vue-generated comments stripped here (on serialized string)\n * 14. Replace strings\n * 15. Prettify\n * 16. Minify\n */\nexport async function runTransformers(\n  html: string,\n  config: MaizzleConfig,\n  filePath?: string,\n  doctype?: string,\n  tailwindBlocks?: TailwindBlock[],\n): Promise<string> {\n  /**\n   * Per-transformer skip map — only honored when useTransformers is an object.\n   * Whole-pipeline opt-out (`useTransformers === false`) is handled upstream\n   * in build.ts / render so we never reach this function in that case.\n   *\n   * A toggle set to `true` *force-enables* its transformer for this run\n   * by layering on the matching config slice (e.g. `prettify: true`\n   * sets `html.format = true`). This only applies to transformers\n   * whose enable flag is a plain boolean — data-driven ones\n   * (filters, baseURL, urlQuery, etc.) need actual config\n   * values, so a bare `true` for those is a no-op.\n   */\n  const toggles = typeof config.useTransformers === 'object' ? config.useTransformers : null\n  const enabled = (key: keyof NonNullable<typeof toggles>) => toggles?.[key] !== false\n\n  let effective = config\n  if (toggles) {\n    const cssOver: Record<string, unknown> = {}\n    const htmlOver: Record<string, unknown> = {}\n    if (toggles.inlineCss === true) cssOver.inline = true\n    if (toggles.purgeCss === true) cssOver.purge = true\n    if (toggles.safeSelectors === true) cssOver.safe = true\n    if (toggles.shorthandCss === true) cssOver.shorthand = true\n    if (toggles.sixHex === true) cssOver.sixHex = true\n    if (toggles.prettify === true) htmlOver.format = true\n    if (toggles.minify === true) htmlOver.minify = true\n    if (toggles.entities === true) htmlOver.decodeEntities = true\n\n    if (Object.keys(cssOver).length || Object.keys(htmlOver).length) {\n      effective = {\n        ...config,\n        css: { ...config.css, ...cssOver },\n        html: { ...config.html, ...htmlOver },\n      }\n    }\n  }\n\n  // Parse once — all DOM transformers share this array\n  let dom = parse(html)\n\n  // 0. Inline <link> stylesheets\n  dom = await inlineLinkDom(dom, filePath)\n\n  // 0.5. <Tailwind> component — compile per-block scoped CSS, inject into <head>\n  if (tailwindBlocks?.length) {\n    dom = await tailwindComponent(dom, tailwindBlocks, effective, filePath)\n  }\n\n  // 1. Tailwind CSS — always runs first\n  dom = await tailwindcss(dom, effective, filePath)\n\n  // 2. Safe class names\n  if (enabled('safeSelectors')) dom = safeSelectorsDom(dom, effective.css)\n\n  // 3. Attribute to style\n  if (enabled('attributeToStyle') && typeof effective.css?.inline === 'object' && effective.css.inline.attributeToStyle) {\n    dom = attributeToStyleDom(dom, effective.css.inline.attributeToStyle)\n  }\n\n  // 4. CSS inliner (serializes/parses internally around juice)\n  if (enabled('inlineCss') && effective.css?.inline) {\n    const inlineOptions = typeof effective.css.inline === 'object' ? effective.css.inline : {}\n    dom = inlineCssDom(dom, inlineOptions)\n  }\n\n  // 4.5. Resolve MSO placeholders (table width + td style) from inlined CSS\n  dom = msoPlaceholders(dom)\n\n  // 4.6. Resolve Column min-width placeholders from nearest sized ancestor\n  dom = columnWidth(dom)\n\n  // 4.7. Backfill width on <Img> images that inherit their parent's width\n  dom = imgWidthDom(dom)\n\n  // 5. Remove attributes\n  if (enabled('removeAttributes')) {\n    const removeRules = effective.html?.attributes?.remove\n    dom = removeAttributesDom(dom, Array.isArray(removeRules) ? removeRules : [])\n  }\n\n  // 6. Shorthand CSS\n  if (enabled('shorthandCss') && effective.css?.shorthand) {\n    const shorthandOptions = typeof effective.css.shorthand === 'object' ? effective.css.shorthand : {}\n    dom = shorthandCssDom(dom, shorthandOptions)\n  }\n\n  // 7. Six-digit HEX\n  if (enabled('sixHex') && effective.css?.sixHex !== false) dom = sixHexDom(dom)\n\n  // 8. Add attributes\n  if (enabled('addAttributes')) dom = addAttributesDom(dom, effective.html?.attributes)\n\n  // 9. Filters\n  if (enabled('filters')) dom = filtersDom(dom, effective.filters)\n\n  // 10. Base URL (serializes/parses internally for VML/MSO regex passes)\n  if (enabled('baseURL') && effective.url?.base) dom = baseDom(dom, effective.url.base)\n\n  // 11. URL query\n  if (enabled('urlQuery') && effective.url?.query && Object.keys(effective.url.query).length > 0) {\n    const { _options: queryOptions, ...queryParams } = effective.url.query as Record<string, unknown>\n    dom = urlQueryDom(dom, queryParams, (queryOptions ?? {}) as import('../types/config.ts').UrlQueryOptions)\n  }\n\n  // 12. Remove unused CSS (serializes/parses internally around email-comb)\n  if (enabled('purgeCss') && effective.css?.purge) {\n    const purgeOptions = typeof effective.css.purge === 'object' ? effective.css.purge : {}\n    dom = purgeCssDom(dom, purgeOptions)\n  }\n\n  // 13. Entities\n  if (enabled('entities')) dom = entitiesDom(dom, effective.html?.decodeEntities)\n\n  // Serialize once — remaining transformers operate on the HTML string\n  const isXhtml = doctype ? /xhtml/i.test(doctype) : false\n  let result = serialize(dom, { selfClosingTags: isXhtml })\n\n  // 14. Replace strings\n  if (enabled('replaceStrings')) result = replaceStrings(result, effective)\n\n  // 15. Format — skipped when `minify` is enabled\n  const minifyWillRun = enabled('minify') && !!effective.html?.minify\n  if (enabled('prettify') && !minifyWillRun && effective.html?.format) {\n    const formatOptions = typeof effective.html.format === 'object' ? effective.html.format : {}\n    result = await format(result, formatOptions)\n  }\n\n  // 16. Minify\n  if (enabled('minify') && effective.html?.minify) {\n    const minifyOptions = typeof effective.html.minify === 'object' ? effective.html.minify : {}\n    result = minify(result, minifyOptions)\n  }\n\n  /**\n   * Strip self-closing slashes for HTML5 doctypes, but preserve content\n   * inside MSO conditional comments (XML-ish, case/syntax sensitive).\n   * MUST run BEFORE minifyCodeInline: at this point, CodeInline's\n   * shiki output is still marker-encoded (§MZLT§/§MZGT§), so any\n   * ` />` in the highlighted source code (e.g. a Vue self-close\n   * tag) hasn't materialized yet and can't be mistakenly\n   * stripped from inside a `<code>` element.\n   */\n  if (!isXhtml) {\n    result = result.replace(\n      /<!--\\[if [^\\]]*\\]>[\\s\\S]*?<!\\[endif\\]-->|( \\/>)/g,\n      (match, selfClose) => selfClose ? '>' : match,\n    )\n  }\n\n  /**\n   * 16.5. Strip whitespace inside `data-minify-inline` markers (CodeInline's\n   * Shiki output, etc.). Runs after format/minify so it cleans up the\n   * pretty-printer's indentation between sibling tags.\n   */\n  result = minifyCodeInline(result)\n\n  return result\n}\n"],"mappings":"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"}

package/dist/transformers/inlineCss.d.ts

@@ -0,0 +1,85 @@
+import { ChildNode } from "domhandler";
+import juice from "juice";
+
+//#region src/transformers/inlineCss.d.ts
+type JuiceOptions = NonNullable<Parameters<typeof juice>[1]>;
+/**
+ * Options for the `inlineCss` transformer. Accepts every Juice option plus a
+ * handful of Maizzle-specific extras.
+ */
+interface InlineCssOptions extends JuiceOptions {
+  /**
+   * Convert `0px`, `0em` etc. to `0` in inline styles.
+   *
+   * @default true
+   */
+  preferUnitlessValues?: boolean;
+  /**
+   * CSS selectors to preserve in `<style>` tags, even after inlining.
+   * Mapped to Juice's `preservedSelectors` option.
+   *
+   * @default []
+   */
+  safelist?: string[];
+  /**
+   * Additional CSS string to inline alongside `<style>` tag contents.
+   * Mapped to Juice's `extraCss` option.
+   */
+  customCSS?: string;
+  /**
+   * Duplicate CSS properties to HTML attributes.
+   * Mapped to Juice's static `styleToAttribute` property.
+   */
+  styleToAttribute?: Record<string, string>;
+  /**
+   * CSS properties to exclude from inlining.
+   * Mapped to Juice's static `excludedProperties` property.
+   */
+  excludedProperties?: string[];
+  /**
+   * Elements that can receive `width` HTML attributes.
+   * Mapped to Juice's static `widthElements` property.
+   *
+   * @default ['img', 'video']
+   */
+  widthElements?: string[];
+  /**
+   * Elements that can receive `height` HTML attributes.
+   * Mapped to Juice's static `heightElements` property.
+   *
+   * @default ['img', 'video']
+   */
+  heightElements?: string[];
+  /**
+   * Template language code blocks to preserve during inlining.
+   * Mapped to Juice's static `codeBlocks` property.
+   */
+  codeBlocks?: Record<string, {
+    start: string;
+    end: string;
+  }>;
+}
+/**
+ * Inline CSS from `<style>` tags into `style` attributes on matching elements.
+ *
+ * @param html    HTML string to transform.
+ * @param options Juice options plus Maizzle-specific extras.
+ * @returns       The transformed HTML string.
+ *
+ * @example
+ * import { inlineCss } from '@maizzle/framework'
+ *
+ * const out = inlineCss('<style>.red{color:red}</style><p class="red">x</p>', {
+ *   removeStyleTags: true,
+ * })
+ */
+declare function inlineCss(html: string, options?: InlineCssOptions): string;
+/**
+ * DOM-form of {@link inlineCss} used by the internal transformer pipeline.
+ * Takes a parsed DOM, returns a parsed DOM — avoids the redundant
+ * serialize/parse round-trips when chained with other transformers.
+ */
+declare function inlineCssDom(dom: ChildNode[], options?: InlineCssOptions): ChildNode[];
+//#endregion
+export { InlineCssOptions, inlineCss, inlineCssDom };
+//# sourceMappingURL=inlineCss.d.ts.map

package/dist/transformers/inlineCss.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inlineCss.d.ts","names":[],"sources":["../../src/transformers/inlineCss.ts"],"mappings":";;;;KAMK,YAAA,GAAe,WAAA,CAAY,UAAA,QAAkB,KAAA;;AADE;;;UAOnC,gBAAA,SAAyB,YAAA;EANV;;;;;EAY9B,oBAAA;EAZgD;;AAAK;AAMvD;;;EAaE,QAAA;EAkCa;;;;EA7Bb,SAAA;EAZA;;;;EAiBA,gBAAA,GAAmB,MAAA;EAKnB;;;;EAAA,kBAAA;EAmB8B;;;AAAkB;AAiBlD;;EA7BE,aAAA;EA6BoE;;;;;AAAA;EAtBpE,cAAA;EA+B0B;;;;EA1B1B,UAAA,GAAa,MAAA;IAAiB,KAAA;IAAe,GAAA;EAAA;AAAA;;;;;AA0B0C;;;;;;;;;;iBATzE,SAAA,CAAU,IAAA,UAAc,OAAA,GAAS,gBAAqB;;;;;;iBAStD,YAAA,CAAa,GAAA,EAAK,SAAA,IAAa,OAAA,GAAS,gBAAA,GAAwB,SAAA"}

package/dist/transformers/inlineCss.js

@@ -0,0 +1,112 @@
+import { parse } from "../utils/ast/parser.js";
+import { walk } from "../utils/ast/walker.js";
+import { serialize } from "../utils/ast/serializer.js";
+import "../utils/ast/index.js";
+import juice from "juice";
+//#region src/transformers/inlineCss.ts
+/** Juice's built-in code blocks, captured before any per-call mutation. */
+const DEFAULT_CODE_BLOCKS = { ...juice.codeBlocks };
+/**
+* Inline CSS from `<style>` tags into `style` attributes on matching elements.
+*
+* @param html    HTML string to transform.
+* @param options Juice options plus Maizzle-specific extras.
+* @returns       The transformed HTML string.
+*
+* @example
+* import { inlineCss } from '@maizzle/framework'
+*
+* const out = inlineCss('<style>.red{color:red}</style><p class="red">x</p>', {
+*   removeStyleTags: true,
+* })
+*/
+function inlineCss(html, options = {}) {
+	return serialize(inlineCssDom(parse(html), options));
+}
+/**
+* DOM-form of {@link inlineCss} used by the internal transformer pipeline.
+* Takes a parsed DOM, returns a parsed DOM — avoids the redundant
+* serialize/parse round-trips when chained with other transformers.
+*/
+function inlineCssDom(dom, options = {}) {
+	const { preferUnitlessValues = true, safelist, customCSS = "", styleToAttribute, excludedProperties, widthElements, heightElements, codeBlocks, ...juicePassthrough } = options;
+	juice.styleToAttribute = styleToAttribute ?? {};
+	juice.excludedProperties = ["--tw-shadow", ...excludedProperties ?? []];
+	juice.widthElements = (widthElements ?? ["img", "video"]).map((i) => i.toUpperCase());
+	juice.heightElements = (heightElements ?? ["img", "video"]).map((i) => i.toUpperCase());
+	juice.codeBlocks = { ...DEFAULT_CODE_BLOCKS };
+	if (codeBlocks && typeof codeBlocks === "object") Object.entries(codeBlocks).forEach(([key, value]) => {
+		if (value.start && value.end) juice.codeBlocks[key] = value;
+	});
+	/**
+	* Handle style tags with embed attributes. We add a marker attribute
+	* that persists through the pipeline, then restore data-embed from
+	* it after Juice runs. `amp-custom` (AMP4Email's CSS attribute)
+	* is treated the same as embed: contents are preserved,
+	* never inlined.
+	*/
+	walk(dom, (node) => {
+		const el = node;
+		if (el.name === "style" && el.attribs) {
+			/**
+			* `amp-custom` → tell juice to skip via data-embed, but don't mirror
+			* back to `embed` (user wrote amp-custom, that's what stays in
+			* output).
+			*/
+			if ("amp-custom" in el.attribs && !("data-embed" in el.attribs)) el.attribs["data-embed"] = "";
+			/**
+			* Sync data-embed ↔ embed. Use `in` so presence-only attrs
+			* (<style embed> → attribs.embed === '') still count.
+			*/
+			if ("embed" in el.attribs && !("data-embed" in el.attribs)) el.attribs["data-embed"] = "";
+			if ("data-embed" in el.attribs && !("embed" in el.attribs) && !("amp-custom" in el.attribs)) el.attribs.embed = "";
+			if ("data-embed" in el.attribs) el.attribs["data-maizzle-embed"] = "";
+		}
+	});
+	const serialized = serialize(dom);
+	let inlinedHtml;
+	try {
+		inlinedHtml = juice(serialized, {
+			removeStyleTags: juicePassthrough.removeStyleTags ?? false,
+			removeInlinedSelectors: juicePassthrough.removeInlinedSelectors ?? true,
+			applyWidthAttributes: juicePassthrough.applyWidthAttributes ?? true,
+			applyHeightAttributes: juicePassthrough.applyHeightAttributes ?? true,
+			preservedSelectors: safelist ?? [],
+			...customCSS ? { extraCss: customCSS } : {},
+			inlineDuplicateProperties: juicePassthrough.inlineDuplicateProperties ?? true,
+			...juicePassthrough
+		});
+	} catch {
+		return dom;
+	}
+	const result = parse(inlinedHtml);
+	if (preferUnitlessValues) walk(result, (node) => {
+		const el = node;
+		if (el.attribs?.style) el.attribs.style = el.attribs.style.replace(/\b0(px|rem|em|%|vh|vw|vmin|vmax|in|cm|mm|pt|pc|ex|ch)\b/g, "0");
+	});
+	/**
+	* Restore `embed` from our marker so the purge step can detect
+	* these tags and skip them. Drop `data-embed` (juice's name)
+	* since it's redundant once `embed` is back, and let purge
+	* strip `embed` itself at the end of its run.
+	*/
+	walk(result, (node) => {
+		const el = node;
+		if (el.name === "style" && el.attribs && "data-maizzle-embed" in el.attribs) {
+			/**
+			* Only restore `embed` when the original signal was embed/data-embed —
+			* an `amp-custom` style was tagged for juice's benefit only and
+			* must not pick up a stray `embed` attribute in the rendered
+			* output.
+			*/
+			if (!("amp-custom" in el.attribs)) el.attribs.embed = "";
+			delete el.attribs["data-embed"];
+			delete el.attribs["data-maizzle-embed"];
+		}
+	});
+	return result;
+}
+//#endregion
+export { inlineCss, inlineCssDom };
+
+//# sourceMappingURL=inlineCss.js.map

package/dist/transformers/inlineCss.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inlineCss.js","names":[],"sources":["../../src/transformers/inlineCss.ts"],"sourcesContent":["import juice from 'juice'\nimport { walk, parse, serialize } from '../utils/ast/index.ts'\n\n/** Juice's built-in code blocks, captured before any per-call mutation. */\nconst DEFAULT_CODE_BLOCKS = { ...juice.codeBlocks }\nimport type { ChildNode, Element } from 'domhandler'\ntype JuiceOptions = NonNullable<Parameters<typeof juice>[1]>\n\n/**\n * Options for the `inlineCss` transformer. Accepts every Juice option plus a\n * handful of Maizzle-specific extras.\n */\nexport interface InlineCssOptions extends JuiceOptions {\n  /**\n   * Convert `0px`, `0em` etc. to `0` in inline styles.\n   *\n   * @default true\n   */\n  preferUnitlessValues?: boolean\n  /**\n   * CSS selectors to preserve in `<style>` tags, even after inlining.\n   * Mapped to Juice's `preservedSelectors` option.\n   *\n   * @default []\n   */\n  safelist?: string[]\n  /**\n   * Additional CSS string to inline alongside `<style>` tag contents.\n   * Mapped to Juice's `extraCss` option.\n   */\n  customCSS?: string\n  /**\n   * Duplicate CSS properties to HTML attributes.\n   * Mapped to Juice's static `styleToAttribute` property.\n   */\n  styleToAttribute?: Record<string, string>\n  /**\n   * CSS properties to exclude from inlining.\n   * Mapped to Juice's static `excludedProperties` property.\n   */\n  excludedProperties?: string[]\n  /**\n   * Elements that can receive `width` HTML attributes.\n   * Mapped to Juice's static `widthElements` property.\n   *\n   * @default ['img', 'video']\n   */\n  widthElements?: string[]\n  /**\n   * Elements that can receive `height` HTML attributes.\n   * Mapped to Juice's static `heightElements` property.\n   *\n   * @default ['img', 'video']\n   */\n  heightElements?: string[]\n  /**\n   * Template language code blocks to preserve during inlining.\n   * Mapped to Juice's static `codeBlocks` property.\n   */\n  codeBlocks?: Record<string, { start: string; end: string }>\n}\n\n/**\n * Inline CSS from `<style>` tags into `style` attributes on matching elements.\n *\n * @param html    HTML string to transform.\n * @param options Juice options plus Maizzle-specific extras.\n * @returns       The transformed HTML string.\n *\n * @example\n * import { inlineCss } from '@maizzle/framework'\n *\n * const out = inlineCss('<style>.red{color:red}</style><p class=\"red\">x</p>', {\n *   removeStyleTags: true,\n * })\n */\nexport function inlineCss(html: string, options: InlineCssOptions = {}): string {\n  return serialize(inlineCssDom(parse(html), options))\n}\n\n/**\n * DOM-form of {@link inlineCss} used by the internal transformer pipeline.\n * Takes a parsed DOM, returns a parsed DOM — avoids the redundant\n * serialize/parse round-trips when chained with other transformers.\n */\nexport function inlineCssDom(dom: ChildNode[], options: InlineCssOptions = {}): ChildNode[] {\n  const {\n    preferUnitlessValues = true,\n    safelist,\n    customCSS = '',\n    styleToAttribute,\n    excludedProperties,\n    widthElements,\n    heightElements,\n    codeBlocks,\n    ...juicePassthrough\n  } = options\n\n  // Configure Juice static properties\n  juice.styleToAttribute = styleToAttribute ?? {}\n  juice.excludedProperties = ['--tw-shadow', ...(excludedProperties ?? [])]\n  juice.widthElements = (widthElements ?? ['img', 'video']).map(i => i.toUpperCase()) as unknown as HTMLElement[]\n  juice.heightElements = (heightElements ?? ['img', 'video']).map(i => i.toUpperCase()) as unknown as HTMLElement[]\n\n  // Reset to defaults each call so a previous template's custom code blocks\n  // don't accumulate on juice's module-global state, then add this call's.\n  juice.codeBlocks = { ...DEFAULT_CODE_BLOCKS }\n  if (codeBlocks && typeof codeBlocks === 'object') {\n    Object.entries(codeBlocks).forEach(([key, value]) => {\n      if (value.start && value.end) {\n        juice.codeBlocks[key] = value\n      }\n    })\n  }\n\n  /**\n   * Handle style tags with embed attributes. We add a marker attribute\n   * that persists through the pipeline, then restore data-embed from\n   * it after Juice runs. `amp-custom` (AMP4Email's CSS attribute)\n   * is treated the same as embed: contents are preserved,\n   * never inlined.\n   */\n  walk(dom, (node) => {\n    const el = node as Element\n    if (el.name === 'style' && el.attribs) {\n      /**\n       * `amp-custom` → tell juice to skip via data-embed, but don't mirror\n       * back to `embed` (user wrote amp-custom, that's what stays in\n       * output).\n       */\n      if ('amp-custom' in el.attribs && !('data-embed' in el.attribs)) {\n        el.attribs['data-embed'] = ''\n      }\n      /**\n       * Sync data-embed ↔ embed. Use `in` so presence-only attrs\n       * (<style embed> → attribs.embed === '') still count.\n       */\n      if ('embed' in el.attribs && !('data-embed' in el.attribs)) {\n        el.attribs['data-embed'] = ''\n      }\n      if ('data-embed' in el.attribs && !('embed' in el.attribs) && !('amp-custom' in el.attribs)) {\n        el.attribs.embed = ''\n      }\n\n      // Add marker that persists through the pipeline\n      if ('data-embed' in el.attribs) {\n        el.attribs['data-maizzle-embed'] = ''\n      }\n    }\n  })\n\n  // Serialize for juice (juice requires a string)\n  const serialized = serialize(dom)\n\n  let inlinedHtml: string\n\n  try {\n    const juiceOptions: JuiceOptions = {\n      removeStyleTags: juicePassthrough.removeStyleTags ?? false,\n      removeInlinedSelectors: juicePassthrough.removeInlinedSelectors ?? true,\n      applyWidthAttributes: juicePassthrough.applyWidthAttributes ?? true,\n      applyHeightAttributes: juicePassthrough.applyHeightAttributes ?? true,\n      preservedSelectors: safelist ?? [],\n      ...customCSS ? { extraCss: customCSS } : {},\n      inlineDuplicateProperties: juicePassthrough.inlineDuplicateProperties ?? true,\n      ...juicePassthrough,\n    }\n\n    inlinedHtml = juice(serialized, juiceOptions)\n  } catch {\n    // If Juice fails, return the dom unchanged\n    return dom\n  }\n\n  const result = parse(inlinedHtml)\n\n  if (preferUnitlessValues) {\n    walk(result, (node) => {\n      const el = node as Element\n      if (el.attribs?.style) {\n        el.attribs.style = el.attribs.style.replace(\n          /\\b0(px|rem|em|%|vh|vw|vmin|vmax|in|cm|mm|pt|pc|ex|ch)\\b/g,\n          '0'\n        )\n      }\n    })\n  }\n\n  /**\n   * Restore `embed` from our marker so the purge step can detect\n   * these tags and skip them. Drop `data-embed` (juice's name)\n   * since it's redundant once `embed` is back, and let purge\n   * strip `embed` itself at the end of its run.\n   */\n  walk(result, (node) => {\n    const el = node as Element\n    if (el.name === 'style' && el.attribs && 'data-maizzle-embed' in el.attribs) {\n      /**\n       * Only restore `embed` when the original signal was embed/data-embed —\n       * an `amp-custom` style was tagged for juice's benefit only and\n       * must not pick up a stray `embed` attribute in the rendered\n       * output.\n       */\n      if (!('amp-custom' in el.attribs)) {\n        el.attribs.embed = ''\n      }\n      delete el.attribs['data-embed']\n      delete el.attribs['data-maizzle-embed']\n    }\n  })\n\n  return result\n}\n"],"mappings":";;;;;;;AAIA,MAAM,sBAAsB,EAAE,GAAG,MAAM,WAAW;;;;;;;;;;;;;;;AAwElD,SAAgB,UAAU,MAAc,UAA4B,CAAC,GAAW;CAC9E,OAAO,UAAU,aAAa,MAAM,IAAI,GAAG,OAAO,CAAC;AACrD;;;;;;AAOA,SAAgB,aAAa,KAAkB,UAA4B,CAAC,GAAgB;CAC1F,MAAM,EACJ,uBAAuB,MACvB,UACA,YAAY,IACZ,kBACA,oBACA,eACA,gBACA,YACA,GAAG,qBACD;CAGJ,MAAM,mBAAmB,oBAAoB,CAAC;CAC9C,MAAM,qBAAqB,CAAC,eAAe,GAAI,sBAAsB,CAAC,CAAE;CACxE,MAAM,iBAAiB,iBAAiB,CAAC,OAAO,OAAO,EAAA,CAAG,KAAI,MAAK,EAAE,YAAY,CAAC;CAClF,MAAM,kBAAkB,kBAAkB,CAAC,OAAO,OAAO,EAAA,CAAG,KAAI,MAAK,EAAE,YAAY,CAAC;CAIpF,MAAM,aAAa,EAAE,GAAG,oBAAoB;CAC5C,IAAI,cAAc,OAAO,eAAe,UACtC,OAAO,QAAQ,UAAU,CAAC,CAAC,SAAS,CAAC,KAAK,WAAW;EACnD,IAAI,MAAM,SAAS,MAAM,KACvB,MAAM,WAAW,OAAO;CAE5B,CAAC;;;;;;;;CAUH,KAAK,MAAM,SAAS;EAClB,MAAM,KAAK;EACX,IAAI,GAAG,SAAS,WAAW,GAAG,SAAS;;;;;;GAMrC,IAAI,gBAAgB,GAAG,WAAW,EAAE,gBAAgB,GAAG,UACrD,GAAG,QAAQ,gBAAgB;;;;;GAM7B,IAAI,WAAW,GAAG,WAAW,EAAE,gBAAgB,GAAG,UAChD,GAAG,QAAQ,gBAAgB;GAE7B,IAAI,gBAAgB,GAAG,WAAW,EAAE,WAAW,GAAG,YAAY,EAAE,gBAAgB,GAAG,UACjF,GAAG,QAAQ,QAAQ;GAIrB,IAAI,gBAAgB,GAAG,SACrB,GAAG,QAAQ,wBAAwB;EAEvC;CACF,CAAC;CAGD,MAAM,aAAa,UAAU,GAAG;CAEhC,IAAI;CAEJ,IAAI;EAYF,cAAc,MAAM,YAAY;GAV9B,iBAAiB,iBAAiB,mBAAmB;GACrD,wBAAwB,iBAAiB,0BAA0B;GACnE,sBAAsB,iBAAiB,wBAAwB;GAC/D,uBAAuB,iBAAiB,yBAAyB;GACjE,oBAAoB,YAAY,CAAC;GACjC,GAAG,YAAY,EAAE,UAAU,UAAU,IAAI,CAAC;GAC1C,2BAA2B,iBAAiB,6BAA6B;GACzE,GAAG;EAGsC,CAAC;CAC9C,QAAQ;EAEN,OAAO;CACT;CAEA,MAAM,SAAS,MAAM,WAAW;CAEhC,IAAI,sBACF,KAAK,SAAS,SAAS;EACrB,MAAM,KAAK;EACX,IAAI,GAAG,SAAS,OACd,GAAG,QAAQ,QAAQ,GAAG,QAAQ,MAAM,QAClC,4DACA,GACF;CAEJ,CAAC;;;;;;;CASH,KAAK,SAAS,SAAS;EACrB,MAAM,KAAK;EACX,IAAI,GAAG,SAAS,WAAW,GAAG,WAAW,wBAAwB,GAAG,SAAS;;;;;;;GAO3E,IAAI,EAAE,gBAAgB,GAAG,UACvB,GAAG,QAAQ,QAAQ;GAErB,OAAO,GAAG,QAAQ;GAClB,OAAO,GAAG,QAAQ;EACpB;CACF,CAAC;CAED,OAAO;AACT"}

package/dist/transformers/inlineLink.d.ts

@@ -0,0 +1,35 @@
+import { ChildNode } from "domhandler";
+
+//#region src/transformers/inlineLink.d.ts
+/**
+ * Inline `<link rel="stylesheet">` tags as `<style>` tags.
+ *
+ * - Local file paths are inlined when `filePath` is provided (resolved
+ *   relative to it).
+ * - Remote URLs (`http://` / `https://`) are only inlined when the link
+ *   carries an `inline` attribute, e.g. `<link rel="stylesheet" inline href="…">`.
+ *
+ * @param html     HTML string to transform.
+ * @param filePath Path of the source file the HTML came from, used as the
+ *                 base for resolving relative `href` values. Required for
+ *                 local-file inlining; remote `inline` links work without it.
+ * @returns        The transformed HTML string.
+ *
+ * @example
+ * import { inlineLink } from '@maizzle/framework'
+ *
+ * const out = await inlineLink(
+ *   '<link rel="stylesheet" href="./styles.css">',
+ *   '/path/to/template.html',
+ * )
+ */
+declare function inlineLink(html: string, filePath?: string): Promise<string>;
+/**
+ * DOM-form of {@link inlineLink} used by the internal transformer pipeline.
+ * Takes a parsed DOM, returns a parsed DOM — avoids redundant
+ * serialize/parse round-trips when chained with other transformers.
+ */
+declare function inlineLinkDom(dom: ChildNode[], filePath?: string): Promise<ChildNode[]>;
+//#endregion
+export { inlineLink, inlineLinkDom };
+//# sourceMappingURL=inlineLink.d.ts.map

package/dist/transformers/inlineLink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inlineLink.d.ts","names":[],"sources":["../../src/transformers/inlineLink.ts"],"mappings":";;;;;AA2BA;;;;;;;;AAA0E;AAS1E;;;;;;;;;;;iBATsB,UAAA,CAAW,IAAA,UAAc,QAAA,YAAoB,OAAO;;;AASiB;;;iBAArE,aAAA,CAAc,GAAA,EAAK,SAAA,IAAa,QAAA,YAAoB,OAAA,CAAQ,SAAA"}

package/dist/transformers/{inlineLink.mjs → inlineLink.js}

@@ -1,22 +1,46 @@
-import { walk } from "../utils/ast/walker.mjs";
-import "../utils/ast/index.mjs";
+import { parse as parse$1 } from "../utils/ast/parser.js";
+import { walk } from "../utils/ast/walker.js";
+import { serialize } from "../utils/ast/serializer.js";
+import "../utils/ast/index.js";
 import { readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-
 //#region src/transformers/inlineLink.ts
 /**
 * Inline `<link rel="stylesheet">` tags as `<style>` tags.
 *
-* - Local file paths are always inlined (resolved relative to the template)
-* - Remote URLs (http/https) are only inlined if the `inline` attribute is present
-* - Runs before the tailwindcss transformer so CSS is compiled normally
+* - Local file paths are inlined when `filePath` is provided (resolved
+*   relative to it).
+* - Remote URLs (`http://` / `https://`) are only inlined when the link
+*   carries an `inline` attribute, e.g. `<link rel="stylesheet" inline href="…">`.
+*
+* @param html     HTML string to transform.
+* @param filePath Path of the source file the HTML came from, used as the
+*                 base for resolving relative `href` values. Required for
+*                 local-file inlining; remote `inline` links work without it.
+* @returns        The transformed HTML string.
+*
+* @example
+* import { inlineLink } from '@maizzle/framework'
+*
+* const out = await inlineLink(
+*   '<link rel="stylesheet" href="./styles.css">',
+*   '/path/to/template.html',
+* )
 */
-async function inlineLink(dom, filePath) {
+async function inlineLink(html, filePath) {
+	return serialize(await inlineLinkDom(parse$1(html), filePath));
+}
+/**
+* DOM-form of {@link inlineLink} used by the internal transformer pipeline.
+* Takes a parsed DOM, returns a parsed DOM — avoids redundant
+* serialize/parse round-trips when chained with other transformers.
+*/
+async function inlineLinkDom(dom, filePath) {
 	const links = [];
 	walk(dom, (node) => {
 		if (node.name !== "link") return;
 		const el = node;
-		const attrs = el.attribs || {};
+		const attrs = el.attribs;
 		if (attrs.rel !== "stylesheet" || !attrs.href) return;
 		const parent = el.parent;
 		if (parent && "children" in parent) {
@@ -70,7 +94,7 @@ async function inlineLink(dom, filePath) {
 	}
 	return dom;
 }
-
 //#endregion
-export { inlineLink };
-//# sourceMappingURL=inlineLink.mjs.map
+export { inlineLink, inlineLinkDom };
+
+//# sourceMappingURL=inlineLink.js.map

package/dist/transformers/inlineLink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inlineLink.js","names":["parse"],"sources":["../../src/transformers/inlineLink.ts"],"sourcesContent":["import { readFileSync } from 'node:fs'\nimport { resolve, dirname } from 'node:path'\nimport type { ChildNode, Element } from 'domhandler'\nimport { parse, serialize, walk } from '../utils/ast/index.ts'\n\n/**\n * Inline `<link rel=\"stylesheet\">` tags as `<style>` tags.\n *\n * - Local file paths are inlined when `filePath` is provided (resolved\n *   relative to it).\n * - Remote URLs (`http://` / `https://`) are only inlined when the link\n *   carries an `inline` attribute, e.g. `<link rel=\"stylesheet\" inline href=\"…\">`.\n *\n * @param html     HTML string to transform.\n * @param filePath Path of the source file the HTML came from, used as the\n *                 base for resolving relative `href` values. Required for\n *                 local-file inlining; remote `inline` links work without it.\n * @returns        The transformed HTML string.\n *\n * @example\n * import { inlineLink } from '@maizzle/framework'\n *\n * const out = await inlineLink(\n *   '<link rel=\"stylesheet\" href=\"./styles.css\">',\n *   '/path/to/template.html',\n * )\n */\nexport async function inlineLink(html: string, filePath?: string): Promise<string> {\n  return serialize(await inlineLinkDom(parse(html), filePath))\n}\n\n/**\n * DOM-form of {@link inlineLink} used by the internal transformer pipeline.\n * Takes a parsed DOM, returns a parsed DOM — avoids redundant\n * serialize/parse round-trips when chained with other transformers.\n */\nexport async function inlineLinkDom(dom: ChildNode[], filePath?: string): Promise<ChildNode[]> {\n  const links: { node: Element; parent: ChildNode; index: number }[] = []\n\n  walk(dom, (node) => {\n    if ((node as Element).name !== 'link') return\n\n    const el = node as Element\n    const attrs = el.attribs\n\n    if (attrs.rel !== 'stylesheet' || !attrs.href) return\n\n    const parent = el.parent as ChildNode\n\n    if (parent && 'children' in parent) {\n      const index = (parent.children as ChildNode[]).indexOf(el)\n      if (index !== -1) {\n        links.push({ node: el, parent, index })\n      }\n    } else {\n      // Top-level node\n      const index = dom.indexOf(el)\n      if (index !== -1) {\n        links.push({ node: el, parent: null as any, index })\n      }\n    }\n  })\n\n  for (const { node, parent, index } of links) {\n    const href = node.attribs.href\n    const isRemote = href.startsWith('http://') || href.startsWith('https://')\n\n    let css: string | undefined\n\n    if (isRemote) {\n      if (!('inline' in node.attribs)) continue\n\n      try {\n        const response = await fetch(href)\n        css = await response.text()\n      } catch {\n        continue\n      }\n    } else {\n      if (!filePath) continue\n\n      try {\n        const absolutePath = resolve(dirname(filePath), href)\n        css = readFileSync(absolutePath, 'utf8')\n      } catch {\n        continue\n      }\n    }\n\n    const styleNode = {\n      type: 'tag',\n      name: 'style',\n      attribs: {},\n      children: [{\n        type: 'text',\n        data: css,\n        parent: null as any,\n      }],\n      parent: parent || null,\n    } as any\n\n    // Set parent reference on the text child\n    styleNode.children[0].parent = styleNode\n\n    const siblings = parent && 'children' in parent\n      ? parent.children as ChildNode[]\n      : dom\n\n    siblings.splice(index, 1, styleNode)\n  }\n\n  return dom\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,eAAsB,WAAW,MAAc,UAAoC;CACjF,OAAO,UAAU,MAAM,cAAcA,QAAM,IAAI,GAAG,QAAQ,CAAC;AAC7D;;;;;;AAOA,eAAsB,cAAc,KAAkB,UAAyC;CAC7F,MAAM,QAA+D,CAAC;CAEtE,KAAK,MAAM,SAAS;EAClB,IAAK,KAAiB,SAAS,QAAQ;EAEvC,MAAM,KAAK;EACX,MAAM,QAAQ,GAAG;EAEjB,IAAI,MAAM,QAAQ,gBAAgB,CAAC,MAAM,MAAM;EAE/C,MAAM,SAAS,GAAG;EAElB,IAAI,UAAU,cAAc,QAAQ;GAClC,MAAM,QAAS,OAAO,SAAyB,QAAQ,EAAE;GACzD,IAAI,UAAU,IACZ,MAAM,KAAK;IAAE,MAAM;IAAI;IAAQ;GAAM,CAAC;EAE1C,OAAO;GAEL,MAAM,QAAQ,IAAI,QAAQ,EAAE;GAC5B,IAAI,UAAU,IACZ,MAAM,KAAK;IAAE,MAAM;IAAI,QAAQ;IAAa;GAAM,CAAC;EAEvD;CACF,CAAC;CAED,KAAK,MAAM,EAAE,MAAM,QAAQ,WAAW,OAAO;EAC3C,MAAM,OAAO,KAAK,QAAQ;EAC1B,MAAM,WAAW,KAAK,WAAW,SAAS,KAAK,KAAK,WAAW,UAAU;EAEzE,IAAI;EAEJ,IAAI,UAAU;GACZ,IAAI,EAAE,YAAY,KAAK,UAAU;GAEjC,IAAI;IAEF,MAAM,OAAM,MADW,MAAM,IAAI,EAAA,CACZ,KAAK;GAC5B,QAAQ;IACN;GACF;EACF,OAAO;GACL,IAAI,CAAC,UAAU;GAEf,IAAI;IAEF,MAAM,aADe,QAAQ,QAAQ,QAAQ,GAAG,IAClB,GAAG,MAAM;GACzC,QAAQ;IACN;GACF;EACF;EAEA,MAAM,YAAY;GAChB,MAAM;GACN,MAAM;GACN,SAAS,CAAC;GACV,UAAU,CAAC;IACT,MAAM;IACN,MAAM;IACN,QAAQ;GACV,CAAC;GACD,QAAQ,UAAU;EACpB;EAGA,UAAU,SAAS,EAAE,CAAC,SAAS;EAM/B,CAJiB,UAAU,cAAc,SACrC,OAAO,WACP,IAAA,CAEK,OAAO,OAAO,GAAG,SAAS;CACrC;CAEA,OAAO;AACT"}

package/dist/transformers/minify.d.ts

@@ -0,0 +1,21 @@
+import { Opts, Opts as MinifyOptions } from "html-crush";
+
+//#region src/transformers/minify.d.ts
+/**
+ * Minify an HTML string using `html-crush`. Maizzle's only default that
+ * differs from html-crush's own defaults is `removeLineBreaks: true`.
+ *
+ * @param html    HTML string to minify.
+ * @param options [html-crush options](https://codsen.com/os/html-crush) merged
+ *                on top of the Maizzle defaults.
+ * @returns       The minified HTML string.
+ *
+ * @example
+ * import { minify } from '@maizzle/framework'
+ *
+ * const tight = minify('<p>  hello  </p>', { removeIndentations: true })
+ */
+declare function minify(html: string, options?: Partial<Opts>): string;
+//#endregion
+export { type MinifyOptions, minify };
+//# sourceMappingURL=minify.d.ts.map

package/dist/transformers/minify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minify.d.ts","names":[],"sources":["../../src/transformers/minify.ts"],"mappings":";;;;AAwBA;;;;;;;;;AAA4E;;;;iBAA5D,MAAA,CAAO,IAAA,UAAc,OAAA,GAAS,OAAO,CAAC,IAAA"}

package/dist/transformers/minify.js

@@ -0,0 +1,25 @@
+import { defu as defu$1 } from "defu";
+import { crush } from "html-crush";
+//#region src/transformers/minify.ts
+const DEFAULT_OPTIONS = { removeLineBreaks: true };
+/**
+* Minify an HTML string using `html-crush`. Maizzle's only default that
+* differs from html-crush's own defaults is `removeLineBreaks: true`.
+*
+* @param html    HTML string to minify.
+* @param options [html-crush options](https://codsen.com/os/html-crush) merged
+*                on top of the Maizzle defaults.
+* @returns       The minified HTML string.
+*
+* @example
+* import { minify } from '@maizzle/framework'
+*
+* const tight = minify('<p>  hello  </p>', { removeIndentations: true })
+*/
+function minify(html, options = {}) {
+	return crush(html, defu$1(options, DEFAULT_OPTIONS)).result;
+}
+//#endregion
+export { minify };
+
+//# sourceMappingURL=minify.js.map

package/dist/transformers/minify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minify.js","names":["merge"],"sources":["../../src/transformers/minify.ts"],"sourcesContent":["import { crush } from 'html-crush'\nimport { defu as merge } from 'defu'\nimport type { Opts as HtmlCrushOptions } from 'html-crush'\n\nexport type { Opts as MinifyOptions } from 'html-crush'\n\nconst DEFAULT_OPTIONS: Partial<HtmlCrushOptions> = {\n  removeLineBreaks: true,\n}\n\n/**\n * Minify an HTML string using `html-crush`. Maizzle's only default that\n * differs from html-crush's own defaults is `removeLineBreaks: true`.\n *\n * @param html    HTML string to minify.\n * @param options [html-crush options](https://codsen.com/os/html-crush) merged\n *                on top of the Maizzle defaults.\n * @returns       The minified HTML string.\n *\n * @example\n * import { minify } from '@maizzle/framework'\n *\n * const tight = minify('<p>  hello  </p>', { removeIndentations: true })\n */\nexport function minify(html: string, options: Partial<HtmlCrushOptions> = {}): string {\n  const merged = merge(options, DEFAULT_OPTIONS) as Partial<HtmlCrushOptions>\n  return crush(html, merged).result\n}\n"],"mappings":";;;AAMA,MAAM,kBAA6C,EACjD,kBAAkB,KACpB;;;;;;;;;;;;;;;AAgBA,SAAgB,OAAO,MAAc,UAAqC,CAAC,GAAW;CAEpF,OAAO,MAAM,MADEA,OAAM,SAAS,eACN,CAAC,CAAC,CAAC;AAC7B"}

package/dist/transformers/minifyCodeInline.d.ts

@@ -0,0 +1,29 @@
+//#region src/transformers/minifyCodeInline.d.ts
+/**
+ * Restore HTML inside elements marked `data-minify-inline`, then strip the
+ * marker attribute and trim formatter-injected whitespace.
+ *
+ * Named for its primary client, `<CodeInline theme="…">`. The component
+ * replaces shiki's structural `<`/`>` with private markers `§MZLT§` /
+ * `§MZGT§` so the format pass (oxfmt with `htmlWhitespaceSensitivity:
+ * 'ignore'`) can't see them as real angle brackets and reflow the
+ * chain of `<span>` tokens. Source-level entities like `&lt;` (a
+ * literal `<` in the user's code) are made of `&`, `l`, `t`, `;` —
+ * no real `<` — so they pass through this pipeline untouched and
+ * land in the browser as entities, rendering correctly as `<`.
+ *
+ * Runs unconditionally near the end of the pipeline so:
+ *   1. The markers always get decoded back to real `<` / `>`.
+ *   2. The `data-minify-inline` attribute never leaks to final HTML
+ *      (whether or not the inner content had markers).
+ *   3. Whitespace the formatter injected around the inner content
+ *      (e.g. between `<code>` and the text node) is trimmed so the
+ *      inline element lands flush.
+ *
+ * The marker attribute is intentionally generic so any component facing
+ * the same formatter-vs-inline-structure problem can opt in.
+ */
+declare function minifyCodeInline(html: string): string;
+//#endregion
+export { minifyCodeInline };
+//# sourceMappingURL=minifyCodeInline.d.ts.map

package/dist/transformers/minifyCodeInline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minifyCodeInline.d.ts","names":[],"sources":["../../src/transformers/minifyCodeInline.ts"],"mappings":";;AAwBA;;;;AAA6C;;;;;;;;;;;;;;;;;;;iBAA7B,gBAAA,CAAiB,IAAY"}

package/dist/transformers/minifyCodeInline.js

@@ -0,0 +1,36 @@
+//#region src/transformers/minifyCodeInline.ts
+/**
+* Restore HTML inside elements marked `data-minify-inline`, then strip the
+* marker attribute and trim formatter-injected whitespace.
+*
+* Named for its primary client, `<CodeInline theme="…">`. The component
+* replaces shiki's structural `<`/`>` with private markers `§MZLT§` /
+* `§MZGT§` so the format pass (oxfmt with `htmlWhitespaceSensitivity:
+* 'ignore'`) can't see them as real angle brackets and reflow the
+* chain of `<span>` tokens. Source-level entities like `&lt;` (a
+* literal `<` in the user's code) are made of `&`, `l`, `t`, `;` —
+* no real `<` — so they pass through this pipeline untouched and
+* land in the browser as entities, rendering correctly as `<`.
+*
+* Runs unconditionally near the end of the pipeline so:
+*   1. The markers always get decoded back to real `<` / `>`.
+*   2. The `data-minify-inline` attribute never leaks to final HTML
+*      (whether or not the inner content had markers).
+*   3. Whitespace the formatter injected around the inner content
+*      (e.g. between `<code>` and the text node) is trimmed so the
+*      inline element lands flush.
+*
+* The marker attribute is intentionally generic so any component facing
+* the same formatter-vs-inline-structure problem can opt in.
+*/
+function minifyCodeInline(html) {
+	if (!html.includes("data-minify-inline")) return html;
+	return html.replace(/<([a-zA-Z][\w-]*)([^>]*?)\s+data-minify-inline(?:="[^"]*")?([^>]*)>([\s\S]*?)<\/\1>/g, (_full, tag, before, after, contents) => {
+		const cleanedAttrs = `${before}${after}`.replace(/\s+/g, " ").trim();
+		return `${cleanedAttrs ? `<${tag} ${cleanedAttrs}>` : `<${tag}>`}${contents.replace(/§MZLT§/g, "<").replace(/§MZGT§/g, ">").trim()}</${tag}>`;
+	});
+}
+//#endregion
+export { minifyCodeInline };
+
+//# sourceMappingURL=minifyCodeInline.js.map

package/dist/transformers/minifyCodeInline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minifyCodeInline.js","names":[],"sources":["../../src/transformers/minifyCodeInline.ts"],"sourcesContent":["/**\n * Restore HTML inside elements marked `data-minify-inline`, then strip the\n * marker attribute and trim formatter-injected whitespace.\n *\n * Named for its primary client, `<CodeInline theme=\"…\">`. The component\n * replaces shiki's structural `<`/`>` with private markers `§MZLT§` /\n * `§MZGT§` so the format pass (oxfmt with `htmlWhitespaceSensitivity:\n * 'ignore'`) can't see them as real angle brackets and reflow the\n * chain of `<span>` tokens. Source-level entities like `&lt;` (a\n * literal `<` in the user's code) are made of `&`, `l`, `t`, `;` —\n * no real `<` — so they pass through this pipeline untouched and\n * land in the browser as entities, rendering correctly as `<`.\n *\n * Runs unconditionally near the end of the pipeline so:\n *   1. The markers always get decoded back to real `<` / `>`.\n *   2. The `data-minify-inline` attribute never leaks to final HTML\n *      (whether or not the inner content had markers).\n *   3. Whitespace the formatter injected around the inner content\n *      (e.g. between `<code>` and the text node) is trimmed so the\n *      inline element lands flush.\n *\n * The marker attribute is intentionally generic so any component facing\n * the same formatter-vs-inline-structure problem can opt in.\n */\nexport function minifyCodeInline(html: string): string {\n  if (!html.includes('data-minify-inline')) return html\n\n  return html.replace(\n    /<([a-zA-Z][\\w-]*)([^>]*?)\\s+data-minify-inline(?:=\"[^\"]*\")?([^>]*)>([\\s\\S]*?)<\\/\\1>/g,\n    (_full, tag, before, after, contents) => {\n      const cleanedAttrs = `${before}${after}`.replace(/\\s+/g, ' ').trim()\n      const open = cleanedAttrs ? `<${tag} ${cleanedAttrs}>` : `<${tag}>`\n      const decoded = contents\n        .replace(/§MZLT§/g, '<')\n        .replace(/§MZGT§/g, '>')\n        .trim()\n      return `${open}${decoded}</${tag}>`\n    },\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,iBAAiB,MAAsB;CACrD,IAAI,CAAC,KAAK,SAAS,oBAAoB,GAAG,OAAO;CAEjD,OAAO,KAAK,QACV,yFACC,OAAO,KAAK,QAAQ,OAAO,aAAa;EACvC,MAAM,eAAe,GAAG,SAAS,QAAQ,QAAQ,QAAQ,GAAG,CAAC,CAAC,KAAK;EAMnE,OAAO,GALM,eAAe,IAAI,IAAI,GAAG,aAAa,KAAK,IAAI,IAAI,KACjD,SACb,QAAQ,WAAW,GAAG,CAAC,CACvB,QAAQ,WAAW,GAAG,CAAC,CACvB,KACoB,EAAE,IAAI,IAAI;CACnC,CACF;AACF"}

package/dist/transformers/msoPlaceholders.d.ts

@@ -0,0 +1,33 @@
+import { ChildNode } from "domhandler";
+
+//#region src/transformers/msoPlaceholders.d.ts
+/**
+ * Resolve all `__MAIZZLE_MSO*__` placeholders inside MSO conditional comments
+ * by reading inlined style + `data-*` markers on the paired elements.
+ *
+ * Two placeholder families:
+ *
+ * MSOW (`__MAIZZLE_MSOW_{id}__`) — emitted by `<Container>` and `<Section>`.
+ *   Source element is marked with `data-maizzle-msow-id`. Reads inlined
+ *   `max-width:` (falls back to `width:`) and normalizes to px. Falls
+ *   back to `data-maizzle-msow-fallback` (default `600px`) when the
+ *   value can't be parsed.
+ *
+ * MSOTDSTYLE (`__MAIZZLE_MSOTDSTYLE_{id}__`) — emitted by `<Container>` and
+ *   `<Section>`'s MSO `<td>`. Source element is marked with
+ *   `data-maizzle-mso-td-id`. Extracts from the inlined style:
+ *     - `background-color` (always, when present) so Word paints the cell.
+ *     - `padding*` (only when no horizontal border on the element, since
+ *       Word drops div padding without a border and a copy would
+ *       double-pad with one).
+ *   Appends the `data-maizzle-mso-style` value (the user's `msoStyle`
+ *   prop) last so it wins on duplicates. Empty input resolves to ''
+ *   so the placeholder collapses cleanly.
+ *
+ * Single collect-walk + single substitute-walk: the same Container div
+ * carries both marker kinds, so one element visit fills both maps.
+ */
+declare function msoPlaceholders(dom: ChildNode[]): ChildNode[];
+//#endregion
+export { msoPlaceholders };
+//# sourceMappingURL=msoPlaceholders.d.ts.map

package/dist/transformers/msoPlaceholders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"msoPlaceholders.d.ts","names":[],"sources":["../../src/transformers/msoPlaceholders.ts"],"mappings":";;;;;AA8CA;;;;;;;;AAA4D;;;;;;;;;;;;;;;;iBAA5C,eAAA,CAAgB,GAAA,EAAK,SAAA,KAAc,SAAS"}