@samva/markup 0.9.0 → 0.10.0

package/dist/render-BPonDpCl.d.ts

@@ -0,0 +1,539 @@
+import { r as JsxSourceLocation } from "./source-locations-C8wCsiAy.js";
+import { r as EmailDiagnostic } from "./diagnostics-B-Gym34R.js";
+import { r as EmailNode } from "./jsx-runtime-ylIOnaSf.js";
+import { n as EmailContent } from "./template-DMPwxMSq.js";
+import "css-tree";
+//#region src/ir.d.ts
+/** The IR version this package writes. A publication pins the version it was built with. */
+declare const SML_IR_VERSION = 1;
+/**
+ * Where a node came from: `[line, column]` in the entry file, or `[line, column, file]` with an
+ * index into `TemplateIr.sources` when the node came from an imported project file. Published
+ * sends strip these.
+ */
+type IrSource = readonly [line: number, column: number, file?: number];
+/**
+ * A value read at render time.
+ *
+ * - a string, number, boolean or `null` is a literal;
+ * - `bind` reads the input: `"order.id"` is a path from the input root, `"$item.title"` a path
+ *   from the enclosing `each` variable named `item` (the `$` prefix keeps loop variables from
+ *   colliding with input fields);
+ * - `lit` is a literal object or array, for formatter options;
+ * - `concat` joins the text of its parts (a template string);
+ * - `format` calls one formatter from `@samva/markup/fmt`;
+ * - `if` selects between two values (a conditional attribute or class);
+ * - `op` is arithmetic, allowed inside formatter arguments and conditions;
+ * - `length` is `.length` of a bound array or string;
+ * - `count` is `.filter(...).length`: the items of an array that satisfy a condition.
+ */
+type IrValue = string | number | boolean | null | {
+  readonly bind: string;
+} | {
+  readonly lit: unknown;
+} | {
+  readonly concat: readonly IrValue[];
+} | {
+  readonly format: IrFormatter;
+  readonly args: readonly IrValue[];
+} | {
+  readonly if: IrPredicate;
+  readonly then: IrValue;
+  readonly else: IrValue;
+} | {
+  readonly op: IrArithmetic;
+  readonly args: readonly [IrValue, IrValue];
+} | {
+  readonly length: IrValue;
+} |
+/** How many items of a bound array satisfy `where`, with each item bound as `$as` while it runs. */
+{
+  readonly count: IrValue;
+  readonly as: string;
+  readonly where: IrPredicate;
+};
+type IrFormatter = "money" | "number" | "date" | "time" | "plural" | "list";
+type IrArithmetic = "+" | "-" | "*" | "/" | "%";
+type IrComparison = "eq" | "ne" | "lt" | "gt" | "le" | "ge";
+/** A condition over the input. Truthiness follows JavaScript: `""`, `0`, `null` and absent are false. */
+type IrPredicate =
+/** The bound value at this path is truthy. */
+{
+  readonly present: string;
+} |
+/** Any value is truthy. */
+{
+  readonly truthy: IrValue;
+} | {
+  readonly not: IrPredicate;
+} | {
+  readonly and: readonly IrPredicate[];
+} | {
+  readonly or: readonly IrPredicate[];
+} | {
+  readonly cmp: IrComparison;
+  readonly args: readonly [IrValue, IrValue];
+};
+/**
+ * An element's inline style. A string is fully static and was checked at compile time; a list
+ * carries declarations whose values are read at render time; `if` selects between two styles.
+ */
+type IrStyle = string | readonly (readonly [property: string, value: IrValue])[] | {
+  readonly if: IrPredicate;
+  readonly then: IrStyle;
+  readonly else: IrStyle;
+};
+/** A part of compatibility markup the primitives emit verbatim. */
+type IrRawPart = string | {
+  readonly attr: IrValue;
+} | {
+  readonly text: IrValue;
+};
+interface IrElement {
+  readonly el: string;
+  readonly attrs?: Readonly<Record<string, IrValue>>;
+  readonly style?: IrStyle;
+  readonly children?: readonly IrNode[];
+  /**
+   * Set by the compiler on the elements `BrandFooter` writes: only they may carry the reserved
+   * footer markers, so an element the author wrote cannot claim a footer the send path would
+   * then not append.
+   */
+  readonly reserved?: true;
+  readonly src?: IrSource;
+}
+/** Content that appears when the predicate holds, or else `else`. */
+interface IrIf {
+  readonly if: IrPredicate;
+  readonly then: readonly IrNode[];
+  readonly else?: readonly IrNode[];
+  readonly src?: IrSource;
+}
+/**
+ * Repeat `children` for each item of a bound array.
+ *
+ * `where` skips the items that fail a condition (`.filter(...)`), with the item bound as `$as`.
+ * `chunk` groups the items into consecutive slices of that size instead: the loop variable `$as`
+ * then holds one slice, an array, and the last slice may be shorter. Filtering applies first.
+ */
+interface IrEach {
+  readonly each: IrValue;
+  /** The loop variable, referenced as `$as.field`. */
+  readonly as: string;
+  /** The zero-based index variable, referenced as `$index`. */
+  readonly index?: string;
+  readonly where?: IrPredicate;
+  readonly chunk?: number;
+  readonly children: readonly IrNode[];
+  readonly src?: IrSource;
+}
+/**
+ * Compatibility markup the email primitives emit verbatim (conditional comments, VML). Bound
+ * parts are escaped for the context they sit in. `text` is what the plain-text part reads.
+ */
+interface IrRaw {
+  readonly raw: readonly IrRawPart[];
+  readonly text?: IrValue;
+  readonly src?: IrSource;
+}
+/** Where the hidden inbox-preview block goes; it renders the channel's `preheader`. */
+interface IrPreheader {
+  readonly preheader: true;
+}
+/** A node in an email body. A bare value in child position is rendered as escaped text. */
+type IrNode = IrValue | IrElement | IrIf | IrEach | IrRaw | IrPreheader;
+interface IrEmail {
+  readonly subject: IrValue;
+  readonly preheader?: IrValue;
+  readonly body: IrNode;
+}
+/** A plain-text channel body: text pieces, conditionals and loops. */
+interface IrSms {
+  readonly category?: string;
+  readonly body: readonly IrNode[];
+}
+type IrWhatsAppButton = {
+  readonly type: "quick-reply";
+  readonly text: IrValue;
+} | {
+  readonly type: "url";
+  readonly text: IrValue;
+  readonly url: IrValue;
+} | {
+  readonly type: "phone";
+  readonly text: IrValue;
+  readonly phone: IrValue;
+} | {
+  readonly type: "copy-code";
+  readonly code: IrValue;
+};
+/** A button, or buttons that appear when a condition over the input holds. */
+type IrWhatsAppButtonNode = IrWhatsAppButton | {
+  readonly if: IrPredicate;
+  readonly then: readonly IrWhatsAppButtonNode[];
+  readonly else?: readonly IrWhatsAppButtonNode[];
+  readonly src?: IrSource;
+};
+interface IrWhatsApp {
+  readonly name?: string;
+  readonly category: string;
+  readonly language: string;
+  /** For a media header, `content` is the media URL. */
+  readonly header?: {
+    readonly type: "text" | "image" | "video" | "document";
+    readonly content: readonly IrNode[];
+  };
+  readonly body: readonly IrNode[];
+  readonly footer?: readonly IrNode[];
+  readonly buttons?: readonly IrWhatsAppButtonNode[];
+}
+interface TemplateIr {
+  readonly sml: typeof SML_IR_VERSION;
+  readonly template: string;
+  readonly locale?: string;
+  /** Project paths that `IrSource` file indexes name; index 0 is the entry. */
+  readonly sources?: readonly string[];
+  readonly email?: IrEmail;
+  readonly sms?: IrSms;
+  readonly whatsapp?: IrWhatsApp;
+  /** The portable JSON Schema every send's input is validated against. */
+  readonly schema: Readonly<Record<string, unknown>>;
+}
+/** How the renderer resolves formatters that take no explicit locale or time zone. */
+interface RenderOptions {
+  /** Overrides the template's `locale`. */
+  readonly locale?: string;
+  /** IANA time zone; defaults to UTC. */
+  readonly timeZone?: string;
+  /** Also return where each element landed in the HTML, for mapping findings back to source. */
+  readonly positions?: boolean;
+}
+/** One rendered element's offset range in the HTML, and the source it was lowered from. */
+interface RenderedPosition {
+  readonly start: number;
+  readonly end: number;
+  readonly tag: string;
+  readonly src?: IrSource;
+}
+interface RenderedIrEmail {
+  readonly subject: string;
+  readonly preheader: string | undefined;
+  readonly html: string;
+  readonly text: string;
+  /** Present when the render asked for `positions`. */
+  readonly positions?: readonly RenderedPosition[];
+}
+type RenderedWhatsAppButton = {
+  readonly type: "quick-reply";
+  readonly text: string;
+} | {
+  readonly type: "url";
+  readonly text: string;
+  readonly url: string;
+} | {
+  readonly type: "phone";
+  readonly text: string;
+  readonly phone: string;
+} | {
+  readonly type: "copy-code";
+  readonly code: string;
+};
+/** A WhatsApp message with every text rendered and every conditional button resolved. */
+interface RenderedIrWhatsApp {
+  readonly name?: string;
+  readonly language: string;
+  readonly category: string;
+  /** For a media header, `text` is the media URL. */
+  readonly header?: {
+    readonly type: "text" | "image" | "video" | "document";
+    readonly text: string;
+  };
+  readonly body: string;
+  readonly footer?: string;
+  readonly buttons: readonly RenderedWhatsAppButton[];
+}
+//#endregion
+//#region src/preview.d.ts
+/**
+ * The attribute a preview stamps so a click in a rendered document resolves to exactly one
+ * rendered element. A delivered message never carries it.
+ */
+declare const INSTANCE_PATH_ATTRIBUTE = "data-samva-instance";
+/** Where one element sits in the emitted document, with the authoring that produced it. */
+interface EmittedPosition {
+  readonly start: number;
+  readonly end: number;
+  readonly origins: ReadonlyArray<JsxSourceLocation>;
+  /**
+   * Dot-separated element indices from the document root, assigned in document order. It is the
+   * identity of one rendered instance.
+   */
+  readonly instancePath: string;
+  readonly tag: string;
+  /** False when a compiler primitive generated this element. */
+  readonly authored: boolean;
+}
+/** One rendered element, and the authoring it came from. */
+interface EmailElementSelection {
+  /**
+   * Dot-separated element indices from the document root. It is the identity of one rendered
+   * instance, which is what tells two iterations of the same authored element apart: their
+   * origins are identical.
+   */
+  readonly instancePath: string;
+  readonly tag: string;
+  /**
+   * The authored JSX element. Empty when the compiler generated this element with no authoring
+   * behind it, the hidden preheader block for instance.
+   */
+  readonly origins: ReadonlyArray<JsxSourceLocation>;
+  /**
+   * False when a compiler primitive generated this element. `origins[0]` is then the authoring
+   * element that asked for it rather than this element itself, so the wrapper selects the
+   * primitive the author wrote.
+   */
+  readonly authored: boolean;
+  /** 1-based position among the rendered elements sharing this origin and tag. */
+  readonly occurrence: number;
+  /**
+   * How many rendered elements share that origin and tag. Above one, one piece of authoring
+   * produced several rendered elements (a loop, or a primitive that generates a repeated cell),
+   * so an edit there changes all of them.
+   */
+  readonly occurrences: number;
+  /** Absent for the document root. */
+  readonly parentPath?: string;
+  /** Offset range in the rendered HTML this selection was taken from. */
+  readonly start: number;
+  readonly end: number;
+}
+/** A render of one fixture for an editor: the delivered content plus the identity of every element. */
+interface IrPreview {
+  readonly subject: string;
+  readonly preheader: string | undefined;
+  /** Carries `INSTANCE_PATH_ATTRIBUTE` on every element. Preview-only. */
+  readonly html: string;
+  readonly text: string;
+  /** Every rendered element in document order. */
+  readonly selections: readonly EmailElementSelection[];
+}
+/**
+ * Turn one render's positions into selections, in document order. `occurrence` and `occurrences`
+ * count the rendered elements that share an authored origin and tag.
+ */
+declare const emailSelections: (positions: readonly EmittedPosition[]) => readonly EmailElementSelection[];
+/**
+ * Render one fixture with an instance path stamped on every element, and the selection each path
+ * resolves to. The selections come from the spans the compiler recorded, so a click on the canvas
+ * lands on the exact node of the source that produced it.
+ */
+declare const renderIrPreview: (ir: TemplateIr, input: unknown, options?: Omit<RenderOptions, "positions">) => IrPreview;
+/** Look selections up by the instance path a rendered document carries. */
+declare const emailSelectionIndex: (selections: readonly EmailElementSelection[]) => ReadonlyMap<string, EmailElementSelection>;
+/**
+ * The authoring element a selection edits. For an authored element that is the element itself; for
+ * a generated wrapper it is the primitive that asked for it. Undefined only where the compiler
+ * generated markup with no authoring behind it, which nothing can edit in place.
+ */
+declare const emailAuthoringTarget: (selection: EmailElementSelection) => JsxSourceLocation | undefined;
+/** Root-first ancestry of a selection, itself last. */
+declare const emailSelectionAncestry: (index: ReadonlyMap<string, EmailElementSelection>, instancePath: string) => readonly EmailElementSelection[];
+/**
+ * Every rendered instance produced by the same authored element, in document order. One entry
+ * means it rendered once; several mean it repeated.
+ */
+declare const emailSelectionSiblings: (selections: readonly EmailElementSelection[], selection: EmailElementSelection) => readonly EmailElementSelection[];
+/**
+ * Every rendered instance of the same authored element. A partial edited at its definition changes
+ * all of these, which is the scope a control has to name before it applies.
+ */
+declare const emailDefinitionInstances: (selections: readonly EmailElementSelection[], selection: EmailElementSelection) => readonly EmailElementSelection[];
+//#endregion
+//#region src/email/font-stacks.d.ts
+/** One `@font-face` rule, its `src` already resolved to served URLs. */
+interface FontFaceRule {
+  /** The family the rule declares, unquoted. */
+  readonly family: string;
+  /** The rule as it goes into the email's `<head>`. */
+  readonly css: string;
+}
+//#endregion
+//#region src/email/fonts.d.ts
+/**
+ * Maps a relative `src` URL, as authored, to the URL its project file is served
+ * from, or `undefined` when the project has no such file. The stylesheet's host
+ * owns this: it knows which file the stylesheet came from and the asset base.
+ */
+type FontFileResolver = (reference: string) => string | undefined;
+//#endregion
+//#region src/email/selectors.d.ts
+type EmailElementNode = Extract<EmailNode, {
+  type: "Element";
+}>;
+interface AttributeTest {
+  readonly name: string;
+  readonly operator?: string | undefined;
+  readonly value?: string | undefined;
+}
+interface Compound {
+  readonly tag?: string | undefined;
+  readonly id?: string | undefined;
+  readonly classes: readonly string[];
+  readonly attributes: readonly AttributeTest[];
+  /** A compound the matcher cannot evaluate — a pseudo-class, say — never matches. */
+  readonly opaque: boolean;
+}
+type Combinator = "descendant" | "child" | "adjacent" | "sibling";
+interface CompiledSelector {
+  /** Document order, left to right; each part names the combinator that follows it. */
+  readonly parts: readonly {
+    readonly compound: Compound;
+    readonly after?: Combinator;
+  }[];
+}
+/** An element together with the ancestors and preceding siblings a combinator needs. */
+interface Ancestry {
+  readonly element: EmailElementNode;
+  readonly parent: Ancestry | undefined;
+  readonly previous: readonly EmailElementNode[];
+}
+declare const classListOf: (element: EmailElementNode) => readonly string[];
+/** Match a compiled selector against one element in its tree position. */
+declare const matchesSelector: (selector: CompiledSelector | undefined, ancestry: Ancestry) => boolean;
+//#endregion
+//#region src/email/css.d.ts
+interface CssDeclaration {
+  /** Kebab-case property name, as authored. */
+  readonly property: string;
+  readonly value: string;
+  readonly important: boolean;
+}
+/** Specificity as the CSS triple (id, class/attribute/pseudo-class, type). */
+type Specificity = readonly [number, number, number];
+interface CssRule {
+  /** Exactly one selector; a selector list is split into one rule each. */
+  readonly selector: string;
+  /** Decoded class identifiers mentioned by this selector, including nested pseudo selectors. */
+  readonly classes: readonly string[];
+  readonly specificity: Specificity;
+  readonly declarations: readonly CssDeclaration[];
+  /** Position across every stylesheet, in the order they were imported. */
+  readonly order: number;
+  /** Declared `@layer` index; unlayered declarations sort above every layer. */
+  readonly layer: number;
+  /** Enclosing conditional at-rule preludes, outermost first. */
+  readonly conditions: readonly string[];
+  /** Unconditional and pseudo-free rules are the only ones that can become an inline style. */
+  readonly inlinable: boolean;
+  /** Compiled at build time so the render lane needs no CSS parser. */
+  readonly matcher: CompiledSelector | undefined;
+}
+interface Stylesheet {
+  readonly rules: readonly CssRule[];
+  /** `@page`, `@keyframes` and other at-rules kept verbatim in `<head>`. */
+  readonly headAtRules: readonly string[];
+  /** Validated `@font-face` rules, `src` resolved; the render hides them from classic Outlook. */
+  readonly fontFaces: readonly FontFaceRule[];
+  /** Unconditional custom properties, for resolving `var()` before inlining. */
+  readonly variables: Readonly<Record<string, string>>;
+  readonly diagnostics: readonly EmailDiagnostic[];
+}
+/** Compile a selector into the plain-data matcher the render lane uses. */
+declare const compileSelector: (selector: string) => CompiledSelector | undefined;
+/** Parse one stylesheet into rules, keeping layer, order and conditions. */
+declare const parseStylesheet: (source: string, options?: {
+  readonly origin?: string;
+  readonly startOrder?: number;
+  /** Resolves a relative `@font-face` src to the URL its project file is served from. */
+  readonly resolveFontFile?: FontFileResolver | undefined;
+  /**
+   * The sheet belongs to the project theme, whose `@import`s the Tailwind
+   * compile resolves; they are layering, not something to report here.
+   */
+  readonly themeImports?: boolean | undefined;
+}) => Stylesheet;
+//#endregion
+//#region src/email/html.d.ts
+/** Escape a value for element content. */
+declare const escapeText: (value: string) => string;
+/** Escape a value for a double-quoted attribute. */
+declare const escapeAttribute: (value: string) => string;
+/** camelCase to kebab-case; already-kebab names pass through unchanged. */
+declare const kebab: (property: string) => string;
+/** A bare number is pixels for every property that takes a length. */
+declare const declarationValue: (property: string, value: string | number) => string;
+interface EmailHtmlOutput {
+  readonly html: string;
+  readonly diagnostics: readonly EmailDiagnostic[];
+  /**
+   * Each emitted element's offset range and origins. A compatibility finding
+   * carries a position in the emitted document, and this is what turns that
+   * back into the authoring element the author can edit.
+   */
+  readonly positions: readonly EmittedPosition[];
+}
+/** How this document will be consumed. Delivery is the default; export is opt-in. */
+interface SerializeEmailOptions {
+  /**
+   * Accept relative references. A local export serves assets from a relative
+   * base beside the file; a delivered message has no directory to resolve one
+   * against, so this stays off for anything that will be sent.
+   */
+  readonly relativeUrls?: boolean | undefined;
+  /**
+   * Stamp every element with its instance path, so an editor preview can
+   * resolve a click in the rendered document to exactly one rendered element.
+   * A delivered message never carries it.
+   */
+  readonly instancePaths?: boolean | undefined;
+}
+/** Lower the derived tree to email HTML, reporting every unsupported construct with its origin. */
+declare const serializeEmailHtml: (node: EmailNode, options?: SerializeEmailOptions) => EmailHtmlOutput;
+/** An authored style object as a declaration list, checked by the same rules as a serialized tree. */
+declare const serializeStyle: (style: Readonly<Record<string, unknown>>, origins: readonly JsxSourceLocation[]) => {
+  readonly css: string;
+  readonly diagnostics: readonly EmailDiagnostic[];
+};
+/**
+ * Check one static attribute value against its element's spec, as serialization does. Returns
+ * the text that would be emitted, or `undefined` when the attribute is dropped or invalid.
+ */
+declare const checkAttribute: (tag: string, name: string, value: unknown, origins: readonly JsxSourceLocation[]) => {
+  readonly text: string | undefined;
+  readonly diagnostics: readonly EmailDiagnostic[];
+};
+//#endregion
+//#region src/email/render.d.ts
+/** Classic Outlook lays a document out correctly only under a transitional doctype. */
+declare const EMAIL_DOCTYPE = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">";
+interface EmailCompileOutput {
+  readonly html: string;
+  readonly text: string;
+  /** Findings that did not block the compile; blocking findings throw. */
+  readonly diagnostics: readonly EmailDiagnostic[];
+  /**
+   * Each emitted element's offset range and origins. Compatibility checks run
+   * in the host over the emitted document, and this is what lets a finding name
+   * the authoring element rather than a character offset.
+   */
+  readonly positions: readonly EmittedPosition[];
+}
+/** Lower the derived tree to HTML and its plain-text alternative. */
+declare const compileEmail: (node: EmailNode, options?: SerializeEmailOptions) => EmailCompileOutput;
+interface RenderedEmail {
+  readonly subject: string;
+  readonly preheader: string | undefined;
+  readonly html: string;
+  readonly text: string;
+  readonly tree: EmailNode;
+  readonly diagnostics: readonly EmailDiagnostic[];
+  readonly positions: readonly EmittedPosition[];
+}
+/**
+ * Render authored content against a stylesheet: inline what a client honors,
+ * keep the rest for `<head>`, and lower to HTML and text.
+ */
+declare const renderEmailContent: (stylesheet: Stylesheet | undefined, render: () => EmailContent, options?: SerializeEmailOptions) => RenderedEmail;
+//#endregion
+export { IrWhatsApp as $, emailAuthoringTarget as A, IrElement as B, Compound as C, EmittedPosition as D, EmailElementSelection as E, emailSelections as F, IrPredicate as G, IrFormatter as H, renderIrPreview as I, IrRawPart as J, IrPreheader as K, IrArithmetic as L, emailSelectionAncestry as M, emailSelectionIndex as N, INSTANCE_PATH_ATTRIBUTE as O, emailSelectionSiblings as P, IrValue as Q, IrComparison as R, CompiledSelector as S, matchesSelector as T, IrIf as U, IrEmail as V, IrNode as W, IrSource as X, IrSms as Y, IrStyle as Z, Specificity as _, renderEmailContent as a, RenderedPosition as at, parseStylesheet as b, checkAttribute as c, TemplateIr as ct, escapeText as d, IrWhatsAppButton as et, kebab as f, CssRule as g, CssDeclaration as h, compileEmail as i, RenderedIrWhatsApp as it, emailDefinitionInstances as j, IrPreview as k, declarationValue as l, serializeStyle as m, EmailCompileOutput as n, RenderOptions as nt, EmailHtmlOutput as o, RenderedWhatsAppButton as ot, serializeEmailHtml as p, IrRaw as q, RenderedEmail as r, RenderedIrEmail as rt, SerializeEmailOptions as s, SML_IR_VERSION as st, EMAIL_DOCTYPE as t, IrWhatsAppButtonNode as tt, escapeAttribute as u, Stylesheet as v, classListOf as w, Ancestry as x, compileSelector as y, IrEach as z };
+//# sourceMappingURL=render-BPonDpCl.d.ts.map

