@lyads/visual-editor 0.0.0-stage → 1.0.1

package/dist/renderers/element-source.d.ts

@@ -0,0 +1,13 @@
+import type { EditorDocumentData, SourceInput } from '../core/document';
+/**
+ * Finds the exact stretch of the exported source which one element occupies. Editing an element
+ * as HTML replaces only that stretch: everything else keeps its original bytes, and the result is
+ * imported through the ordinary validation like any other source.
+ */
+export declare class ElementSourceMap {
+    /** The markup of one element as it stands in the source, or undefined when it has none. */
+    read(document: EditorDocumentData, source: SourceInput, id: string): string | undefined;
+    /** The whole source with one element replaced by `html`. */
+    replace(document: EditorDocumentData, source: SourceInput, id: string, html: string): SourceInput | undefined;
+    private locate;
+}

package/dist/renderers/email-renderer.d.ts

@@ -0,0 +1,14 @@
+import type { EditorDocumentData, SourceInput } from '../core/document';
+import type { DocumentOutputCodec, DocumentOutputPolicy } from './page-renderer';
+export interface MjmlCompilerPort {
+    compile(source: string): Promise<string>;
+}
+/** MJML is for creating supported content; imported HTML is never recompiled. */
+export declare class MjmlEmailRenderer {
+    private readonly codec;
+    private readonly policy;
+    private readonly compiler;
+    constructor(codec: DocumentOutputCodec, policy: DocumentOutputPolicy, compiler: MjmlCompilerPort);
+    render(document: EditorDocumentData): SourceInput;
+    createSource(mjml: string): Promise<SourceInput>;
+}

package/dist/renderers/marked-preview.d.ts

@@ -0,0 +1,34 @@
+import type { DocumentKind, SourceInput } from '../core/document';
+import type { SecureIdentifier } from '../security/identity';
+import type { CanvasBridgeRegion } from './canvas-bridge';
+import type { PreviewFrameDocument, PreviewFrameOptions, SelectionPreview, SelectionPreviewSource } from './preview-frame';
+/**
+ * The preview of a block piece (schema 2) for the editing frame: the output of the generators
+ * in preview mode, already marked with `data-visual-editor-node` and
+ * `data-visual-editor-edit-node`, and the regions of its blocks.
+ */
+export interface BlockPreviewInput {
+    readonly id: string;
+    readonly revision: number;
+    readonly kind: DocumentKind;
+    readonly source: SourceInput;
+    readonly regions: readonly CanvasBridgeRegion[];
+}
+/**
+ * Builds the frame document of a block piece and keeps the marks the generators wrote. A mark
+ * is kept only for a block of the piece, once per block, and an edit mark only for an editable
+ * block, inside its own selectable element; every other reserved attribute is removed. The
+ * content rules of the blocks already refuse those attributes in free HTML: this is the second
+ * barrier, so markup of the author can never pose as a block.
+ */
+export declare class MarkedPreviewRenderer implements SelectionPreviewSource<BlockPreviewInput> {
+    private readonly frame;
+    private readonly identifiers;
+    constructor(frame: PreviewFrameDocument, identifiers: SecureIdentifier);
+    build(input: BlockPreviewInput, selectionLabel: string, options?: PreviewFrameOptions): SelectionPreview;
+    update(input: BlockPreviewInput, selectionLabel: string, current: Pick<SelectionPreview, 'nonce'>, options?: PreviewFrameOptions): SelectionPreview;
+    private render;
+    /** Validates the marks in document order; returns the ids of the blocks and texts found. */
+    private keepMarks;
+    private attribute;
+}

package/dist/renderers/markup-tree.d.ts

