@h-k-dev/angular-email-editor 0.0.0-placeholder.0 → 0.0.1

package/types/h-k-dev-angular-email-editor.d.ts

@@ -0,0 +1,3959 @@
+import { Schema, NodeSpec, MarkSpec, ParseRule, TagParseRule, Node, DOMParser, Mark, MarkType, NodeType, ResolvedPos } from 'prosemirror-model';
+import { Command, EditorState, Plugin, PluginKey, Transaction } from 'prosemirror-state';
+import { InputRule } from 'prosemirror-inputrules';
+import * as _h_k_dev_angular_email_editor from '@h-k-dev/angular-email-editor';
+import { AddressRules } from '@h-k-dev/angular-email-editor/address';
+import { EditorView } from 'prosemirror-view';
+import * as i0 from '@angular/core';
+
+/** Passed to every extension factory once the schema has been built. */
+interface ExtensionContext {
+    schema: Schema;
+    /** All extensions of the editor, so aggregators (e.g. a suggestion menu) can introspect them. */
+    extensions: readonly Extension[];
+}
+/**
+ * A command factory: called with user arguments (e.g. a heading level),
+ * returns a ProseMirror {@link Command} ready to run against the editor.
+ */
+type CommandFactory = (...args: any[]) => Command;
+interface SuggestionItemBase {
+    /** Stable and locale-neutral (`'heading-2'`, `'table'`): what a menu's
+        `i18n` labels are keyed by, and what a renderer tracks rows by. Unique
+        within its level. */
+    id: string;
+    /** Shown, and matched first — the menu's `i18n` may translate it. */
+    title: string;
+    /** Extra strings the query is matched against besides the title. */
+    keywords?: string[];
+    /** A secondary line for the row — a merge tag's path, a shortcut. */
+    detail?: string;
+    /** An icon name, for renderers that show one (the demo: Material). */
+    icon?: string;
+    /** The heading a renderer groups rows under — a stable id (`'blocks'`,
+        `'styling'`, `'color'`), worded by the trigger's `sections` (see
+        `SuggestionTrigger`). Rows are listed in the order given, so a
+        section's rows are listed together, and a renderer shows the heading
+        where the section changes. */
+    section?: string;
+    /** A colour the row shows in an icon's place — a palette's rows. */
+    swatch?: string;
+}
+/** A suggestion that acts: picking it deletes the trigger and query text,
+    then runs `command` at that spot. The only kind a {@link SuggestionGroup}
+    may hold. */
+interface SuggestionCommandItem extends SuggestionItemBase {
+    /** Runs after the trigger and query text have been deleted. */
+    command: Command;
+    /** Whether it can run right now, when the item wants to say. A menu does
+        not offer a row that says no; a button for it shows disabled. Absent,
+        a menu always offers the row — it never asks a plain command, which a
+        host may not have written to the dry-run convention — and a button
+        asks the command itself (see {@link isActionEnabled}). */
+    isEnabled?: (state: EditorState) => boolean;
+    children?: never;
+}
+/**
+ * Something an extension can do, declared once and shown wherever a host
+ * wants it: a row of a `/` menu, a toolbar button, a bubble menu, a menu
+ * item. It is a {@link SuggestionCommandItem} — the same id, words, icon and
+ * command — that also knows its state, so a button can show it.
+ *
+ * An action is permanent and named; a *suggestion* in the narrower sense (a
+ * merge tag for `{{fi`, a template, a correction) is an answer to a moment
+ * and comes from a {@link SuggestionSource}. Both end in the same row.
+ */
+interface EditorAction extends SuggestionCommandItem {
+    /** Whether it is on at the selection — a toggle's pressed state. Absent
+        for what has no "on": inserting a table, sending. */
+    isActive?: (state: EditorState) => boolean;
+}
+/** Whether `action` can run on `state`: its own `isEnabled` when it has
+    one, else the command is asked the ProseMirror way — run without a
+    dispatch, it only says whether it would apply. An extension's commands
+    keep to that; declare `isEnabled` where the answer is too costly to ask
+    on every transaction. */
+declare const isActionEnabled: (action: EditorAction, state: EditorState) => boolean;
+/** What a {@link SuggestionSource} is asked for. */
+interface SuggestionRequest {
+    /** The search string of the level being asked for. */
+    query: string;
+    /** `null` for the first page, else the `nextCursor` the previous page
+        returned. */
+    cursor: string | null;
+    /** Aborted once the answer is no longer wanted — a newer query, a
+        dismissal, a destroyed editor. Hand it to `fetch` / `HttpClient`. */
+    signal: AbortSignal;
+}
+/** One page of suggestions. A non-null `nextCursor` means more pages exist:
+    the menu reports `hasMore` and fetches the next on `loadMore()`. */
+interface SuggestionPage<T extends SuggestionItem = SuggestionItem> {
+    items: T[];
+    nextCursor?: string | null;
+}
+/** A server-backed (or any computed) list of suggestions, asked per query
+    and per page; it owns its own matching. A bare array is one page with
+    nothing after it. A rejected promise is the menu's `error`. */
+type SuggestionSource<T extends SuggestionItem = SuggestionItem> = (request: SuggestionRequest) => T[] | SuggestionPage<T> | Promise<T[] | SuggestionPage<T>>;
+/**
+ * A suggestion that opens a second level: picking it rewrites the query to
+ * `<word> ` (its title, lowercased, spaces as hyphens) after the trigger, and
+ * whatever is typed after that space searches its children. Two levels, no
+ * more — a group's children are command items.
+ *
+ * `children` is either a list, which the menu filters and ranks like the
+ * first level, or a {@link SuggestionSource}.
+ */
+interface SuggestionGroup extends SuggestionItemBase {
+    /** Shown after `<trigger><word> `, until the group's own query is typed —
+        "Search templates…". The second level's counterpart of a trigger's
+        `placeholder`, handed to the session's decoration the same way; the
+        menu's `i18n` may translate it. */
+    placeholder?: string;
+    children: readonly SuggestionCommandItem[] | SuggestionSource<SuggestionCommandItem>;
+    command?: never;
+}
+/** An entry in a suggestion menu. */
+type SuggestionItem = SuggestionCommandItem | SuggestionGroup;
+interface BaseExtension {
+    name: string;
+    /** Named commands exposed on the editor, e.g. `editor.commands.toggleBold()`. */
+    commands?: (ctx: ExtensionContext) => Record<string, CommandFactory>;
+    /** Key bindings. Earlier extensions in the array win over later ones. */
+    keymap?: (ctx: ExtensionContext) => Record<string, Command>;
+    /** Markdown-style input rules, e.g. `# ` becoming a heading. */
+    inputRules?: (ctx: ExtensionContext) => InputRule[];
+    /** Arbitrary ProseMirror plugins (decorations, paste handling, ...). */
+    plugins?: (ctx: ExtensionContext) => Plugin[];
+    /** What this extension can do, for every surface that shows it — a `/`
+        menu's rows, a toolbar's buttons. Gathered by {@link extensionActions}. */
+    actions?: (ctx: ExtensionContext) => EditorAction[];
+}
+interface NodeExtension extends BaseExtension {
+    type: 'node';
+    /** Marks this node as the document root. Exactly one extension must set it. */
+    topNode?: boolean;
+    spec: NodeSpec;
+}
+interface MarkExtension extends BaseExtension {
+    type: 'mark';
+    spec: MarkSpec;
+}
+/** Behaviour-only extension: history, base keymap, future `/`-command, ... */
+interface FunctionalExtension extends BaseExtension {
+    type: 'extension';
+}
+type Extension = NodeExtension | MarkExtension | FunctionalExtension;
+declare const defineNode: (extension: Omit<NodeExtension, "type">) => NodeExtension;
+declare const defineMark: (extension: Omit<MarkExtension, "type">) => MarkExtension;
+declare const defineExtension: (extension: Omit<FunctionalExtension, "type">) => FunctionalExtension;
+/** Every action the editor's extensions declare, in kit order. */
+declare const extensionActions: (ctx: ExtensionContext) => EditorAction[];
+/** The extensions' actions as the rows of a `/` menu — the same list, seen as
+    suggestions: `createSuggestionMenu({ trigger: '/', items: extensionSuggestions })`. */
+declare const extensionSuggestions: (ctx: ExtensionContext) => SuggestionItem[];
+
+/**
+ * Builds a ProseMirror {@link Schema} from a list of extensions.
+ * Node and mark order follows the array order, which matters for
+ * parse precedence and mark nesting.
+ */
+declare function createSchema(extensions: Extension[]): Schema;
+
+/**
+ * How markup is parsed through the schema.
+ *
+ * - `email` — the default for everything a host or the source pane hands the
+ *   editor. Every tag, attribute and CSS property that Apple Mail, Outlook or
+ *   Gmail applies is recognized and kept **exactly as authored** (see
+ *   `email-vocabulary.ts`): MJML's output, a hand-built table template, the
+ *   document envelope, Outlook conditional comments. Text lines, headings and
+ *   images become real editor nodes carrying their authored attributes;
+ *   layout structure stays structure. Anything no floor client applies is
+ *   dropped.
+ * - `preserve` — the opt-in for special needs: like `email`, but nothing is
+ *   dropped for being outside the vocabulary (custom elements, `data-*`,
+ *   framework attributes, invented CSS). Executable content is still refused.
+ * - `repair` — the schema is law: markup is rewritten into the composer's
+ *   canonical form. The clipboard and the reply/forward/import seeds use it —
+ *   pasted Word or Docs markup is cleaned, not kept.
+ */
+type ParseMode = 'email' | 'preserve' | 'repair';
+/** Which parse rules take part: the `repair` set, or the `authored` set
+    shared by `email` and `preserve` (they differ only in the vocabulary
+    filter that runs before the parse). */
+type RuleScope = 'repair' | 'authored';
+/** The rule scope a mode parses with. */
+declare function scopeOf(mode: ParseMode): RuleScope;
+/** Custom key on a parse rule restricting it to one scope. */
+declare const PARSE_SCOPE_KEY = "aeeParseScope";
+/** A parse rule that only takes part in the given scope. */
+declare function ruleForScope<T extends ParseRule>(scope: RuleScope, rule: T): T;
+/** The scope a rule is restricted to, if any. */
+declare function ruleScope(rule: ParseRule | TagParseRule): RuleScope | undefined;
+
+/** Serializes a document (or any node) to an HTML string, e.g. for the email
+    body. A document carrying an envelope (see {@link DocumentEnvelope})
+    serializes as a whole document — doctype, head and all. */
+declare function serializeToHTML(doc: Node, schema: Schema): string;
+interface ParseOptions {
+    /** `repair` (this function's default — canonical form), `email` (the
+        editor's default — the email vocabulary, kept exactly as authored) or
+        `preserve` (anything but executable content). See {@link ParseMode}. */
+    mode?: ParseMode;
+}
+/**
+ * Parses an HTML string into a document conforming to the schema.
+ *
+ * - `repair` (the default here; paste, seeds, templates): parsing is repair
+ *   (principle 2). A builder's export leans on its stylesheet, on wrapper
+ *   tables and on hiding what a client cannot show; the canonical schema
+ *   reads none of those, so the import pipeline (import-html.ts) folds,
+ *   unwraps and drops them first.
+ * - `email` (the editor's default) and `preserve`: the markup is kept as
+ *   authored — comments survive as nodes, a document envelope (`<!doctype>`,
+ *   `<html>`, `<head>`, `<body>` attributes) lands on the document node's
+ *   `envelope` attribute, and `email` first corrects what another editor
+ *   stored wrongly (corrections.ts: `mailto://`, Word's `<o:p>`, Bootstrap
+ *   borders, an inline around blocks, a video embed) and then drops whatever
+ *   no floor client applies (email-vocabulary.ts).
+ *
+ * Every mode then shares the structural repairs. Tables are where foreign
+ * markup breaks the rules hardest: real mail arrives with rows of unequal
+ * length and spans that reach past the grid, and `repairTables` normalizes
+ * the composer's own tables so every pure consumer of the parser —
+ * `importedDocument`, `replyDocument`, the source pane's round trip — sees
+ * the same rectangle the editor would. `{{path}}` tokens in running text
+ * become `mergeTag` pills (`promoteMergeTags`): the serialized email carries
+ * the raw Handlebars-flavoured text, and parse restores the structured form.
+ * Button atoms lose marks the parser painted from their own `font-weight`
+ * (`bareButtons`) — the box is already bold.
+ */
+declare function parseHTML(html: string, schema: Schema, options?: ParseOptions): Node;
+/**
+ * A command inserting an HTML fragment at the selection — a template, a
+ * snippet — parsed exactly as {@link parseHTML} parses a whole document, so
+ * tables are repaired and merge tags promoted on the way in. Block content
+ * dropped into an empty paragraph takes its place.
+ */
+declare const insertHTML: (html: string, options?: ParseOptions) => Command;
+/** A command that puts `html` in the whole document's place — an example
+    loaded over what is written, as one undoable change; the caret lands at
+    its end. A whole document parsed in the `email` or `preserve` mode brings
+    its envelope along. */
+declare const replaceHTML: (html: string, options?: ParseOptions) => Command;
+
+/**
+ * What a whole HTML document needs before the schema parses its body — the
+ * two things a builder's export (MJML, Stripo, Mailchimp) leans on that the
+ * canonical email HTML never has:
+ *
+ * 1. **A stylesheet.** The head's `<style>` rules are folded into the
+ *    elements they match ({@link inlineStyles}), so the mobile-first pattern
+ *    — `width: 100%` inline, `width: 50% !important` in a `min-width` media
+ *    query — comes out the way a desktop client draws it.
+ * 2. **Wrapper tables.** Every section, column and image sits in a one-cell
+ *    `role="presentation"` table for Outlook's sake; each one would parse as
+ *    a table of ours with its content hoisted out beside it. They are
+ *    unwrapped ({@link unwrapLayoutTables}) — only the builders' own, which
+ *    the canonical form never emits, and never one that carries a fill or a
+ *    padding: that is a band, the section node's own.
+ * 3. **Hidden elements.** What a builder hides with `display: none` — the
+ *    trigger of a hamburger menu, a preview text, a desktop-only or
+ *    mobile-only variant — is dropped ({@link dropHidden}), rather than
+ *    read as text standing in the message: the schema has no notion of
+ *    hidden, and the client the import is drawn for would not show it.
+ * 4. **Inheritance.** A builder writes the colour, the size, the face and
+ *    the alignment on a wrapping `<div>` or `<td>` and lets CSS carry them
+ *    down; the schema reads a paragraph's alignment off the paragraph and
+ *    a colour off a `<span>`. What an ancestor declares is written down
+ *    onto the blocks and the runs beneath it ({@link inheritTextStyles}),
+ *    so it reaches the words the way a client's cascade would.
+ */
+/**
+ * Drops the comments, and every element hidden with an inline
+ * `display: none` (the sheet's having been folded in, a rule's counts too). A builder's export hides
+ * the part of a trick the client cannot pull off — the label of an
+ * MJML hamburger menu, whose ☰ would otherwise stand in the message as
+ * text — and the alternative of a responsive pair; a preview text sits
+ * in such a block as well, and goes with it: an email of ours carries no
+ * hidden text. Not `visibility` or `mso-hide`: those are a client's
+ * concern, not a rendering's.
+ */
+/**
+ * Drops the whitespace a client never shows: the text nodes of nothing but
+ * spaces inside a box whose own `font-size` is 0. A builder kills the gaps
+ * between a row of inline-block boxes that way — MJML's navbar links, its
+ * grouped columns — and the row is laid out as the boxes abutting, their
+ * own padding apart. Read as text, each gap would be a space at the
+ * paragraph's size: 13px over four links, and the last one wraps.
+ */
+declare function dropZeroSizedWhitespace(root: ParentNode): void;
+declare function dropHidden(root: ParentNode): void;
+/**
+ * Writes down, on each element, the `width` its author gave it inline —
+ * `data-aee-own-width` — before {@link inlineStyles} folds a sheet's
+ * `!important` over it. A column's own width is what says whether it
+ * stacks on a phone (`width: 100%`, the mobile-first pattern, capped by a
+ * `min-width` rule) or holds its share (`width: 50%`, a builder's grouped
+ * columns): folded at 600px both read `50%`, and only the author's own
+ * word tells them apart.
+ */
+declare function noteOwnWidths(root: ParentNode): void;
+/** The width the import is drawn at: an email's container. A `min-width`
+    media query at or below it applies; a `max-width` one below it does not. */
+declare const IMPORT_VIEWPORT_WIDTH = 600;
+interface Declaration {
+    name: string;
+    value: string;
+    important: boolean;
+}
+/**
+ * Folds the document's `<style>` rules into inline styles, then drops the
+ * blocks. The cascade is the simple one an email tool can afford: a rule
+ * applies to what its selector matches, in document order, later rules
+ * over earlier ones; an inline declaration stands unless the rule is
+ * `!important` (the mobile-first pattern relies on exactly that);
+ * specificity is not weighed. Media queries are answered for
+ * {@link IMPORT_VIEWPORT_WIDTH}; other at-rules and selectors the document
+ * cannot match (`:hover`, `::before`) are skipped.
+ */
+declare function inlineStyles(doc: Document, viewportWidth?: number): void;
+interface StyleRule {
+    selector: string;
+    declarations: Declaration[];
+}
+/** The style rules of a sheet, flattened: those inside a media query that
+    holds at `viewportWidth`, in order; other at-rules dropped. */
+declare function parseRules(css: string, viewportWidth: number): StyleRule[];
+/** Whether a media query list holds for a screen `viewportWidth` wide:
+    `screen`/`all`, `min-width` and `max-width` in px, `and` between them;
+    `not`, `print` and any other feature do not hold. */
+declare function mediaMatches(query: string, viewportWidth: number): boolean;
+/**
+ * Takes the builders' wrapper tables out: a one-row, one-cell
+ * `role="presentation"` table carrying the attributes the builders write
+ * (`cellpadding`, `cellspacing`, `border="0"`) whose cell holds nothing but
+ * elements — a column, another table, an image — is replaced by what it
+ * holds. A cell written right-to-left (`direction: rtl`, MJML's way to put
+ * an image on the right) hands its children over in reverse, which is the
+ * order a client draws them in. Innermost first, until none is left. A
+ * table with text in its one cell is a table, and stays one; the
+ * canonical form's own tables carry none of those attributes.
+ */
+declare function unwrapLayoutTables(root: ParentNode): void;
+/** A box's four sides, in px — top, right, bottom, left. */
+type Box = [number, number, number, number];
+/** An element's padding, where it declares one that is not all zeros —
+    the CSSOM's longhands, else the attribute's own shorthand. */
+declare function paddingOf(el: HTMLElement): Box | null;
+/** Shares a dissolved box's padding out among the blocks it held, the way
+    the box laid them out: the sides on every block, the top on the first,
+    the bottom on the last — on top of any padding of their own. A table or
+    a list takes none (they read no padding); a paragraph, a heading, a div
+    do, and a paragraph's becomes its spacing. */
+declare function distributePadding(box: Box, blocks: HTMLElement[]): void;
+/** Whether an element lays out as a block — a column, a paragraph, a
+    table — as against a run of a line (a link, an image, a span). */
+declare function isBlock(el: Element): boolean;
+/** Whether a cell holds a block of its own — what a section's does, as
+    against a button's wrapper (one anchor) or an image's (one `<img>`). */
+declare function holdsBlock(cell: Element): boolean;
+/** Whether a cell declares a padding that is not all zeros. */
+declare function isPadded(cell: Element): boolean;
+/** Whether a cell holds a column — a builder's inline-block div, or our
+    own centring div — which is what a section's cell holds. */
+declare function holdsColumn(cell: Element): boolean;
+/**
+ * Writes down what CSS would inherit. A builder puts `color`, `font-size`,
+ * `font-family` and `text-align` on a wrapping `<div>` (MJML's text
+ * block), or `align` on a cell, and the words beneath inherit them; the
+ * schema reads a colour off a `<span>` and an alignment off the paragraph
+ * itself, so the cascade is materialised: each declaring element hands
+ * the properties to the blocks under it that declare none of their own
+ * (alignment and line height among them), and wraps its runs of inline content in a
+ * `<span>` carrying the colour, the size and the face — an anchor's own
+ * colour included, which is how a navbar's black links stay black. Top
+ * down, so a grandchild takes the nearer ancestor's word. A `font-size`
+ * of 0 (a builder's way to kill the gaps between inline-block columns)
+ * is not a size and is not passed on.
+ */
+declare function inheritTextStyles(root: ParentNode): void;
+
+/** Applies every correction to a parsed document, in place. */
+declare function correctStoredMistakes(dom: Document): void;
+/** `mailto://` and `tel://` back to the scheme a client reads; `http://` off
+    a link that is one placeholder and nothing else. */
+declare function repairLinkSchemes(root: ParentNode): void;
+/** The page a viewer opens for an embedded player's address. */
+declare function videoPage(src: string): string;
+/** Each embedded player becomes a link to its page, where it stood. */
+declare function embedsAsLinks(root: ParentNode): void;
+/** `<o:p>` replaced by what it holds (an `&nbsp;` keeps an empty line). */
+declare function unwrapOfficeParagraphMarks(root: ParentNode): void;
+/** `Mso…` class names no `<style>` in the document mentions. */
+declare function dropDeadOfficeClasses(dom: Document): void;
+/** Bordered tables whose borders came from a class no stylesheet here
+    defines get them inline; declarations the author wrote win. */
+declare function inlineBootstrapTableBorders(dom: Document): void;
+/**
+ * `<font color><div>a</div>b</font>` → `<div><font color>a</font></div><font color>b</font>`.
+ * Each run of inline children keeps a copy of the wrapper; each block gets
+ * one inside it, around its own content — recursively, so a block of blocks
+ * hands it on down. An `<hr>` or an empty block takes none.
+ */
+declare function lowerInlinesAroundBlocks(root: ParentNode): void;
+
+/**
+ * Tag classifications shared by the source language (scanner, formatter) and
+ * the preserving parser. One vocabulary, so "what is a block" never differs
+ * between the pane that formats the source and the pane that parses it.
+ */
+/** Elements that never have content and never a closing tag. */
+declare const VOID_TAGS: Set<string>;
+/** Phrasing-level containers: they lay out inline and become marks (or, when
+    they wrap blocks, generic containers) in the preserving parse. */
+declare const INLINE_TAGS: Set<string>;
+/** Void elements that lay out inline. */
+declare const INLINE_VOID_TAGS: Set<string>;
+/** Table sections: structure the browser injects and the serializer emits on
+    its own — they are walked through, never nodes of their own, wherever the
+    surrounding table is canonical. */
+declare const TABLE_SECTION_TAGS: Set<string>;
+/** Tags that make up a document's envelope rather than its content. Gmail
+    strips the head anyway, so they are neither content nor a deliverability
+    warning — just the envelope MJML-class tooling emits. */
+declare const DOCUMENT_TAGS: Set<string>;
+/** Never preserved, in any mode: executable or embedding content has no
+    place in an email and the parse refuses it outright. */
+declare const REFUSED_TAGS: Set<string>;
+/** Whether an element takes part in block layout among its siblings —
+    everything that is neither phrasing content nor an inline void. */
+declare function isBlockLevel(tag: string): boolean;
+
+/** Attributes as an ordered list of pairs — JSON-plain, so ProseMirror can
+    compare node attrs, and ordered, so the round trip keeps authored order. */
+type AttributePairs = [string, string][];
+/**
+ * A DOM element with its attributes set **verbatim**. Array output specs run
+ * `style` through the CSSOM (`style.cssText = …`), which reformats it and
+ * drops every declaration the browser does not know — MJML's `mso-*` hints
+ * for Outlook would vanish. Preserved markup therefore builds its own
+ * elements; `setAttribute` keeps the string as authored.
+ */
+declare function verbatimElement(tag: string, attrs: Iterable<[string, string | null | undefined]>, content: boolean): {
+    dom: HTMLElement;
+    contentDOM?: HTMLElement;
+};
+
+/** Placeholder element the comment pre-pass turns DOM comments into:
+    ProseMirror's parser never sees comment nodes, elements it does. */
+declare const COMMENT_TAG = "aee-comment";
+/** An element's attributes, verbatim and in order — minus what must never be
+    emitted: event handlers, `srcdoc`, script URLs, styles with script hooks. */
+declare function preservedAttributes(element: Element): AttributePairs;
+/** Comment text with its inner indentation dropped: `<!--[if mso]>\n  <xml>`
+    and `<!--[if mso]>\n<xml>` are the same comment, and the formatter must
+    be free to re-indent inner lines without changing the document. */
+declare function normalizeCommentText(text: string): string;
+/** CSS with every line trimmed and re-indented by brace depth — idempotent,
+    whitespace-only, so the head styles are a byte-stable fixpoint no matter
+    how the source pane indents them. */
+declare function normalizeCss(css: string): string[];
+/** Turns every comment under `root` into a placeholder element the parse
+    rules can see. Runs on the throwaway DOM a parse builds, never on live DOM. */
+declare function materializeComments(root: globalThis.Node): void;
+/**
+ * Drops the edge whitespace inside phrasing elements that are displayed as
+ * boxes (`<a style="display: inline-block">` — MJML's navbar links and
+ * buttons come as `<a> home </a>`). A box drops the whitespace at the start
+ * and end of its own line boxes, so this is rendering-neutral in a client —
+ * but the editor view keeps whitespace (`pre-wrap`, as an editor must), where
+ * those spaces would take width and wrap a navbar the client keeps on one
+ * line. Runs on the throwaway DOM a parse builds.
+ */
+declare function trimInlineBoxes(root: Element): void;
+/**
+ * Whether an element takes part in block layout among its siblings: a
+ * block-level tag, or a phrasing element wrapping blocks (`<a href><table>`).
+ * Images are inline (the composer's image node is an inline atom), so a
+ * `td > img` is a cell holding an image, and `td > a > img` a linked image.
+ */
+declare function isBlockish(element: Element): boolean;
+/** Whether an element lays its children out as blocks (any block-ish child). */
+declare function hasBlockChildren(element: Element): boolean;
+/** Replaces emitted comment placeholders under `root` with comment nodes. */
+declare function realizeComments(root: Element): void;
+/** A foreign block container — anything holding block-level children. */
+declare const HtmlElement: _h_k_dev_angular_email_editor.NodeExtension;
+/** A structural block holding inline content — a `<td>` with a link (MJML's
+    button cell), a `<center>` or `<label>`-free text container. Text lines
+    (`div`, `p`) and headings are the composer's own nodes instead; see
+    `authored.ts`. Enter inserts a line break here (see {@link AuthoredEnter})
+    — splitting a table cell would add a cell. */
+declare const HtmlTextElement: _h_k_dev_angular_email_editor.NodeExtension;
+/** A foreign void element among inline content (`<img>` in a cell, `<input>`). */
+declare const HtmlVoid: _h_k_dev_angular_email_editor.NodeExtension;
+/** A foreign void element among blocks (`<hr class>`, an `<input>` between divs). */
+declare const HtmlVoidBlock: _h_k_dev_angular_email_editor.NodeExtension;
+/** A comment between blocks — MJML's Outlook conditionals live here. Hidden
+    in the editor (a browser renders nothing for it either); the serializer
+    emits a real comment node. */
+declare const HtmlComment: _h_k_dev_angular_email_editor.NodeExtension;
+/** A comment among inline content. */
+declare const HtmlCommentInline: _h_k_dev_angular_email_editor.NodeExtension;
+/**
+ * A `<style>` in the body, text kept raw (whitespace-normalized). Hidden in
+ * the editor — a live `<style>` inside the editable DOM would restyle the host
+ * app; the `DocumentStyles` extension applies it scoped, like the head's.
+ * Also carries the refusals: executable content is never parsed, in any mode,
+ * and a body `<style>` dies in repair mode (its text would leak otherwise).
+ */
+declare const HtmlRaw: _h_k_dev_angular_email_editor.NodeExtension;
+/** A phrasing element no canonical mark claims (`<span class="…">`,
+    `<label>`, `<font face>`), kept verbatim. Instances nest freely
+    (`excludes: ''`), outermost first, so `<a><span>…` survives as authored. */
+declare const HtmlInline: _h_k_dev_angular_email_editor.MarkExtension;
+/**
+ * Enter inside a structural text block ({@link HtmlTextElement}) inserts a
+ * line break instead of splitting it: splitting a `<td>` adds a table cell,
+ * splitting a `<center>` duplicates a container. Must sit before the kit's
+ * `SplitKeepingMarks`, whose split would otherwise claim Enter.
+ */
+declare const AuthoredEnter: _h_k_dev_angular_email_editor.FunctionalExtension;
+/** The whole family, in schema order: block nodes, then inline atoms, then
+    the mark. Both kits include it; the mode decides whether it takes part. */
+declare const preserveExtensions: (_h_k_dev_angular_email_editor.NodeExtension | _h_k_dev_angular_email_editor.MarkExtension)[];
+/**
+ * The schema's parser for a mode. `repair` is the plain schema parser minus
+ * the authored rules. `email` and `preserve` share one parser (they differ
+ * only in the vocabulary filter applied before it runs): it drops style
+ * rules (they would mark authored text up — `font-weight: bold` on an
+ * authored `<div>` must stay a style, not become a `<strong>`), lets the
+ * nodes that carry authored markup claim theirs, strictifies every other
+ * canonical node rule, and lets the preserve family take the rest.
+ */
+declare function createDOMParser(schema: Schema, mode: ParseMode): DOMParser;
+
+interface DocumentEnvelope {
+    /** The doctype as re-emitted (`<!doctype html>`), or null when absent. */
+    doctype: string | null;
+    /** Attributes of `<html>`, in authored order. */
+    html: AttributePairs;
+    /** The head in canonical line form, `\n`-joined, unindented; `''` when empty. */
+    head: string;
+    /** Attributes of `<body>`, in authored order. */
+    body: AttributePairs;
+}
+/** Whether HTML carries a document envelope rather than being a bare body
+    fragment — a doctype or an explicit `html`/`head`/`body` tag. */
+declare function hasDocumentEnvelope(html: string): boolean;
+/** Parses HTML into a throwaway document. A bare fragment is parsed inside
+    an explicit `<body>`: otherwise the HTML parser files a leading comment
+    or `<style>` under the head, and body-only consumers would lose it. */
+declare function parseDocument(html: string): Document;
+/** Reads the envelope off a parsed document. */
+declare function readEnvelope(dom: Document): DocumentEnvelope;
+/**
+ * The head, one child per line: `<title>`/`<meta>`/`<link>` on a line each,
+ * `<style>` with its CSS trimmed and re-indented by nesting, comments with
+ * their inner indentation dropped. Whitespace-only normalization, idempotent —
+ * so the head string is a fixpoint of parse → serialize → format → parse.
+ * Executable content (`<script>`, `<base>`) never makes it in.
+ */
+declare function canonicalHead(head: Element | null): string;
+/** The canonical document: envelope lines around the zero-whitespace body. */
+declare function serializeDocument(envelope: DocumentEnvelope, body: string): string;
+/** An opening tag with escaped attribute values; a valueless attribute is
+    written bare (`<td nowrap>`), matching how the browser serializes it. */
+declare function openTag(tag: string, attrs: AttributePairs): string;
+/** One attribute as the source writes it: `name="value"` — bare only for an
+    HTML boolean, where the name alone is the value. An empty value anywhere
+    else is spelled out (`alt=""` is a decision, not a leftover). */
+declare function attributeString(name: string, value: string): string;
+/** Whether the attribute is one of HTML's booleans — written bare. */
+declare function isBooleanAttribute(name: string): boolean;
+declare function escapeText(text: string): string;
+declare function escapeAttribute(value: string): string;
+
+/**
+ * The email vocabulary: every tag, attribute and CSS property that at least
+ * one of the floor clients — **Apple Mail, Outlook, Gmail** — applies. This is
+ * what the default `email` parse mode recognizes and keeps *exactly as
+ * authored*; it is the reason MJML's output survives untouched, because MJML
+ * emits nothing a floor client ignores.
+ *
+ * Curation rule: grounded in caniemail's feature list (a feature supported by
+ * any one of the three clients is usable), plus Outlook's own dialect
+ * (`mso-*` properties, VML and Office namespaced elements), plus the legacy
+ * presentational HTML every email toolchain still relies on (`bgcolor`,
+ * `cellpadding`, `align`, …). Anything outside — framework attributes
+ * (`ng-*`, `v-*`), `data-*`, typos, invented CSS properties, custom elements —
+ * is dropped by the `email` parse and kept only in `preserve` mode, which is
+ * the opt-in for special needs.
+ *
+ * Deliberately static: filtering by what the *running* browser knows
+ * (`CSS.supports`, `in style`) would make canonical output depend on the
+ * engine — and no browser knows `mso-*`.
+ */
+/** Tags applied by at least one floor client. */
+declare const EMAIL_TAGS: Set<string>;
+/** Attributes applied by at least one floor client, on any element — the
+    global set, the legacy presentational set, and the per-element ones
+    flattened (an `href` on a `<div>` is inert, not harmful). */
+declare const EMAIL_ATTRIBUTES: Set<string>;
+/** CSS properties applied by at least one floor client — caniemail's
+    property list plus the universally supported basics it doesn't track. */
+declare const EMAIL_CSS_PROPERTIES: Set<string>;
+/** Whether a tag is applied by at least one floor client. */
+declare function isEmailTag(tag: string): boolean;
+/** Whether an attribute is applied by at least one floor client. Outlook's
+    own elements keep all their attributes — VML is its own vocabulary. */
+declare function isEmailAttribute(name: string, tag?: string): boolean;
+/**
+ * Whether a CSS property is applied by at least one floor client: a listed
+ * property, a vendor-prefixed one (`-webkit-`, `-moz-`, `-ms-`) of a listed
+ * or known vendor-only property, Outlook's `mso-*`, or a custom property
+ * (Apple Mail supports CSS variables).
+ */
+declare function isEmailCssProperty(property: string): boolean;
+/** A style attribute split into declarations at top-level semicolons —
+    never inside quotes or parentheses, so `url(data:image/png;base64,…)`
+    stays one declaration. Each entry keeps its exact original text. */
+declare function splitDeclarations(style: string): string[];
+/** The property name of one declaration, lower-cased; `null` when the
+    declaration has no `:` (empty or malformed). */
+declare function declarationProperty(declaration: string): string | null;
+/**
+ * A style attribute with every declaration outside the email vocabulary
+ * removed. **Byte-identical when nothing is dropped** — the kept declarations
+ * keep their exact text and separators, so authored styles round-trip as
+ * written. Returns the dropped property names alongside.
+ */
+declare function filterEmailStyle(style: string): {
+    style: string;
+    dropped: string[];
+};
+/**
+ * Applies the email vocabulary to a throwaway DOM, in place: elements
+ * outside it are unwrapped (their content stays, as the repair parse does) —
+ * except executable ones, which go with their content, never leaking it as
+ * text — attributes outside it are removed, style declarations outside it
+ * are removed. Comments and text are untouched. Runs before the `email` parse.
+ */
+declare function applyEmailVocabulary(root: Element): void;
+
+/**
+ * Authored markup on the composer's own nodes and marks.
+ *
+ * In the `email` parse mode every node and mark the schema knows recognizes
+ * the markup its parse rule accepts — MJML's styled `<div>` is a paragraph, a
+ * hand-written `<table>` a table, `<b class="x">` bold — while the element's
+ * tag and attributes ride along **exactly as authored** in an `html` attr.
+ * For a node whose rendering is several elements deep (a table and its
+ * `<tbody>`, a section's band), every element on the way to the content is
+ * kept.
+ *
+ * The rule for rendering is one sentence: **verbatim until edited, then the
+ * edit patched in.** While the modelled attributes are what the parse read,
+ * the authored elements render as written. Once a command changes them (an
+ * alignment, a cell fill, a link's href), the node's canonical rendering is
+ * computed twice — for what was parsed and for what is now — and only that
+ * difference is applied to the authored markup: an attribute set or removed,
+ * a style declaration replaced in place, appended or dropped. Everything the
+ * edit did not touch stays byte for byte.
+ *
+ * `html` is `null` for the composer's own canonical output and for everything
+ * a command creates, which is why the golden corpus is unaffected.
+ *
+ * Installed once, for every node and mark, by the schema builder
+ * ({@link withAuthoredMarkup}); a spec opts out with `authoredMarkup: false`.
+ */
+
+interface AuthoredElement {
+    /** Lower-cased tag name as authored. */
+    tag: string;
+    /** Attributes verbatim, in authored order. */
+    attrs: AttributePairs;
+}
+interface AuthoredMarkup {
+    /** The authored elements from the node's outer element down to the one
+        holding its content — one entry for most nodes. */
+    path: AuthoredElement[];
+    /** The modelled attributes as the parse read them (`html` excluded): the
+        baseline an edit is measured against. */
+    parsed: Record<string, unknown>;
+}
+/** The attribute holding authored markup, on every node and mark. */
+declare const AUTHORED_ATTR = "html";
+/** Spec key: `false` opts a node or mark out of authored markup (the
+    preserve family, which is verbatim by construction). */
+declare const AUTHORED_SPEC_KEY = "authoredMarkup";
+/** Spec key: style values to write instead of *removing* a declaration an
+    edit took away — `{ 'text-align': 'left' }` on the paragraph, because an
+    authored line usually sits in a container with an alignment of its own
+    (MJML cells centre) and a removed declaration would inherit that. */
+declare const AUTHORED_STYLE_DEFAULTS_KEY = "authoredStyleDefaults";
+type Subject = Node | Mark;
+declare function authoredMarkupOf(subject: Subject): AuthoredMarkup | null;
+/** A node or mark spec with the `html` attribute and authored rendering —
+    applied by `createSchema` to every spec that does not opt out. */
+declare function withAuthoredMarkup<T extends NodeSpec | MarkSpec>(spec: T): T;
+/** The node's (or mark's) canonical rendering, authored markup ignored —
+    what the parse compares an element against. `emit` picks the email's
+    rendering over the editor view's. */
+declare function canonicalRender(subject: Subject, emit: boolean): {
+    dom: globalThis.Node;
+    contentDOM?: HTMLElement;
+} | null;
+/** The elements from a rendering's outer element down to its content hole
+    (or the outer element alone for a leaf). */
+declare function renderedPath(rendered: {
+    dom: globalThis.Node;
+    contentDOM?: HTMLElement;
+}): Element[] | null;
+/** The value of one attribute, or null. */
+declare function authoredAttribute(markup: AuthoredElement, name: string): string | null;
+/**
+ * Sets one CSS declaration in the markup's `style`, touching nothing else:
+ * an existing declaration keeps its place and spacing, a new one is appended
+ * in the style's own punctuation (`a:b;` stays compact, `a: b;` stays spaced).
+ */
+declare function withStyleDeclaration(markup: AuthoredElement, property: string, value: string): AuthoredElement;
+/** Removes one CSS declaration from the markup's `style` (and the attribute
+    when nothing is left). */
+declare function withoutStyleDeclaration(markup: AuthoredElement, property: string): AuthoredElement;
+/** Sets one attribute, in place when present, appended otherwise. */
+declare function withAttribute(markup: AuthoredElement, name: string, value: string): AuthoredElement;
+declare function withoutAttribute(markup: AuthoredElement, name: string): AuthoredElement;
+/** The markup of a block split off an authored one: everything inherited
+    but the attributes that must stay unique (`id`). */
+declare function inheritedMarkup(markup: AuthoredMarkup): AuthoredMarkup;
+/**
+ * For a NodeView that builds its own elements (the table's scroll wrapper,
+ * the columns' resize box): the attributes the view should put on the
+ * element standing for path entry `index`, or null when the node carries no
+ * authored markup — then the view keeps its canonical attributes. Classes the
+ * view sets itself are kept alongside the authored ones by
+ * {@link applyAuthoredAttributes}.
+ */
+declare function authoredViewAttributes(node: Node, index: number): AttributePairs | null;
+/** Puts a node's authored attributes on a view-built element: every other
+    attribute goes, except the view's own classes, which stay beside the
+    authored ones. No authored markup: nothing changes. */
+declare function applyAuthoredAttributes(element: HTMLElement, node: Node, index: number): void;
+
+/**
+ * MJML's "Worldly" reference template, compiled — the target the preserving
+ * parse is measured against: a document envelope with head styles and media
+ * queries, Outlook conditional comments in head and body, nested layout
+ * tables with legacy attributes, VML inside conditionals, a checkbox-driven
+ * navbar, images with `height="auto"`. It must survive the round trip and
+ * render identically in every pane.
+ */
+declare const MJML_WORLDLY_HTML = "<!doctype html>\n<html lang=\"und\" dir=\"auto\" xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:o=\"urn:schemas-microsoft-com:office:office\">\n\n<head>\n  <title></title>\n  <!--[if !mso]><!-->\n  <meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\">\n  <!--<![endif]-->\n  <meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">\n  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n  <style type=\"text/css\">\n    #outlook a {\n      padding: 0;\n    }\n\n    body {\n      margin: 0;\n      padding: 0;\n      -webkit-text-size-adjust: 100%;\n      -ms-text-size-adjust: 100%;\n    }\n\n    table,\n    td {\n      border-collapse: collapse;\n      mso-table-lspace: 0pt;\n      mso-table-rspace: 0pt;\n    }\n\n    img {\n      border: 0;\n      height: auto;\n      line-height: 100%;\n      outline: none;\n      text-decoration: none;\n      -ms-interpolation-mode: bicubic;\n    }\n\n    p {\n      display: block;\n      margin: 13px 0;\n    }\n  </style>\n  <!--[if mso]>\n    <noscript>\n    <xml>\n    <o:OfficeDocumentSettings>\n      <o:AllowPNG/>\n      <o:PixelsPerInch>96</o:PixelsPerInch>\n    </o:OfficeDocumentSettings>\n    </xml>\n    </noscript>\n    <![endif]-->\n  <!--[if lte mso 11]>\n    <style type=\"text/css\">\n      .mj-outlook-group-fix { width:100% !important; }\n    </style>\n    <![endif]-->\n  <!--[if !mso]><!-->\n  <link href=\"https://fonts.googleapis.com/css?family=Ubuntu:300,400,500,700\" rel=\"stylesheet\" type=\"text/css\">\n  <style type=\"text/css\">\n    @import url(https://fonts.googleapis.com/css?family=Ubuntu:300,400,500,700);\n  </style>\n  <!--<![endif]-->\n  <style type=\"text/css\">\n    @media only screen and (min-width:480px) {\n      .mj-column-per-100 {\n        width: 100% !important;\n        max-width: 100%;\n      }\n\n      .mj-column-per-50 {\n        width: 50% !important;\n        max-width: 50%;\n      }\n\n      .mj-column-per-33 {\n        width: 33% !important;\n        max-width: 33%;\n      }\n\n      .mj-column-per-33-33333333333333 {\n        width: 33.33333333333333% !important;\n        max-width: 33.33333333333333%;\n      }\n    }\n  </style>\n  <style media=\"screen and (min-width:480px)\">\n    .moz-text-html .mj-column-per-100 {\n      width: 100% !important;\n      max-width: 100%;\n    }\n\n    .moz-text-html .mj-column-per-50 {\n      width: 50% !important;\n      max-width: 50%;\n    }\n\n    .moz-text-html .mj-column-per-33 {\n      width: 33% !important;\n      max-width: 33%;\n    }\n\n    .moz-text-html .mj-column-per-33-33333333333333 {\n      width: 33.33333333333333% !important;\n      max-width: 33.33333333333333%;\n    }\n  </style>\n  <style type=\"text/css\">\n    @media only screen and (max-width:479px) {\n      table.mj-full-width-mobile {\n        width: 100% !important;\n      }\n\n      td.mj-full-width-mobile {\n        width: auto !important;\n      }\n    }\n\n    noinput.mj-menu-checkbox {\n      display: block !important;\n      max-height: none !important;\n      visibility: visible !important;\n    }\n\n    @media only screen and (max-width:479px) {\n      .mj-menu-checkbox[type=\"checkbox\"]~.mj-inline-links {\n        display: none !important;\n      }\n\n      .mj-menu-checkbox[type=\"checkbox\"]:checked~.mj-inline-links,\n      .mj-menu-checkbox[type=\"checkbox\"]~.mj-menu-trigger {\n        display: block !important;\n        max-width: none !important;\n        max-height: none !important;\n        font-size: inherit !important;\n      }\n\n      .mj-menu-checkbox[type=\"checkbox\"]~.mj-inline-links>a {\n        display: block !important;\n      }\n\n      .mj-menu-checkbox[type=\"checkbox\"]:checked~.mj-menu-trigger .mj-menu-icon-close {\n        display: block !important;\n      }\n\n      .mj-menu-checkbox[type=\"checkbox\"]:checked~.mj-menu-trigger .mj-menu-icon-open {\n        display: none !important;\n      }\n    }\n  </style>\n</head>\n\n<body style=\"word-spacing:normal;background-color:#d2eeff;\">\n  <div aria-roledescription=\"email\" role=\"article\" lang=\"und\" dir=\"auto\" style=\"word-spacing:normal;background-color:#d2eeff;\">\n    <!--[if mso | IE]><table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" class=\"\" role=\"presentation\" style=\"width:600px;\" width=\"600\" ><tr><td style=\"line-height:0px;font-size:0px;mso-line-height-rule:exactly;\"><![endif]-->\n    <div style=\"margin:0px auto;max-width:600px;\">\n      <table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"width:100%;\">\n        <tbody>\n          <tr>\n            <td style=\"direction:ltr;font-size:0px;padding:0px;padding-bottom:20px;padding-top:20px;text-align:center;\">\n              <!--[if mso | IE]><table role=\"presentation\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\"><tr><td class=\"\" style=\"width:600px;\" ><![endif]-->\n              <div class=\"mj-column-per-100 mj-outlook-group-fix\" style=\"font-size:0;line-height:0;text-align:left;display:inline-block;width:100%;direction:ltr;\">\n                <!--[if mso | IE]><table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" ><tr><td style=\"vertical-align:top;width:300px;\" ><![endif]-->\n                <div class=\"mj-column-per-50 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:50%;\">\n                  <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" width=\"100%\">\n                    <tbody>\n                      <tr>\n                        <td style=\"vertical-align:top;padding:0px;\">\n                          <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style width=\"100%\">\n                            <tbody>\n                              <tr>\n                                <td align=\"left\" style=\"font-size:0px;padding:0 20px;word-break:break-word;\">\n                                  <div style=\"font-family:Ubuntu, Helvetica, Arial, sans-serif;font-size:11px;line-height:1;text-align:left;color:#000000;\"><a href=\"https://mjml.io\" style=\"text-decoration: none; color: inherit;\">[[HEADLINE]]</a></div>\n                                </td>\n                              </tr>\n                            </tbody>\n                          </table>\n                        </td>\n                      </tr>\n                    </tbody>\n                  </table>\n                </div>\n                <!--[if mso | IE]></td><td style=\"vertical-align:top;width:300px;\" ><![endif]-->\n                <div class=\"mj-column-per-50 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:50%;\">\n                  <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" width=\"100%\">\n                    <tbody>\n                      <tr>\n                        <td style=\"vertical-align:top;padding:0px;\">\n                          <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style width=\"100%\">\n                            <tbody>\n                              <tr>\n                                <td align=\"right\" style=\"font-size:0px;padding:0 20px;word-break:break-word;\">\n                                  <div style=\"font-family:Ubuntu, Helvetica, Arial, sans-serif;font-size:11px;line-height:1;text-align:right;color:#000000;\"><a href=\"https://mjml.io\" style=\"text-decoration: none; color: inherit;\">[[PERMALINK_LABEL]]</a></div>\n                                </td>\n                              </tr>\n                            </tbody>\n                          </table>\n                        </td>\n                      </tr>\n                    </tbody>\n                  </table>\n                </div>\n                <!--[if mso | IE]></td></tr></table><![endif]-->\n              </div>\n              <!--[if mso | IE]></td></tr></table><![endif]-->\n            </td>\n          </tr>\n        </tbody>\n      </table>\n    </div>\n    <!--[if mso | IE]></td></tr></table><table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" class=\"\" role=\"presentation\" style=\"width:600px;\" width=\"600\" bgcolor=\"#ffffff\" ><tr><td style=\"line-height:0px;font-size:0px;mso-line-height-rule:exactly;\"><![endif]-->\n    <div style=\"background:#ffffff;background-color:#ffffff;margin:0px auto;max-width:600px;\">\n      <table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"background:#ffffff;background-color:#ffffff;width:100%;\">\n        <tbody>\n          <tr>\n            <td style=\"direction:ltr;font-size:0px;padding:0px;text-align:center;\">\n              <!--[if mso | IE]><table role=\"presentation\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\"><tr><td class=\"\" style=\"vertical-align:top;width:600px;\" ><![endif]-->\n              <div class=\"mj-column-per-100 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:100%;\">\n                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" width=\"100%\">\n                  <tbody>\n                    <tr>\n                      <td style=\"vertical-align:top;padding:0px;\">\n                        <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style width=\"100%\">\n                          <tbody>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:10px 0;word-break:break-word;\">\n                                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:collapse;border-spacing:0px;\">\n                                  <tbody>\n                                    <tr>\n                                      <td style=\"width:105px;\">\n                                        <img alt=\"Worldly logo\" src=\"https://static.mailjet.com/mjml-website/templates/worldly-logo.png\" style=\"border:0;display:block;outline:none;text-decoration:none;height:auto;width:100%;font-size:13px;\" width=\"105\" height=\"auto\">\n                                      </td>\n                                    </tr>\n                                  </tbody>\n                                </table>\n                              </td>\n                            </tr>\n                          </tbody>\n                        </table>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </div>\n              <!--[if mso | IE]></td></tr></table><![endif]-->\n            </td>\n          </tr>\n        </tbody>\n      </table>\n    </div>\n    <!--[if mso | IE]></td></tr></table><table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" class=\"\" role=\"presentation\" style=\"width:600px;\" width=\"600\" bgcolor=\"#ffe118\" ><tr><td style=\"line-height:0px;font-size:0px;mso-line-height-rule:exactly;\"><![endif]-->\n    <div style=\"background:#ffe118;background-color:#ffe118;margin:0px auto;max-width:600px;\">\n      <table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"background:#ffe118;background-color:#ffe118;width:100%;\">\n        <tbody>\n          <tr>\n            <td style=\"direction:ltr;font-size:0px;padding:20px;text-align:center;\">\n              <!--[if mso | IE]><table role=\"presentation\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\"><tr><td class=\"\" style=\"vertical-align:top;width:560px;\" ><![endif]-->\n              <div class=\"mj-column-per-100 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:100%;\">\n                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" width=\"100%\">\n                  <tbody>\n                    <tr>\n                      <td style=\"vertical-align:top;padding:0px;\">\n                        <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style width=\"100%\">\n                          <tbody>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:0px;word-break:break-word;\">\n                                <!--[if !mso]><!--><input type=\"checkbox\" id=\"29f3f9bba1fb0a37\" class=\"mj-menu-checkbox\" style=\"display:none !important; max-height:0; visibility:hidden;\"><!--<![endif]-->\n                                <div class=\"mj-menu-trigger\" style=\"display:none;max-height:0px;max-width:0px;font-size:0px;overflow:hidden;\">\n                                  <label for=\"29f3f9bba1fb0a37\" class=\"mj-menu-label\" style=\"display:block;cursor:pointer;mso-hide:all;-moz-user-select:none;user-select:none;color:#444444;font-size:30px;font-family:Ubuntu, Helvetica, Arial, sans-serif;text-transform:uppercase;text-decoration:none;line-height:30px;padding:10px;\" align=\"center\">\n                                    <span class=\"mj-menu-icon-open\" style=\"mso-hide:all;\"> &#9776; </span>\n                                    <span class=\"mj-menu-icon-close\" style=\"display:none;mso-hide:all;\"> &#8855; </span>\n                                  </label>\n                                </div>\n                                <div class=\"mj-inline-links\" style>\n                                  <!--[if mso | IE]><table role=\"presentation\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" align=\"center\"><tr><td style=\"padding:0 35px;\" class=\"\" ><![endif]-->\n                                  <a class=\"mj-link\" href=\"https://mjml.iohttps://mjml.io\" target=\"_blank\" style=\"display: inline-block; color: #000000; font-family: Ubuntu, Helvetica, Arial, sans-serif; font-size: 12px; font-weight: bold; line-height: 22px; text-decoration: none; text-transform: uppercase; padding: 0 35px;\"> home </a>\n                                  <!--[if mso | IE]></td><td style=\"padding:0 35px;\" class=\"\" ><![endif]-->\n                                  <a class=\"mj-link\" href=\"https://mjml.iohttps://mjml.io\" target=\"_blank\" style=\"display: inline-block; color: #000000; font-family: Ubuntu, Helvetica, Arial, sans-serif; font-size: 12px; font-weight: bold; line-height: 22px; text-decoration: none; text-transform: uppercase; padding: 0 35px;\"> Summer deals </a>\n                                  <!--[if mso | IE]></td><td style=\"padding:0 35px;\" class=\"\" ><![endif]-->\n                                  <a class=\"mj-link\" href=\"https://mjml.iohttps://mjml.io\" target=\"_blank\" style=\"display: inline-block; color: #000000; font-family: Ubuntu, Helvetica, Arial, sans-serif; font-size: 12px; font-weight: bold; line-height: 22px; text-decoration: none; text-transform: uppercase; padding: 0 35px;\"> Our blog </a>\n                                  <!--[if mso | IE]></td><td style=\"padding:0 35px;\" class=\"\" ><![endif]-->\n                                  <a class=\"mj-link\" href=\"https://mjml.iohttps://mjml.io\" target=\"_blank\" style=\"display: inline-block; color: #000000; font-family: Ubuntu, Helvetica, Arial, sans-serif; font-size: 12px; font-weight: bold; line-height: 22px; text-decoration: none; text-transform: uppercase; padding: 0 35px;\"> Follow us </a>\n                                  <!--[if mso | IE]></td></tr></table><![endif]-->\n                                </div>\n                              </td>\n                            </tr>\n                          </tbody>\n                        </table>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </div>\n              <!--[if mso | IE]></td></tr></table><![endif]-->\n            </td>\n          </tr>\n        </tbody>\n      </table>\n    </div>\n    <!--[if mso | IE]></td></tr></table><table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" class=\"\" role=\"presentation\" style=\"width:600px;\" width=\"600\" ><tr><td style=\"line-height:0px;font-size:0px;mso-line-height-rule:exactly;\"><v:rect style=\"width:600px;\" xmlns:v=\"urn:schemas-microsoft-com:vml\" fill=\"true\" stroke=\"false\"><v:fill origin=\"0, -0.5\" position=\"0, -0.5\" src=\"https://static.mailjet.com/mjml-website/templates/worldly-hero.jpg\" type=\"frame\" size=\"1,1\" aspect=\"atleast\" /><v:textbox style=\"mso-fit-shape-to-text:true\" inset=\"0,0,0,0\"><![endif]-->\n    <div style=\"background:url('https://static.mailjet.com/mjml-website/templates/worldly-hero.jpg') center top / cover no-repeat;background-position:center top;background-repeat:no-repeat;background-size:cover;margin:0px auto;max-width:600px;\">\n      <div style=\"line-height:0;font-size:0;\">\n        <table align=\"center\" background=\"https://static.mailjet.com/mjml-website/templates/worldly-hero.jpg\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"background:url('https://static.mailjet.com/mjml-website/templates/worldly-hero.jpg') center top / cover no-repeat;background-position:center top;background-repeat:no-repeat;background-size:cover;width:100%;\">\n          <tbody>\n            <tr>\n              <td style=\"direction:ltr;font-size:0px;padding:20px 0;text-align:center;\">\n                <!--[if mso | IE]><table role=\"presentation\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\"><tr><td class=\"\" style=\"vertical-align:top;width:300px;\" ><![endif]-->\n                <div class=\"mj-column-per-50 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:100%;\">\n                  <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" width=\"100%\">\n                    <tbody>\n                      <tr>\n                        <td style=\"vertical-align:top;padding:0px;\">\n                          <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style width=\"100%\">\n                            <tbody>\n                              <tr>\n                                <td align=\"center\" style=\"font-size:0px;padding:10px;word-break:break-word;\">\n                                  <div style=\"font-family:Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif;font-size:28px;line-height:32px;text-align:center;color:#ffffff;\">ARE YOU <br> SEASCAPE?</div>\n                                </td>\n                              </tr>\n                            </tbody>\n                          </table>\n                        </td>\n                      </tr>\n                    </tbody>\n                  </table>\n                </div>\n                <!--[if mso | IE]></td><td class=\"\" style=\"vertical-align:bottom;width:300px;\" ><![endif]-->\n                <div class=\"mj-column-per-50 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:bottom;width:100%;\">\n                  <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" width=\"100%\">\n                    <tbody>\n                      <tr>\n                        <td style=\"vertical-align:bottom;padding:0px;\">\n                          <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style width=\"100%\">\n                            <tbody>\n                              <tr>\n                                <td align=\"center\" style=\"font-size:0px;padding:0px;padding-top:180px;word-break:break-word;\">\n                                  <div style=\"font-family:Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif;font-size:28px;line-height:32px;text-align:center;color:#ffffff;\">OR <br> CITYSCAPE?</div>\n                                </td>\n                              </tr>\n                            </tbody>\n                          </table>\n                        </td>\n                      </tr>\n                    </tbody>\n                  </table>\n                </div>\n                <!--[if mso | IE]></td></tr></table><![endif]-->\n              </td>\n            </tr>\n          </tbody>\n        </table>\n      </div>\n    </div>\n    <!--[if mso | IE]></v:textbox></v:rect></td></tr></table><table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" class=\"\" role=\"presentation\" style=\"width:600px;\" width=\"600\" bgcolor=\"#ffffff\" ><tr><td style=\"line-height:0px;font-size:0px;mso-line-height-rule:exactly;\"><![endif]-->\n    <div style=\"background:#ffffff;background-color:#ffffff;margin:0px auto;max-width:600px;\">\n      <table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"background:#ffffff;background-color:#ffffff;width:100%;\">\n        <tbody>\n          <tr>\n            <td style=\"direction:ltr;font-size:0px;padding:20px 0;text-align:center;\">\n              <!--[if mso | IE]><table role=\"presentation\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\"><tr><td class=\"\" style=\"vertical-align:top;width:300px;\" ><![endif]-->\n              <div class=\"mj-column-per-50 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:100%;\">\n                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" width=\"100%\">\n                  <tbody>\n                    <tr>\n                      <td style=\"vertical-align:top;padding:0px;\">\n                        <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style width=\"100%\">\n                          <tbody>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:10px 25px;word-break:break-word;\">\n                                <div style=\"font-family:Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif;font-size:15px;line-height:1;text-align:center;color:#BD8714;\">\n                                  <p>SUNNIEST DESTINATIONS</p>\n                                </div>\n                              </td>\n                            </tr>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:0px;word-break:break-word;\">\n                                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:collapse;border-spacing:0px;\">\n                                  <tbody>\n                                    <tr>\n                                      <td style=\"width:240px;\">\n                                        <img alt=\"Maldives, Corse : -15%\" src=\"https://static.mailjet.com/mjml-website/templates/worldly-offer1.jpg\" style=\"border:0;display:block;outline:none;text-decoration:none;height:auto;width:100%;font-size:13px;\" width=\"240\" height=\"auto\">\n                                      </td>\n                                    </tr>\n                                  </tbody>\n                                </table>\n                              </td>\n                            </tr>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:20px 25px;word-break:break-word;\">\n                                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:separate;line-height:100%;\">\n                                  <tbody>\n                                    <tr>\n                                      <td align=\"center\" bgcolor=\"#bd8714\" role=\"presentation\" style=\"border:none;border-radius:3px;cursor:auto;mso-padding-alt:10px 25px;background:#bd8714;\" valign=\"middle\">\n                                        <a href=\"https://mjml.io\" style=\"display: inline-block; background: #bd8714; color: #FFFFFF; font-family: Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif; font-size: 13px; font-weight: normal; line-height: 120%; margin: 0; text-decoration: none; text-transform: none; padding: 10px 25px; mso-padding-alt: 0px; border-radius: 3px;\" target=\"_blank\"> BOOK NOW </a>\n                                      </td>\n                                    </tr>\n                                  </tbody>\n                                </table>\n                              </td>\n                            </tr>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:10px 25px;word-break:break-word;\">\n                                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:collapse;border-spacing:0px;\">\n                                  <tbody>\n                                    <tr>\n                                      <td style=\"width:240px;\">\n                                        <img alt=\"Tahiti, Bora Bora : -10 %\" src=\"https://static.mailjet.com/mjml-website/templates/worldly-offer2.jpg\" style=\"border:0;display:block;outline:none;text-decoration:none;height:auto;width:100%;font-size:13px;\" width=\"240\" height=\"auto\">\n                                      </td>\n                                    </tr>\n                                  </tbody>\n                                </table>\n                              </td>\n                            </tr>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:20px 25px;word-break:break-word;\">\n                                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:separate;line-height:100%;\">\n                                  <tbody>\n                                    <tr>\n                                      <td align=\"center\" bgcolor=\"#bd8714\" role=\"presentation\" style=\"border:none;border-radius:3px;cursor:auto;mso-padding-alt:10px 25px;background:#bd8714;\" valign=\"middle\">\n                                        <a href=\"https://mjml.io\" style=\"display: inline-block; background: #bd8714; color: #FFFFFF; font-family: Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif; font-size: 13px; font-weight: normal; line-height: 120%; margin: 0; text-decoration: none; text-transform: none; padding: 10px 25px; mso-padding-alt: 0px; border-radius: 3px;\" target=\"_blank\"> BOOK NOW </a>\n                                      </td>\n                                    </tr>\n                                  </tbody>\n                                </table>\n                              </td>\n                            </tr>\n                          </tbody>\n                        </table>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </div>\n              <!--[if mso | IE]></td><td class=\"\" style=\"vertical-align:top;width:300px;\" ><![endif]-->\n              <div class=\"mj-column-per-50 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:100%;\">\n                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" width=\"100%\">\n                  <tbody>\n                    <tr>\n                      <td style=\"vertical-align:top;padding:0px;\">\n                        <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style width=\"100%\">\n                          <tbody>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:10px 25px;word-break:break-word;\">\n                                <div style=\"font-family:Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif;font-size:15px;line-height:1;text-align:center;color:#BD8714;\">\n                                  <p>CHEAP CITY TOUR</p>\n                                </div>\n                              </td>\n                            </tr>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:0px;word-break:break-word;\">\n                                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:collapse;border-spacing:0px;\">\n                                  <tbody>\n                                    <tr>\n                                      <td style=\"width:240px;\">\n                                        <img alt=\"Stockholm, Rome : from 162 \u20AC / day\" src=\"https://static.mailjet.com/mjml-website/templates/worldly-offer3.jpg\" style=\"border:0;display:block;outline:none;text-decoration:none;height:auto;width:100%;font-size:13px;\" width=\"240\" height=\"auto\">\n                                      </td>\n                                    </tr>\n                                  </tbody>\n                                </table>\n                              </td>\n                            </tr>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:20px 25px;word-break:break-word;\">\n                                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:separate;line-height:100%;\">\n                                  <tbody>\n                                    <tr>\n                                      <td align=\"center\" bgcolor=\"#48b6bf\" role=\"presentation\" style=\"border:none;border-radius:3px;cursor:auto;mso-padding-alt:10px 25px;background:#48b6bf;\" valign=\"middle\">\n                                        <a href=\"https://mjml.io\" style=\"display: inline-block; background: #48b6bf; color: #FFFFFF; font-family: Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif; font-size: 13px; font-weight: normal; line-height: 120%; margin: 0; text-decoration: none; text-transform: none; padding: 10px 25px; mso-padding-alt: 0px; border-radius: 3px;\" target=\"_blank\"> BOOK NOW </a>\n                                      </td>\n                                    </tr>\n                                  </tbody>\n                                </table>\n                              </td>\n                            </tr>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:10px 25px;word-break:break-word;\">\n                                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:collapse;border-spacing:0px;\">\n                                  <tbody>\n                                    <tr>\n                                      <td style=\"width:240px;\">\n                                        <img alt=\"New York, London : -30 %\" src=\"https://static.mailjet.com/mjml-website/templates/worldly-offer4.jpg\" style=\"border:0;display:block;outline:none;text-decoration:none;height:auto;width:100%;font-size:13px;\" width=\"240\" height=\"auto\">\n                                      </td>\n                                    </tr>\n                                  </tbody>\n                                </table>\n                              </td>\n                            </tr>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:20px 25px;word-break:break-word;\">\n                                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:separate;line-height:100%;\">\n                                  <tbody>\n                                    <tr>\n                                      <td align=\"center\" bgcolor=\"#48b6bf\" role=\"presentation\" style=\"border:none;border-radius:3px;cursor:auto;mso-padding-alt:10px 25px;background:#48b6bf;\" valign=\"middle\">\n                                        <a href=\"https://mjml.io\" style=\"display: inline-block; background: #48b6bf; color: #FFFFFF; font-family: Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif; font-size: 13px; font-weight: normal; line-height: 120%; margin: 0; text-decoration: none; text-transform: none; padding: 10px 25px; mso-padding-alt: 0px; border-radius: 3px;\" target=\"_blank\"> BOOK NOW </a>\n                                      </td>\n                                    </tr>\n                                  </tbody>\n                                </table>\n                              </td>\n                            </tr>\n                          </tbody>\n                        </table>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </div>\n              <!--[if mso | IE]></td></tr></table><![endif]-->\n            </td>\n          </tr>\n        </tbody>\n      </table>\n    </div>\n    <!--[if mso | IE]></td></tr></table><table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" class=\"\" role=\"presentation\" style=\"width:600px;\" width=\"600\" bgcolor=\"#ffffff\" ><tr><td style=\"line-height:0px;font-size:0px;mso-line-height-rule:exactly;\"><![endif]-->\n    <div style=\"background:#ffffff;background-color:#ffffff;margin:0px auto;max-width:600px;\">\n      <table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"background:#ffffff;background-color:#ffffff;width:100%;\">\n        <tbody>\n          <tr>\n            <td style=\"direction:ltr;font-size:0px;padding:20px 0;text-align:center;\">\n              <!--[if mso | IE]><table role=\"presentation\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\"><tr><td class=\"\" style=\"vertical-align:top;width:300px;\" ><![endif]-->\n              <div class=\"mj-column-per-50 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:100%;\">\n                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" width=\"100%\">\n                  <tbody>\n                    <tr>\n                      <td style=\"vertical-align:top;padding:0px;\">\n                        <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style width=\"100%\">\n                          <tbody>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:0 25px;word-break:break-word;\">\n                                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:collapse;border-spacing:0px;\">\n                                  <tbody>\n                                    <tr>\n                                      <td style=\"width:250px;\">\n                                        <a href=\"https://mjml.io\" target=\"_blank\" style=\"text-decoration: none; color: inherit;\">\n                                          <img alt=\"NEW : Donwload your city guide\" src=\"https://static.mailjet.com/mjml-website/templates/worldly-image1.jpg\" style=\"border:0;display:block;outline:none;text-decoration:none;height:auto;width:100%;font-size:13px;\" width=\"250\" height=\"auto\">\n                                        </a>\n                                      </td>\n                                    </tr>\n                                  </tbody>\n                                </table>\n                              </td>\n                            </tr>\n                          </tbody>\n                        </table>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </div>\n              <!--[if mso | IE]></td><td class=\"\" style=\"vertical-align:top;width:300px;\" ><![endif]-->\n              <div class=\"mj-column-per-50 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:100%;\">\n                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" width=\"100%\">\n                  <tbody>\n                    <tr>\n                      <td style=\"vertical-align:top;padding:0px;\">\n                        <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style width=\"100%\">\n                          <tbody>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:0 25px;word-break:break-word;\">\n                                <div style=\"font-family:Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif;font-size:13px;font-weight:bold;line-height:1;text-align:center;color:#000000;\">\n                                  <p>RATE YOUR STAY !</p>\n                                </div>\n                              </td>\n                            </tr>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:0px;word-break:break-word;\">\n                                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:collapse;border-spacing:0px;\">\n                                  <tbody>\n                                    <tr>\n                                      <td style=\"width:131px;\">\n                                        <a href=\"https://mjml.io\" target=\"_blank\" style=\"text-decoration: none; color: inherit;\">\n                                          <img alt=\"Book rate\" src=\"https://static.mailjet.com/mjml-website/templates/worldly-image2.jpg\" style=\"border:0;display:block;outline:none;text-decoration:none;height:auto;width:100%;font-size:13px;\" width=\"131\" height=\"auto\">\n                                        </a>\n                                      </td>\n                                    </tr>\n                                  </tbody>\n                                </table>\n                              </td>\n                            </tr>\n                          </tbody>\n                        </table>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </div>\n              <!--[if mso | IE]></td></tr></table><![endif]-->\n            </td>\n          </tr>\n        </tbody>\n      </table>\n    </div>\n    <!--[if mso | IE]></td></tr></table><table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" class=\"\" role=\"presentation\" style=\"width:600px;\" width=\"600\" bgcolor=\"#4b525c\" ><tr><td style=\"line-height:0px;font-size:0px;mso-line-height-rule:exactly;\"><![endif]-->\n    <div style=\"background:#4b525c;background-color:#4b525c;margin:0px auto;max-width:600px;\">\n      <table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"background:#4b525c;background-color:#4b525c;width:100%;\">\n        <tbody>\n          <tr>\n            <td style=\"direction:ltr;font-size:0px;padding:0px;text-align:center;\">\n              <!--[if mso | IE]><table role=\"presentation\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\"><tr><td class=\"\" style=\"vertical-align:top;width:198px;\" ><![endif]-->\n              <div class=\"mj-column-per-33 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:100%;\">\n                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" width=\"100%\">\n                  <tbody>\n                    <tr>\n                      <td style=\"vertical-align:top;padding:0px;\">\n                        <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style width=\"100%\">\n                          <tbody>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:10px 25px;word-break:break-word;\">\n                                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:collapse;border-spacing:0px;\">\n                                  <tbody>\n                                    <tr>\n                                      <td style=\"width:30px;\">\n                                        <img alt=\"Best companies for your flights\" src=\"https://static.mailjet.com/mjml-website/templates/worldly-icon1.png\" style=\"border:0;display:block;outline:none;text-decoration:none;height:auto;width:100%;font-size:13px;\" width=\"30\" height=\"auto\">\n                                      </td>\n                                    </tr>\n                                  </tbody>\n                                </table>\n                              </td>\n                            </tr>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:0 25px;word-break:break-word;\">\n                                <div style=\"font-family:Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif;font-size:15px;line-height:1;text-align:center;color:#ffffff;\">\n                                  <p> BEST COMPANIES FOR YOUR FLIGHTS </p>\n                                </div>\n                              </td>\n                            </tr>\n                          </tbody>\n                        </table>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </div>\n              <!--[if mso | IE]></td><td class=\"\" style=\"vertical-align:top;width:198px;\" ><![endif]-->\n              <div class=\"mj-column-per-33 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:100%;\">\n                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" width=\"100%\">\n                  <tbody>\n                    <tr>\n                      <td style=\"vertical-align:top;padding:0px;\">\n                        <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style width=\"100%\">\n                          <tbody>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:10px 25px;word-break:break-word;\">\n                                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:collapse;border-spacing:0px;\">\n                                  <tbody>\n                                    <tr>\n                                      <td style=\"width:29px;\">\n                                        <img alt=\"Insurances included\" src=\"https://static.mailjet.com/mjml-website/templates/worldly-icon2.png\" style=\"border:0;display:block;outline:none;text-decoration:none;height:auto;width:100%;font-size:13px;\" width=\"29\" height=\"auto\">\n                                      </td>\n                                    </tr>\n                                  </tbody>\n                                </table>\n                              </td>\n                            </tr>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:0 25px;word-break:break-word;\">\n                                <div style=\"font-family:Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif;font-size:15px;line-height:1;text-align:center;color:#ffffff;\">\n                                  <p> INSURANCES INCLUDED </p>\n                                </div>\n                              </td>\n                            </tr>\n                          </tbody>\n                        </table>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </div>\n              <!--[if mso | IE]></td><td class=\"\" style=\"vertical-align:top;width:198px;\" ><![endif]-->\n              <div class=\"mj-column-per-33 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:100%;\">\n                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" width=\"100%\">\n                  <tbody>\n                    <tr>\n                      <td style=\"vertical-align:top;padding:0px;\">\n                        <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style width=\"100%\">\n                          <tbody>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:10px 25px;word-break:break-word;\">\n                                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:collapse;border-spacing:0px;\">\n                                  <tbody>\n                                    <tr>\n                                      <td style=\"width:31px;\">\n                                        <img alt=\"Hotels best selection\" src=\"https://static.mailjet.com/mjml-website/templates/worldly-icon3.png\" style=\"border:0;display:block;outline:none;text-decoration:none;height:auto;width:100%;font-size:13px;\" width=\"31\" height=\"auto\">\n                                      </td>\n                                    </tr>\n                                  </tbody>\n                                </table>\n                              </td>\n                            </tr>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:0 25px;word-break:break-word;\">\n                                <div style=\"font-family:Ubuntu, Helvetica, Arial, sans-serif, Helvetica, Arial, sans-serif;font-size:15px;line-height:1;text-align:center;color:#ffffff;\">\n                                  <p> HOTELS BEST SELECTION </p>\n                                </div>\n                              </td>\n                            </tr>\n                          </tbody>\n                        </table>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </div>\n              <!--[if mso | IE]></td></tr></table><![endif]-->\n            </td>\n          </tr>\n        </tbody>\n      </table>\n    </div>\n    <!--[if mso | IE]></td></tr></table><table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" class=\"\" role=\"presentation\" style=\"width:600px;\" width=\"600\" bgcolor=\"#4395b1\" ><tr><td style=\"line-height:0px;font-size:0px;mso-line-height-rule:exactly;\"><![endif]-->\n    <div style=\"background:#4395b1;background-color:#4395b1;margin:0px auto;max-width:600px;\">\n      <table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"background:#4395b1;background-color:#4395b1;width:100%;\">\n        <tbody>\n          <tr>\n            <td style=\"direction:ltr;font-size:0px;padding:0px;text-align:center;\">\n              <!--[if mso | IE]><table role=\"presentation\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\"><tr><td class=\"\" style=\"vertical-align:top;width:200px;\" ><![endif]-->\n              <div class=\"mj-column-per-33-33333333333333 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:100%;\">\n                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" width=\"100%\">\n                  <tbody>\n                    <tr>\n                      <td style=\"vertical-align:top;padding:0px;\">\n                        <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style width=\"100%\">\n                          <tbody>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:10px 25px;word-break:break-word;\">\n                                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:collapse;border-spacing:0px;\">\n                                  <tbody>\n                                    <tr>\n                                      <td style=\"width:97px;\">\n                                        <img alt=\"Call us : 0 800 123 456\" src=\"https://static.mailjet.com/mjml-website/templates/worldly-footerlogo.png\" style=\"border:0;display:block;outline:none;text-decoration:none;height:auto;width:100%;font-size:13px;\" width=\"97\" height=\"auto\">\n                                      </td>\n                                    </tr>\n                                  </tbody>\n                                </table>\n                              </td>\n                            </tr>\n                          </tbody>\n                        </table>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </div>\n              <!--[if mso | IE]></td><td class=\"\" style=\"vertical-align:top;width:200px;\" ><![endif]-->\n              <div class=\"mj-column-per-33-33333333333333 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:100%;\">\n                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" width=\"100%\">\n                  <tbody>\n                    <tr>\n                      <td style=\"vertical-align:top;padding:0px;\">\n                        <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style width=\"100%\">\n                          <tbody>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:10px 25px;word-break:break-word;\">\n                                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:collapse;border-spacing:0px;\">\n                                  <tbody>\n                                    <tr>\n                                      <td style=\"width:117px;\">\n                                        <a href=\"https://mjml.io\" target=\"_blank\" style=\"text-decoration: none; color: inherit;\">\n                                          <img alt=\"Meet us : find an agency\" src=\"https://static.mailjet.com/mjml-website/templates/worldly-contact1.png\" style=\"border:0;display:block;outline:none;text-decoration:none;height:auto;width:100%;font-size:13px;\" width=\"117\" height=\"auto\">\n                                        </a>\n                                      </td>\n                                    </tr>\n                                  </tbody>\n                                </table>\n                              </td>\n                            </tr>\n                          </tbody>\n                        </table>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </div>\n              <!--[if mso | IE]></td><td class=\"\" style=\"vertical-align:top;width:200px;\" ><![endif]-->\n              <div class=\"mj-column-per-33-33333333333333 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:100%;\">\n                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" width=\"100%\">\n                  <tbody>\n                    <tr>\n                      <td style=\"vertical-align:top;padding:0px;\">\n                        <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style width=\"100%\">\n                          <tbody>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:10px 25px;word-break:break-word;\">\n                                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"border-collapse:collapse;border-spacing:0px;\">\n                                  <tbody>\n                                    <tr>\n                                      <td style=\"width:110px;\">\n                                        <a href=\"https://mjml.io\" target=\"_blank\" style=\"text-decoration: none; color: inherit;\">\n                                          <img alt=\"ASK US : find an expert\" src=\"https://static.mailjet.com/mjml-website/templates/worldly-contact2.png\" style=\"border:0;display:block;outline:none;text-decoration:none;height:auto;width:100%;font-size:13px;\" width=\"110\" height=\"auto\">\n                                        </a>\n                                      </td>\n                                    </tr>\n                                  </tbody>\n                                </table>\n                              </td>\n                            </tr>\n                          </tbody>\n                        </table>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </div>\n              <!--[if mso | IE]></td></tr></table><![endif]-->\n            </td>\n          </tr>\n        </tbody>\n      </table>\n    </div>\n    <!--[if mso | IE]></td></tr></table><table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" class=\"\" role=\"presentation\" style=\"width:600px;\" width=\"600\" ><tr><td style=\"line-height:0px;font-size:0px;mso-line-height-rule:exactly;\"><![endif]-->\n    <div style=\"margin:0px auto;max-width:600px;\">\n      <table align=\"center\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style=\"width:100%;\">\n        <tbody>\n          <tr>\n            <td style=\"direction:ltr;font-size:0px;padding:20px 0;text-align:center;\">\n              <!--[if mso | IE]><table role=\"presentation\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\"><tr><td class=\"\" style=\"vertical-align:top;width:600px;\" ><![endif]-->\n              <div class=\"mj-column-per-100 mj-outlook-group-fix\" style=\"font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:100%;\">\n                <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" width=\"100%\">\n                  <tbody>\n                    <tr>\n                      <td style=\"vertical-align:top;padding:0px;\">\n                        <table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" role=\"presentation\" style width=\"100%\">\n                          <tbody>\n                            <tr>\n                              <td align=\"center\" style=\"font-size:0px;padding:0px;word-break:break-word;\">\n                                <div style=\"font-family:Ubuntu, Helvetica, Arial, sans-serif;font-size:11px;line-height:1;text-align:center;color:#000000;\">[[DELIVERY_INFO]] <p>[[POSTAL_ADDRESS]]</p>\n                                </div>\n                              </td>\n                            </tr>\n                          </tbody>\n                        </table>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </div>\n              <!--[if mso | IE]></td></tr></table><![endif]-->\n            </td>\n          </tr>\n        </tbody>\n      </table>\n    </div>\n    <!--[if mso | IE]></td></tr></table><![endif]-->\n  </div>\n</body>\n\n</html>\n";
+
+type HtmlTokenType = 'delimiter' | 'tagName' | 'attributeName' | 'attributeValue' | 'comment';
+interface HtmlToken {
+    type: HtmlTokenType;
+    from: number;
+    to: number;
+}
+interface HtmlTag {
+    /** Lower-cased tag name. */
+    name: string;
+    kind: 'open' | 'close';
+    selfClosing: boolean;
+    /** False when the tag never reaches its `>` (e.g. `<div` at end of input). */
+    terminated: boolean;
+    from: number;
+    to: number;
+    nameFrom: number;
+    nameTo: number;
+}
+interface HtmlScan {
+    tokens: HtmlToken[];
+    tags: HtmlTag[];
+}
+/** The responsiveness ledger's floor: below it iOS Mail auto-inflates text
+    and reflows the layout. The picker never offers less; a hand-typed size
+    is linted. */
+declare const MIN_FONT_SIZE = 14;
+/** The ledger's line budget: about this many characters fit a 320px line at
+    14px. A longer run with no break point forces the email to scroll
+    sideways. */
+declare const MAX_UNBROKEN_RUN = 40;
+/** How the source is read: the parse mode of the visual editor it feeds.
+    `repair` (the default) lints and formats for the canonical import;
+    `email` and `preserve` for markup kept as authored — the document
+    envelope formats whole, a wide style breaks reversibly, comments are
+    content, and `email` warns on whatever the email vocabulary drops. */
+interface SourceOptions {
+    mode?: ParseMode;
+}
+interface HtmlDiagnostic {
+    from: number;
+    to: number;
+    severity: 'error' | 'warning';
+    message: string;
+}
+/** Tags the composer's own blocks are built from — the autocomplete's
+    suggestions. What the parse *accepts* is wider: see `email-vocabulary.ts`. */
+declare const EMAIL_SAFE_TAGS: Set<string>;
+/** Single-pass scanner producing highlight tokens and a tag event stream. */
+declare function scanHTML(source: string): HtmlScan;
+/** Balance-checks the tag stream: unclosed tags, stray closers, closed void
+    elements, and an error for a comment that never closes. What else is
+    flagged follows the parse mode (see {@link SourceOptions}): in `repair`,
+    tags outside the email-safe set and comments the schema drops; in
+    `email`, every tag, attribute and CSS property outside the email
+    vocabulary — exactly what that parse drops (the document envelope is
+    inside it: Gmail strips the head, and that is fine). */
+declare function lintHTML(source: string, scan?: HtmlScan, options?: SourceOptions): HtmlDiagnostic[];
+/** Complete character references (`&amp;`, `&#169;`, `&#xA9;`) — spans that
+    edits and selection endpoints must treat as atomic: splitting one breaks
+    the reference and changes the decoded text. */
+declare function entitySpans(source: string): [number, number][];
+/** Text regions of the source — everything outside tags and comments. */
+/** The runs of source outside tags and comments — running text, where tokens
+    live. Exported for the highlighter. */
+declare function textRegions(source: string, scan: HtmlScan): [number, number][];
+/** Names of tags still open at the end of the source, outermost first.
+    Powers `</` auto-completion: the innermost open tag is the last entry. */
+declare function openTags(source: string, scan?: HtmlScan): string[];
+/** What the cursor is in the middle of typing, for autocomplete. */
+type CompletionContext = {
+    kind: 'tag';
+    query: string;
+} | {
+    kind: 'closing';
+    query: string;
+} | {
+    kind: 'attribute';
+    tag: string;
+    query: string;
+    existing: string[];
+} | {
+    kind: 'style-property';
+    tag: string;
+    query: string;
+};
+/**
+ * Derives the completion context at a source offset — like the slash menu,
+ * this reads the *document*, not keystrokes, so it survives any way the text
+ * got there. Returns `null` when the cursor is in plain prose or a
+ * non-`style` attribute value.
+ */
+declare function completionContextAt(source: string, offset: number): CompletionContext | null;
+/**
+ * Pretty-prints HTML for the source editor: block tags on their own indented
+ * lines, inline content kept together. Parses through the browser's DOM, so
+ * malformed input comes back auto-corrected — formatting is also repair.
+ *
+ * A whole document (doctype, `<html>`, `<head>`) formats as one: the head is
+ * printed in exactly the canonical line form the parse stores (see
+ * `canonicalHead`), so the pretty source and the canonical document can never
+ * disagree about it.
+ */
+/** The width the formatter optimizes for — Prettier's. Email HTML is built
+    for arbitrary line lengths; the formatter only ever adds whitespace the
+    parser discards, so a break lands on a space in running text (never
+    inside a tag, an attribute value or a `{{ }}` token) or between a tag's
+    attributes. A word wider than the line stays whole and overflows. */
+declare const FORMAT_WIDTH = 80;
+declare function formatHTML(html: string, indent?: string, width?: number, options?: SourceOptions): string;
+
+/**
+ * The dual-contrast rule (we don't fight dark mode): a text color is only
+ * offered if it reads against both a white and a near-black background, so
+ * it survives light mode and forced dark-mode inversion without a single
+ * dark-mode declaration in the output.
+ *
+ * Honest math note: 4.5:1 (WCAG AA body text) against *both* backgrounds is
+ * mathematically empty — no color satisfies it. 3:1, the WCAG threshold for
+ * large text and UI components, leaves a band of mid-tones; that band is the
+ * palette. Enforcement lives here, at the affordance — colors hand-typed in
+ * the HTML source are the author's own responsibility and are never policed.
+ */
+/** Light-mode reference background. */
+declare const DUAL_CONTRAST_LIGHT = "#ffffff";
+/** Typical forced-inversion background (Gmail dark mode territory). */
+declare const DUAL_CONTRAST_DARK = "#121212";
+/** WCAG large-text/UI threshold — see the math note above for why not 4.5. */
+declare const DUAL_CONTRAST_MIN_RATIO = 3;
+/** WCAG relative luminance of a `#rrggbb` color. */
+declare function relativeLuminance(hex: string): number;
+/** WCAG contrast ratio between two `#rrggbb` colors, 1..21. */
+declare function contrastRatio(a: string, b: string): number;
+/** Whether a color reads against both the light and the dark reference. */
+declare function passesDualContrast(hex: string): boolean;
+interface PaletteColor {
+    name: string;
+    value: string;
+    /** Offered although it fails its palette's rule — and why. The palette
+        tests hold every other swatch to the rule, and this one to failing it,
+        so an exception is always a decision on record, never an accident. */
+    exception?: string;
+}
+/**
+ * The dual-contrast rule for *backgrounds* (principle 9, again). Dark mode
+ * hits a fill in two different ways, and a fill must survive both:
+ *
+ *   1. **Non-transforming dark modes** (Apple Mail, and any surface that only
+ *      flips the *default text* to near-white while explicit styles stay):
+ *      near-white text on an untouched pale fill is unreadable. No palette can
+ *      fix this — the fix is that every fill is **paired with an explicit
+ *      text colour** inline ({@link fillTextColor}), so the text on a fill
+ *      never depends on the client's default.
+ *   2. **Forced inversion** (Gmail/Outlook dark mode): fill *and* text are
+ *      recoloured together — a pale fill becomes dark, its near-black text
+ *      near-white; a dark fill becomes light, its white text dark. The pair
+ *      must still read after that flip.
+ *
+ * Unlike the text rule (mid-tones), this selects the **ends**: pale tints
+ * paired with near-black text, and near-blacks paired with white. Mid-tone
+ * fills fail one side and are excluded — enforcement at the affordance, never
+ * policing hand-typed source.
+ */
+declare const DUAL_BACKGROUND_MIN_RATIO = 4.5;
+/**
+ * The text colour a pale fill carries (highlight span, table cell, column
+ * panel) alongside its `background-color`. Near-black, so it reads on every
+ * pale fill in light mode and in non-transforming dark modes; its complement
+ * is near-white, so forced inversion keeps the pair readable. Emitted as an
+ * *artifact of the fill* — parsing absorbs it back to "no explicit colour"
+ * (see {@link isFillTextColor}), so it round-trips clean.
+ */
+declare const FILL_TEXT_COLOR = "#202124";
+/** {@link FILL_TEXT_COLOR} as the CSSOM serialises it. */
+declare const FILL_TEXT_COLOR_RGB = "rgb(32, 33, 36)";
+/** The text colour a dark fill carries: white — the mirror of
+    {@link FILL_TEXT_COLOR}, for the same two dark-mode reasons. */
+declare const FILL_TEXT_COLOR_LIGHT = "#ffffff";
+/** The text a fill is paired with: white on a dark fill, near-black on
+    anything else (a colour this cannot read included). */
+declare function fillTextColor(background: string): string;
+/** Whether a parsed `color` is the text paired with `background` (hex or
+    CSSOM rgb form) — an emit artifact to absorb, not an authored colour to
+    keep. */
+declare function isFillTextColor(raw: string | null | undefined, background: string): boolean;
+/** Whether a fill reads with the text it is paired with ({@link fillTextColor})
+    both as-is (light mode and non-transforming dark modes) and after forced
+    inversion. */
+declare function passesDualBackground(hex: string): boolean;
+/**
+ * The curated background palette: white, pale tints and a near-black, all
+ * passing {@link passesDualBackground} — proven by test. Shared by every
+ * background affordance (text highlight, table cells, column panels) so fills
+ * read the same everywhere and survive inversion. Black carries white text.
+ */
+declare const emailBackgroundPalette: PaletteColor[];
+/**
+ * The curated text palette: mid-tone hues that pass {@link passesDualContrast}
+ * — proven by test, not by promise. This is what a color picker should offer
+ * instead of an arbitrary hex input.
+ *
+ * Black and white are the two exceptions (no neutral near either end passes:
+ * the band runs from #616161 to #949494), offered because a writer needs
+ * them — black to take coloured text back to plain, white for text on a dark
+ * fill.
+ */
+declare const emailTextPalette: PaletteColor[];
+
+/**
+ * The client-support data module (M3): a curated, versioned subset of what
+ * caniemail documents about our floor clients. Pure data + lookups — the
+ * lint engine, tooltips and (later) autocomplete all read from here.
+ *
+ * Curation rule: only entries we are confident about, phrased as what
+ * *actually happens* in the client. Accuracy beats coverage.
+ */
+type EmailClient = 'gmail' | 'outlook-desktop' | 'outlook-web' | 'apple-mail' | 'yahoo';
+declare const CLIENT_LABELS: Record<EmailClient, string>;
+declare function clientList(clients: EmailClient[]): string;
+interface CssSupportIssue {
+    /** Lower-cased CSS property this entry describes. */
+    property: string;
+    /** Restrict to matching values (e.g. display:flex, background:url(…)). */
+    valuePattern?: RegExp;
+    /** Restrict to these tags (e.g. padding is fine on table cells). */
+    onTags?: string[];
+    /** Clients where the declaration does not do what it says. */
+    ignoredBy: EmailClient[];
+    /** What actually happens — this is the tooltip. */
+    note: string;
+}
+declare const CSS_SUPPORT: CssSupportIssue[];
+/** Issues that apply to a concrete declaration on a concrete tag. */
+declare function findCssIssues(property: string, value: string, tag: string): CssSupportIssue[];
+/** Attributes worth suggesting per email-safe tag; `'*'` applies to all.
+    The schema knows what is legal — autocomplete offers only that. */
+declare const EMAIL_TAG_ATTRIBUTES: Record<string, string[]>;
+/** Style properties safe enough to *suggest*. Anything here that still has
+    a CSS_SUPPORT entry (max-width, padding) is legitimate but situational —
+    the lint explains the situation when it applies. */
+declare const EMAIL_SAFE_STYLE_PROPERTIES: string[];
+/** Gmail clips messages above ~102 KB — the recipient sees a truncated email
+    with a "[View entire message]" link, and tracking of anything below the
+    clip is lost. The hardest size constraint in email. */
+declare const GMAIL_CLIP_BYTES: number;
+interface SizeBudget {
+    bytes: number;
+    limit: number;
+    level: 'ok' | 'warning' | 'error';
+}
+/** UTF-8 size of the canonical HTML against the Gmail clipping limit;
+    warning from 80% of the budget, error above it. */
+declare function emailSizeBudget(html: string): SizeBudget;
+
+/** The clients a rendering can be drawn for: the three that matter, and
+    that read HTML differently enough to look at one by one. */
+type RenderingClient = 'apple-mail' | 'gmail' | 'outlook-desktop';
+declare const RENDERING_CLIENTS: readonly RenderingClient[];
+interface ClientRenderingOptions {
+    /** Draw the client's dark mode: Gmail's forced inversion, Apple Mail's
+        and Outlook's own dark surfaces. */
+    dark?: boolean;
+    /** The reading pane: a phone draws the message edge to edge (iOS Mail,
+        the Gmail app), a desktop pane keeps a margin round it. Default
+        desktop. */
+    pane?: 'phone' | 'desktop';
+}
+/**
+ * The email as a client would draw it — a simulation, in a browser, of what
+ * each client keeps of the HTML and what it drops, from the same
+ * client-support data the linter reads. Not a screenshot service: what the
+ * data says a client ignores is taken out, what only that client reads is
+ * put in, and the client's own surface (its default face, size and colours)
+ * is laid underneath. The result is a whole document for a sandboxed frame.
+ *
+ * - **Apple Mail** reads it all: the document as it is, on Apple's surface.
+ * - **Gmail** drops the comments, the form controls (a hamburger's
+ *   checkbox and label), every `<style>` rule whose selector it cannot
+ *   match (pseudo-classes, attribute selectors, sibling combinators), and
+ *   the declarations the data marks as ignored there (position, flex and
+ *   grid, transforms, animation). Its dark mode inverts the colours.
+ * - **Outlook on Windows** reads what the Word engine reads: the
+ *   conditional comments meant for it are opened (`[if mso]`, `[if mso |
+ *   IE]`, `[if gte mso 9]`) and the parts kept from it are taken out
+ *   (`[if !mso]><!-->` … `<!--<![endif]`); media queries go; the
+ *   declarations the data marks as ignored go (`max-width`, a padding on
+ *   anything but a cell, `border-radius`, background images, floats,
+ *   shadows, and the rest), and an `inline-block` block stacks. VML is left
+ *   standing — a browser draws none of it, so a picture behind text shows
+ *   as the colour beneath, which is what an Outlook without VML shows too.
+ *
+ * Takes a fragment (the editor's canonical HTML) or a whole document (an
+ * import as it was pasted): a document keeps its head — its `<style>`,
+ * subject to the client — with the client's surface laid before it.
+ */
+declare function renderForClient(html: string, client: RenderingClient, options?: ClientRenderingOptions): string;
+/** Gmail keeps a rule whose selector it can match — elements, classes,
+    ids, descendants — and drops one with a pseudo-class, an attribute
+    selector or a sibling combinator; media queries it keeps. */
+declare function keepGmailRules(css: string): string;
+/** The Word engine reads no media query. */
+declare function dropMediaQueries(css: string): string;
+
+/**
+ * The `text/plain` projection of canonical email HTML — the multipart
+ * alternative every well-formed email should carry (spam scoring cares, and
+ * some recipients read it). Blockquotes become `> `, lists become `- ` /
+ * `1. `, links keep their URL, images fall back to their alt text.
+ */
+declare function emailPlainText(html: string): string;
+
+interface EmailDocumentOptions {
+    /** The body's language (`en`, `ja`, `de`, …) — screen readers pick their
+        voice from it, and for CJK it picks the glyph set: without `lang="ja"`
+        a client may draw Japanese text with Chinese forms. */
+    lang?: string;
+    /** Text direction; `auto` (the default) lets the first strong character
+        decide, so a right-to-left body renders right-to-left unasked. */
+    dir?: 'ltr' | 'rtl' | 'auto';
+    /** The document `<title>` — usually the subject. Webmail ignores it; the
+        clients that open the message as a page (web views, some Android apps)
+        show it. */
+    title?: string;
+    /** The inbox snippet shown next to the subject. Without it the client
+        takes the first text it finds — often an image's alt or a greeting. */
+    previewText?: string;
+}
+/**
+ * The body's head and shell: the fixes every mail client needs, none of which
+ * belongs in the editor's canonical HTML.
+ *
+ * - Outlook on Windows scales everything by the screen DPI unless told the
+ *   document is 96 DPI (`o:PixelsPerInch`), and blocks PNGs without
+ *   `o:AllowPNG`. The Office XML sits in a conditional comment only Outlook
+ *   reads; every other client drops comments.
+ * - iOS enlarges small text unless `-webkit-text-size-adjust` says not to,
+ *   and Apple Mail rewraps layouts unless
+ *   `x-apple-disable-message-reformatting` is set.
+ * - The body sits in `role="article" aria-roledescription="email"`, which
+ *   screen readers announce as the message, carrying `lang` and `dir`.
+ *
+ * Everything the email needs is inline. The head's one `<style>` rule is an
+ * enhancement nothing depends on: on a phone a stacked column takes the
+ * whole width instead of its desktop cap (columns.ts, `STACK_RULE`). A
+ * client that strips the head (Gmail's app with a non-Google account)
+ * keeps the cap — narrower, still whole — and loses nothing else, which is
+ * the same rule the canonical HTML already keeps.
+ *
+ * The result is for the transport, not for the editor: parse and
+ * `emailPlainText` take the fragment `serializeToHTML` returns (the preview
+ * text would otherwise read as body text).
+ */
+declare function emailDocument(html: string, options?: EmailDocumentOptions): string;
+
+/**
+ * The inbound message a reply or forward is built from. Everything here is
+ * caller-supplied **data**: the documents render what becomes content — the
+ * reply attribution line, the forwarded-message header block — and
+ * {@link replyEnvelope} reads the addressing to propose who the answer goes
+ * to. Sending stays the host's.
+ *
+ * Address fields are header form — mailboxes separated by commas, a name
+ * holding a comma quoted: `Jane <jane@x>, "Miller, Bob" <bob@x>`.
+ */
+interface InboundMessage {
+    /** The inbound body as HTML. Preferred over `text` when both exist. */
+    html?: string;
+    /** The `text/plain` part — the content when no HTML part exists. */
+    text?: string;
+    /** Sender, rendered exactly as given ("Jane Doe" or "Jane <jane@x>"). */
+    from?: string;
+    /** Sent date: a `Date` (formatted via `locale`) or a preformatted string. */
+    date?: Date | string;
+    /** The forward header's Subject line, and what a reply's subject answers. */
+    subject?: string;
+    /** The forward header's To line, and who a reply-all copies. */
+    to?: string;
+    /** Who a reply-all copies besides `to`. Never rendered. */
+    cc?: string;
+    /** Where the sender asked answers to go — a reply goes there instead of
+        `from` when it is set. Never rendered. */
+    replyTo?: string;
+}
+interface ComposeSeedOptions {
+    /** BCP 47 locale for formatting a `Date`-typed `date`. Default `en-US`.
+        A string `date` is always used verbatim — pass one for full control. */
+    locale?: string;
+    /** The words the seeds write into the document, in the host's language.
+        Each one left out stays English. */
+    labels?: ComposeSeedLabels;
+}
+/**
+ * The words a reply or forward writes into the document. Plain text, never
+ * markup — the seeds put them into text nodes, so a sender's `<` stays a `<`.
+ * A host with translation files maps its keys here once:
+ *
+ * ```ts
+ * labels: {
+ *   attribution: ({ from, date }) =>
+ *     from ? translate.instant('REPLY.WROTE', { from, date }) : null,
+ *   forwarded: translate.instant('FORWARD.HEADER'),
+ *   from: translate.instant('FORWARD.FROM'),
+ * }
+ * ```
+ */
+interface ComposeSeedLabels {
+    /** The reply's attribution line, from what is known of the message — the
+        sender as given, the date already formatted for `locale`; either may be
+        missing. A function, not a pattern, because languages order the two
+        differently ("Am {date} schrieb {from}:") and each decides what a
+        partial line says. Null or empty: no line; the quote stands alone.
+        Default: "On {date}, {from} wrote:", "{from} wrote:", "On {date}:". */
+    attribution?: (known: {
+        from?: string;
+        date?: string;
+    }) => string | null;
+    /** The prefix a reply's subject starts with, space included. Default "Re: ". */
+    re?: string;
+    /** The prefix a forward's subject starts with, space included. Default "Fwd: ". */
+    fwd?: string;
+    /** The forward's opening line. Default "---------- Forwarded message ---------". */
+    forwarded?: string;
+    /** The forward header's field names. Default "From", "Date", "Subject", "To". */
+    from?: string;
+    date?: string;
+    subject?: string;
+    to?: string;
+}
+/**
+ * The shape modern MIME parsers hand back — postal-mime's `Email`, and
+ * anything structurally like it. Accepted **duck-typed** so this library
+ * never depends on any parser: parsing `.eml` is a solved problem with a
+ * decade of edge-case scar tissue (postal-mime, mailparser), and we don't
+ * compete with it. {@link toInboundMessage} is the whole integration.
+ */
+interface ParsedEmailLike {
+    html?: string | null;
+    text?: string | null;
+    subject?: string | null;
+    /** ISO string (postal-mime), `Date`, or any human-readable string. */
+    date?: string | Date | null;
+    from?: ParsedAddressLike | null;
+    to?: ParsedAddressLike[] | null;
+    cc?: ParsedAddressLike[] | null;
+    replyTo?: ParsedAddressLike[] | null;
+}
+interface ParsedAddressLike {
+    name?: string | null;
+    address?: string | null;
+    /** A group's members (postal-mime's shape): the group's name is no mailbox. */
+    group?: ParsedAddressLike[] | null;
+}
+/**
+ * Bridges a parser result into the seeds — the only glue an `.eml` import
+ * needs, front- or backend-parsed alike:
+ *
+ * ```ts
+ * const parsed = await PostalMime.parse(file);           // File is a Blob
+ * html.set(importedDocument(toInboundMessage(parsed)));  // import it
+ * // …or replyDocument(toInboundMessage(parsed)) to answer it.
+ * ```
+ *
+ * Every field is optional and null-tolerant, so a partial parse still seeds
+ * a sensible document. A parseable date becomes a `Date` (the seeds format
+ * it via Intl with your locale); anything else passes through verbatim.
+ */
+declare function toInboundMessage(parsed: ParsedEmailLike, options?: {
+    addressRules?: AddressRules;
+}): InboundMessage;
+/**
+ * The quoted history of a reply: the attribution line and the inbound
+ * message wrapped in a blockquote — what the editor keeps beside the body
+ * (`createEditor({ quoted })`, `QuotedHistory`), so no template, import or
+ * source edit ever replaces it.
+ *
+ * The history **is** the schema's blockquote — deliberately not a dedicated
+ * node: our output carries no classes, so it would have no honest parse
+ * discriminator against a plain blockquote (Gmail's `class="gmail_quote"`
+ * drops on parse like every class). Keeping it beside the body is what
+ * tells it apart.
+ */
+declare function replyQuote(inbound: InboundMessage, options?: ComposeSeedOptions): string;
+/**
+ * The reply as one document — an empty line to type on, then
+ * {@link replyQuote}'s history *in* the body, where it is ordinary text. For
+ * a host without the kept history; with it, seed the body empty and pass
+ * `replyQuote` as `quoted`.
+ */
+declare function replyDocument(inbound: InboundMessage, options?: ComposeSeedOptions): string;
+/**
+ * The history of a forward: the conventional forwarded-message header block
+ * (only the lines whose data was supplied), a separating empty line, then
+ * the inbound message **unquoted** — a forward passes the message along, it
+ * doesn't comment on it. Kept beside the body like {@link replyQuote}.
+ */
+declare function forwardQuote(inbound: InboundMessage, options?: ComposeSeedOptions): string;
+/** The forward as one document — an empty line, then {@link forwardQuote}'s
+    history in the body. See {@link replyDocument}. */
+declare function forwardDocument(inbound: InboundMessage, options?: ComposeSeedOptions): string;
+/**
+ * A body with its quoted history under it — the message as it goes out,
+ * for a host that holds the two as strings (a preview, its own send). A
+ * whole document keeps its head; the history lands at the end of its body.
+ */
+declare function withQuotedHistory(html: string, quoted: string | null, options?: ParseOptions): string;
+/** Who an answer is for: the sender, everyone on the message, or — a
+    forward — nobody yet. */
+type ReplyKind = 'reply' | 'reply-all' | 'forward';
+interface ReplyEnvelopeOptions extends ComposeSeedOptions {
+    /** The account's own addresses. A reply-all never copies them, and a
+        reply to one's own message goes to the people it went to. */
+    self?: string | readonly string[];
+    /** Who the answer goes to instead of the sender — a CRM's customer, say.
+        A reply-all then copies the sender with everyone else. */
+    to?: readonly string[];
+    /** The address rule to read the headers by — the host's, when it has one
+        (the same it provides to the address input). Ours by default. */
+    addressRules?: AddressRules;
+}
+/** The envelope an answer starts with. Addresses in header form, each
+    recipient once — what `[email-address-input]` holds. */
+interface ReplyEnvelope {
+    to: string[];
+    cc: string[];
+    subject: string;
+}
+/**
+ * Who an answer goes to and what it is called — the envelope half of the
+ * seed, beside {@link replyDocument} / {@link forwardDocument}'s body. Pure;
+ * pass the same options to both:
+ *
+ * ```ts
+ * const seed = { locale, labels, self: account.email };
+ * const { to, cc, subject } = replyEnvelope(inbound, 'reply-all', seed);
+ * html.set(replyDocument(inbound, seed));
+ * ```
+ *
+ * - A reply goes to `replyTo` when the message names one, else to `from`;
+ *   answering one's own message, to the people it went to.
+ * - A reply-all copies everyone else on the message — sender, To, Cc —
+ *   never `self`, never who it is already to; one entry per address, under
+ *   the first name it came with.
+ * - A forward addresses nobody yet.
+ * - The subject takes `labels.re` / `labels.fwd` once. A prefix of the same
+ *   family the subject already carries is replaced, in any of the languages
+ *   below or the host's own ("AW: Re: RE: x" → "Re: x"), numbered repeats
+ *   ("Re[2]:") included; the other family's stays, so a forwarded reply
+ *   reads "Fwd: Re: x", as every major client writes it.
+ */
+declare function replyEnvelope(inbound: InboundMessage, kind: ReplyKind, options?: ReplyEnvelopeOptions): ReplyEnvelope;
+/**
+ * The imported message as the document itself — the `.eml`-drop / paste law:
+ * the body parses through the email schema (full strip, which doubles as
+ * sanitization) and *becomes* the document; nothing else of the message
+ * survives into it. Pair with `parseEml`:
+ * `html.set(importedDocument(parseEml(raw)))`.
+ */
+declare function importedDocument(inbound: InboundMessage): string;
+/**
+ * What an import will lose — the *legibility of loss* half of the import law.
+ * The parse itself never reports (it just repairs); this walks the inbound
+ * HTML against the schema's own parse vocabulary and says what won't survive,
+ * so the host can tell the user instead of losing content silently.
+ */
+interface ImportLoss {
+    /** Elements whose tag the schema has no parse rule for — the element is
+        removed on parse (its text content may still survive, unwrapped). */
+    removedElements: number;
+    /** The distinct removed tags, most frequent first. */
+    removedTags: string[];
+    /** Images pointing at `cid:` MIME parts — they parse in, but stay
+        unresolvable until the attachments story lands. */
+    inlineImages: number;
+}
+/** Computes the {@link ImportLoss} for an inbound message — pure, derived
+    from the same HTML `importedDocument` consumes:
+    `const loss = importLoss(inbound)` alongside the import, then surface it
+    ("3 elements outside the schema removed (o:p, font)…"). */
+declare function importLoss(inbound: InboundMessage): ImportLoss;
+
+interface EditorOptions {
+    /** Element the editable view is mounted into. */
+    parent: HTMLElement;
+    extensions: Extension[];
+    /** Initial content as HTML. */
+    content?: string;
+    /** The quoted history a reply or forward answers, as HTML (`replyQuote`,
+        `forwardQuote`) — kept beside the body, never replaced with it. See
+        `QuotedHistory`. */
+    quoted?: string | null;
+    /** How `content` and `setContent` parse markup. Default `email`: every
+        tag, attribute and CSS property Apple Mail, Outlook or Gmail applies is
+        recognized — as the kit's own nodes and marks wherever their rules
+        accept it (a table is a table, `<b>` is bold) — and kept exactly as
+        authored (authored.ts); a whole document keeps its head and
+        conditional comments. `preserve` additionally keeps what no floor
+        client applies — the opt-in for special needs. `repair` rewrites into
+        canonical blocks through the import pipeline (import-html.ts), as the
+        paste path always does. */
+    parseMode?: ParseMode;
+    /** DOM attributes for the editable element. */
+    attributes?: Record<string, string>;
+    /** Called after every transaction that changed the document. */
+    onUpdate?: (editor: Editor) => void;
+}
+interface Editor {
+    view: EditorView;
+    schema: Schema;
+    readonly state: EditorState;
+    /**
+     * Named commands collected from all extensions, bound to the live view:
+     * `editor.commands.toggleBold()` runs immediately and returns whether it applied.
+     */
+    commands: Record<string, (...args: any[]) => boolean>;
+    /** Every action the editor's extensions declare, in kit order — what a
+        toolbar, a bubble menu or a `/` menu shows. */
+    readonly actions: readonly EditorAction[];
+    /** Runs a raw ProseMirror command against the current state. */
+    exec(command: Command): boolean;
+    /**
+     * Calls `listener` after every change of the editor's state — the text,
+     * the selection, a stored mark — and returns the way to stop. Unlike
+     * `onUpdate` (document changes, given at creation) it can be asked of an
+     * editor that already exists, which is what lets a toolbar bind to one.
+     */
+    subscribe(listener: (editor: Editor) => void): () => void;
+    /** Whether a node or mark with the given name (and attrs) is active at the selection. */
+    isActive(name: string, attrs?: Record<string, any>): boolean;
+    getHTML(): string;
+    /** Replaces the document with the given HTML, applied as a minimal diff:
+        unchanged content keeps its positions, so selection, scroll and plugin
+        state survive. The change counts as an external sync — it never enters
+        the undo history and never fires `onUpdate`, so editors mirroring each
+        other cannot echo. */
+    setContent(html: string): void;
+    /** The quoted history, as canonical HTML, or null — the part of the
+        message {@link getHTML} leaves out and the send intent puts back. */
+    getQuoted(): string | null;
+    /** Replaces the quoted history — sanitized through the schema — or drops
+        it. Same external-sync semantics as {@link setContent}. */
+    setQuoted(html: string | null): void;
+    /** The document as plain text: top-level blocks joined with newlines. */
+    getText(): string;
+    /** Replaces the document with plain text, one default block per line.
+        Same external-sync semantics as {@link setContent}. */
+    setText(text: string): void;
+    focus(): void;
+    destroy(): void;
+}
+declare function createEditor(options: EditorOptions): Editor;
+/**
+ * The selected node that carries `type` as an attribute instead of as a
+ * mark — or null. An atom that paints its own text (a button: its label is
+ * an attribute, and it allows no marks) names the marks it takes this way
+ * in its spec, `markAttrs: ['bold', 'italic']`, each a boolean attribute of
+ * the mark's name. Bold and italic then work on it as on text — the
+ * toolbar, the bubble menu, Mod-B — through {@link isMarkActive} and the
+ * kit's `toggleMark`. The atom is the selection's whole content (clicked,
+ * or dragged over with nothing but whitespace, `soleInlineAtom`); in a
+ * range with text the kit's `setMark` flips it along with the text.
+ */
+declare function selectedMarkAtom(state: EditorState, type: MarkType): {
+    pos: number;
+    node: Node;
+} | null;
+/** Whether the mark is on in the selection: at a caret, what typing would
+    carry; in a range, whether any of it has the mark — text marked, or an
+    atom whose attribute for it is on (a bold button). */
+declare function isMarkActive(state: EditorState, type: MarkType): boolean;
+/** Checks the selection's whole ancestor chain, so wrapper nodes
+    (blockquote, lists) report active even though the cursor's direct
+    parent is a paragraph. */
+declare function isNodeActive(state: EditorState, type: NodeType, attrs?: Record<string, any>): boolean;
+
+/** Semantic HTML output (`<p>` paragraphs) for content rendered in the app. */
+declare const richTextExtensions: Extension[];
+/**
+ * Email-safe output: `<div>` lines instead of `<p>` (mail clients render
+ * paragraph margins as double spacing) and empty lines as `<div><br></div>`.
+ */
+declare const emailExtensions: Extension[];
+/**
+ * The parallel source-editor kit: the document is HTML source text, one
+ * `codeLine` per line, with highlighting, linting and formatting instead of
+ * rich-text nodes. Developed alongside the email kit on the same extension
+ * contract — only the extension set differs.
+ */
+declare const htmlSourceExtensions: Extension[];
+
+interface HtmlLanguageOptions {
+    /** Called with fresh diagnostics whenever the text is rescanned: once
+        typing rests, and at once for a wholesale change. */
+    onDiagnostics?: (diagnostics: HtmlDiagnostic[]) => void;
+    /** How long typing must rest, in ms, before the whole text is rescanned
+        — highlighting and lint rebuilt from scratch. Until then each edit
+        only moves the existing decorations along. Default
+        {@link TYPING_REST}. */
+    rescanDelay?: number;
+    /** The parse mode of the visual editor this source feeds — lint and
+        format follow it (see `SourceOptions`). Default `email`, the editor's
+        own default. */
+    parseMode?: ParseMode;
+}
+/**
+ * How long typing must rest before work that covers the whole text runs, in
+ * ms — tuned for the fastest typists, not the average: around 300 words a
+ * minute a record typist lands a key every ~40 ms (~30 in a burst), so five
+ * missed keys is a stop, not a gap between two. Shorter would fire mid-burst;
+ * longer only keeps a finished edit waiting.
+ */
+declare const TYPING_REST = 200;
+/** The document's source text: top-level lines joined with newlines. */
+declare function docText(doc: Node): string;
+/**
+ * Maps offsets in the joined source text back to ProseMirror positions.
+ * Line i's text starts at `linePm[i]`; the newline between lines has no
+ * position of its own, so offsets into it clamp to the line end.
+ */
+declare function createOffsetMapper(doc: Node): (offset: number) => number;
+/** Maps a ProseMirror position to its offset in the joined source text. */
+declare function textOffsetAt(doc: Node, pos: number): number;
+/**
+ * The HTML language service of the source editor kit: syntax-highlight and
+ * lint decorations over the document treated as HTML source text, a
+ * `formatDocument` command (Shift-Alt-F and Mod-S, VS Code style), tag auto-closing
+ * while typing, format-on-blur when the markup is error-free, and line-aware
+ * pasting. Diagnostics render as wavy underlines with the message as tooltip.
+ *
+ * Formatting is presentation-only: the indentation and line breaks it inserts
+ * are exactly the whitespace the email schema's parser discards, so the
+ * serialized output never changes.
+ */
+declare const createHtmlLanguage: (options?: HtmlLanguageOptions) => FunctionalExtension;
+/** Default instance for kits; use {@link createHtmlLanguage} for callbacks. */
+declare const HtmlLanguage: FunctionalExtension;
+
+interface AutocompleteItem {
+    label: string;
+}
+interface AutocompleteState {
+    open: boolean;
+    query: string;
+    items: AutocompleteItem[];
+    activeIndex: number;
+    /** Applies an item: replaces the typed query with the completion. */
+    select: (item: AutocompleteItem) => void;
+}
+interface AutocompleteOptions {
+    /** The floating listbox; contents rendered by the host app from the state
+        received through `onChange`. Needs a `position: relative` ancestor. */
+    element: HTMLElement;
+    /** Gap between the line and the menu, in px. */
+    offset?: number;
+    /** Notified when the menu opens, closes, filters, or moves its highlight. */
+    onChange?: (state: AutocompleteState) => void;
+}
+/**
+ * IDE-style completion for the HTML source editor, offering only the
+ * email-safe vocabulary: tags after `<`, the currently open tags after `</`,
+ * per-tag attributes inside a tag, and safe style properties inside
+ * `style="…"`. Same interaction contract as the slash menu — the host app
+ * renders the listbox from the emitted state.
+ */
+declare const createHtmlAutocomplete: (options: AutocompleteOptions) => FunctionalExtension;
+
+interface SourceMarksOptions {
+    /** The rich-text extension set whose schema defines the mark semantics —
+        pass the same kit the visual editor runs so both sides toggle alike. */
+    extensions: Extension[];
+    /** The parse mode of the visual editor this source pane mirrors. Default
+        `email`, the editor's own default; pass the visual editor's mode when it
+        chose another, so a toggle never drops markup the visual side keeps. */
+    parseMode?: ParseMode;
+}
+/**
+ * Rich-text mark editing for the HTML source editor: every mark extension's
+ * keymap (Mod-B, Mod-I, ...) and commands are mirrored, but instead of string
+ * surgery the selected source is parsed through the rich schema, the original
+ * mark command runs on the resulting document, and the source is replaced
+ * with the re-serialized, formatted result. Toggling therefore behaves
+ * exactly like the visual editor — it *is* the visual editor's command.
+ *
+ * Side effect by design: the command pipeline canonicalizes, so running one
+ * also repairs and formats the document, like Shift-Alt-F does.
+ */
+declare const createSourceMarks: ({ extensions, parseMode, }: SourceMarksOptions) => FunctionalExtension;
+
+/**
+ * Pre-parse cleanup for pasted HTML. Deliberately minimal: the email schema
+ * already discards classes, ids, unknown tags and unknown styles on parse —
+ * this only removes what would otherwise *leak through* the parse:
+ *
+ * - `<style>`/`<script>`/… subtrees (their text content would survive),
+ * - Word's namespaced tags (`<o:p>`, `<w:sdt>`, `<v:shape>`, …),
+ * - Word's fake list glyphs (`<span style="mso-list:Ignore">·&nbsp;</span>`),
+ *   which would paste literal bullet characters into the text.
+ *
+ * Everything else — `class` soup, `mso-*` style properties, Google Docs'
+ * `<b style="font-weight:normal">` wrapper — dies in the schema parse, where
+ * it belongs.
+ */
+declare function sanitizePastedHTML(html: string): string;
+/** Cleans clipboard HTML before it reaches the schema parse — and parses it
+    in `repair` mode: the source pane may be law, the clipboard never is.
+    Pasted class soup, foreign tables and Word's markup are still repaired
+    into canonical form, exactly as before the preserving parse existed. */
+declare const PasteHygiene: _h_k_dev_angular_email_editor.FunctionalExtension;
+
+declare const ClearFormatting: _h_k_dev_angular_email_editor.FunctionalExtension;
+
+/**
+ * One line of source code. The document of the HTML source kit is a flat list
+ * of these; the source text is the lines joined with newlines. `code: true`
+ * makes ProseMirror treat pastes as plain text, and `marks: ''` keeps
+ * formatting out — colour comes from decorations, not marks.
+ */
+declare const CodeLine: _h_k_dev_angular_email_editor.NodeExtension;
+
+/**
+ * The document root. Two attributes, neither of them content:
+ *
+ * - `envelope` holds a parsed document's surroundings — doctype,
+ *   `<html>`/`<body>` attributes, the canonical head — when the source
+ *   carried them (see `DocumentEnvelope`); `null` for a bare body fragment,
+ *   which is what the composer produces on its own. The serializer wraps the
+ *   body in it, the editor never shows it. It comes *with* content: a
+ *   replacement brings its own.
+ * - `quoted` holds the quoted history a reply or forward answers — canonical
+ *   HTML, or `null` (see `QuotedHistory`). It stays *beside* the content: a
+ *   replacement of the body never touches it; only a deliberate step does.
+ */
+declare const Document$1: _h_k_dev_angular_email_editor.NodeExtension;
+/** The document attributes that come with content — what a replacement of
+    the body carries over from the new document. Every other one stays. */
+declare const CONTENT_ATTRS: readonly string[];
+
+declare const Paragraph: _h_k_dev_angular_email_editor.NodeExtension;
+
+type ParagraphAlignment = 'center' | 'right' | null;
+/** One indent level, in px — Gmail's step, and what its own indented
+    messages carry, so the two round-trip into each other. */
+declare const INDENT_STEP = 40;
+/** The deepest indent offered: eight steps are 320px, a phone screen's
+    worth of margin — past that a line has no room left to say anything. */
+declare const INDENT_MAX = 8;
+/**
+ * Email flavour of the paragraph. Mail clients render the default margins of
+ * `<p>` as double spacing, so email bodies use `<div>` lines instead — the
+ * same model contenteditable composers (Gmail, Outlook) produce natively.
+ *
+ * A line carries its alignment and its indent (in steps of
+ * {@link INDENT_STEP}); both serialize as inline style, the only style mail
+ * clients keep, and both stay on the next line when Enter is pressed at the
+ * line's end (see `splitKeepingMarks`), as they do in Gmail.
+ */
+declare const EmailParagraph: _h_k_dev_angular_email_editor.NodeExtension;
+
+declare const Text: _h_k_dev_angular_email_editor.NodeExtension;
+
+declare const HardBreak: _h_k_dev_angular_email_editor.NodeExtension;
+
+/**
+ * Personalization tokens — `{{cf_70}}`, `{{customer_gender == 'male' ? 'Herr'
+ * : 'Frau'}}` — as **text with a mark** (decided 2026-09-02; they were inline
+ * atoms before). The raw `{{expression}}` is ordinary document text, braces
+ * included, so the cursor lands anywhere inside it, it is edited like any
+ * text, and a long expression wraps across lines like text. The `mergeTag`
+ * mark only paints the pill, editor-only: the serialized email carries the
+ * raw text, stored and re-emitted **verbatim** — the expression is another
+ * system's program (an AngularJS-style evaluator, a Handlebars renderer, …)
+ * and rewriting so much as its spacing could change what a string literal or
+ * date format means. The editor protects; it never interprets.
+ *
+ * Two invariants, kept by the extension's `appendTransaction` after every
+ * change (and by {@link promoteMergeTags} at parse time):
+ *
+ *  0. **A token is padded canonically**: `{{ expr }}`, one space each side
+ *     ({@link canonicalMergeTagInner}) — the only rewrite the editor makes
+ *     to a token, applied on parse, on completion, and by the formatter; a
+ *     token under the cursor is left alone until the cursor leaves it.
+ *  1. **The mark covers exactly the tokens.** Text that reads `{{…}}` (per
+ *     {@link isMergeTagExpression}) carries the mark, nothing else does —
+ *     type a token by hand and it becomes a pill on the closing brace,
+ *     delete a brace and the pill is gone. Derived from the text, never
+ *     stored: the round trip cannot lie.
+ *  2. **Formatting is all-or-nothing on a token.** Bold, italic, colour, a
+ *     link: whatever applies to any part of a token applies to the whole of
+ *     it — Ctrl-B with the cursor inside bolds the entire `{{…}}`, so the
+ *     value it renders to ("Mr Wild") is bold as a whole. A mark added or
+ *     removed over part of a token is widened to the token; a token that
+ *     arrives partially formatted (a paste, the source pane) is repaired to
+ *     whole.
+ *
+ * What is *not* a token: Handlebars block helpers and partials (`{{#if}}`,
+ * `{{/each}}`, `{{>partial}}`) — half of a block is not a value and pairing
+ * them is a renderer's job — plus anything nested, multi-line, or past the
+ * length ceiling. Those stay plain text.
+ */
+/** The longest expression the editor protects as one token, in characters
+    inside the braces. Real templates run long — a salutation with four
+    branches and string concatenation passes 300 — so the ceiling is a
+    runaway guard, not a style limit: past it, stray braces around ordinary
+    prose stay prose. Measured on the trimmed expression; the scanner and the
+    source-pane lint mask allow it plus the two padding spaces (regex
+    literals cannot read a constant). */
+declare const MAX_MERGE_TAG_LENGTH = 1000;
+declare const isMergeTagPath: (path: string) => boolean;
+/** An inner text the editor will protect as one token: single-line, sanely
+    sized, no nested braces, not block syntax (a Handlebars helper / closer /
+    `{{else}}` / partial / comment) — half of a block is not a value. */
+declare function isMergeTagExpression(raw: string): boolean;
+/** The canonical padding of a token: `{{ expr }}` — one space each side of
+    the trimmed expression. Edge whitespace is insignificant to every dialect
+    we transport (AngularJS `$parse`, Handlebars), so this is the one
+    rewrite the editor allows itself on a token; the expression itself stays
+    byte-verbatim. Handlebars' `{{~ … ~}}` whitespace control and `{{& …}}`
+    need their sigil against the braces: those are left as written. */
+declare function canonicalMergeTagInner(expr: string): string;
+/** Every token in running text at its canonical padding — the source
+    formatter's rule (Shift-Alt-F, Mod-S, format-on-blur), and the same form
+    the schema serializes. Pure. */
+declare function normalizeMergeTagText(text: string): string;
+/** Every token in a piece of running text, as offsets: the whole `{{ … }}`
+    and the expression inside it — what a highlighter paints (the source
+    pane mutes the braces, Angular-template style). Pure. */
+declare function scanMergeTags(text: string, options?: {
+    multiline?: boolean;
+}): {
+    from: number;
+    to: number;
+    expr: [number, number];
+}[];
+/** A token's place in the document: `[from, to)` around the braces. */
+interface MergeTagRange {
+    from: number;
+    to: number;
+    /** The inner expression, verbatim. */
+    expr: string;
+}
+/** Every token in the document, in document order — derived from the text,
+    which is the only truth about them. */
+declare function mergeTagRanges(doc: Node): MergeTagRange[];
+/** Every token's raw expression, in document order — for a host that wants
+    to evaluate or audit the template as written. */
+declare function mergeTagExpressions(doc: Node): string[];
+/** The token at `pos` — inside it or at either edge — if any. */
+declare function mergeTagAt(doc: Node, pos: number): MergeTagRange | undefined;
+/** A command inserting the token for `path` at the selection — what a `{{`
+    suggestion runs. The token is text; the pill follows from the mark's
+    invariants. */
+declare const insertMergeTag: (path: string) => Command;
+/** Whether a selection lies within one token — the bubble menu stays away
+    then (formatting still works from the keyboard, on the whole token). */
+declare function selectionInsideMergeTag(state: EditorState): boolean;
+/** Whether the caret stands strictly inside a token — between its braces,
+    at neither edge. What a `{{` suggestion menu's `allow` turns down: there
+    the braces before the caret open a token that is already written, and
+    picking a row would write a second one into it. */
+declare function caretInsideMergeTag(state: EditorState): boolean;
+/**
+ * Applies both invariants to a parsed document — the token half of "parsing
+ * is repair", run by `parseHTML` right after the table repair. A schema
+ * without the mark (the HTML source editor) passes straight through.
+ */
+declare function promoteMergeTags(doc: Node, schema: Schema): Node;
+declare const MergeTag: _h_k_dev_angular_email_editor.MarkExtension;
+/**
+ * The *required fields* of the document: every identifier the token
+ * expressions read that the host must supply a value for, deduplicated, in
+ * first-use order. This is a lex over the tokens' expressions, not a text
+ * parse of the HTML — and it understands enough expression grammar to
+ * exclude what is not a field:
+ *
+ *  - string literals (`'Herr'`, `"+5 days"`),
+ *  - filter names (`x | formatPrice` — the identifier after a single `|`),
+ *  - function calls (`round(…)`, `parseFloat(…)`),
+ *  - dotted tails (`customer.name` needs `customer`, not `name`),
+ *  - locals assigned inside any token (`mwst = …; mwst` — `mwst` is
+ *    computed, not fetched; the assignment is seen document-wide),
+ *  - literals and builtins (`true`, `null`, `now`, …).
+ *
+ * `{{ mwst = round(parseFloat(cf_70) * 0.19, 2); mwst }}` therefore requires
+ * exactly `cf_70`.
+ */
+declare function mergeTagFields(doc: Node): string[];
+
+/** The ledger's conservative scale: reads at 320px and on a desktop alike. */
+declare const HEADING_SIZES: Record<number, number>;
+/** A heading's canonical inline style. No margins — lines carry none
+    (principle 3), spacing is an empty line; no `line-height` — Outlook
+    substitutes its own (the client-support module says so) and our output
+    stays lint-clean. Incoming heading styles never survive: the scale is the
+    schema's, not the author's. */
+declare const headingStyle: (level: number) => string;
+declare const Heading: _h_k_dev_angular_email_editor.NodeExtension;
+
+/** The ledger's answer to reply chains whose margins stack until text is one
+    word per line: a small fixed indent and a rule, no margins at all — each
+    nesting level costs 14px, never more. The grey is the divider's, safe
+    against both white and near-black (the dual-contrast rule). */
+declare const BLOCKQUOTE_STYLE = "margin: 0px; padding-left: 12px; border-left: 2px solid rgb(224, 224, 224);";
+declare const Blockquote: _h_k_dev_angular_email_editor.NodeExtension;
+
+/**
+ * Inline images — the half of the attachment story that lives in the
+ * document. Dropped and pasted image files enter the editor as data-URL
+ * images (the only thing a browser editor can hold on its own), but a data
+ * URL is not an email image: Gmail and Outlook refuse it and the recipient
+ * sees a hole. The email form is a `cid:` reference to a `multipart/related`
+ * part — and assembling MIME is the host's job, not ours.
+ *
+ * So the editor reports the truth about the document at send time
+ * ({@link promoteInlineImages}): every data-URL image is decoded into its
+ * bytes and re-pointed at a generated Content-ID *in the payload copy only*;
+ * the document itself keeps its data URL (the editor still has to display
+ * it, and the round trip never learns about the promotion). Images that
+ * already reference a `cid:` — an imported reply's inline parts — are
+ * reported with the bytes the configured registry holds for them, else by
+ * id alone: the host received those parts with the import and owns them.
+ */
+interface InlineImage {
+    /** The Content-ID the payload's HTML references as `src="cid:<cid>"` —
+        bare, without the `cid:` scheme or the `<…>` the MIME header wraps it
+        in. */
+    cid: string;
+    /** The image bytes, typed — present for images the editor holds itself
+        (dropped, pasted, picked), `null` for pre-existing `cid:` references
+        whose part the host already has. */
+    blob: Blob | null;
+}
+interface PromotedInlineImages {
+    /** A copy of the document with every data-URL image pointing at its
+        `cid:` — serialize this for the payload; the original is untouched. */
+    doc: Node;
+    /** Every inline part the payload references, in document order, each id
+        once. */
+    images: InlineImage[];
+}
+/** Decodes a `data:` URL into a typed `Blob` — base64 or percent-encoded,
+    the media type without its parameters. `null` for anything that is not a
+    well-formed data URL, so a malformed source is left alone rather than
+    sent as garbage. */
+declare function decodeDataUrl(src: string): Blob | null;
+/** The send-time projection: data-URL images become `cid:` parts in a copy
+    of the document; every inline reference — promoted or pre-existing — is
+    listed once, in document order. Pure: the input document is never
+    modified, and an image whose data URL cannot be decoded keeps its source
+    (the source-pane lint names it). Identical data URLs share one part. */
+declare function promoteInlineImages(doc: Node, registry?: InlineImageRegistry): PromotedInlineImages;
+/**
+ * The inline image registry — the half of the attachment story that the
+ * editor owns (decided 2026-09-02, the Gmail model): one map per composer
+ * from Content-ID to bytes, with a display URL for each. Two writers — the
+ * editor (a dropped, pasted or picked file) and the host (an import's MIME
+ * parts) — and four readers: the editor view, the preview, the send intent,
+ * and the host persisting a draft's parts. With a registry configured
+ * ({@link createInlineImages}) a drop produces `src="cid:…"` at once and the
+ * document stays light; without one, today's data-URL path still applies.
+ * The contract is framework-free; the Angular service implements it with a
+ * signal underneath.
+ */
+interface InlineImageRegistry {
+    /** Registers bytes and returns their Content-ID — a supplied one is kept
+        (an import's part), otherwise one is generated. Re-registering a cid
+        replaces its bytes. */
+    add(blob: Blob, cid?: string): string;
+    /** The display URL for the editor (an object URL); undefined for a part
+        the registry does not hold. */
+    resolve(cid: string): string | undefined;
+    /** The bytes; undefined when the host owns the part. */
+    blob(cid: string): Blob | undefined;
+    /** Change notification, so views can re-resolve; returns the unsubscribe. */
+    subscribe?(listener: () => void): () => void;
+}
+interface InlineImageStoreOptions {
+    /** How display URLs are made (default `URL.createObjectURL`) … */
+    createUrl?: (blob: Blob) => string;
+    /** … and released (default `URL.revokeObjectURL`). */
+    revokeUrl?: (url: string) => void;
+}
+/** The in-memory registry. Parts stay registered after their image is
+    deleted from the document (undo brings it back); the send intent reports
+    only what the document references, and so should a host's draft. Every
+    URL is released by {@link revokeAll} when the composer goes away. */
+declare class InlineImageStore implements InlineImageRegistry {
+    #private;
+    private readonly options;
+    constructor(options?: InlineImageStoreOptions);
+    add(blob: Blob, cid?: string): string;
+    resolve(cid: string): string | undefined;
+    blob(cid: string): Blob | undefined;
+    has(cid: string): boolean;
+    /** Every registered Content-ID, in registration order. */
+    cids(): string[];
+    subscribe(listener: () => void): () => void;
+    /** Releases every display URL and forgets every part. */
+    revokeAll(): void;
+}
+/** The registry configured for an editor, if any — plugin state, so the
+    Image node, the send intent and the host all read the same one. */
+declare const inlineImagesKey: PluginKey<InlineImagesState>;
+interface InlineImagesState {
+    registry: InlineImageRegistry;
+    /** Bumped on every registry change: the image decorations carry it, so a
+        node view re-resolves its `cid:` when a part arrives late. */
+    version: number;
+}
+declare const inlineImageRegistry: (state: EditorState) => InlineImageRegistry | undefined;
+/**
+ * The registry extension — the roadmap's "`cid:` resolver input", and the
+ * editor's write side. Hands the registry to the Image node (drops register
+ * their bytes and insert `cid:` sources; node views resolve them for display)
+ * and to the send intent (bytes for `inlineImages`). A registry change is a
+ * meta transaction that bumps a version carried by a node decoration on every
+ * `cid:` image, which is how ProseMirror re-renders those node views without
+ * the document changing.
+ */
+declare const createInlineImages: (options: {
+    registry: InlineImageRegistry;
+}) => FunctionalExtension;
+/** Every Content-ID the html's images reference, once each, in document
+    order — the parts a draft has to keep (the registry holds more: a
+    deleted image's part stays for undo). Pure. */
+declare function inlineImageCids(html: string): string[];
+/** Rewrites every `cid:` image source the resolver knows — the preview's
+    projection (a sandboxed, opaque-origin frame cannot load the editor's
+    blob URLs, so the preview resolves to data URLs). Unknown cids are left
+    untouched. Pure. */
+declare function rewriteInlineImageSources(html: string, resolve: (cid: string) => string | undefined): string;
+
+interface ImageAttrs {
+    /** `null` is a placeholder: a sized frame awaiting its file (see the
+        NodeView) — serialized as an `<img>` without `src`, linted as unfilled. */
+    src: string | null;
+    alt?: string | null;
+    title?: string | null;
+    /** Natural display width in px, capped at {@link MAX_IMAGE_WIDTH}. */
+    width?: number | null;
+}
+/** Email convention: wider than this overflows phones and gets Gmail-clipped
+    layouts; parse and file drops both cap to it. */
+declare const MAX_IMAGE_WIDTH = 600;
+/** Reads a dropped/pasted/picked image file into insertable attrs: alt
+    defaulted from the filename, natural width capped for email, and the
+    source — a `cid:` when a registry holds the bytes (the Gmail model: the
+    document stays light, the part travels with the send intent), else a
+    data URL (the registry-less fallback, promoted at send). */
+declare function readImageFile(file: File, registry?: InlineImageRegistry): Promise<ImageAttrs>;
+/**
+ * The drop-claim rule (decided 2026-09-02): the editor takes a file drop only
+ * when *every* file is an image. Pure images are content and embed inline;
+ * a mixed drop — an image alongside a PDF, say — is an attachment gesture,
+ * so the editor leaves the event untouched and it bubbles *whole* to the
+ * host's dropzone. Nothing to decide, nothing silently lost: the host
+ * attaches everything, and may still embed the images itself via
+ * `readImageFile` + `insertImage` if it wants to.
+ */
+declare function claimedImageFiles(files: Iterable<File>): File[];
+/**
+ * Whether an image drag the editor will embed is over it — the drag phase of
+ * the claim rule (`isImageDrag`), told to the host.
+ *
+ * A host that wraps the editor in a file dropzone needs this to say the
+ * right thing while a file hangs over the text: its zone reports a drag it
+ * would take, and an image drag is exactly the one it will *not* get — the
+ * editor claims those as they come over it (`claimImageDrag`), so the zone
+ * stands down and reads nothing. This is the other half, from the editor
+ * that knows: on while an image-only drag is over the editing
+ * surface, off when it leaves, drops, or turns out to be mixed. Reported on
+ * change only. The drop line (`ImageDropLine`) is what tracks it — this is
+ * the same state, spoken.
+ *
+ * And it is where the host says how the editor tells that zone "this one is
+ * mine" — `claim`. The library depends on no dropzone; any of them fits:
+ *
+ *     // @h-k-dev/angular-file-drop: a mark the zone reads.
+ *     createImageDrag({ claim: claimDragEvent, onChange })
+ *
+ *     // dropzone.js, ngx-file-drop, a hand-written zone — anything that
+ *     // listens for the drag events bubbling up to it: they never get there.
+ *     createImageDrag({ claim: (event) => event.stopPropagation(), onChange })
+ */
+declare const createImageDrag: (options: ImageDragOptions) => FunctionalExtension;
+interface ImageDragOptions {
+    /** Told when an image-only drag comes over the editing surface, and when
+        it is gone. */
+    onChange?: (over: boolean) => void;
+    /**
+     * Claims a drag event for the editor, so a dropzone around it stands
+     * down: called on every `dragenter` and `dragover` of an image-only drag,
+     * and on the `drop` the editor takes (after its `preventDefault()`).
+     * Never for a mixed drag or a file the editor will not embed — those stay
+     * the zone's. What it does is the zone's protocol: mark the event, stop
+     * it bubbling, flip a flag the zone checks.
+     */
+    claim?: (event: DragEvent) => void;
+}
+interface ImageDropTarget {
+    /** The caret — the image is inserted inline where the cursor sits (Gmail's
+        rule: the pointer only says the drag is over the editor). */
+    pos: number;
+    /** The drop line on screen: the bottom of the visual line the image is
+        about to join, spanning that line's block. */
+    top: number;
+    left: number;
+    width: number;
+}
+/** Where an image drag drops — the caret, exactly what the drop uses — and
+    the line to draw for it: under the visual line the caret is on (the
+    caret's own box gives the line's bottom, the surrounding block its
+    width). Gmail's rule: the image lands where the cursor sat before the
+    drag; the pointer decides only that the drag is over the editor. */
+declare function imageDropTarget(view: EditorView): ImageDropTarget;
+/** How long a keyboard-opened chooser waits for the pointer to move before
+    it opens regardless — inside the browser's window of user activation
+    (five seconds in Chromium), so the click still counts. */
+declare const FILE_CHOOSER_POINTER_WAIT = 2500;
+/**
+ * Opens a file chooser the way the pointer stays visible in it. Chromium on
+ * Windows hides the mouse pointer while a key is typed and shows it again
+ * on the next mouse move *it* handles; the OS file dialog is modal and
+ * takes the moves itself, so a chooser opened from a keyboard action — a
+ * `/image` picked with Enter — runs with no pointer at all. Where the last
+ * input was a key on Windows, the opening waits for the pointer to move
+ * (the page shows it again on that move), or for a moment to pass
+ * ({@link FILE_CHOOSER_POINTER_WAIT}) for the writer who never reaches for
+ * the mouse. Anywhere else, and after a click, it opens at once.
+ */
+declare function openFileChooser(open: () => void, options?: {
+    keyboard?: boolean;
+    windows?: boolean;
+    wait?: number;
+}): void;
+/** Floor for a resized image: below this a pad has nothing left to grab. */
+declare const MIN_IMAGE_WIDTH = 40;
+/** Room an image leaves at the end of its line for the caret (decided
+    2026-09-24): the widest an image gets in a line is the line less this,
+    so the caret can always stand to its right — on a drop, and at the top
+    of a resize. Wider, and the caret's spot (ProseMirror's 1px separator)
+    wraps to the next line, with nothing beside the image to click or to
+    start a drag from. */
+declare const CARET_ROOM = 4;
+/** `width` fitted under a line's `ceiling` (see `CARET_ROOM`): an unknown
+    width stays unknown (fluid, `max-width: 100%`), and without a ceiling
+    the width stands. */
+declare function fitImageWidth(width: number | null | undefined, ceiling: number | null): number | null;
+/** Width a fresh placeholder opens at — the ledger's phone width; the pads
+    take it from there. */
+declare const PLACEHOLDER_WIDTH = 320;
+/** A placeholder keeps the frame its author sized: the picked file supplies
+    the source (and the alt when the placeholder has none); `width` stays. */
+declare function filledPlaceholderAttrs(placeholder: ImageAttrs, picked: ImageAttrs): ImageAttrs;
+/**
+ * The image a selection holds and nothing else, or null: a click's node
+ * selection, or a range that covers the image alone — a drag over it, or
+ * Shift-arrow, that caught nothing but whitespace along the way (spaces,
+ * tabs, a line break: no character, no token, no second atom; see
+ * `soleInlineAtom`). What an image's own chrome (a bubble menu, its
+ * actions) keys on; a range with text in it is a text selection.
+ */
+declare function selectedImage(state: EditorState): {
+    pos: number;
+    node: Node;
+} | null;
+/** The selected image's alt text: `''` when it has none, `null` when no
+    image is the selection (see {@link selectedImage}). */
+declare function selectedImageAlt(state: EditorState): string | null;
+/**
+ * Inline image — Gmail's and Proton's model (decided 2026-09-02): the image
+ * sits in the text line like a character, so the caret can stand right
+ * beside it at the image's height and typing continues next to it. The
+ * serialized form is then Gmail's own (`<div><img …></div>` for an image on
+ * a line of its own), which is as safe as email HTML gets. Sizing is the
+ * responsiveness-ledger hybrid: the `width`
+ * *attribute* for Outlook (which ignores `max-width` entirely) plus
+ * `width:100%; max-width:<n>px; height:auto` for everyone else — fluid on
+ * phones, capped at natural size on desktop, no media queries. `float` never
+ * parses and never serializes. Dropped or pasted image files insert as
+ * data-URL images — what a browser editor can hold on its own; the send
+ * intent promotes them to `cid:` parts (`promoteInlineImages`), and the
+ * source pane lints them until then. Which drops the editor claims at all
+ * is {@link claimedImageFiles}: all images, or none.
+ */
+declare const Image: _h_k_dev_angular_email_editor.NodeExtension;
+
+/** A block-level rule. Ledger row: horizontal rule → `width: 100%`, done —
+    no fixed pixel width to overflow a phone. Colour is a faint neutral line,
+    not text, so it is exempt from the dual-contrast rule. */
+declare const Divider: _h_k_dev_angular_email_editor.NodeExtension;
+
+/** The button's canonical styling — the *border-based* bulletproof button:
+    the touch target (≥ 44px tall, per the ledger) comes from borders in the
+    background colour, not from padding, because Outlook's Word engine ignores
+    padding on an anchor (the client-support module says so) and would render
+    a padded button as a bare coloured text run — while it does draw borders
+    on inline elements, so the box survives there too. No `height`. No
+    `border-radius` — Outlook squares it anyway, and dropping it keeps our own
+    output lint-clean. rgb() colours, not hex: the browser normalizes hex to
+    rgb on the serialize round trip, so the canonical form must already be
+    rgb to stay stable. The label's weight and slant are the button's
+    own (`bold`, `italic`): this is a default button's. */
+declare const BUTTON_STYLE: string;
+/** The default button's fill — the primary blue — and the text on it. */
+declare const BUTTON_FILL = "rgb(26, 115, 232)";
+/** The canonical style of a button with that label styling and fill: bold
+    is `font-weight: bold` and not bold `normal` (said, never left out — a
+    client's own anchor styling may be bold); italic adds `font-style`
+    after the weight, and not italic leaves it out; the fill (hex, null for
+    the default blue) colours the box and its borders, in the rgb form the
+    CSSOM prints, with the words in `color` (hex) or, null, the text the
+    fill pairs (`fillTextColor`; white on the default blue). */
+declare function buttonStyle({ bold, italic, background, color, fontFamily, }: {
+    bold: boolean;
+    italic: boolean;
+    background?: string | null;
+    color?: string | null;
+    fontFamily?: string | null;
+}): string;
+/**
+ * A call-to-action button: an inline atom that serializes to a bordered
+ * `inline-block` anchor — the email-safe "fake button" every client,
+ * Outlook included, renders as a tappable coloured box. `display: inline-block` in the style is also the parse
+ * discriminator: it is what tells a button apart from an ordinary link, so the
+ * two never collide on the round trip.
+ *
+ * Inline, like an image, so it sits in a paragraph *or* a table cell
+ * (`inline*`) — cells stay textblocks; they do not open to headings or
+ * nested tables. It is an **atom** (label and href are attributes, not
+ * editable content): a contentEditable `<a>` would ignore the node
+ * boundary and unwrap when you type. Selected text becomes one, and a
+ * button linked text again (`button-link`, a toggle); a selected button's
+ * link is set with `setButtonHref`, its words with `setButtonLabel`. The
+ * label is bold or italic as a whole — attributes, not marks: the kit's own
+ * Bold and Italic (the toolbar's, Mod-B, Mod-I) flip them on a selected
+ * button (`markAttrs`, see `selectedMarkAtom`).
+ */
+declare const Button: _h_k_dev_angular_email_editor.NodeExtension;
+/** Where a clicked button is, for the host's link editor to stand on. */
+interface ButtonEditTarget {
+    pos: number;
+    /** The button's box in viewport coordinates — null where nothing is laid
+        out (a test DOM). */
+    rect: DOMRect | null;
+}
+interface ButtonEditOptions {
+    /** A button was clicked, and is now the selection: open its link editor.
+        (A click never follows the button's link — its editor's own "open"
+        is the way out.) */
+    onEdit: (target: ButtonEditTarget) => void;
+}
+/**
+ * What a click on a button does, told to the host: the kit selects the
+ * button and never follows its link; this hands the host the moment to
+ * open its link editor on it — the one a text link opens with, so a button
+ * is edited the way a link is. Without it, a click only selects the button
+ * (and a bubble menu can offer the editor).
+ *
+ *     createButtonEdit({ onEdit: () => linkEditor.show() })
+ */
+declare const createButtonEdit: (options: ButtonEditOptions) => FunctionalExtension;
+/** The button a selection holds and nothing else, or null: a click's node
+    selection, or a range — a drag's, Shift-arrow's — that covers the button
+    and whitespace only (see `soleInlineAtom`). A range with text in it is
+    a text selection: the button in it takes the text styling with the
+    text (its `bold`, its `italic`). */
+declare function selectedButton(state: EditorState): {
+    pos: number;
+    node: Node;
+} | null;
+/** A button's `href` before it has been given one — the placeholder
+    `insertButton` and a text without a link start from. */
+declare const UNSET_BUTTON_HREF = "#";
+/**
+ * The parser paints `font-weight: bold` from {@link BUTTON_STYLE} onto the
+ * atom as a wrapping mark — it asks the parent, not the node, whether bold
+ * is allowed. The box already is bold; those marks would re-serialize as a
+ * `<strong>` around every button. Strip them so parse stays a fixpoint.
+ */
+declare function bareButtons(doc: Node, schema: Schema): Node;
+
+/** An inline atom with a box of its own — what a range can cover like a
+    character, and a click selects whole: an image, a button. Not a line
+    break, which has no box to paint. */
+declare function isInlineAtom(node: Node): boolean;
+/** The marks an atom takes as boolean attributes of the mark's name — a
+    button's `bold` and `italic` (`markAttrs` in its spec). Empty for the
+    rest. */
+declare function markAttrsOf(node: Node): readonly string[];
+interface InlineAtomAt {
+    pos: number;
+    node: Node;
+}
+/**
+ * The inline atom a selection holds and nothing else, or null: a click's
+ * node selection, or a range — a drag's, Shift-arrow's — whose content is
+ * that one atom. Whitespace does not count: a range that took the spaces or
+ * tabs around an image, or the line break after it, still holds the image
+ * alone (a hundred spaces are no space). A letter does, and so does a
+ * second atom — a range over an image and a button is a text selection.
+ *
+ * What an atom's own chrome keys on: an image's bubble menu, a button's,
+ * their actions. `type` narrows it to one node type.
+ */
+declare function soleInlineAtom(state: EditorState, type?: string): InlineAtomAt | null;
+
+/** The class a text range puts on every inline atom it covers — an image,
+    a button: the highlight the app draws, since the browser draws none. */
+declare const IN_SELECTION_CLASS = "aee-atom--in-selection";
+/**
+ * Inline atoms — an image, a button — selected the way characters are, by
+ * a click-drag over them, and shown selected when they are.
+ *
+ * **Why by hand.** An atom is a non-editable island in the editable text,
+ * and the browser's selection will not treat it as a character: a
+ * selection based inside the island never leaves it, and one based
+ * beside it — anywhere on its line — will not grow over it either (Chrome
+ * keeps a selection from crossing an editing boundary, and snaps a point
+ * over the island to its nearer side). The atom's element, draggable,
+ * answers a press with a drag of itself besides. Only a drag from another
+ * line, passing clear across the atom, covers it on its own.
+ *
+ * **So.** A press on an atom, or on a line that holds one, is kept from
+ * the browser at `mousedown` (its default is prevented — after
+ * ProseMirror's own handling of the press, which stays: a press released
+ * in place is still its click, the node selection, a button's link
+ * editor), and the plugin makes the selection itself from the press,
+ * following the pointer through `posAtCoords` (`dragRange`). A press
+ * elsewhere is the browser's drag, corrected for the stretch the pointer
+ * spends over an atom — on each move, and again whenever ProseMirror reads
+ * the browser's selection back, so the two never disagree. Where the
+ * browser puts a DOM endpoint *inside* an atom's element (past it at the
+ * line's end), ProseMirror reads the point as "before the atom": such an
+ * endpoint covers the atom too. A *selected* atom's press is ProseMirror's
+ * whole: its drag moves the node, as in Gmail. Shift-arrow from a selected
+ * atom grows a range that keeps it (`extendFromAtom`).
+ *
+ * **Showing.** A range that covers an atom is a text selection (it copies
+ * and deletes it as a character), but the element is contenteditable false,
+ * so the browser never paints `::selection` on it: {@link IN_SELECTION_CLASS}
+ * is the highlight the app draws instead. A click is a node selection;
+ * `ProseMirror-selectednode` covers that.
+ *
+ * What an atom's own chrome (a bubble menu) keys on is {@link soleInlineAtom}:
+ * the atom alone, clicked or dragged over with nothing but whitespace.
+ */
+declare const InlineAtomSelection: _h_k_dev_angular_email_editor.FunctionalExtension;
+
+/**
+ * Email data tables: a real `<table>` (the most client-compatible layout there
+ * is), driven by **prosemirror-tables** — the same model Tiptap and friends
+ * run on. That library owns the hard parts we were re-deriving by hand: the
+ * `TableMap` (grid geometry through merged cells), `CellSelection`
+ * (shift-drag a rectangle of cells), and `fixTables` (repair of ragged or
+ * overlapping tables). This is a *data* table (it stays tabular, the user
+ * scrolls on a phone); `/columns` is the spongy layout that stacks. Styles are
+ * longhand-only + rgb() so they survive the CSSOM serialize round trip
+ * identically across engines (see ROADMAP).
+ *
+ * Two deliberate departures from the library's defaults:
+ *  - **No pixel column widths.** The library's own `columnResizing` plugin
+ *    writes `colwidth` in *pixels* — the responsiveness ledger's central trap
+ *    — so it stays off. Our `ColumnResize` extension reuses the same
+ *    `colwidth` attr but holds **percentages**, serialized as `width: n%` on
+ *    the cells (never a `<colgroup>` — enough clients strip it): fluid at
+ *    every viewport, read by fixed layout in every client, identical in the
+ *    editor and the email.
+ *  - **No header cells.** `<th>` parses (as a plain cell) but never
+ *    serializes: an email table is presentational, and a header row that
+ *    renders bold in one client and not another is a lie we'd rather not tell.
+ *
+ * `colspan`/`rowspan`, by contrast, are fully email-safe — Outlook's Word
+ * engine handles both — so merged cells are a real feature here, and imported
+ * mail keeps its shape instead of being flattened.
+ */
+/** The table's serialized style. Width and offset are attrs (percent; width
+    defaults to 100, offset to 0) so the whole table can be resized from
+    either edge — the same email-honest unit as the columns: fluid at every
+    viewport, and nested percentages compose (a 50% column of an 80% table is
+    40% of the container, in every client and in the editor alike). The
+    offset serializes as `margin-left` — inline margins on tables are what
+    Outlook's own Word composer emits, so its engine reads them, and a client
+    that strips them degrades the table gracefully to left-aligned. */
+declare const tableStyle: (width: number, offset: number) => string;
+/** How a cell's content sits across its width. The same three the rest of the
+    editor aligns by (a paragraph's `align`), so one set of buttons drives
+    both — and `left` is the default, which canonicalizes to `null` and
+    serializes nothing. */
+type CellAlignment = 'center' | 'right' | null;
+/** How a cell's content sits down its height. `top` is the default and *is*
+    serialized: a cell with no `vertical-align` reads as `middle` in enough
+    clients (it is the HTML default) that leaving it out would make the email
+    disagree with the editor. */
+type CellVerticalAlignment = 'top' | 'middle' | 'bottom';
+/**
+ * A px-only padding (the shorthand, or any set of longhands) off parsed
+ * markup, canonicalized through the CSSOM so serialize → parse → serialize is
+ * a fixpoint. Anything else — %, em, negative, calc — repairs away: padding
+ * in the email is a deliberate authored choice, in the one unit every client
+ * reads the same.
+ */
+declare function parsePadding(dom: HTMLElement): string | null;
+/** The bordered table's default grid color: Excel's classic gridline
+    blue-gray (#D0D7E5) — the shade a spreadsheet-shaped table is expected to
+    wear, light enough to organize without shouting, and legible on both
+    white and dark-mode-inverted grounds. Serialized per *cell* (`border` on
+    `<td>` is the bulletproof border in email — Outlook's Word engine renders
+    it), with `border-collapse` on the table keeping the grid single-lined. */
+declare const TABLE_BORDER_COLOR = "rgb(208, 215, 229)";
+/** The bordered table's *real* cell padding — Excel-style breathing room, so
+    the rendered email is readable inside its grid. Deliberately the same
+    value as the editor's editorial default spacing (the app's `.aee-editor
+    table td` rule): a bordered and a plain table feel identical while
+    composing; only what the recipient gets differs — the preset ships its
+    padding, the plain table ships none unless authored. */
+declare const TABLE_CELL_PADDING = "8px 12px";
+/** Canonical percentage: one decimal at most, no trailing zero (25%, 33.3%). */
+declare const formatPct: (n: number) => string;
+/** No column below 10%: at 320px that is ~32px — the width where a column
+    stops being a column. The resize drag clamps here, and the add-column
+    rescale floors here. */
+declare const MIN_COLUMN_PCT = 10;
+/** No table below 20% of its container — narrower stops being a table. */
+declare const MIN_TABLE_PCT = 20;
+declare const TableCell: _h_k_dev_angular_email_editor.NodeExtension;
+declare const TableRow: _h_k_dev_angular_email_editor.NodeExtension;
+declare const Table: _h_k_dev_angular_email_editor.NodeExtension;
+/**
+ * Normalizes every table in a freshly parsed document: ragged rows are padded,
+ * overlong spans are trimmed. The transaction-driven half lives in the node's
+ * repair plugin; this is the pure-function path, so `importedDocument` and
+ * `replyDocument` produce the same repaired canonical HTML the editor would.
+ * A schema without tables (the HTML source editor) passes straight through.
+ */
+declare function repairTables(doc: Node, schema: Schema): Node;
+/** Sets (or clears) the `background` attr of the cell the cursor is in — or of
+    every cell in a cell selection, which the library's `setCellAttr` handles.
+    Exposed for the app's fill affordance. */
+declare function setCellBackground(color: string | null): Command;
+interface TableContext {
+    table: Node;
+    tablePos: number;
+    tableDepth: number;
+    rowIndex: number;
+    colIndex: number;
+    cols: number;
+    rows: number;
+}
+/** Locates the table around the selection: the enclosing table node plus the
+    current row/column indices. Indices are *grid* coordinates (a merged cell
+    reports its top-left corner), because that is what the geometry means once
+    spans exist. `null` when the cursor is outside any table. */
+declare function findTableContext(state: EditorState): TableContext | null;
+/**
+ * Appends a column at the table's end — what the editor's `+` pill on the
+ * table's right flank commits (the `ColumnResize` NodeView renders it).
+ * Position-addressed rather than selection-relative, because the pill knows
+ * which table it belongs to regardless of where the caret is. Runs the same
+ * width rescale as every other column add.
+ */
+declare function addColumnAtEnd(tablePos: number): Command;
+/** The row twin: appends a row at the table's end for the pill under the
+    bottom edge. No width math — rows carry none. */
+declare function addRowAtEnd(tablePos: number): Command;
+/**
+ * Selects a whole row (or column) of the table at `tablePos` — what a grip
+ * on the row's flank does when it is pressed.
+ *
+ * The selection is the handle's whole trick: once the row is a
+ * {@link CellSelection}, every command the menu offers is the ordinary
+ * selection-relative one — insert, delete, fill, align — and the row lights
+ * up while its menu is open, which is the feedback the gesture needs. The
+ * library builds the selection out of the two cells at the row's ends, which
+ * is also how a shift-drag across the row ends up.
+ */
+declare function selectRow(tablePos: number, index: number): Command;
+/** The column twin. */
+declare function selectColumn(tablePos: number, index: number): Command;
+/**
+ * Moves the selected row one place up or down (`offset` −1 or 1) — the
+ * menu's Move row up/down, and the gesture a grip exists for.
+ *
+ * Rows move as whole nodes: the table's children are reordered and written
+ * back in one transaction, so nothing is re-derived and the move is one undo
+ * step. A merged cell reaching across either boundary makes the move a lie —
+ * the grid would have to be rebuilt around it, and "move" is not a promise
+ * to restructure — so the command refuses, and the menu item shows disabled.
+ */
+declare function moveRow(offset: number): Command;
+/** Duplicates the selected row (or rows) straight below — the menu's
+    Duplicate row. Refused where a merged cell crosses the block's edges, for
+    the same reason a move is. */
+declare function duplicateRow(): Command;
+/** The column twins. A column is not a node — it is one cell per row — so
+    these rebuild every row with its cells reordered (or copied), which is
+    exactly what the browser's own column-less table model forces. The same
+    span rule applies: a cell spanning a boundary the column crosses refuses
+    the move. */
+declare function moveColumn(offset: number): Command;
+declare function duplicateColumn(): Command;
+/** Backspace/Delete with a whole structural unit selected: the user marked
+    it — deleting "all the content" of a table, row or column *is* deleting
+    the unit, and leaving an empty husk behind would be the one thing that
+    selection did not ask for. Full grid → the table; full-width rows → those
+    rows; full-height columns → those columns. Any lesser selection returns
+    false and falls through to `deleteCellSelection` (clear contents), the
+    library default. */
+declare const deleteFullySelected: Command;
+/** The cell the caret is in, as its position in the document — null for a
+    cell selection (which knows its cells) and outside any table. */
+declare function caretCellPos(state: EditorState): number | null;
+/** Deletes the content of the caret's cell, or of every selected cell. */
+declare const clearCells: Command;
+
+type ColumnsAlignment = 'left' | 'center' | 'right';
+/**
+ * The block's own alignment, expressed as auto margins against its `max-width`.
+ *
+ * Auto margins are normally the thing to distrust in email (Outlook's Word
+ * engine handles them poorly), but they are *safe here by the same pairing
+ * logic as `width: 100%` + `max-width`*: Outlook ignores `max-width` entirely,
+ * so the container spans the full width there and has nothing to align — the
+ * only clients where the cap is visible are the ones that honour auto margins.
+ *
+ * `left` carries **no declaration** — the same rule the email paragraph uses for
+ * its default, so an unaligned block stays free of styling. Longhand only
+ * (never the `margin: 0 auto` shorthand): shorthands re-serialize
+ * non-deterministically through the CSSOM and break the canonical fixpoint.
+ */
+declare const containerStyle: (align: ColumnsAlignment) => string;
+/**
+ * The most columns a block will grow to. At 4 the even split is already down
+ * to ~140px per column — enough for an icon-and-caption feature row, but the
+ * floor for readable prose; a fifth would put every column below it. The cap
+ * lives on the *command* (the affordance is the enforcement, like the colour
+ * palette): authored markup with more columns still parses — parsing is
+ * repair, not opinion.
+ */
+declare const MAX_COLUMNS = 4;
+/** No column cap below this: ~an icon-and-caption column. The boundary drag
+    clamps here from both sides. */
+declare const MIN_COLUMN_CAP = 120;
+/** Every column's px cap, in order — the block's geometry, straight from the
+    model: a column's left edge is the sum of the caps before it. */
+declare function columnCaps(columns: Node): number[];
+/**
+ * Sets the caps of the two columns meeting at `boundary` — what the boundary
+ * drag commits. `leftCap` is the left column's new cap in px; the pair's
+ * total is conserved (the block's budget never changes, so a phone still
+ * stacks exactly as before), and both sides clamp at {@link MIN_COLUMN_CAP}.
+ * Position-addressed: the NodeView knows its block wherever the caret is.
+ */
+declare function setColumnsBoundary(columnsPos: number, boundary: number, leftCap: number): Command;
+/**
+ * The class a stacking column carries in the sent email — the hook of the
+ * one rule the email document's head holds ({@link STACK_RULE}): on a phone
+ * a stacked column takes the whole width instead of its desktop cap. Where
+ * a client drops the head, the column keeps its cap: narrower, still whole.
+ * The editor's HTML never carries it ({@link markStackingColumns} adds it
+ * at send), so the canonical form stays class-free.
+ */
+declare const STACK_CLASS = "aee-stack";
+/** The phone rule for {@link STACK_CLASS} — MJML's breakpoint. */
+declare const STACK_RULE: string;
+/** Canonical HTML with every stacking column carrying {@link STACK_CLASS}
+    — for the email document only. */
+declare function markStackingColumns(html: string): string;
+/** A single column: an `inline-block` div, recognised on parse by that style
+    (a `<div>`, so it never collides with the inline-block button `<a>`). */
+declare const Column: _h_k_dev_angular_email_editor.NodeExtension;
+/** The column container: a plain `<div>` whose direct children are column
+    divs. The child check discriminates it from an ordinary paragraph div. */
+declare const Columns: _h_k_dev_angular_email_editor.NodeExtension;
+/** Exposed for the app to detect when the cursor is inside a columns block. */
+declare function findColumnsContext(state: EditorState): {
+    pos: number;
+    node: Node;
+} | null;
+/** The single `column` enclosing the selection (the innermost, if nested).
+    Exposed so the app can route a fill to the column the cursor sits in. */
+declare function findColumnContext(state: EditorState): {
+    pos: number;
+    node: Node;
+} | null;
+/** Inserts an empty column after the cursor's, up to {@link MAX_COLUMNS};
+    every cap re-splits evenly and the cursor lands in the new column. */
+declare const addColumn: Command;
+/** Deletes the cursor's column and re-splits the rest evenly. Refuses on the
+    last column — emptying the block is {@link deleteColumns}' job, on its own
+    explicit affordance (mirrors the table's deleteRow/deleteTable split). */
+declare const removeColumn: Command;
+/** Deletes the whole columns block (the table's `deleteTable` sibling). */
+declare const deleteColumns: Command;
+/** Sets (or clears) the `background` of the `column` the cursor is in. */
+declare function setColumnBackground(color: string | null): Command;
+/**
+ * The hybrid's other half, for the email as sent: round every columns
+ * block a fixed table the Word engine reads and no one else sees — one
+ * cell per column, the column's cap as its width — inside `[if mso]`
+ * conditional comments, before, between and after the fluid columns.
+ * Outlook lays the columns side by side at their caps (it ignores
+ * `inline-block` and `max-width`, and would stack them); every other
+ * client drops the comments and keeps the fluid divs. MJML's own way, and
+ * the one way to a row in Outlook. A serializer's pass over the rendered
+ * DOM (`serializeToHTML`): the comments stand between the columns, where
+ * no node's own `emitDOM` can put them; on parse they are dropped, and
+ * the block re-emits them, so the round trip holds.
+ */
+declare function outlookColumns(root: HTMLElement): void;
+
+/** How wide a section's content runs: the email's container, centred in
+    the band. */
+declare const SECTION_CONTENT_MAX = 600;
+/** A band's default breathing room, above and below — MJML's own. */
+declare const SECTION_PADDING = "20px 0px";
+/** The content column's inline inset inside the band. */
+declare const SECTION_INSET = 16;
+/**
+ * A section: a full-width band of the email — a fill running edge to edge
+ * across the reader's window with the content centred in the 600px column
+ * inside it — the one layout effect a 600px table cannot produce, and what
+ * makes a newsletter read as header band, hero, footer rather than one
+ * white sheet. MJML's `mj-section`, rendered our way.
+ *
+ * **Rendered once, for every client.** MJML renders a section twice — a
+ * `<div>` for the clients that read `max-width`, and the same content again
+ * in a 600px table inside an Outlook-only conditional comment — because
+ * Outlook's Word engine ignores `max-width` and `inline-block`. Gmail drops
+ * every comment, and its app strips the head for non-Google accounts, so
+ * what both keep is what this emits: one `role="presentation"` table,
+ * 100% wide, its one cell carrying the fill as `bgcolor` *and* as an
+ * inline `background-color` (Outlook reads the attribute, everyone else
+ * the style), and inside it a `<div>` capped at 600px with auto margins.
+ * Where that div cannot be honoured (Outlook) the content runs the band's
+ * full width — the graceful half of the same bargain the columns block
+ * strikes. Nothing here needs a stylesheet or a comment.
+ *
+ * **The fill pairs its text.** A filled band writes an explicit text colour
+ * (`fillTextColor`), since the dark modes that flip default text keep the
+ * fill; the swatches are the dual-safe background palette, so both survive
+ * a forced inversion. `bgcolor` carries the same colour as hex for Outlook.
+ *
+ * **A background image, for both clients.** A band may carry an image
+ * behind its content (MJML's `background-url`): the cell gets it as a
+ * `background` attribute *and* as inline `background-image`, centred,
+ * covering, not repeating — Gmail and the rest read those — with the fill
+ * colour beneath for the clients that hold images back. Outlook's Word
+ * engine reads neither, and draws VML: the cell's content is wrapped in a
+ * `v:rect` with a `v:fill` of the image, inside `[if mso]` conditional
+ * comments that every other client discards. That is the one place the
+ * email carries a comment — MJML's translation of the same idea, and the
+ * only way to a picture behind text in Outlook; without it the colour
+ * shows, which is the fallback anyway. A band without an image emits no
+ * comment at all.
+ *
+ * **On parse** a section is a one-cell presentation table whose cell holds
+ * nothing but elements and carries a fill, an image or a padding — a
+ * builder's section (MJML's, with the fill on its table or wrapping div,
+ * the image as the table's `background` or a `url()` in a style) as much
+ * as our own. A one-cell table with words in it is a table, and stays one.
+ * Only an `http(s)` image is taken.
+ */
+declare const Section: _h_k_dev_angular_email_editor.NodeExtension;
+/** Whether a URL may stand as a band's image: `http(s)` only — never a
+    script, a data URL (Gmail shows nothing for it) or a file. */
+declare function isSectionImageUrl(url: string | null): url is string;
+/** The background an element declares inline — the CSSOM's reading, else
+    the attribute's own words (`background: #fff` as a builder writes it,
+    which not every engine expands). */
+declare function declaredBackground(el: Element): string;
+/** The section around the cursor, innermost. */
+declare function findSectionContext(state: EditorState): {
+    pos: number;
+    node: Node;
+} | null;
+/** Sets (or clears) the fill of the section the cursor is in. */
+declare function setSectionBackground(color: string | null): Command;
+/** Puts an image behind (or takes it from) the section the cursor is in.
+    A URL that is not `http(s)` is refused: the command answers false. */
+declare function setSectionImage(url: string | null): Command;
+
+/** Depth of the innermost list wrapping the selection start, or null. */
+declare const findListDepth: ($from: ResolvedPos) => number | null;
+/**
+ * Wraps the selection in a list, lifts out of it when already in that list,
+ * or converts the list in place when it is of the other flavour.
+ */
+declare const toggleList: (listType: NodeType, itemType: NodeType) => Command;
+/**
+ * Tiptap-inspired helper: Intercepts the default splitListItem transaction
+ * and ensures marks (bold, italic, etc.) are carried over to the new list item.
+ */
+declare const splitListItemKeepMarks: (itemType: NodeType) => Command;
+/** The ledger's answer to the 40px-per-level default indent that eats a
+    third of a phone screen: a small explicit indent, no margins (lines carry
+    none). Nested lists compound 24px per level, readable at 320px. */
+declare const LIST_STYLE = "margin: 0px; padding-left: 24px;";
+declare const ListItem: _h_k_dev_angular_email_editor.NodeExtension;
+declare const BulletList: _h_k_dev_angular_email_editor.NodeExtension;
+declare const OrderedList: _h_k_dev_angular_email_editor.NodeExtension;
+
+/** What a menu lets its scroll behaviour do. */
+interface MenuScrollApi {
+    /** Report the menu closed; the next selection change brings it back. */
+    close(): void;
+    /** Report the menu's box afresh, where it is open. */
+    refresh(): void;
+}
+/**
+ * What a floating menu does when what it stands over scrolls — the
+ * editor's own scroll container, or the page:
+ *
+ * - `'close'` (the default): the menu goes. The box it reported is in
+ *   viewport coordinates, and stale the moment the editor scrolls under it.
+ * - `'follow'`: the box is reported afresh, once per frame, so a host that
+ *   repositions on the box's change keeps the menu over the selection.
+ * - `'keep'`: nothing — the menu stays where it was reported.
+ * - a function: the host's own say, per event — close for the editor's
+ *   scroller but follow for the page, or close past a threshold.
+ *
+ * The listener is the window's, in the capture phase, so every scroll
+ * container on the page is heard without being marked (no `cdkScrollable`
+ * needed), and only a scroll that moves the editor counts: the document's,
+ * or an ancestor's. A scrollable list inside the host's own menu never
+ * closes the menu it is in.
+ */
+type MenuScroll = 'close' | 'follow' | 'keep' | ((event: Event, menu: MenuScrollApi) => void);
+/** Starts watching for {@link MenuScroll}; returns what stops it. */
+declare function watchMenuScroll(view: EditorView, scroll: MenuScroll | undefined, menu: MenuScrollApi): () => void;
+
+interface BubbleMenuState {
+    isOpen: boolean;
+    boundingBox: DOMRect | null;
+    /** What the menu is for: `'image'` when an image is the whole selection
+        — clicked, or dragged over with nothing but whitespace beside it
+        (`selectedImage`); `'button'` likewise for a button (`selectedButton`)
+        — the box is then the node's own; `'text'` otherwise: a range with
+        text in it, or with an image and a button both. A host shows each
+        one's own tools. Absent while closed. */
+    kind?: 'text' | 'image' | 'button';
+}
+interface BubbleMenuOptions {
+    /** How long a selection stands before the menu *opens* over it (150ms):
+        a drag's or a Shift-Arrow's intermediate ranges never pop a menu. A
+        menu that is already open follows the selection at once — see the
+        plugin view. */
+    updateDelay?: number;
+    onStateChange: (state: BubbleMenuState) => void;
+    shouldShow?: (state: EditorState) => boolean;
+    /** What the menu does when the editor scrolls under it — closes, by
+        default. See {@link MenuScroll}. */
+    scroll?: MenuScroll;
+}
+declare const defaultBubbleShouldShow: (state: EditorState) => boolean;
+declare const createBubbleMenu: (options: BubbleMenuOptions) => FunctionalExtension;
+
+/** The layout blocks the editor treats as structures in their own right: their
+    shape is invisible in the exported email (our tables are borderless; columns
+    are bare inline-block divs), so the editor has to reveal it — and they carry
+    block-level commands (align, add/remove row…) that need somewhere to live.
+    One definition, shared by the guides and the block menu. */
+type LayoutBlockType = 'table' | 'columns' | 'section';
+interface LayoutBlock {
+    pos: number;
+    node: Node;
+    type: LayoutBlockType;
+}
+/** The innermost `table`/`columns`/`section` ancestor of the selection, or null. */
+declare function layoutBlockAt(state: EditorState): LayoutBlock | null;
+/** Class on the layout block the cursor is currently inside. */
+declare const GUIDES_ACTIVE_CLASS = "aee-guides-active";
+/** Class on the editor root while the peek modifier is held — reveals *every*
+    layout block's guides at once. */
+declare const GUIDES_PEEK_CLASS = "aee-guides-peek";
+/**
+ * How long Ctrl must be held before guides appear. Ctrl is also the prefix for
+ * every shortcut (Ctrl-B, Ctrl-C, Ctrl-Z), so revealing instantly would make the
+ * grid flash on every one of them. A hold delay — cancelled by any other key —
+ * separates "I'm peeking at the layout" from "I'm running a shortcut".
+ *
+ * Kept just under the ~100ms that still reads as instant: a real chord presses
+ * its letter 30–80ms after the modifier, so this catches shortcuts while a
+ * deliberate hold feels immediate. The rest of the debouncing is perceptual —
+ * the guides *fade* in (see the `.aee-guides-*` transition in the app's global
+ * styles), so anything slipping past this timer is a soft partial fade rather
+ * than a hard blink. Longer than this and a deliberate peek just feels laggy.
+ */
+declare const GUIDES_PEEK_DELAY_MS = 100;
+/**
+ * One shared mechanism for showing the structure of layout blocks (tables and
+ * columns alike) while editing — never in the email itself.
+ *
+ * Three ways in, all resolved in CSS against a border that is *always reserved
+ * as transparent*, so revealing a guide never shifts layout:
+ *   1. **Cursor inside** — the block being edited is tagged {@link GUIDES_ACTIVE_CLASS}.
+ *   2. **Hover** — pure CSS on the block itself; nothing to coordinate here.
+ *   3. **Peek** — hold Ctrl ({@link GUIDES_PEEK_DELAY_MS}) to reveal every block
+ *      at once via {@link GUIDES_PEEK_CLASS} on the editor root.
+ *
+ * The app owns the pixels (see the `.aee-guides-*` rules in its global styles);
+ * this extension only supplies the state.
+ */
+declare const LayoutGuides: _h_k_dev_angular_email_editor.FunctionalExtension;
+
+interface BlockMenuState {
+    isOpen: boolean;
+    /** The layout block's own rect — the menu anchors to the block, not the caret. */
+    boundingBox: DOMRect | null;
+    /** Which block the cursor is in, so the app can offer its commands. */
+    block: LayoutBlockType | null;
+}
+interface BlockMenuOptions {
+    onStateChange: (state: BlockMenuState) => void;
+    /**
+     * Resolves the rendered menu element, lazily — it lives in an overlay, so it
+     * only exists while the menu is open.
+     *
+     * Without it the menu is **mouse-only**: it stays open only while the editor
+     * has focus, so Tabbing toward it blurs the editor and closes the very thing
+     * you were reaching for. Given this, focus landing inside the menu counts as
+     * still-active, which is what makes {@link BLOCK_MENU_FOCUS_KEY} usable.
+     */
+    menuElement?: () => HTMLElement | null | undefined;
+    /** What the menu does when the editor scrolls under it — closes, by
+        default. See {@link MenuScroll}. */
+    scroll?: MenuScroll;
+}
+/**
+ * Moves focus into the menu — the ARIA "jump to toolbar" gesture, and the only
+ * way to reach a contextual toolbar that is anchored to the caret's block.
+ * Alt-F10 follows CKEditor's convention; bare F10 is out because browsers give
+ * it to their own menu bar, and Alt alone would too (a chord is safe).
+ */
+declare const BLOCK_MENU_FOCUS_KEY = "Alt-F10";
+/**
+ * The block menu: the bubble menu's sibling for *layout blocks*.
+ *
+ * The bubble menu answers "what can I do to this text?" and anchors to the
+ * selection. This answers "what can I do to this block?" and anchors to the
+ * block itself. It exists because block-level commands kept piling up with
+ * nowhere to live — the table's structural commands (`addRowAt`, `deleteColumnAt`,
+ * …) have been library-only, and column alignment would have been the third
+ * feature to hit the same wall.
+ *
+ * It opens on a **bare cursor** inside a table/columns block, so it never
+ * competes with the text bubble menu (which needs a non-empty selection) —
+ * the two are mutually exclusive by construction, never stacked.
+ *
+ * Reachable by keyboard: press {@link BLOCK_MENU_FOCUS_KEY} to move focus into
+ * it, Escape (wired by the app) to come back. See {@link BlockMenuOptions.menuElement}
+ * for why that needs the element.
+ *
+ * Deliberately *not* the reverted Notion-style overlay: no pointer tracking, no
+ * hover handles, no steppers. It is one calm toolbar, positioned by the app.
+ */
+declare const createBlockMenu: (options: BlockMenuOptions) => FunctionalExtension;
+
+interface SuggestionMenuState {
+    open: boolean;
+    /** The trigger this state answers to — `/`, `{{`, `@`. A menu of several
+        triggers reports the one that is open. */
+    trigger: string;
+    /** What that trigger's list is called ({@link SuggestionTrigger.label}) —
+        the listbox's accessible name on level 1. Null when it was given none. */
+    label: string | null;
+    /** 1 on the menu's own items; 2 inside a {@link SuggestionGroup} —
+        `<trigger><word> <query>`. */
+    level: 1 | 2;
+    /** The group whose children are listed, at level 2; null at level 1. */
+    parent: SuggestionGroup | null;
+    /** The search string of the current level: everything after the trigger
+        at level 1, everything after `<word> ` at level 2. */
+    query: string;
+    /** Items matching the query: static matches ranked title-first (given
+        order within a tier), then what a source answered for this query — the
+        menu's {@link SuggestionMenuOptions.source} at level 1, the group's
+        children source at level 2. Titles and keywords are already translated. */
+    items: SuggestionItem[];
+    /** Index of the keyboard-highlighted item. */
+    activeIndex: number;
+    /** A source's first page for the current query is in flight (or waiting
+        out {@link SuggestionMenuOptions.debounce}) — render a "Searching…"
+        row. The menu counts as open while loading, even with no items yet. */
+    loading: boolean;
+    /** The source's items on screen answer the *previous* query: they stay
+        until the new page lands, so the list is diffed rather than torn down
+        and rebuilt on every keystroke. Enter and Tab pass over a stale row. */
+    stale: boolean;
+    /** Where the session sits in the document: the trigger's first character
+        to the caret. Null while closed. */
+    range: {
+        from: number;
+        to: number;
+    } | null;
+    /** The trigger's box in viewport coordinates, measured when called — for
+        the renderer to place the menu after it has rendered its rows. Null
+        while closed. */
+    clientRect: () => SuggestionRect | null;
+    /** A further page is in flight — render a loading row at the list's end. */
+    loadingMore: boolean;
+    /** The source has more pages: the renderer's scroll should call
+        {@link loadMore} near the end (ArrowDown on the last row already does). */
+    hasMore: boolean;
+    /** Why the source's last answer failed; null while it has not. Cleared by
+        the next query. The menu stays open to say so. */
+    error: unknown;
+    /** The id the listbox element must carry: the editor points at it
+        (`aria-controls`) while the menu is open. */
+    listboxId: string;
+    /** The id the option at `index` must carry (with `role="option"`): the
+        editor points at the highlighted one (`aria-activedescendant`), and the
+        pointer's highlight finds its row by it. */
+    optionId: (index: number) => string;
+    /** The heading for a section id (an item's `section`): the trigger's
+        `sections` wording, else the library's own ({@link
+        suggestionSectionTitles}), else the id itself. Asked as headings are
+        rendered, so a function given as `sections` is heard afresh. */
+    sectionTitle: (id: string) => string;
+    /** Applies an item. A command item removes the trigger and query text,
+        then runs its command; a group rewrites the query to `<word> `,
+        opening level 2. */
+    select: (item: SuggestionItem) => void;
+    /** Level 2 back to level 1 with an empty query — the pointer's way; the
+        keyboard's is Backspace over the space. A no-op at level 1. */
+    back: () => void;
+    /** Fetches the next page and appends it. A no-op while anything is loading,
+        when no page is left, or when the menu is closed — safe from any scroll
+        handler without guards. */
+    loadMore: () => void;
+    /** Closes the menu as Escape does — for a renderer's own close control. It
+        stays shut for this trigger until the caret has been somewhere else. A
+        no-op while closed. */
+    dismiss: () => void;
+}
+/** A box in viewport coordinates. */
+interface SuggestionRect {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+/** A translation for one item, keyed by its id in
+    {@link SuggestionMenuOptions.i18n}. */
+interface SuggestionItemLabel {
+    /** Replaces the item's title — shown, ranked first, and (for a group)
+        the word written into the query. The original title stays searchable. */
+    title?: string;
+    /** Extra search strings, added to the item's own — never replacing them,
+        so the original words keep working in every locale. */
+    keywords?: string[];
+    /** Replaces a group's `placeholder`. */
+    placeholder?: string;
+}
+/** What a trigger's {@link SuggestionTrigger.allow} is asked about: a session
+    that would open. */
+interface SuggestionAllowProps {
+    state: EditorState;
+    /** The trigger's first character to the caret. */
+    range: {
+        from: number;
+        to: number;
+    };
+    /** The text after the trigger, leading whitespace dropped. */
+    query: string;
+}
+/** One trigger of a suggestion menu: what opens it, what it lists, what its
+    query may look like. Any string is a trigger — `'/'`, `'{{'`, `'@'`,
+    `'||'`. */
+interface SuggestionTrigger {
+    /** What opens the menu when typed: `'/'`, `'{{'`, `'@'`. */
+    trigger: string;
+    /** What this trigger's list is called — "Insert block", "Personalization
+        tokens". Handed on as {@link SuggestionMenuState.label}: the listbox's
+        accessible name. A function is asked afresh whenever the menu opens,
+        like `i18n`: the words of the language in use. */
+    label?: string | (() => string);
+    /** Only at the start of a line or after whitespace — `/` in a URL stays
+        text. In a script that writes no spaces (Japanese, Chinese) every
+        character counts as one: `/` opens right after こんにちは. Default true. Either way a trigger right after its own first
+        character never opens: not `//`, not Handlebars' `{{{`. */
+    startOfWord?: boolean;
+    /** What the text between the trigger and the caret may be. Default: not
+        starting with whitespace (typing `/ ` dismisses), spaces inside allowed
+        (`/heading 2`), and no trigger character (a later one starts a new
+        session). A merge-tag menu narrows it to a path: `/^ ?[\w.]*$/`. The
+        query handed on is that text with its leading whitespace dropped. */
+    query?: RegExp;
+    /** The longest query that still counts as one. Default 100. */
+    maxLength?: number;
+    /** The menu's own items — a list, or a function of the editor's extensions
+        (`extensionSuggestions` for the kit's `/` commands). Filtered and
+        ranked by the query; groups among them open a second level. */
+    items?: readonly SuggestionItem[] | ((ctx: ExtensionContext) => readonly SuggestionItem[]);
+    /**
+     * The menu's dynamic items, asked per query and per page — a server
+     * catalogue, a search backend. Its answers are appended after the static
+     * matches, **not** re-filtered: the source owns its matching. Stale answers
+     * are dropped and their requests aborted (a newer query, a dismissal, a
+     * destroyed editor) — the host never race-guards. A group's children
+     * source works the same way at level 2.
+     */
+    source?: SuggestionSource;
+    /** Shown after the bare trigger, until a query is typed — "Type to
+        filter…". It is handed to the session's decoration as
+        `data-placeholder`; the host's stylesheet shows it (see
+        {@link createSuggestionMenu}, "Marked in the text"). Inside a group the
+        group's own takes its place: `/templates ` shows
+        {@link SuggestionGroup.placeholder}. A function is asked afresh whenever
+        the menu opens. */
+    placeholder?: string | (() => string);
+    /**
+     * The host's veto: asked for every session the text would open, and the
+     * menu stays shut — for this trigger; one further back may still open —
+     * when it says no. For what the text alone cannot tell: a caret that is
+     * not typing a query but standing in something already written. The `{{`
+     * menu needs one — the braces before a caret *inside* `{{ firstName }}`
+     * open that token, and picking a row there would write a second token into
+     * the first:
+     *
+     *     allow: ({ state }) => !caretInsideMergeTag(state)
+     *
+     * Asked once per editor state, so it may look at the document.
+     */
+    allow?: (props: SuggestionAllowProps) => boolean;
+    /** Milliseconds to sit on a keystroke before asking a source for a new
+        query — a server should see the settled query, not every letter.
+        Default 300; 0 asks at once (an in-memory source). Static matches never
+        wait, and neither does a further page. */
+    debounce?: number;
+    /**
+     * Translations by item id, at either level: a title, extra keywords, a
+     * group's placeholder. A map — or a function of the id, which is asked
+     * afresh every time the menu opens: hand it a translation service's lookup
+     * and a language switch reaches the menu, its search included, with
+     * nothing to re-create. Whatever it answers is *added* to the item's own
+     * words, so the original language keeps matching beside the chosen one.
+     */
+    i18n?: Readonly<Record<string, SuggestionItemLabel>> | ((id: string) => SuggestionItemLabel | undefined);
+    /**
+     * The headings of the items' sections (`SuggestionItem.section`), by id:
+     * a map, or a function of the id, asked whenever a heading is rendered —
+     * hand it a translation service's lookup and a language switch reaches
+     * the headings too. What it leaves out is worded by the library
+     * ({@link suggestionSectionTitles}), and an id neither knows shows as it
+     * is.
+     */
+    sections?: Readonly<Record<string, string>> | ((id: string) => string | undefined);
+    /** The listbox id ({@link SuggestionMenuState.listboxId}); unique by default. */
+    id?: string;
+}
+/** The library's wording of the sections its own actions declare — and of
+    the ones a host commonly adds: its palette's rows (`color`), its groups. */
+declare const suggestionSectionTitles: Readonly<Record<string, string>>;
+/**
+ * A suggestion menu: the element it shows in, and the triggers that open it
+ * — one, written inline, or several in `triggers`:
+ *
+ *     createSuggestionMenu({ element, onChange, trigger: '/', items: extensionSuggestions })
+ *     createSuggestionMenu({ element, onChange, triggers: [
+ *       { trigger: '/', label: 'Insert block', items: extensionSuggestions },
+ *       { trigger: '{{', label: 'Tokens', startOfWord: false, source: fetchMergeTags },
+ *       { trigger: '||', label: 'Snippets', source: fetchSnippets },
+ *     ] })
+ */
+interface SuggestionMenuOptions extends Partial<SuggestionTrigger> {
+    /**
+     * The menu's element, rendered by the host from the
+     * {@link SuggestionMenuState} it receives through `onChange`. The plugin
+     * never writes to it — placing and showing it is the renderer's, after its
+     * rows are in (see `clientRect`) — it only listens: a press on it keeps the
+     * editor's focus, a press anywhere else dismisses.
+     */
+    element: HTMLElement;
+    /** Further triggers that open this same menu — after the inline one, when
+        there is one. They never open together (the trigger nearest the caret
+        wins), so one element and one `onChange` serve them all: the state says
+        whose list it is (`trigger`, `label`, `listboxId`). */
+    triggers?: readonly SuggestionTrigger[];
+    /** Notified when the menu opens, closes, filters, loads, or moves — with
+        the state of the trigger that is open, or of the one that just closed. */
+    onChange?: (state: SuggestionMenuState) => void;
+}
+/**
+ * A suggestion menu: typing `trigger` opens a list under the caret, the text
+ * after it searches the list, and picking an item replaces trigger and query
+ * with what the item does. One factory for every such menu — the `/` command
+ * menu and the `{{` merge-tag picker are two triggers with different
+ * options, in one menu (one element, one state) or in a menu each:
+ *
+ *     createSuggestionMenu({ element, onChange, triggers: [
+ *       { trigger: '/', items: extensionSuggestions },
+ *       { trigger: '{{', startOfWord: false, query: /^ ?[\w.]*$/, source: fetchMergeTags },
+ *     ] })
+ *
+ * The host renders the list from the state (the library's
+ * `email-suggestion-menu` pair does it); this plugin does the rest —
+ * detection, filtering, the paged and debounced source, keyboard navigation,
+ * applying. It never writes to the menu element: showing and placing it are
+ * the renderer's, after its rows are in (`clientRect` says where).
+ *
+ * **Read from the text.** A session is a caret right after
+ * `<trigger><query>`, however the text got there, and nothing else is held:
+ * undo, paste, and moving the caret back into a query all land right.
+ *
+ * **Two levels.** A {@link SuggestionGroup} ("Templates") picked on level 1
+ * rewrites the query to `templates `; from then on the words after that
+ * space search the group's children. Backspace over the space is level 1
+ * again.
+ *
+ * **One at a time.** Several menus on one editor never open together: when
+ * two sessions overlap (`/templates {{`), the trigger nearest the caret wins
+ * and the other stays shut until it is gone.
+ *
+ * **Marked in the text.** While a session lasts, its trigger and query are
+ * wrapped in a decoration — `<span class="aee-suggestion" data-trigger="/">`,
+ * with `data-level`, and with `aee-suggestion-empty` and a
+ * `data-placeholder` while the level's query is empty (the trigger's after
+ * `/`, the group's after `/templates `) — for the host's stylesheet: the
+ * library paints nothing.
+ * Nothing of it is in the document or the HTML. The session, and the place
+ * where Escape dismissed one, live in the plugin's state and move with the
+ * text: what a sync writes before a dismissed trigger does not reopen it.
+ *
+ * **One highlight.** The arrows move it and so does the pointer, over the
+ * rows that carry the state's option ids — hover is not a second one.
+ *
+ * **The editor is the combobox.** Focus never leaves it: while the menu is
+ * open the editable carries `aria-controls` (the listbox) and
+ * `aria-activedescendant` (the highlighted option), whose ids the state
+ * hands the renderer.
+ */
+declare const createSuggestionMenu: (options: SuggestionMenuOptions) => FunctionalExtension;
+
+/** Where a stream is writing: what it has written so far. */
+interface ContentStreamRange {
+    from: number;
+    to: number;
+}
+/** What the extension reports: whether something is streaming in, and where. */
+interface ContentStreamState {
+    streaming: boolean;
+    range: ContentStreamRange | null;
+}
+/** How a stream shows what has come in — see {@link ContentStreamOptions.reveal}. */
+type ContentStreamReveal = 'block' | 'character' | 'instant';
+interface ContentStreamOptions {
+    /** A caret after the last thing written — a widget, `span.aee-stream-caret`,
+        for the host's stylesheet; the library paints nothing. Default true. */
+    caret?: boolean;
+    /**
+     * How what has come in is *revealed*. A model's tokens come in bursts — a
+     * word, a pause, three words — and written as they come they read like a
+     * slide show.
+     *
+     * - `'block'` (the default): a block — a paragraph, a list item, a line of
+     *   plain text — shows *whole*, once all of it is in: when the next one
+     *   starts, or the stream ends. Nothing types; blocks that land together
+     *   follow each other a beat apart. The caret waits after the last one.
+     * - `'character'`: a steady pace, a character or a few a frame, never
+     *   splitting one: faster when it falls behind, slower as it catches up.
+     * - `'instant'`: each piece the moment it comes.
+     *
+     * The stream ends — and `done` settles — once all of it shows.
+     */
+    reveal?: ContentStreamReveal;
+    /**
+     * How long, in ms, what was just revealed is *fresh*: it carries
+     * `aee-stream-fresh` — with `--email-stream-fade-in` set to this duration
+     * — for the host's stylesheet to fade it in; the library paints nothing.
+     * A block revealed whole carries it *itself* (the `p`, the `li`), so it
+     * can be wiped or moved as well as faded; text that joins a line already
+     * there, and everything under `'character'`, is wrapped in a `span`.
+     * Default 600; 0 marks nothing.
+     */
+    fadeIn?: number;
+    /** Escape stops the stream mid-way. Default true. */
+    stopOnEscape?: boolean;
+    /** Told when a stream starts, writes, and ends. */
+    onChange?: (state: ContentStreamState) => void;
+}
+/** What {@link streamContent}'s callback writes with. */
+interface ContentStreamWriter {
+    /** Appends a piece of the content — a token, a word, a chunk of a
+        response body. A no-op once the stream has been stopped. */
+    write(partial: string): void;
+    /** A `WritableStream` that writes what is piped into it — text, or bytes
+        decoded as UTF-8: `response.body.pipeTo(writer.getWritableStream())`. */
+    getWritableStream(): WritableStream<string | Uint8Array>;
+    /** Aborts when the stream is stopped — Escape, `stop()`, the editor going
+        away. Hand it to `fetch` or to the model's client. */
+    readonly signal: AbortSignal;
+}
+interface StreamContentOptions {
+    /**
+     * What the pieces are. `'text'` (the default) is appended as it comes.
+     * `'html'` is *re-read as a whole* on every write: the pieces collect in a
+     * buffer, the buffer is parsed through the schema, and what has been
+     * written so far is replaced by the result — so a list or a bold word
+     * takes shape as it streams, and a tag split over two pieces never shows
+     * as text.
+     */
+    format?: 'text' | 'html';
+    /** Rewrites the buffer before it is parsed (`'html'`) — strip a code
+        fence, turn Markdown into HTML. Given everything received so far. */
+    transform?: (buffer: string) => string;
+    /** Whether what is written enters the undo history. Default true: the
+        pieces undo as one. `false` keeps the writing out of it — for content
+        that is only *proposed* (see `proposeContent`), which is committed or
+        taken back as a whole later, so that neither undoes anything else. */
+    history?: boolean;
+}
+/** A stream in progress. */
+interface ContentStreamRun {
+    /** Stops it where it is: what shows stays, what has come in but not shown
+        yet does not. */
+    stop(): void;
+    /** True once the callback has finished and all of it shows; false when it
+        was stopped first. Rejects with what the callback threw, if it was not
+        an abort. */
+    readonly done: Promise<boolean>;
+}
+/** What a transaction of a stream says about where the stream is now —
+    for another plugin (a proposal's) to follow the range as precisely as
+    the stream itself does: `undefined` when the transaction is not the
+    stream's own, `null` when the stream ended with it. */
+declare const streamedRange: (tr: Transaction) => ContentStreamRange | null | undefined;
+/** Whether content is streaming into the editor — for an action that starts
+    one to say it cannot run again yet. */
+declare const isStreaming: (state: EditorState) => boolean;
+/** Where content is streaming in, if it is. */
+declare const streamingRange: (state: EditorState) => ContentStreamRange | null;
+/**
+ * Lets content **stream into the document** — a model's answer, a slow
+ * import — and owns everything around that: where the next piece goes while
+ * the writer keeps typing, how it shows — block by block — a caret, the fade
+ * on what is new, `aria-busy` on the editor, Escape to stop, the abort signal,
+ * the end. Install it, then call {@link streamContent}:
+ *
+ *     createEditor({ extensions: [...kit, createContentStream()] })
+ *
+ *     streamContent(editor.view, editor.state.selection.from, async ({ write, signal }) => {
+ *       for await (const token of model.stream(prompt, { signal })) write(token);
+ *     });
+ *
+ * One stream at a time per editor. What it writes is ordinary content in
+ * ordinary transactions: it is in the document, in the HTML, and in the undo
+ * history — pieces that follow each other closely undo as one.
+ */
+declare const createContentStream: (options?: ContentStreamOptions) => FunctionalExtension;
+/**
+ * Streams content into the document at `target` — a position, or a range
+ * that the first piece replaces ("rewrite this selection"). `callback` does
+ * the writing; the stream ends when it returns and all it wrote shows.
+ *
+ * Needs {@link createContentStream} among the editor's extensions, and no
+ * other stream running (ask {@link isStreaming}).
+ */
+declare function streamContent(view: EditorView, target: number | ContentStreamRange, callback: (writer: ContentStreamWriter) => Promise<void> | void, options?: StreamContentOptions): ContentStreamRun;
+
+/** What the extension reports: whether something is proposed, and where. */
+interface ContentProposalState {
+    range: ContentStreamRange | null;
+    /** The proposal is still being written. */
+    streaming: boolean;
+}
+interface ContentProposalOptions {
+    /** The class on what is proposed — `aee-proposal` — for the host's
+        stylesheet: the library paints nothing. */
+    className?: string;
+    /** Told when a proposal starts, grows, and ends — accepted or discarded. */
+    onChange?: (state: ContentProposalState) => void;
+}
+/** Whether something is proposed in the editor — written, but not the
+    writer's yet. */
+declare const isProposing: (state: EditorView["state"]) => boolean;
+/** Where the proposal stands, if there is one. */
+declare const proposalRange: (state: EditorView["state"]) => ContentStreamRange | null;
+/**
+ * Lets content be **proposed** into the document — an assistant's answer,
+ * shown in the text where it would go, before the writer decides. It is
+ * real content, in the document and in the HTML, so a list forms and a
+ * bold phrase arrives bold where they will stand; but it is marked
+ * (`aee-proposal`, for the host to paint), it stays out of the undo history,
+ * and it ends one of two ways: {@link acceptProposal} commits it, as one
+ * change — one undo — and {@link discardProposal} takes it out, leaving the
+ * document and its history exactly as they were. Nothing else touches
+ * either: a second proposal replaces the first, the editor going away
+ * discards.
+ *
+ * Opt-in, on top of the content stream:
+ *
+ *     createEditor({ extensions: [...kit, createContentStream(), createContentProposal()] })
+ *
+ *     proposeContent(editor.view, editor.state.selection.from, async ({ write, signal }) => {
+ *       for await (const token of model.stream(prompt, { signal })) write(token);
+ *     }, { format: 'html' });
+ *
+ * The Angular side — `injectProposal`, the accept and discard triggers, an
+ * input's keys — is `@h-k-dev/angular-email-editor/proposal`, its own entry: a host
+ * that brings its own panel imports what it uses.
+ */
+declare const createContentProposal: (options?: ContentProposalOptions) => FunctionalExtension;
+/**
+ * Proposes content at `target` — a position, or a range the proposal
+ * replaces — streamed in by `callback` (see `streamContent`, whose options
+ * these are). A proposal already there is discarded first. Needs
+ * {@link createContentProposal} and `createContentStream` in the kit.
+ */
+declare function proposeContent(view: EditorView, target: number | ContentStreamRange, callback: (writer: ContentStreamWriter) => Promise<void> | void, options?: Omit<StreamContentOptions, 'history'>): ContentStreamRun;
+/**
+ * Revises a *part* of the proposal: `range`, inside it, is replaced by what
+ * `callback` streams — "rewrite this bit" — while the rest of the proposal
+ * stands, still proposed, and the whole is accepted or discarded together
+ * as before. Null (and nothing streamed) when no proposal holds the range.
+ */
+declare function reviseProposal(view: EditorView, range: ContentStreamRange, callback: (writer: ContentStreamWriter) => Promise<void> | void, options?: Omit<StreamContentOptions, 'history'>): ContentStreamRun | null;
+/** Stops the writing where it is; what is proposed stays proposed. */
+declare function stopProposal(view: EditorView): void;
+/**
+ * Takes the proposal into the document for good: the same content, now
+ * the writer's own — one change in the history, so one undo takes all of
+ * it back. The caret lands after it. False when nothing is proposed.
+ */
+declare function acceptProposal(view: EditorView): boolean;
+/**
+ * Takes the proposal out, as if it had never been written: the document
+ * and its history are as they were, the caret where the proposal began.
+ * False when nothing is proposed.
+ */
+declare function discardProposal(view: EditorView): boolean;
+
+/** A box in viewport coordinates — what `coordsAtPos` answers. */
+interface MenuAnchor {
+    left: number;
+    top: number;
+    bottom: number;
+}
+/**
+ * Where a floating menu goes for an anchor line: under it, clamped to its
+ * scroll container, flipped above when below would overflow the visible
+ * area. Read-only — it measures and returns, and the caller writes `left` /
+ * `top` in its own write phase, so measuring never follows a write in the
+ * same task. The element must be `position: absolute` inside a
+ * `position: relative` scroll container; its size is read as rendered, so
+ * call it after its contents are in.
+ */
+declare function measureMenuPlacement(anchor: MenuAnchor, element: HTMLElement, offset: number): {
+    left: number;
+    top: number;
+} | null;
+
+/**
+ * An *expression dialect*: what the `{{…}}` tokens mean. The merge-tag mark
+ * is dialect-neutral — it finds tokens, keeps the pill honest and formats
+ * them whole — and a dialect layers meaning on top, opt-in, one per editor:
+ * a parser for the token language, exact required fields from the parse,
+ * syntax diagnostics before the template ever reaches a renderer. The first
+ * dialect is AngularJS expressions (`createAngularExpressions`); Handlebars
+ * follows. Without a dialect the generic lexer in `mergeTagFields` stands in.
+ */
+interface ExpressionDialect {
+    /** A short name, e.g. `angular`. */
+    readonly name: string;
+    /** The identifiers the document's tokens read — the values the host must
+        supply — deduplicated, in first-use order. */
+    requiredFields(doc: Node): string[];
+    /** Diagnostics for one token's inner expression, positions relative to it. */
+    analyze(expr: string): ExpressionIssue[];
+}
+/** A problem inside one expression, `[from, to)` relative to its text. */
+interface ExpressionIssue {
+    from: number;
+    to: number;
+    message: string;
+}
+/** A problem in the document: a token's issue at document positions. */
+interface ExpressionDiagnostic extends ExpressionIssue {
+    /** The token's inner expression, verbatim. */
+    expr: string;
+}
+/** The dialect installed on an editor, as plugin state, so the send intent
+    and the host read the one the editor was configured with. */
+declare const expressionDialectKey: PluginKey<{
+    dialect: ExpressionDialect;
+}>;
+declare const expressionDialect: (state: EditorState) => ExpressionDialect | undefined;
+
+type AngularNode = {
+    type: 'Literal';
+    value: string | number | boolean | null | undefined;
+} | {
+    type: 'Identifier';
+    name: string;
+} | {
+    type: 'Member';
+    object: AngularNode;
+    property: AngularNode;
+    computed: boolean;
+} | {
+    type: 'Call';
+    callee: AngularNode;
+    args: AngularNode[];
+} | {
+    type: 'Unary';
+    operator: string;
+    argument: AngularNode;
+} | {
+    type: 'Binary';
+    operator: string;
+    left: AngularNode;
+    right: AngularNode;
+} | {
+    type: 'Conditional';
+    test: AngularNode;
+    consequent: AngularNode;
+    alternate: AngularNode;
+} | {
+    type: 'Assignment';
+    target: AngularNode;
+    value: AngularNode;
+} | {
+    type: 'Filter';
+    name: string;
+    input: AngularNode;
+    args: AngularNode[];
+} | {
+    type: 'Array';
+    elements: AngularNode[];
+} | {
+    type: 'Program';
+    statements: AngularNode[];
+};
+/** Parses one token's inner expression. Throws an {@link ExpressionError}
+    (message + position) on the first problem. */
+declare function parseAngularExpression(expr: string): AngularNode;
+/** The parse's verdict on one expression: its issues (at most one — the
+    first — today), empty when it is a valid program. */
+declare function analyzeAngularExpression(expr: string): ExpressionIssue[];
+/** The required fields of a set of expressions: values read anywhere, minus
+    locals assigned anywhere (an assignment is seen across all tokens), in
+    first-use order. An expression that does not parse contributes nothing —
+    the diagnostic says why. */
+declare function angularRequiredFields(expressions: string[]): string[];
+declare const angularDialect: ExpressionDialect;
+interface AngularExpressionsOptions {
+    /** Called with the document's expression diagnostics whenever they change
+        (an empty list when every token parses) — the host's status strip. */
+    onDiagnostics?: (diagnostics: ExpressionDiagnostic[]) => void;
+}
+/**
+ * Installs the AngularJS dialect on an editor: the send intent's required
+ * fields come from the parse, every token is checked after each change, a
+ * problem is underlined in place (`.aee-expr-error`, the app owns the
+ * pixels) and reported through `onDiagnostics` with document positions —
+ * so a host can count it in its status strip and jump to it. Opt-in: an
+ * editor without it keeps the generic lexer and no checking.
+ */
+declare const createAngularExpressions: (options?: AngularExpressionsOptions) => FunctionalExtension;
+
+/** **bold** */
+declare const starInputRegex: RegExp;
+/** **bold** while pasting. */
+declare const starPasteRegex: RegExp;
+/** __bold__ */
+declare const underscoreInputRegex: RegExp;
+/** __bold__ while pasting. */
+declare const underscorePasteRegex: RegExp;
+/**
+ * Email specific html bold parsing rules.
+ * Watchout for normlization against
+ * - numeric font weights
+ * - case-insensitive font weights
+ * - inline styles resetting the weight back to normal
+ * - inline styles resetting the weight back to 400
+ * - inline styles resetting the weight back to normal
+ * - inline styles resetting the weight back to 400
+ */
+declare const Bold: _h_k_dev_angular_email_editor.MarkExtension;
+
+/** *italic* */
+declare const italicStarInputRegex: RegExp;
+/** *italic* while pasting. */
+declare const italicStarPasteRegex: RegExp;
+/** _italic_ */
+declare const italicUnderscoreInputRegex: RegExp;
+/** _italic_ while pasting. */
+declare const italicUnderscorePasteRegex: RegExp;
+declare const Italic: _h_k_dev_angular_email_editor.MarkExtension;
+
+declare const Underline: _h_k_dev_angular_email_editor.MarkExtension;
+
+interface LinkAttrs {
+    href: string;
+    title?: string | null;
+    target?: string;
+}
+interface LinkRange {
+    from: number;
+    to: number;
+    attrs: LinkAttrs;
+}
+/** The contiguous extent of the link at `pos`, if any — the range that a
+    link edit from a bare cursor (no selection) applies to. */
+declare function linkRangeAt(state: EditorState, pos: number): LinkRange | null;
+/** A simple security check to prevent XSS. Shared by every URL-bearing
+    extension (links, images): script URLs are refused on parse and on the
+    inserting command alike — the schema is the sanitizer. */
+declare function isSafeUrl(url: string | null): boolean;
+/**
+ * What a person typed into a link field → the href it means: a scheme or a
+ * `#fragment` as written, an address `mailto:`, a `{{ token }}` untouched
+ * (it becomes a URL at send), anything else `https://`. Empty stays empty.
+ */
+declare function normalizeHref(raw: string): string;
+/** Why a typed link cannot be applied — see {@link hrefProblem}. */
+type HrefProblem = 'required' | 'unsafe' | 'invalid';
+/**
+ * Whether what was typed into a link field can be a link in an email, after
+ * {@link normalizeHref}: `'required'` for nothing (or a bare `#`),
+ * `'unsafe'` for a script or `data:` URL — refused like `isSafeUrl`, plus
+ * `data:`, the phishing favourite no mail client should be handed —
+ * `'invalid'` for what is no URL at all (no host, a scheme mail cannot
+ * use, a host without a dot), null when it is fine. A link holding a
+ * `{{ token }}` passes: its shape is known only once it is filled in.
+ */
+declare function hrefProblem(raw: string): HrefProblem | null;
+/** Paste a URL onto selected text and the text becomes the link, rather than
+    replacing the selection with the raw URL (the Gmail/Docs behaviour). */
+declare const linkPastePlugin: Plugin<any>;
+declare const linkClickPlugin: Plugin<any>;
+declare const Link: _h_k_dev_angular_email_editor.MarkExtension;
+
+/**
+ * Allow only color values that can't smuggle extra declarations into the
+ * `style` attribute: hex, rgb[a]/hsl[a] functional notation, or a bare CSS
+ * named color. Mirrors the security-consciousness of the link mark's
+ * `isSafeUrl`. `node.style.color` is already normalised by the browser's
+ * CSSOM, but the legacy `<font color>` path and the programmatic `setColor`
+ * command take raw strings, so we gate both.
+ */
+declare function isSafeColor(color: string | null | undefined): color is string;
+/**
+ * Normalise any CSS color to a hex string the editor stores internally.
+ * Call this before passing a color value to setColor — never store oklch/lab/hsl
+ * in the mark attrs, because toDOM emits them verbatim into email HTML.
+ */
+declare function toEmailSafeColor(raw: string): string | null;
+type TextTransform = 'uppercase' | 'lowercase' | 'capitalize';
+/** A `text-transform` the mark takes: the three cases; `none` and the
+    rest are the words as written. */
+declare function parseTextTransform(raw: string | null | undefined): TextTransform | null;
+declare const ALLOWED_SIZES: readonly [10, 12, 14, 16, 18, 24, 32];
+type FontSize = (typeof ALLOWED_SIZES)[number];
+declare function isSafeFontSize(value: unknown): value is FontSize;
+/**
+ * Parse a font-size value from the DOM into one of our allowed sizes.
+ * Handles px strings ("16px"), plain numbers, and rejects everything else.
+ */
+declare function parseFontSize(raw: string | null | undefined): FontSize | null;
+/**
+ * The sizes the toolbar picker offers: the phone-safe subset (≥14px). Below
+ * ~13px iOS auto-inflates text and reflows the layout (responsiveness ledger,
+ * principle 8), so we don't *offer* those — but {@link parseFontSize} still
+ * accepts the full {@link ALLOWED_SIZES} range, because a hand-typed size in
+ * the HTML source pane is the author's own responsibility, exactly like a
+ * hand-typed hex colour.
+ */
+declare const emailFontSizes: FontSize[];
+/** A curated, email-safe font stack the toolbar offers. */
+interface EmailFont {
+    /** Toolbar label. */
+    name: string;
+    /** The exact `font-family` value emitted — the canonical stored form. */
+    stack: string;
+}
+/**
+ * The curated font stacks — the picker offers only these, no free-form fonts
+ * (principle 7: if a mainstream client can't render it, we don't emit it).
+ *
+ * Deliberately built from *single-word* family identifiers plus a generic
+ * fallback: a stack like `Courier New` would round-trip through the CSSOM
+ * (serialization builds real elements and re-reads them) and come back quoted
+ * as `"Courier New"` in Chrome but unquoted in jsdom — a byte-instability that
+ * breaks canonical determinism and makes tests disagree with the runtime (the
+ * same trap the longhand/`rgb()` rule guards against). Bare identifiers and
+ * generic keywords serialize identically everywhere.
+ */
+declare const emailFontFamilies: EmailFont[];
+declare function isSafeFontFamily(value: unknown): value is string;
+/**
+ * Parse a font-family value from the DOM into one of our curated stacks,
+ * returning the *canonical* stack string (so a cosmetically different but
+ * equivalent input normalises to the exact bytes we emit). A stack of
+ * someone else's reads as the curated one it falls back to — the first of
+ * its families a curated stack names, its generic last: a builder's web
+ * font (`Ubuntu, Helvetica, Arial, sans-serif`) is Sans-serif, the face a
+ * client without that font draws anyway. Nothing to fall back to, no font.
+ */
+declare function parseFontFamily(raw: string | null | undefined): string | null;
+/**
+ * TipTap-style `textStyle` mark: a `<span style="…">` container holding inline
+ * text-styling attributes — `color`, `fontSize`, `fontFamily` and
+ * `backgroundColor` (the highlighter). All hang off one shared span and merge
+ * into a single `style` string instead of nesting wrapper tags.
+ *
+ * Modeled on `@tiptap/extension-text-style` + `@tiptap/extension-color`: each
+ * primitive is an *attribute* on the span, not its own mark, so `setColor`,
+ * `setFontSize`, … all coalesce onto the same element. `backgroundColor` fills
+ * only from the curated dual-safe background palette (principle 9); a hand-typed
+ * fill in the HTML source is the author's own responsibility, never policed.
+ */
+declare const TextStyle: _h_k_dev_angular_email_editor.MarkExtension;
+
+declare const History: _h_k_dev_angular_email_editor.FunctionalExtension;
+
+declare const ColumnResize: _h_k_dev_angular_email_editor.FunctionalExtension;
+
+/** The declared width of each grid column (`null` = unspecified, shares the
+    leftover) — read from the first cell in the column that declares one. */
+declare function columnWidths(table: Node): (number | null)[];
+/** Every column's effective share, normalized to sum to 100: declared widths
+    as declared, undeclared columns splitting the leftover equally — the same
+    distribution fixed layout uses, so these numbers *are* the pixels and the
+    boundary lines can be placed by pure arithmetic. */
+declare function effectiveWidths(table: Node): number[];
+/**
+ * Sets the widths of the two columns meeting at `boundary` (the line between
+ * grid columns `boundary` and `boundary + 1`) — what a resize drag commits.
+ * `leftPct` is the left column's new share; the pair's total is conserved, so
+ * only these two columns move. Clamped so neither side drops below
+ * {@link MIN_COLUMN_PCT}. Every cell touching the two columns gets its
+ * `colwidth` entries set (spans included, sum-preserving), so the widths
+ * survive first-row edits and row deletion alike.
+ */
+declare function setColumnBoundary(tablePos: number, boundary: number, leftPct: number): Command;
+/**
+ * Sets the table's box — left offset and width, both percent of the
+ * container — what dragging either outer edge commits. The left edge moves
+ * the offset (the right edge stays put), the right edge moves the width;
+ * the pair clamps so the offset stays ≥ 0, the width keeps its floor, and
+ * together they never pass 100.
+ *
+ * `absorb` is the Word rule that keeps columns independent of the table's
+ * edges: column widths are percentages *of the table*, so changing the table
+ * width would slide every interior boundary proportionally. With `absorb`,
+ * the edge-adjacent column ('first' for a left-edge drag, 'last' for a
+ * right-edge one) takes the entire change and every other column is rescaled
+ * by oldWidth/newWidth — same absolute size, boundaries exactly where they
+ * were (to the 0.1% rounding). The width additionally floors where the
+ * absorbing column would hit {@link MIN_COLUMN_PCT}. Without `absorb`,
+ * columns scale proportionally.
+ */
+declare function setTableBox(tablePos: number, offsetPct: number, widthPct: number, absorb?: 'first' | 'last'): Command;
+/** Width-only convenience over {@link setTableBox}: keeps the offset. */
+declare function setTableWidth(tablePos: number, widthPct: number): Command;
+
+/** Which band — or which cell — of which table a grip stands for, and
+    where it is on screen. */
+interface TableHandleTarget {
+    kind: 'row' | 'column' | 'cell';
+    /** The band's index in the grid, counted from the top / the start; a
+        cell's column. */
+    index: number;
+    /** A cell's row. */
+    row?: number;
+    /** The table's position in the document — what the select commands take. */
+    tablePos: number;
+    /** The grip's own rect: what the app's menu anchors to. */
+    boundingBox: DOMRect;
+}
+interface TableHandlesOptions {
+    /** A grip was pressed (its band is selected by then), or the handles have
+        nothing to offer any more (`null`) — the table went away under them. */
+    onOpen: (target: TableHandleTarget | null) => void;
+    /** What a grip says to assistive tech, translated by the host. Called with
+        the band's 1-based number, as a person counts rows; for the caret
+        cell's grip, the cell's column. */
+    label?: (kind: 'row' | 'column' | 'cell', number: number) => string;
+}
+/**
+ * The row and column grips: a handle on each row's flank and above each
+ * column, the gesture every table editor has settled on (Notion's, Google
+ * Docs', Domternal's). Pressing one selects that whole band and hands the
+ * host a target to open a menu at — insert, move, duplicate, fill, align,
+ * delete — all of which are the ordinary selection-relative commands once
+ * the band is selected.
+ *
+ * **The grips are widget decorations inside the band's first cell**, not an
+ * overlay measured against the table. That is the whole trick: a decoration
+ * in a cell is positioned by that cell's own box, so a row grip is exactly
+ * as tall as its row and a column grip exactly as wide as its column,
+ * through merged cells, wrapped text and a resize drag alike — with no
+ * measurement, no ResizeObserver and no pointer tracking, which is the same
+ * bargain the boundary lines strike (see column-resize.ts).
+ *
+ * A band whose first cell is covered by a merge from above (or from the
+ * left) has no cell of its own to hang a grip in, and gets none: there is
+ * nothing there to grab that would not be a lie about what it selects.
+ *
+ * What a press *opens* is the host's: the extension reports the band and the
+ * grip's rect, and the app renders the menu (see the app's table-menu),
+ * exactly as the block menu is arranged.
+ *
+ * Decorations are built when a table's *grid* changes and then mapped, the
+ * way Notion and Tiptap keep their chrome off the keystroke path. Typing
+ * inside a cell is not a grid change — the widgets stay the same DOM nodes,
+ * so a pointer resting on a grip is never rebuilt out from under itself.
+ * The expanded state is a cheap attribute write on those nodes, not a
+ * decoration rebuild: `aria-expanded` is what the stylesheet (and a screen
+ * reader) already keys off.
+ */
+declare const createTableHandles: (options: TableHandlesOptions) => FunctionalExtension;
+
+/**
+ * Boundary drag for the `/columns` layout block — the table drag's twin, with
+ * the layout model underneath (see ROADMAP, "Columns and tables — decided").
+ *
+ * Same vocabulary: full-height primary lines on every boundary, hover to
+ * reveal, deferred commit (only the line moves, one transaction on release,
+ * one undo step), window-level listeners so the pointer can't outrun the
+ * handle, guides pinned for the drag's lifetime.
+ *
+ * Different model: a table splits 100% of itself; columns redistribute the
+ * email's px *budget* — the `max-width` caps that make the block fluid
+ * (side by side where the caps fit, stacked on a phone). The drag moves px
+ * between two neighbouring caps and conserves their sum, so the block's
+ * stacking behaviour never changes, only the split.
+ *
+ * Geometry, as always, from the model: the NodeView's *box* carries the
+ * container style (the email's centred 600px box), so a boundary's `left` is
+ * simply the sum of the caps before it, in px. And "stacked" — the one state
+ * where a horizontal drag means nothing — is a CSS container query on that
+ * same box: the caps sum to a constant budget, so the block stacks at a
+ * constant width, and the lines hide themselves. No measurement, no
+ * observer.
+ */
+declare const ColumnsResize: _h_k_dev_angular_email_editor.FunctionalExtension;
+
+/**
+ * A real cursor in the gaps *between* block nodes — ProseMirror's own answer to
+ * the trap every layout block falls into: our table and columns are
+ * `isolating`, so when one is the last thing in the document there is no text
+ * position after it, and clicking the empty space below it does nothing.
+ *
+ * With this, that click (and ArrowDown/ArrowRight out of a block, and a
+ * click *between* two adjacent blocks) lands a blinking gap cursor; typing
+ * there creates a paragraph. It is the mouse sibling of the block escapes we
+ * hand-rolled per node — one mechanism, every block, no per-node code.
+ *
+ * Ordering note: this must sit *after* the layout nodes in the kit. Extension
+ * plugins run in kit order and gap-cursor claims the arrow keys, so the
+ * table's own ArrowDown escape (which writes a paragraph below a trailing
+ * table rather than parking a cursor in the gap) has to be reached first.
+ *
+ * Pixels: `.ProseMirror-gapcursor` in the app's global styles, transcribed
+ * from `prosemirror-gapcursor/style/gapcursor.css` (MIT) and scoped to
+ * `.aee-editor` like everything else we ship.
+ */
+declare const Gapcursor: _h_k_dev_angular_email_editor.FunctionalExtension;
+
+/**
+ * The quoted history a reply or forward answers — Gmail's `⋯` — kept
+ * **beside** the body, never in it.
+ *
+ * - **It stays.** The history is the document's `quoted` attribute, not its
+ *   content: a template applied, an `.eml` dropped, the source pane
+ *   rewritten — anything that replaces the body (`setContent`, `setText`,
+ *   `replaceHTML`) leaves it where it is. `getHTML()` is the body alone.
+ * - **Only a deliberate step changes it.** The trash drops it; Edit moves it
+ *   into the body, where it is ordinary text from then on. Both are steps of
+ *   the document, so one undo brings it back — Edit's undo takes the text
+ *   out of the body again in the same step.
+ * - **It is sent.** The send intent puts it under the body
+ *   ({@link withQuoted}): HTML, plain text and inline images alike.
+ * - **It is what the schema keeps.** Whatever comes in is parsed through the
+ *   schema the way a paste is — foreign markup repaired, unsafe markup gone —
+ *   and held as canonical HTML.
+ *
+ * It renders as a widget after the last block — read-only, folded behind a
+ * `⋯` toggle, with Edit and a trash beside it. Behaviour and structure ship
+ * here; pixels are the host's, through `.aee-quoted` and its `data-slot`
+ * parts (`bar`, `fold`, `edit`, `remove`, `content`), the fold button keeping
+ * its `.aee-quote-fold` class.
+ */
+interface QuotedHistoryLabels {
+    /** The fold toggle while folded. Default "Show quoted text". */
+    show?: QuotedHistoryLabel;
+    /** The fold toggle while open. Default "Hide quoted text". */
+    hide?: QuotedHistoryLabel;
+    /** Moves the history into the body. Default "Edit quoted text". */
+    edit?: QuotedHistoryLabel;
+    /** Drops the history. Default "Remove quoted text". */
+    remove?: QuotedHistoryLabel;
+}
+/** A word, or a function asked for it each time the widget is drawn or
+    brought up to date — so a language switched at runtime reaches it. */
+type QuotedHistoryLabel = string | (() => string);
+interface QuotedHistoryOptions {
+    /** The widget's words, in the host's language; each left out stays English. */
+    labels?: QuotedHistoryLabels;
+}
+/** The quoted history, as canonical HTML, or null. */
+declare function quotedHistory(state: EditorState): string | null;
+/** Whether the quoted history is folded behind its `⋯` — true while there
+    is one and the user has not opened it. */
+declare function isQuotedHistoryFolded(state: EditorState): boolean;
+/** The document with its quoted history under the body — what is sent. */
+declare function withQuoted(doc: Node): Node;
+/** Sets the quoted history — sanitized through the schema — or drops it.
+    False when that is what it already is. A host's own sync marks the
+    transaction as such (the editor's `setQuoted` does). */
+declare const setQuotedHistory: (html: string | null) => Command;
+/** The trash: the history goes — as a step, so undo brings it back. */
+declare const removeQuotedHistory: Command;
+/** Edit: the history moves to the end of the body, as ordinary text, and
+    stops being kept — one step, so one undo reverses both. */
+declare const editQuotedHistory: Command;
+/** The quoted history as an editor extension — see {@link QuotedHistoryLabels}
+    for its words. The email kit carries it as {@link QuotedHistory}. */
+declare function createQuotedHistory(options?: QuotedHistoryOptions): FunctionalExtension;
+/** The email kit's quoted history, in English. */
+declare const QuotedHistory: FunctionalExtension;
+
+/**
+ * Each source line's indentation, as the custom property `--aee-line-indent`
+ * (in characters) on its `.aee-code-line` — what a host needs for VS Code's
+ * soft wrap: a wrapped line continues under its own indentation, not at the
+ * margin (`wrappingIndent: "same"`). The pixels are the host's:
+ *
+ *     .aee-code-line {
+ *       padding-inline-start: calc(var(--aee-line-indent, 0) * 1ch);
+ *       text-indent: calc(var(--aee-line-indent, 0) * -1ch);
+ *     }
+ *
+ * The first row starts at the margin (its spaces fill the indent); every row
+ * the line wraps into starts where its text does.
+ *
+ * Decorations, not the line's `toDOM`: a line's element is not re-rendered
+ * when its text changes, so an indent typed or deleted would never reach it.
+ * An edit rebuilds only the lines it touched — a keystroke in a 3000-line
+ * template costs one line.
+ */
+declare const CodeLineIndent: _h_k_dev_angular_email_editor.FunctionalExtension;
+
+/**
+ * Line folding for sending — the HTML as compact as ever, its lines kept
+ * short enough to survive any transport.
+ *
+ * RFC 5322 caps a line at 998 octets. A mailer that sends the HTML part
+ * quoted-printable or base64 never meets the cap; one that sends it 7bit or
+ * 8bit lets a relay cut a longer line wherever it reaches the cap — inside a
+ * tag, inside a word — which is where the stray `!` and the broken layout of
+ * a forwarded Exchange mail come from. Our serialized body is one line.
+ *
+ * **Two edits only**, both whitespace the HTML tokenizer ignores:
+ * - a space or tab *between the attributes of a start tag* becomes a line
+ *   break;
+ * - where a line has no such space (MJML's runs of Outlook conditionals and
+ *   end tags), a line break goes right before the `>` that closes a tag —
+ *   `</td⏎>` is `</td>`, Prettier prints it — never after a `/`, where it
+ *   would undo a self-closing slash.
+ *
+ * Never touched: text (its spaces may be `pre`), attribute values, comments
+ * (Outlook's conditional ones are markup to Outlook, kept byte for byte),
+ * doctypes, CDATA, processing instructions, the content of raw text
+ * elements (`style`, `title`, `textarea`, `noscript`, …) — and *anything*
+ * after `<svg>`, `<math>`, `<script>` or `<plaintext>`: in foreign content
+ * other elements hold raw text, a script's end hides behind escapes, and
+ * where they end takes the parser's whole tree, not a tokenizer. A line with
+ * nowhere to fold stays long — a transport encoding carries it.
+ *
+ * The tokenizer is the HTML standard's (§13.2.5) in every state a fold
+ * depends on — tag and attribute states, where `<` opens a tag, the end of
+ * a comment, of raw text. Where it is unsure it folds nothing: a missed fold
+ * costs a long line, a wrong one the email.
+ */
+/** Default fold width, in octets: well inside the 998 RFC 5322 allows,
+    leaving room for a transport's CR and dot-stuffing. */
+declare const FOLD_WIDTH = 900;
+/**
+ * `html` with its long lines folded — see above. Lines are measured in
+ * octets (UTF-8); a line that fits is never touched, and folding twice
+ * changes nothing.
+ */
+declare function foldHTML(html: string, width?: number): string;
+
+/** Editor root class while the document carries an envelope — the host's
+    hook for rendering a template like a client would (browser typography
+    rather than the composer's), see the example app's styles. */
+declare const DOCUMENT_CLASS = "aee-document";
+/**
+ * Applies a preserved document's stylesheets to the editor view, so the
+ * visual pane renders an MJML-class template exactly as the preview does:
+ * the head's `<style>` blocks (media queries included — that is what makes
+ * MJML columns responsive), its `<link rel="stylesheet">`s, and any `<style>`
+ * in the body. Everything is wrapped in `@scope (.<this editor>) { … }`, so
+ * a template's `table, td { … }` or `p { margin: 13px 0 }` reaches this
+ * editor's content and nothing else on the page (`body { … }` rules match
+ * nothing inside a scope and simply do not apply). `@import`s are hoisted
+ * ahead of the scope block, where CSS requires them. The `<body>`'s own
+ * inline style and `bgcolor` land on the editor root, the closest thing the
+ * editable view has to a body.
+ *
+ * Behaviour only: the style element sits beside the editor's DOM and is
+ * removed with it. No pixels of its own.
+ */
+declare const DocumentStyles: _h_k_dev_angular_email_editor.FunctionalExtension;
+/** One stylesheet text: hoisted imports, then everything else under `@scope`. */
+declare function scopedDocumentCss(doc: Node, scope: string): string;
+
+/**
+ * What the composer hands the host when the user asks to send: the canonical
+ * HTML, its `text/plain` projection — the two parts of a well-formed
+ * `multipart/alternative` body — the inline image parts that HTML references
+ * (`multipart/related`, should the host want it), and the personalization
+ * fields the body requires. Everything else (addressing, headers, transport)
+ * is the host's; nothing network-shaped lives in this library.
+ */
+interface SendIntent {
+    /** The canonical HTML — with every data-URL image already promoted to a
+        `cid:` reference (see {@link promoteInlineImages}); the document in the
+        editor keeps its data URLs. Folded for the wire (see {@link foldHTML}):
+        no line longer than the width wherever a space between a tag's
+        attributes allows it, so a relay's 998-octet cut never lands in the
+        middle of a tag — the same email to every parser, only line breaks
+        where spaces were. */
+    html: string;
+    text: string;
+    /** Every inline image `html` references, in document order: promoted
+        data-URL images carry their bytes, pre-existing `cid:` references
+        (an imported reply's parts, which the host already owns) carry none.
+        Empty when the body has no inline images — plain
+        `multipart/alternative` then. */
+    inlineImages: InlineImage[];
+    /** Every field identifier the body's merge tags read, in first-use order —
+        the values the host must resolve before the mail can render. Straight
+        off the document's nodes (see `mergeTagFields`), so a host without its
+        own template engine never text-parses the HTML to discover them; a host
+        with one (an AngularJS-expression evaluator, say) is free to ignore
+        this and scan `html` itself. Empty when the body is template-free. */
+    requiredFields: string[];
+}
+interface SendIntentOptions {
+    /** Called with the ready payload whenever the user requests a send —
+        `/send`, Mod-Enter (Gmail's shortcut), or the `requestSend` command. */
+    onSend: (intent: SendIntent) => void;
+}
+/**
+ * The send affordance — an *intent*, not a transport. The user's "send" is
+ * just another editor action; what it produces is a payload event the host
+ * wires to its own transport, exactly like the seed side (`replyDocument`)
+ * feeds the same `html` signal from the other direction.
+ *
+ * Three ways in, one payload: the `/send` slash item, Mod-Enter, and the
+ * `requestSend` command (for a toolbar button). The slash menu deletes the
+ * `/send` query text *before* running the item's command, so the emitted
+ * HTML is always clean of it.
+ */
+declare const createSendIntent: (options: SendIntentOptions) => FunctionalExtension;
+
+/**
+ * Fills the document's placeholders in with their values — the step a CRM
+ * runs before a templated mail goes out ("Platzhalter einsetzen").
+ *
+ * A host whose evaluator takes text (core's TextParser: `parseStrings`)
+ * would otherwise push the whole HTML body through it and take new HTML
+ * back. That loses three ways: an expression with `&&`, `>` or `<` arrives
+ * entity-escaped (`&amp;&amp;`) and fails to compile, a value is spliced
+ * into the markup unescaped, and the swapped body takes the undo history
+ * with it. Here the tokens are read off the document, where they are text:
+ *
+ * - the host is asked for each distinct expression **once, raw** —
+ *   `cf_3 > 0 && cf_4 ? 'x' : ''`, never an entity in sight;
+ * - each value goes in **as text**, in the token's place and with its
+ *   formatting (a bold `{{ customer_lastName }}` becomes the bold name), a
+ *   line break in a value a hard break;
+ * - all of it is **one transaction**: one Mod-Z brings the tokens back.
+ *
+ * Tokens in running text and in any string attribute of a node or mark — a
+ * link's or a button's `href`, a button's label, an image's `src` or `alt`
+ * — are filled alike, everywhere a renderer of the HTML would have looked.
+ * With a selection holding tokens, only those are filled; else the whole
+ * document.
+ *
+ * The request is asynchronous: the user may go on writing while the host
+ * answers. The scope is mapped through every change made meanwhile, tokens
+ * are found again when the values arrive, and a token edited in between is
+ * left alone (its expression is not the one asked for). One request at a
+ * time — {@link mergeTagResolutionPending} says when one is out.
+ *
+ * Bound to Mod-Shift-Enter — beside Mod-Enter's send, "fill in, then send";
+ * free in every browser and on every keyboard layout — and declared as the
+ * `resolve-placeholders` action, so it is a `/` menu row and a toolbar
+ * button with no further wiring.
+ */
+/** What became of a request — for the host's message ("3 Platzhalter ohne
+    Wert"). */
+interface MergeTagResolutionReport {
+    /** Where the request applied. */
+    scope: 'selection' | 'document';
+    /** How many token occurrences were replaced by a value. */
+    filled: number;
+    /** Expressions whose value came back empty — a field without a value, or
+        one the evaluator could not compute (most say `''` for both). Their
+        tokens are gone. */
+    empty: string[];
+    /** Expressions the host left unresolved (`null`): their tokens stay. */
+    kept: string[];
+}
+interface MergeTagResolutionOptions {
+    /**
+     * Values for the distinct expressions asked for, in the same order — each
+     * the trimmed text between the braces, as written. A string replaces the
+     * token (`''` removes it); `null` or `undefined` leaves it as it is. The
+     * editor never evaluates anything itself: this is the host's evaluator.
+     *
+     * ```ts
+     * resolve: async (expressions) => {
+     *   const raw = Object.fromEntries(expressions.map((e, i) => [i, `{{${e}}}`]));
+     *   const parsed = await textParser.parseStrings(raw, referenceId, {});
+     *   return expressions.map((_, i) => parsed[i]);
+     * }
+     * ```
+     */
+    resolve: (expressions: string[]) => Promise<readonly (string | null | undefined)[]>;
+    /** Called once the values are in the document. */
+    onResolved?: (report: MergeTagResolutionReport) => void;
+    /** Called when `resolve` rejects — the document is left as it was. */
+    onError?: (error: unknown) => void;
+    /** Called with `true` when a request goes out and `false` when it is
+        settled — the host's spinner. */
+    onPendingChange?: (pending: boolean) => void;
+}
+/** Whether a request is out — the action is disabled meanwhile, and a
+    host can show it. */
+declare function mergeTagResolutionPending(state: EditorState): boolean;
+/**
+ * The placeholder fill: `resolve` asks the host, `onResolved` reports. See
+ * the file comment for the contract; the command is `resolveMergeTags`, the
+ * action `resolve-placeholders`, the key Mod-Shift-Enter.
+ */
+declare const createMergeTagResolution: (options: MergeTagResolutionOptions) => FunctionalExtension;
+
+/**
+ * Selected text in contenteditable is natively draggable, which is never
+ * wanted in a composer. Node drags (e.g. images) stay allowed.
+ */
+declare const NoTextDrag: _h_k_dev_angular_email_editor.FunctionalExtension;
+
+/**
+ * The marks active at the cursor that should *continue past a break* — dropping
+ * any that opt out via `splittable: false` (e.g. `link`, so a break inside a
+ * link doesn't drag it onto the next line).
+ *
+ * This is the single rule both break paths share: forced line breaks
+ * (Shift-Enter, {@link ../nodes/hard-break}) and paragraph splits (Enter,
+ * below). Formatting like font/colour/bold has no `splittable` flag, so it
+ * survives — matching Gmail, where a font chosen on a bare cursor sticks for
+ * the rest of the passage you type, new lines included.
+ */
+declare function marksAcrossBreak(state: EditorState): readonly Mark[] | 0;
+/**
+ * Binds Enter to a mark-preserving paragraph split. Must sit *after* the list
+ * and blockquote extensions in the kit (so their own Enter handling wins inside
+ * those structures) and *before* {@link ../base-keymap} (whose plain
+ * `splitBlock` this replaces as the fallback). Lists already keep marks via
+ * `splitListItemKeepMarks`; this closes the same gap for ordinary `<div>` lines.
+ */
+declare const SplitKeepingMarks: _h_k_dev_angular_email_editor.FunctionalExtension;
+
+/**
+ * Enter, Backspace, Delete, select-all, ... Keep this last in the extension
+ * list so node/mark specific bindings take precedence.
+ */
+declare const BaseKeymap: _h_k_dev_angular_email_editor.FunctionalExtension;
+
+/**
+ * The inline image registry as an Angular service — the wiring around the
+ * framework-free {@link InlineImageStore}: one per composer (provide it on
+ * the composer component, never in root — two composers must not share
+ * parts), a signal that bumps on every change so the preview and the host
+ * can react, data URLs for the preview (a sandboxed, opaque-origin frame
+ * cannot load the editor's blob URLs), and every URL revoked with the
+ * composer. The editor pane hands it to `createInlineImages`; the host feeds
+ * it an import's parts and reads the referenced ones for a draft.
+ */
+declare class InlineImages extends InlineImageStore {
+    #private;
+    /** Bumps on every registered part (and again once its data URL is ready);
+        read it in a `computed`/`effect` to re-derive from the registry. */
+    readonly version: i0.Signal<number>;
+    constructor();
+    add(blob: Blob, cid?: string): string;
+    revokeAll(): void;
+    /** The part as a data URL, once read; undefined until then. */
+    dataUrl(cid: string): string | undefined;
+    /** The preview's projection of the canonical HTML: every `cid:` source the
+        registry holds becomes a data URL. Reads {@link version}, so a
+        `computed` over it re-runs when a part arrives. */
+    previewHtml(html: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InlineImages, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+export { AUTHORED_ATTR, AUTHORED_SPEC_KEY, AUTHORED_STYLE_DEFAULTS_KEY, AuthoredEnter, BLOCKQUOTE_STYLE, BLOCK_MENU_FOCUS_KEY, BUTTON_FILL, BUTTON_STYLE, BaseKeymap, Blockquote, Bold, BulletList, Button, CARET_ROOM, CLIENT_LABELS, COMMENT_TAG, CONTENT_ATTRS, CSS_SUPPORT, ClearFormatting, CodeLine, CodeLineIndent, Column, ColumnResize, Columns, ColumnsResize, DOCUMENT_CLASS, DOCUMENT_TAGS, DUAL_BACKGROUND_MIN_RATIO, DUAL_CONTRAST_DARK, DUAL_CONTRAST_LIGHT, DUAL_CONTRAST_MIN_RATIO, Divider, Document$1 as Document, DocumentStyles, EMAIL_ATTRIBUTES, EMAIL_CSS_PROPERTIES, EMAIL_SAFE_STYLE_PROPERTIES, EMAIL_SAFE_TAGS, EMAIL_TAGS, EMAIL_TAG_ATTRIBUTES, EmailParagraph, FILE_CHOOSER_POINTER_WAIT, FILL_TEXT_COLOR, FILL_TEXT_COLOR_LIGHT, FILL_TEXT_COLOR_RGB, FOLD_WIDTH, FORMAT_WIDTH, GMAIL_CLIP_BYTES, GUIDES_ACTIVE_CLASS, GUIDES_PEEK_CLASS, GUIDES_PEEK_DELAY_MS, Gapcursor, HEADING_SIZES, HardBreak, Heading, History, HtmlComment, HtmlCommentInline, HtmlElement, HtmlInline, HtmlLanguage, HtmlRaw, HtmlTextElement, HtmlVoid, HtmlVoidBlock, IMPORT_VIEWPORT_WIDTH, INDENT_MAX, INDENT_STEP, INLINE_TAGS, INLINE_VOID_TAGS, IN_SELECTION_CLASS, Image, InlineAtomSelection, InlineImageStore, InlineImages, Italic, LIST_STYLE, LayoutGuides, Link, ListItem, MAX_COLUMNS, MAX_IMAGE_WIDTH, MAX_MERGE_TAG_LENGTH, MAX_UNBROKEN_RUN, MIN_COLUMN_CAP, MIN_COLUMN_PCT, MIN_FONT_SIZE, MIN_IMAGE_WIDTH, MIN_TABLE_PCT, MJML_WORLDLY_HTML, MergeTag, NoTextDrag, OrderedList, PARSE_SCOPE_KEY, PLACEHOLDER_WIDTH, Paragraph, PasteHygiene, QuotedHistory, REFUSED_TAGS, RENDERING_CLIENTS, SECTION_CONTENT_MAX, SECTION_INSET, SECTION_PADDING, STACK_CLASS, STACK_RULE, Section, SplitKeepingMarks, TABLE_BORDER_COLOR, TABLE_CELL_PADDING, TABLE_SECTION_TAGS, TYPING_REST, Table, TableCell, TableRow, Text, TextStyle, UNSET_BUTTON_HREF, Underline, VOID_TAGS, acceptProposal, addColumn, addColumnAtEnd, addRowAtEnd, analyzeAngularExpression, angularDialect, angularRequiredFields, applyAuthoredAttributes, applyEmailVocabulary, attributeString, authoredAttribute, authoredMarkupOf, authoredViewAttributes, bareButtons, buttonStyle, canonicalHead, canonicalMergeTagInner, canonicalRender, caretCellPos, caretInsideMergeTag, claimedImageFiles, clearCells, clientList, columnCaps, columnWidths, completionContextAt, containerStyle, contrastRatio, correctStoredMistakes, createAngularExpressions, createBlockMenu, createBubbleMenu, createButtonEdit, createContentProposal, createContentStream, createDOMParser, createEditor, createHtmlAutocomplete, createHtmlLanguage, createImageDrag, createInlineImages, createMergeTagResolution, createOffsetMapper, createQuotedHistory, createSchema, createSendIntent, createSourceMarks, createSuggestionMenu, createTableHandles, declarationProperty, declaredBackground, decodeDataUrl, defaultBubbleShouldShow, defineExtension, defineMark, defineNode, deleteColumns, deleteFullySelected, discardProposal, distributePadding, docText, dropDeadOfficeClasses, dropHidden, dropMediaQueries, dropZeroSizedWhitespace, duplicateColumn, duplicateRow, editQuotedHistory, effectiveWidths, emailBackgroundPalette, emailDocument, emailExtensions, emailFontFamilies, emailFontSizes, emailPlainText, emailSizeBudget, emailTextPalette, embedsAsLinks, entitySpans, escapeAttribute, escapeText, expressionDialect, expressionDialectKey, extensionActions, extensionSuggestions, fillTextColor, filledPlaceholderAttrs, filterEmailStyle, findColumnContext, findColumnsContext, findCssIssues, findListDepth, findSectionContext, findTableContext, fitImageWidth, foldHTML, formatHTML, formatPct, forwardDocument, forwardQuote, hasBlockChildren, hasDocumentEnvelope, headingStyle, holdsBlock, holdsColumn, hrefProblem, htmlSourceExtensions, imageDropTarget, importLoss, importedDocument, inheritTextStyles, inheritedMarkup, inlineBootstrapTableBorders, inlineImageCids, inlineImageRegistry, inlineImagesKey, inlineStyles, insertHTML, insertMergeTag, isActionEnabled, isBlock, isBlockLevel, isBlockish, isBooleanAttribute, isEmailAttribute, isEmailCssProperty, isEmailTag, isFillTextColor, isInlineAtom, isMarkActive, isMergeTagExpression, isMergeTagPath, isNodeActive, isPadded, isProposing, isQuotedHistoryFolded, isSafeColor, isSafeFontFamily, isSafeFontSize, isSafeUrl, isSectionImageUrl, isStreaming, italicStarInputRegex, italicStarPasteRegex, italicUnderscoreInputRegex, italicUnderscorePasteRegex, keepGmailRules, layoutBlockAt, linkClickPlugin, linkPastePlugin, linkRangeAt, lintHTML, lowerInlinesAroundBlocks, markAttrsOf, markStackingColumns, marksAcrossBreak, materializeComments, measureMenuPlacement, mediaMatches, mergeTagAt, mergeTagExpressions, mergeTagFields, mergeTagRanges, mergeTagResolutionPending, moveColumn, moveRow, normalizeCommentText, normalizeCss, normalizeHref, normalizeMergeTagText, noteOwnWidths, openFileChooser, openTag, openTags, outlookColumns, paddingOf, parseAngularExpression, parseDocument, parseFontFamily, parseFontSize, parseHTML, parsePadding, parseRules, parseTextTransform, passesDualBackground, passesDualContrast, preserveExtensions, preservedAttributes, promoteInlineImages, promoteMergeTags, proposalRange, proposeContent, quotedHistory, readEnvelope, readImageFile, realizeComments, relativeLuminance, removeColumn, removeQuotedHistory, renderForClient, renderedPath, repairLinkSchemes, repairTables, replaceHTML, replyDocument, replyEnvelope, replyQuote, reviseProposal, rewriteInlineImageSources, richTextExtensions, ruleForScope, ruleScope, sanitizePastedHTML, scanHTML, scanMergeTags, scopeOf, scopedDocumentCss, selectColumn, selectRow, selectedButton, selectedImage, selectedImageAlt, selectedMarkAtom, selectionInsideMergeTag, serializeDocument, serializeToHTML, setCellBackground, setColumnBackground, setColumnBoundary, setColumnsBoundary, setQuotedHistory, setSectionBackground, setSectionImage, setTableBox, setTableWidth, soleInlineAtom, splitDeclarations, splitListItemKeepMarks, starInputRegex, starPasteRegex, stopProposal, streamContent, streamedRange, streamingRange, suggestionSectionTitles, tableStyle, textOffsetAt, textRegions, toEmailSafeColor, toInboundMessage, toggleList, trimInlineBoxes, underscoreInputRegex, underscorePasteRegex, unwrapLayoutTables, unwrapOfficeParagraphMarks, verbatimElement, videoPage, watchMenuScroll, withAttribute, withAuthoredMarkup, withQuoted, withQuotedHistory, withStyleDeclaration, withoutAttribute, withoutStyleDeclaration };
+export type { AngularExpressionsOptions, AngularNode, AttributePairs, AuthoredElement, AuthoredMarkup, AutocompleteItem, AutocompleteOptions, AutocompleteState, BlockMenuOptions, BlockMenuState, BubbleMenuOptions, BubbleMenuState, ButtonEditOptions, ButtonEditTarget, CellAlignment, CellVerticalAlignment, ClientRenderingOptions, CommandFactory, CompletionContext, ComposeSeedLabels, ComposeSeedOptions, ContentProposalOptions, ContentProposalState, ContentStreamOptions, ContentStreamRange, ContentStreamReveal, ContentStreamRun, ContentStreamState, ContentStreamWriter, CssSupportIssue, DocumentEnvelope, Editor, EditorAction, EditorOptions, EmailClient, EmailDocumentOptions, EmailFont, ExpressionDiagnostic, ExpressionDialect, ExpressionIssue, Extension, ExtensionContext, FontSize, FunctionalExtension, HrefProblem, HtmlDiagnostic, HtmlLanguageOptions, HtmlScan, HtmlTag, HtmlToken, HtmlTokenType, ImageAttrs, ImageDragOptions, ImageDropTarget, ImportLoss, InboundMessage, InlineAtomAt, InlineImage, InlineImageRegistry, InlineImageStoreOptions, LayoutBlock, LayoutBlockType, LinkAttrs, LinkRange, MarkExtension, MenuAnchor, MenuScroll, MenuScrollApi, MergeTagRange, MergeTagResolutionOptions, MergeTagResolutionReport, NodeExtension, PaletteColor, ParagraphAlignment, ParseMode, ParseOptions, ParsedAddressLike, ParsedEmailLike, PromotedInlineImages, QuotedHistoryLabel, QuotedHistoryLabels, QuotedHistoryOptions, RenderingClient, ReplyEnvelope, ReplyEnvelopeOptions, ReplyKind, RuleScope, SendIntent, SendIntentOptions, SizeBudget, SourceMarksOptions, SourceOptions, StreamContentOptions, SuggestionAllowProps, SuggestionCommandItem, SuggestionGroup, SuggestionItem, SuggestionItemLabel, SuggestionMenuOptions, SuggestionMenuState, SuggestionPage, SuggestionRect, SuggestionRequest, SuggestionSource, SuggestionTrigger, TableHandleTarget, TableHandlesOptions, TextTransform };