package/dist/{email/render.js → render-BQmfh94k.js}

@@ -1,9 +1,103 @@
-import { EmailCompileError, hasBlockingDiagnostic } from "./diagnostics.js";
-import { EmailNode, drainEmailDiagnostics } from "./jsx-runtime.js";
-import { t as applyStylesheet } from "../cascade-t6kxlgEI.js";
-import { serializeEmailHtml } from "./html.js";
-import { preheaderNode } from "./components.js";
-import { deriveEmailText } from "./text.js";
+import { P as emailElement, f as preheaderNode, v as serializeEmailHtml } from "./components-BZCqegS8.js";
+import { i as drainEmailDiagnostics, t as EmailNode } from "./jsx-runtime-CBlexoeR.js";
+import { n as applyStylesheet } from "./ir-CLhlklKV.js";
+import { r as hasBlockingDiagnostic, t as EmailCompileError } from "./diagnostics-CnKFefKz.js";
+//#region src/email/text.ts
+const PARAGRAPH = "\n\n";
+const LINE = "\n";
+const INVISIBLE = /\u200b|\u200c|\u200d|\u200e|\u200f|\u2060|\ufeff/g;
+const isLayoutTable = (props) => props.role === "presentation" || props.role === "none";
+/**
+* A data-table cell that reads as nothing and holds only imagery with empty alt text carries no
+* column of its own; an empty cell without such an image is a positional placeholder.
+*/
+const isDecorativeCell = (cell, context) => {
+	const images = collect(cell.children, (tag) => tag === "img", () => true);
+	return images.length > 0 && images.every((image) => image.props.alt === "") && childText(cell, context).trim() === "";
+};
+/** Wrap a block's content in separators; empty blocks contribute nothing. */
+const block = (inner, separator) => {
+	const trimmed = inner.replace(/^\s+/, "").replace(/\s+$/, "");
+	return trimmed === "" ? "" : `${separator}${trimmed}${separator}`;
+};
+const collect = (nodes, keep, descend) => nodes.flatMap((child) => {
+	if (child.type === "Fragment") return collect(child.children, keep, descend);
+	if (child.type !== "Element") return [];
+	if (keep(child.tag)) return [child];
+	return descend(child.tag) ? collect(child.children, keep, descend) : [];
+});
+const TABLE_SECTIONS = /* @__PURE__ */ new Set([
+	"thead",
+	"tbody",
+	"tfoot"
+]);
+const childText = (node, context) => node.children.map((child) => derive(child, context)).join("");
+const derive = (node, context) => {
+	switch (node.type) {
+		case "Text": return context.preformatted ? node.value : node.value.replace(INVISIBLE, "").replace(/[^\S\n]+/g, " ");
+		case "Raw": return node.text;
+		case "Fragment": return node.children.map((child) => derive(child, context)).join("");
+		case "Element": {
+			const spec = emailElement(node.tag);
+			if (spec === void 0) return childText(node, context);
+			switch (spec.layout) {
+				case "metadata": return "";
+				case "document":
+				case "inline":
+				case "list-item": return childText(node, context);
+				case "break": return LINE;
+				case "rule": return `${PARAGRAPH}---${PARAGRAPH}`;
+				case "image": {
+					const alt = typeof node.props.alt === "string" ? node.props.alt.trim() : "";
+					return alt === "" ? "" : `[${alt}]`;
+				}
+				case "link": {
+					const label = childText(node, context).replace(/\s+/g, " ").trim();
+					const href = typeof node.props.href === "string" ? node.props.href : "";
+					if (href === "" || href === label) return label;
+					return label === "" ? href : `${label} (${href})`;
+				}
+				case "list": {
+					const indent = "  ".repeat(context.listDepth);
+					const start = Number(node.props.start ?? 1);
+					const first = Number.isFinite(start) ? start : 1;
+					const nested = {
+						...context,
+						listDepth: context.listDepth + 1
+					};
+					const lines = collect(node.children, (tag) => tag === "li", () => false).map((item, index) => {
+						const marker = node.tag === "ol" ? `${first + index}.` : "-";
+						const continuation = `${indent}${" ".repeat(marker.length + 1)}`;
+						const [head = "", ...rest] = derive(item, nested).replace(/^\s+/, "").replace(/\s+$/, "").replace(/\n{2,}/g, LINE).split("\n");
+						return [`${indent}${marker} ${head}`, ...rest.map((line) => line.trim() === "" ? "" : /^\s/.test(line) ? line : `${continuation}${line}`)].join(LINE);
+					});
+					return block(lines.join(LINE), PARAGRAPH);
+				}
+				case "table": {
+					if (isLayoutTable(node.props)) return childText(node, context);
+					const rows = collect(node.children, (tag) => tag === "tr", (tag) => TABLE_SECTIONS.has(tag)).map((row) => collect(row.children, (tag) => tag === "td" || tag === "th", () => false).filter((cell) => !isDecorativeCell(cell, context)).map((cell) => childText(cell, context).replace(/\s+/g, " ").trim()).join(" | "));
+					return block(rows.join(LINE), PARAGRAPH);
+				}
+				case "row": return block(collect(node.children, (tag) => tag === "td" || tag === "th", () => false).map((cell) => childText(cell, context).replace(/^\s+|\s+$/g, "")).filter((cell) => cell !== "").join(LINE), LINE);
+				case "table-section":
+				case "cell": return block(childText(node, context), LINE);
+				case "preformatted": return block(childText(node, {
+					...context,
+					preformatted: true
+				}), PARAGRAPH);
+				case "block": return block(childText(node, context), PARAGRAPH);
+			}
+		}
+	}
+};
+/** Collapse the separators the walk emits into readable plain text. */
+const normalize = (value) => value.replace(/\r\n?/g, "\n").split("\n").map((line) => line.replace(/[^\S\n]+$/, "")).join("\n").replace(/\n{3,}/g, PARAGRAPH).trim();
+/** Derive the plain-text alternative from the semantic tree in reading order. */
+const deriveEmailText = (node) => normalize(derive(node, {
+	preformatted: false,
+	listDepth: 0
+}));
+//#endregion
 //#region src/email/render.ts
 /** Classic Outlook lays a document out correctly only under a transitional doctype. */
 const EMAIL_DOCTYPE = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">";
@@ -158,6 +252,6 @@ const renderEmailContent = (stylesheet, render, options = {}) => {
 	};
 };
 //#endregion
-export { EMAIL_DOCTYPE, compileEmail, renderEmailContent };
+export { deriveEmailText as i, compileEmail as n, renderEmailContent as r, EMAIL_DOCTYPE as t };
 
-//# sourceMappingURL=render.js.map
+//# sourceMappingURL=render-BQmfh94k.js.map