@@ -0,0 +1,36 @@
+import type { DefaultTreeAdapterMap } from 'parse5';
+import type { DocumentNode } from '../core/document';
+export type MarkupElement = DefaultTreeAdapterMap['element'];
+export type MarkupParent = DefaultTreeAdapterMap['parentNode'];
+export interface DocumentParts {
+    readonly root?: MarkupElement;
+    readonly head?: MarkupElement;
+    /** Absent in a page made of frames, which has a `frameset` where the body would be. */
+    readonly body?: MarkupElement;
+    readonly frameset?: MarkupElement;
+}
+/** The elements every parsed document has, wherever the source wrote or implied them. */
+export declare function documentParts(document: DefaultTreeAdapterMap['document']): DocumentParts;
+/** The children a walk follows: the content of a template stands where its children would. */
+export declare function markupChildren(node: MarkupParent): readonly DefaultTreeAdapterMap['childNode'][];
+/** Removes every attribute reserved to the editor below `root`, template contents included. */
+export declare function stripReservedAttributes(root: MarkupParent): void;
+/** Elements of the document which a parser shows as elements of the piece, in document order. */
+export declare function canonicalElements(nodes: readonly DocumentNode[]): DocumentNode[];
+export interface AlignmentVisitor {
+    /** Every element of the HTML tree, infrastructure included, before it is matched. */
+    element?(element: MarkupElement): void;
+    /**
+     * An element of the markup and the node of the document it stands for. `island` is an inline
+     * SVG or MathML: one node of the document, whose inside is never walked. Return `false` to end
+     * the walk there.
+     */
+    match(element: MarkupElement, node: DocumentNode, island: boolean): boolean | void;
+}
+/**
+ * The one rule which pairs the markup a parser reads with the nodes of the document: the same
+ * elements in the same order, skipping what every document has (`html`, `head`, `body`, `style`,
+ * `meta`, `title`) and never going inside foreign content, which the document keeps as source.
+ * Returns how many nodes were paired, or undefined when markup and document disagree.
+ */
+export declare function alignElements(root: MarkupParent, canonical: readonly DocumentNode[], visitor: AlignmentVisitor): number | undefined;

package/dist/renderers/page-renderer.d.ts

@@ -0,0 +1,15 @@
+import type { EditorDocument, EditorDocumentData, SourceInput } from '../core/document';
+export interface DocumentOutputCodec {
+    export(document: EditorDocumentData): SourceInput;
+}
+export interface DocumentOutputPolicy {
+    /** An `EditorDocument` was validated when it was built; its content is checked again. */
+    assertSafe(document: EditorDocumentData | EditorDocument): void;
+}
+/** Serializes the canonical page rather than rebuilding it from recognized blocks. */
+export declare class PageRenderer {
+    private readonly codec;
+    private readonly policy;
+    constructor(codec: DocumentOutputCodec, policy: DocumentOutputPolicy);
+    render(document: EditorDocumentData): SourceInput;
+}

package/dist/renderers/preview-document.d.ts

@@ -0,0 +1,39 @@
+import type { DocumentKind, EditorDocumentData, ImportResult, SourceInput } from '../core/document';
+import type { DocumentOutputPolicy } from './page-renderer';
+export interface SourceValidationCodec {
+    import(source: SourceInput, kind: DocumentKind): ImportResult;
+    /** Read without touching the preservation cache of the documents being edited. */
+    inspect?(source: SourceInput, kind: DocumentKind): ImportResult;
+    /** Needed when the rules of the kind changed what the given source parses to. */
+    export?(document: EditorDocumentData): SourceInput;
+}
+export interface HtmlAssemblyPort {
+    build(source: SourceInput, kind: DocumentKind, preview?: boolean): string;
+}
+/** Produces a complete portable file from an already policy-validated source. */
+export declare class HtmlDocumentAssembler {
+    #private;
+    private readonly codec;
+    private readonly policy;
+    constructor(codec: SourceValidationCodec, policy: DocumentOutputPolicy, imageOrigins?: readonly string[]);
+    build(source: SourceInput, kind: DocumentKind, preview?: boolean): string;
+    /**
+     * Changes only the copy shown in the editor, never the document. A policy written by the
+     * author cannot stand next to the editor's (it could neither loosen it nor break the
+     * editing script), a refresh would navigate the frame away, and a base would redirect
+     * every relative reference. The elements which stay keep their place in the tree.
+     *
+     * The content of `noscript` is text to a parser with scripting and markup to one without: the
+     * editing frame reads it the first way, the plain preview and the parser which reconciles a
+     * revision read it the second. It is read here as markup, given the same treatment, cleared
+     * of every attribute reserved to the editor and written back as text.
+     */
+    private neutralize;
+    private noscript;
+}
+/** Sandbox remains mandatory even with CSP; no user markup reaches the host DOM. */
+export declare class PreviewDocument {
+    private readonly assembler;
+    constructor(assembler: HtmlAssemblyPort);
+    build(source: SourceInput, kind: DocumentKind): string;
+}

package/dist/renderers/preview-frame.d.ts

@@ -0,0 +1,102 @@
+import type { DefaultTreeAdapterMap } from 'parse5';
+import * as v from 'valibot';
+import type { DocumentKind, SourceInput } from '../core/document';
+import type { CanvasBridgeLabels, CanvasBridgeRegion, CanvasBridgeTheme } from './canvas-bridge';
+import type { MarkupElement } from './markup-tree';
+import type { HtmlAssemblyPort } from './preview-document';
+export interface SelectionPreview {
+    readonly html: string;
+    /**
+     * The secret of the message protocol of this window. It only exists inside the text of the
+     * runtime script, never in an attribute, and has no part in the CSP, which authorizes that
+     * script by the digest of its text. The name is the one the protocol always used.
+     */
+    readonly nonce: string;
+    readonly revision: number;
+    readonly nodeIds: readonly string[];
+    readonly regions: readonly CanvasBridgeRegion[];
+    readonly readOnly: boolean;
+    /** Test mode: only then does the host accept fidelity reports from the frame. */
+    readonly diagnostics: boolean;
+}
+/** Options every preview of the editing frame takes, whatever document it shows. */
+export interface PreviewFrameOptions {
+    readonly readOnly?: boolean;
+    readonly labels?: CanvasBridgeLabels;
+    readonly title?: string;
+    readonly lang?: string;
+    /** Test mode of the frame runtime; never enabled by a document. */
+    readonly diagnostics?: boolean;
+    /** Colors of the host shell for the controls drawn over the piece. */
+    readonly theme?: CanvasBridgeTheme;
+    /** False: the host opens no block menu, so the frame never asks for one. */
+    readonly menu?: false;
+    /** Friendly names of the variables of the host by key (at most 500, names up to 200). */
+    readonly variables?: Readonly<Record<string, string>>;
+}
+/** What the editing frame asks of the renderer of its document: a new window or a revision. */
+export interface SelectionPreviewSource<D extends {
+    readonly id: string;
+    readonly revision: number;
+}> {
+    build(document: D, selectionLabel: string, options?: PreviewFrameOptions): SelectionPreview;
+    update(document: D, selectionLabel: string, current: Pick<SelectionPreview, 'nonce'>, options?: PreviewFrameOptions): SelectionPreview;
+}
+/**
+ * One document bound to its renderer, as the editing frame takes it: the frame only knows the
+ * identity of what it shows and asks for a new window or the next revision. A new renderer
+ * means a new window.
+ */
+export interface FramePreviewSource {
+    readonly id: string;
+    readonly revision: number;
+    readonly renderer: object;
+    build(selectionLabel: string, options?: PreviewFrameOptions): SelectionPreview;
+    update(selectionLabel: string, current: Pick<SelectionPreview, 'nonce'>, options?: PreviewFrameOptions): SelectionPreview;
+}
+export declare function framePreview<D extends {
+    readonly id: string;
+    readonly revision: number;
+}>(renderer: SelectionPreviewSource<D>, document: D): FramePreviewSource;
+/** Only plain color values and a bounded radius ever reach the style of the controls. */
+export declare const previewThemeSchema: v.StrictObjectSchema<{
+    readonly accent: v.ExactOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 80, undefined>, v.CheckAction<string, undefined>]>, undefined>;
+    readonly contrast: v.ExactOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 80, undefined>, v.CheckAction<string, undefined>]>, undefined>;
+    readonly surface: v.ExactOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 80, undefined>, v.CheckAction<string, undefined>]>, undefined>;
+    readonly text: v.ExactOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 80, undefined>, v.CheckAction<string, undefined>]>, undefined>;
+    readonly border: v.ExactOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 80, undefined>, v.CheckAction<string, undefined>]>, undefined>;
+    readonly radius: v.ExactOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 24, undefined>]>, undefined>;
+}, undefined>;
+/** The page is made of frames: it has no body to edit in the piece, only its source. */
+export declare const PREVIEW_FRAMESET = "PREVIEW_FRAMESET";
+/** Normalizes optional DOM metadata; strict public options are validated separately. */
+export declare function normalizePreviewLanguage(value: string | undefined): string | undefined;
+/** An opened frame document: the parsed tree and the parts the renderers mark. */
+export interface OpenedPreview {
+    readonly parsed: DefaultTreeAdapterMap['document'];
+    readonly head: MarkupElement;
+    readonly body: MarkupElement;
+    readonly hostLanguage: string;
+    readonly labels: CanvasBridgeLabels;
+    readonly theme: CanvasBridgeTheme | undefined;
+}
+/**
+ * The parts of an editing-frame document every renderer shares: the assembled copy with its
+ * CSP, the language and title, the selection style and the single runtime script authorized by
+ * the digest of its text. What marks the blocks is the renderer's own.
+ */
+export declare class PreviewFrameDocument {
+    #private;
+    private readonly assembler;
+    constructor(assembler: HtmlAssemblyPort);
+    open(source: SourceInput, kind: DocumentKind, selectionLabel: string, options: PreviewFrameOptions): OpenedPreview;
+    /** Adds the selection style and, for a new window, the runtime; serializes the result. */
+    close(opened: OpenedPreview, preview: {
+        readonly revision: number;
+        readonly regions: readonly CanvasBridgeRegion[];
+        readonly nodeIds: readonly string[];
+        readonly token: string;
+        readonly executable: boolean;
+    }, options: PreviewFrameOptions): SelectionPreview;
+    private uniformLabels;
+}

package/dist/renderers/section-scaffold.d.ts

@@ -0,0 +1,16 @@
+import type { SectionScaffoldPort } from '../application/section-layout';
+import type { SectionLayoutProjection, SectionLayoutSettings } from '../core/section-layout';
+import type { SourceInput } from '../core/document';
+import type { CssDocumentCodec } from '../codecs/css';
+import { MjmlEmailRenderer } from './email-renderer';
+/** Generates only an empty MJML layout shell. Existing column HTML is transplanted by application. */
+export declare class MjmlSectionScaffold implements SectionScaffoldPort {
+    private readonly renderer;
+    private readonly styles;
+    constructor(renderer: MjmlEmailRenderer, styles: Pick<CssDocumentCodec, 'inspect' | 'readDeclarations'>);
+    create(settings: SectionLayoutSettings, original: SectionLayoutProjection): Promise<SourceInput>;
+    supports(projection: SectionLayoutProjection): boolean;
+    private geometry;
+    private layoutComment;
+    private layoutTag;
+}

package/dist/renderers/selection-preview.d.ts

@@ -0,0 +1,47 @@
+import type { EditorDocumentData } from '../core/document';
+import type { DocumentOutputCodec, DocumentOutputPolicy } from './page-renderer';
+import type { HtmlAssemblyPort } from './preview-document';
+import { CanvasLayout } from '../core/canvas-layout';
+import { BlockCatalog } from '../core/catalog';
+import type { CanvasRegion } from '../core/canvas-layout';
+import type { SourceInput } from '../core/document';
+import type { PreviewFrameOptions, SelectionPreview, SelectionPreviewSource } from './preview-frame';
+import type { BlockPreviewInput } from './marked-preview';
+export { framePreview, normalizePreviewLanguage, previewThemeSchema, PREVIEW_FRAMESET, } from './preview-frame';
+export type { FramePreviewSource, PreviewFrameOptions, SelectionPreview, SelectionPreviewSource, } from './preview-frame';
+export type { BlockPreviewInput } from './marked-preview';
+export interface SelectionPreviewOptions extends PreviewFrameOptions {
+    /** Friendly name of each selectable block, in the language of the host shell. */
+    readonly describe?: (region: CanvasRegion) => string | undefined;
+}
+/** Instruments logical regions after validating the complete untrusted document. */
+export declare class SelectionPreviewRenderer implements SelectionPreviewSource<EditorDocumentData> {
+    #private;
+    private readonly codec;
+    private readonly policy;
+    private readonly assembler;
+    /**
+     * The previews of block pieces (schema 2). Their markup comes from the generators already
+     * marked; this path keeps those marks, only for blocks of the piece and once each, instead
+     * of deriving them from an HTML document.
+     */
+    readonly blocks: SelectionPreviewSource<BlockPreviewInput>;
+    constructor(codec: DocumentOutputCodec, policy: DocumentOutputPolicy, assembler: HtmlAssemblyPort, 
+    /** The catalog and the layout of the editor it serves; its own when used alone. */
+    structure?: {
+        readonly catalog?: BlockCatalog;
+        readonly layout?: CanvasLayout;
+    });
+    /** The markup one element has in the exported source, for editing it as HTML. */
+    elementSource(document: EditorDocumentData, id: string): string | undefined;
+    /** The exported source with one element replaced; it still has to be imported and validated. */
+    replaceElementSource(document: EditorDocumentData, id: string, html: string): SourceInput | undefined;
+    /** A complete preview for a new window: a fresh protocol secret, CSP and the runtime script. */
+    build(document: EditorDocumentData, selectionLabel: string, options?: SelectionPreviewOptions): SelectionPreview;
+    /**
+     * The next revision for a window which is already running: same secret, no script. The frame
+     * runtime reconciles this markup over what it shows instead of reloading.
+     */
+    update(document: EditorDocumentData, selectionLabel: string, current: Pick<SelectionPreview, 'nonce'>, options?: SelectionPreviewOptions): SelectionPreview;
+    private render;
+}

package/dist/rich-text/command-executor.d.ts

@@ -0,0 +1,26 @@
+import type { Editor } from '@tiptap/core';
+import type { Mark as ProseMirrorMark } from '@tiptap/pm/model';
+import type { RichTextCommandName, RichTextCommandState, RichTextStyleName } from './commands';
+import { RichTextFormatting } from './formatting';
+export interface RichTextRange {
+    readonly from: number;
+    readonly to: number;
+}
+/** Resolves the value a text run shows when the person gave it no style of their own. */
+export type RichTextInheritedStyle = (marks: readonly ProseMirrorMark[], position: number) => Partial<Record<RichTextStyleName, string>>;
+/** Applies the closed command vocabulary to an editor; values are validated by the caller. */
+export declare class RichTextCommandExecutor {
+    private readonly formatting;
+    private readonly focus;
+    /**
+     * @param focus Whether a command also takes the keyboard. The editor inside the preview
+     * frame never does: its commands come from controls which must keep the focus they have.
+     */
+    constructor(formatting?: RichTextFormatting, focus?: boolean);
+    run(editor: Editor, command: RichTextCommandName, value?: string | null, range?: RichTextRange): boolean;
+    private clamp;
+}
+/** Reads what the controls show: active formats, the styles of the selection and history. */
+export declare class RichTextStateReader {
+    read(editor: Editor, ready: boolean, normalize?: (style: RichTextStyleName, value: string) => string, inherited?: RichTextInheritedStyle): RichTextCommandState;
+}

package/dist/rich-text/commands.d.ts

@@ -0,0 +1,36 @@
+/** Closed vocabulary shared by the host controls, the message policy and the frame runtime. */
+export declare const RICH_TEXT_COMMANDS: readonly ["bold", "italic", "underline", "strike", "superscript", "subscript", "bulletList", "orderedList", "color", "backgroundColor", "fontFamily", "fontSize", "lineHeight", "clearFormatting", "setLink", "unsetLink", "insertText", "undo", "redo", "finish", "cancel"];
+export type RichTextCommandName = (typeof RICH_TEXT_COMMANDS)[number];
+export declare const RICH_TEXT_TOGGLES: readonly ["bold", "italic", "underline", "strike", "superscript", "subscript", "bulletList", "orderedList"];
+export type RichTextToggleName = (typeof RICH_TEXT_TOGGLES)[number];
+export declare const RICH_TEXT_STYLES: readonly ["color", "backgroundColor", "fontFamily", "fontSize", "lineHeight"];
+export type RichTextStyleName = (typeof RICH_TEXT_STYLES)[number];
+/** Commands which carry a value. `null` clears a style; every other command takes none. */
+export declare const RICH_TEXT_VALUE_COMMANDS: readonly RichTextCommandName[];
+export declare const RICH_TEXT_LIMITS: Readonly<{
+    commandValue: 2048;
+    insertedText: 1024;
+    styleValue: 200;
+}>;
+export interface RichTextStyleState {
+    readonly value: string;
+    readonly own: boolean;
+    readonly mixed: boolean;
+}
+export interface RichTextCommandState {
+    /** A caret or selection exists, so commands have a target. */
+    readonly ready: boolean;
+    readonly marks: readonly RichTextToggleName[];
+    readonly styles: Readonly<Record<RichTextStyleName, RichTextStyleState>>;
+    readonly link: boolean;
+    readonly href: string;
+    readonly empty: boolean;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+}
+export declare function emptyRichTextState(): RichTextCommandState;
+/** One command surface for the local panel editor and the editor inside the preview frame. */
+export interface RichTextCommands {
+    readonly state: RichTextCommandState;
+    run(command: RichTextCommandName, value?: string | null): boolean;
+}

package/dist/rich-text/document-builder.d.ts

@@ -0,0 +1,52 @@
+import { RichTextProjectionRules } from './projection-rules';
+/** Source markup seen without a DOM: a document node or an element of the preview frame. */
+export interface RichTextSourceNode {
+    readonly type: 'text' | 'element' | 'other';
+    readonly text?: string;
+    readonly tag?: string;
+    /** Present only when the element must be restored from its source node. */
+    readonly origin?: string;
+    readonly attributes?: Readonly<Record<string, string>>;
+    readonly children?: readonly RichTextSourceNode[];
+}
+export interface RichTextJsonMark {
+    type: string;
+    attrs?: Record<string, unknown>;
+}
+export interface RichTextJsonNode {
+    type: string;
+    attrs?: Record<string, unknown>;
+    content?: RichTextJsonNode[];
+    marks?: RichTextJsonMark[];
+    text?: string;
+}
+export interface RichTextBuildOptions {
+    /** Mark names of the schema, outermost first: the only nesting the editor can render. */
+    readonly markOrder: readonly string[];
+    /** The block collapses white space, so source spacing at its edges is not content. */
+    readonly collapse: boolean;
+}
+/**
+ * Builds the editor document straight from source markup, so mounting over the real element
+ * keeps loose text loose and every source tag and attribute available to the rendered view.
+ * Markup whose nesting the schema cannot reproduce is refused instead of being rearranged.
+ */
+export declare class RichTextDocumentBuilder {
+    #private;
+    private readonly rules;
+    constructor(rules?: RichTextProjectionRules);
+    /** Returns undefined for markup the editor cannot represent faithfully. */
+    build(children: readonly RichTextSourceNode[], allowBlocks: boolean, options: RichTextBuildOptions): RichTextJsonNode | undefined;
+    private visit;
+    private origin;
+    /** A span which wraps another mark must be rendered outside it. */
+    private wraps;
+    private nest;
+    private inline;
+    /** Inline content of one block, with collapsible edge spacing and a final break set aside. */
+    private textblock;
+    private paragraph;
+    private blocks;
+    private block;
+    private item;
+}

package/dist/rich-text/formatting.d.ts

@@ -0,0 +1,17 @@
+import { Mark } from '@tiptap/core';
+import type { Editor, Extensions } from '@tiptap/core';
+import type { Transaction } from '@tiptap/pm/state';
+import type { RichTextFormat } from '../core/rich-text-format';
+/** Keeps preservation provenance independent from removable semantic marks. */
+export declare class RichTextFormatting {
+    styleExtensions(): Extensions;
+    markName(format: RichTextFormat): string;
+    markNames(): readonly string[];
+    extensions(): readonly Mark[];
+    toggle(editor: Editor, format: Exclude<RichTextFormat, 'link'>, focus?: boolean): boolean;
+    removeLink(editor: Editor, focus?: boolean): boolean;
+    /** The source tag and attributes travel with the origin wherever the schema declares them. */
+    private carried;
+    preserve(tr: Transaction, format: RichTextFormat): boolean;
+    restore(tr: Transaction, format: RichTextFormat): boolean;
+}

package/dist/rich-text/projection-export.d.ts

@@ -0,0 +1,17 @@
+import type { Node as ProseMirrorNode, Schema } from '@tiptap/pm/model';
+/**
+ * Serializes an editor document to the rich-text projection without a DOM: allowlisted tags,
+ * the origin marker and the styles the person applied. Source attributes never leave with it.
+ */
+export declare class RichTextProjectionExporter {
+    #private;
+    /** Captures the projection specs; construct it before the schema gains a faithful view. */
+    constructor(schema: Schema);
+    export(document: ProseMirrorNode): string;
+    /** The text of a block, with the source spacing and terminal break the editor set aside. */
+    private text;
+    private blocks;
+    private node;
+    private inline;
+    private compile;
+}

package/dist/rich-text/projection-rules.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Which source markup the rich-text projection understands and when an element must carry its
+ * origin, so the host projection and the editor inside the preview frame agree on one answer.
+ */
+export declare class RichTextProjectionRules {
+    isInline(tag: string): boolean;
+    isBlock(tag: string): boolean;
+    supports(tag: string): boolean;
+    canonicalTag(tag: string): string;
+    semanticAttributes(tag: string): readonly string[];
+    /** The element keeps attributes or a tag which only its source node can restore. */
+    needsOrigin(tag: string, attributeNames: readonly string[]): boolean;
+}

package/dist/rich-text/schema.d.ts

@@ -0,0 +1,50 @@
+import type { Extensions } from '@tiptap/core';
+import type { Schema } from '@tiptap/pm/model';
+import { RichTextFormatting } from './formatting';
+export declare const RICH_TEXT_RAW_ATTRIBUTE = "raw";
+export declare const RICH_TEXT_IMPLICIT_ATTRIBUTE = "implicit";
+/** Collapsible source spacing and a terminal line break around the text of a block. */
+export declare const RICH_TEXT_EDGE_ATTRIBUTE = "edge";
+/** A source span which wraps other marks; the plain preserved span is always the innermost. */
+export declare const RICH_TEXT_OUTER_SPAN = "preservedOuterSpan";
+export interface RichTextEdge {
+    readonly lead: string;
+    readonly tail: string;
+    readonly br: boolean;
+}
+export declare function isRichTextEdge(value: unknown): value is RichTextEdge;
+/** Marks the element which the frame runtime renders for a source node with an origin. */
+export declare const RICH_TEXT_VIEW_ORIGIN_ATTRIBUTE = "data-visual-editor-text-origin";
+/** A neutral block for loose text between blocks; it never matches author selectors by tag. */
+export declare const RICH_TEXT_IMPLICIT_TAG = "visual-editor-line";
+export interface RichTextRaw {
+    readonly tag: string;
+    readonly attrs: Readonly<Record<string, string>>;
+}
+export interface RichTextSchemaOptions {
+    /**
+     * `paragraph` and `block+` are the projection documents of the panel editor. `inline*` puts the
+     * text directly in the mounted element, so a heading or a link gains no inner paragraph.
+     */
+    readonly content: 'paragraph' | 'block+' | 'inline*';
+    readonly links: boolean;
+    readonly isAllowedUri: (value: string) => boolean;
+    /** Keeps source tags and attributes in the rendered view. Only for the real element. */
+    readonly fidelity?: boolean;
+}
+export declare function isRichTextRaw(value: unknown): value is RichTextRaw;
+/** The single rich-text schema definition of the panel editor and of the frame runtime. */
+export declare class RichTextSchema {
+    readonly formatting: RichTextFormatting;
+    private readonly formats;
+    extensions(options: RichTextSchemaOptions): Extensions;
+    /**
+     * Makes the rendered view reuse the source tag and attributes of every node with an origin.
+     * Capture the projection specs (RichTextProjectionExporter) before calling this.
+     */
+    applyFidelity(schema: Schema): void;
+    private faithful;
+    /** Outermost mark of the schema, so a source span can keep wrapping a link or a bold. */
+    private outerSpan;
+    private fidelityExtension;
+}

package/dist/rich-text/whitespace.d.ts

@@ -0,0 +1,7 @@
+import { DOMParser } from '@tiptap/pm/model';
+import type { ParseOptions, Schema, Slice } from '@tiptap/pm/model';
+/** Keeps clipboard parsing on the schema's parser while preserving authored spacing. */
+export declare class RichTextWhitespaceParser extends DOMParser {
+    constructor(schema: Schema);
+    parseSlice(dom: Node, options?: ParseOptions): Slice;
+}

package/dist/security/bounded-parser.d.ts

@@ -0,0 +1,18 @@
+import type { DefaultTreeAdapterMap, ParserOptions } from 'parse5';
+type Options = Omit<ParserOptions<DefaultTreeAdapterMap>, 'treeAdapter'>;
+/**
+ * Parses untrusted markup with a ceiling on nesting which is enforced while the tree is built.
+ * The parser scans its stack of open elements on most tags, so a source of tens of thousands of
+ * nested elements costs time quadratic in its depth before any limit of the document model could
+ * see it. Here the parse ends at the first element placed deeper than the limit, with the same
+ * diagnostic the model gives. A tree within the limit is exactly the tree of the plain parser.
+ */
+export declare class BoundedHtmlParser {
+    #private;
+    constructor(depth?: number);
+    document(markup: string, options?: Options): DefaultTreeAdapterMap['document'];
+    /** `context` is the element whose content the markup is, e.g. an `svg` root for an island. */
+    fragment(markup: string, options?: Options, context?: DefaultTreeAdapterMap['element']): DefaultTreeAdapterMap['documentFragment'];
+    private guard;
+}
+export {};

package/dist/security/conditional-comment.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Downlevel-revealed conditionals (`<![if !mso]>` ... `<![endif]>`) reach the tree as bogus
+ * comments. Only the exact opening and closing forms over a closed vocabulary are recognized;
+ * the content between the markers is ordinary markup validated like the rest of the document.
+ */
+export declare class DownlevelRevealedConditional {
+    isOpening(value: string): boolean;
+    isClosing(value: string): boolean;
+    isMarker(value: string): boolean;
+    /**
+     * `<![ENDIF]>` or `<![endif] >` would only survive as an ordinary comment, which no longer
+     * closes the revealed block for Outlook. Anything but the exact closer is refused.
+     */
+    isClosingLookalike(value: string): boolean;
+    /**
+     * Document-order comment values: every revealed opener needs a later exact closer and a
+     * second opener may not appear before it. A closer on its own stays an inert comment.
+     */
+    isBalanced(comments: Iterable<string>): boolean;
+    /**
+     * expression := term (('&' | '|') term)*
+     * term       := ['!'] ('(' expression ')' | [gt | gte | lt | lte] (mso | IE) [version])
+     */
+    private validExpression;
+    private tokens;
+    /** Index after the expression which starts at `start`, or -1 when none is well formed. */
+    private expression;
+    private term;
+    private version;
+}