@zuilib/text-editor 0.11.0 → 0.12.0

package/dist/mermaid-BwGHjwpk.d.ts

@@ -0,0 +1,553 @@
+import { LexicalCommand, NodeKey } from 'lexical';
+import { a as BlockWidth } from './presets-BtNPH0pa.js';
+import { c as DrawingShape, P as Point, B as Binding, e as NodeShapeType, b as ConnectorType, a as BindingSide, D as DrawingData } from './drawing-data-EWzEQ1_i.js';
+
+/**
+ * Handles `INSERT_DRAWING_COMMAND`. The `DrawingNode` itself must be in the
+ * editor's `nodes` (it is in the default entry; add it yourself on top of
+ * `./core`).
+ */
+declare function DrawingPlugin(): null;
+
+/**
+ * Dispatched by a drawing canvas when it gains focus (its node key) or
+ * loses it (`null`). A drawing is a decorator, so Lexical's selection does
+ * not follow the caret into it; `useMarkdownEditor()` listens to this to
+ * know which block `blockWidth` refers to.
+ */
+declare const DRAWING_FOCUS_COMMAND: LexicalCommand<NodeKey | null>;
+/**
+ * Insert an empty drawing at the selection. Handled by `DrawingPlugin`
+ * (mounted by the default `MarkdownEditor`; absent from the `./core`
+ * entry, where the command is a no-op).
+ */
+declare const INSERT_DRAWING_COMMAND: LexicalCommand<{
+    width?: BlockWidth;
+} | undefined>;
+
+/**
+ * JSON Schema (draft-07) for the payload of a ```drawing fenced block
+ * (format version 3).
+ *
+ * Use it to validate LLM- or tool-generated drawings before embedding them,
+ * or pass it as a structured-output / tool schema so a model is forced to
+ * emit valid payloads. Kept in sync with `deserializeDrawingData` /
+ * `normalizeShape` in types.ts; update both together.
+ *
+ * For generation prefer the ```diagram skeleton
+ * (`DRAWING_SKELETON_JSON_SCHEMA`): it needs no coordinates and expands into
+ * this format on import.
+ */
+declare const DRAWING_DATA_JSON_SCHEMA: {
+    readonly $schema: "http://json-schema.org/draft-07/schema#";
+    readonly title: "DrawingData";
+    readonly description: "Vector drawing embedded in markdown as a ```drawing fenced code block (format version 3)";
+    readonly type: "object";
+    readonly required: readonly ["version", "canvasHeight", "shapes"];
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly version: {
+            readonly const: 3;
+            readonly description: "Format version; always 3";
+        };
+        readonly canvasHeight: {
+            readonly type: "number";
+            readonly minimum: 80;
+            readonly description: "Canvas height in pixels. Make it large enough to contain every shape plus ~20px margin.";
+        };
+        readonly canvasWidth: {
+            readonly type: "number";
+            readonly minimum: 120;
+            readonly description: "Optional logical canvas width in pixels. When set, the drawing is scaled down to fit narrower layouts (SVG viewBox) so coordinates can assume this width. When omitted the canvas is fluid and coordinates are CSS pixels.";
+        };
+        readonly width: {
+            readonly enum: readonly ["full", "text", "content"];
+            readonly description: "Block width: \"full\" (default, omit it) spans the editor; \"text\" aligns the block with the text column (same as \"full\" unless the app sets a text measure); \"content\" fits the shapes' horizontal extent and left-aligns with the text";
+        };
+        readonly title: {
+            readonly type: "string";
+            readonly description: "Optional accessible name of the drawing, read by screen readers in place of the shapes";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly description: "Optional longer accessible description of what the drawing shows";
+        };
+        readonly shapes: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/definitions/shape";
+            };
+            readonly maxItems: 5000;
+            readonly description: "Render order: later shapes draw on top";
+        };
+    };
+    readonly definitions: {
+        readonly point: {
+            readonly type: "object";
+            readonly required: readonly ["x", "y"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly x: {
+                    readonly type: "number";
+                    readonly description: "Absolute canvas x";
+                };
+                readonly y: {
+                    readonly type: "number";
+                    readonly description: "Absolute canvas y";
+                };
+            };
+        };
+        readonly binding: {
+            readonly type: "object";
+            readonly description: "Where a connector endpoint attaches to a box. Omit fixedPoint to let the endpoint auto-aim from the box center at the other end.";
+            readonly required: readonly ["id"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly description: "Id of the box this endpoint is attached to";
+                };
+                readonly fixedPoint: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly minimum: 0;
+                        readonly maximum: 1;
+                    };
+                    readonly minItems: 2;
+                    readonly maxItems: 2;
+                    readonly description: "Attach point as a ratio of the box's bounding box: [0,0] top-left, [1,1] bottom-right, [0.5,0] top edge midpoint, [1,0.5] right edge midpoint. Omitted: the endpoint auto-aims from the box center at the other end.";
+                };
+                readonly mode: {
+                    readonly enum: readonly ["orbit", "inside"];
+                    readonly description: "\"orbit\" (default): the endpoint is projected onto the box outline with a 6px gap. \"inside\": the endpoint sits exactly on the fixed point.";
+                };
+            };
+        };
+        readonly shape: {
+            readonly type: "object";
+            readonly required: readonly ["id", "type", "x", "y", "width", "height", "stroke", "fill", "strokeWidth"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly description: "Unique within the drawing; connector bindings reference it";
+                };
+                readonly type: {
+                    readonly enum: readonly ["rect", "ellipse", "diamond", "note", "cylinder", "cloud", "queue", "actor", "arrow", "line", "text"];
+                    readonly description: "Boxes (cards with label/text/footer slots): rect, ellipse, diamond, note (sticky note with a folded corner), cylinder (database), cloud, queue (horizontal cylinder), actor (stick figure; only the text slot, rendered as a name under the figure). Connectors: arrow (head at the end), line. Free-floating annotation: text.";
+                };
+                readonly x: {
+                    readonly type: "number";
+                    readonly description: "Boxes/text: left edge of the bounding box. Connectors: start point x.";
+                };
+                readonly y: {
+                    readonly type: "number";
+                    readonly description: "Boxes/text: top edge of the bounding box. Connectors: start point y.";
+                };
+                readonly width: {
+                    readonly type: "number";
+                    readonly description: "Boxes/text: width (non-negative). Connectors: delta x to the end point (may be negative).";
+                };
+                readonly height: {
+                    readonly type: "number";
+                    readonly description: "Boxes/text: height (non-negative). Connectors: delta y to the end point (may be negative).";
+                };
+                readonly stroke: {
+                    readonly type: "string";
+                    readonly description: "CSS color of the outline (and of any text). Palette: #1e1e1e (default), #e03131 red, #2f9e44 green, #1971c2 blue, #f08c00 orange, #7048e8 purple.";
+                };
+                readonly fill: {
+                    readonly type: "string";
+                    readonly description: "CSS color of the interior; \"transparent\" for none. Palette: #ffc9c9 red, #b2f2bb green, #a5d8ff blue, #ffec99 yellow, #d0bfff purple.";
+                };
+                readonly strokeWidth: {
+                    readonly type: "number";
+                    readonly description: "Outline width; use 2";
+                };
+                readonly text: {
+                    readonly type: "string";
+                    readonly description: "Standalone text content; center content of a box (the name under an actor); midpoint label of a connector";
+                };
+                readonly label: {
+                    readonly type: "string";
+                    readonly description: "Boxes only (not actor): small bold heading at the top";
+                };
+                readonly footer: {
+                    readonly type: "string";
+                    readonly description: "Boxes only (not actor): small dim line at the bottom";
+                };
+                readonly startBinding: {
+                    readonly $ref: "#/definitions/binding";
+                    readonly description: "Connectors only: box the start point attaches to. The editor re-anchors the endpoint onto that box and keeps it attached as the box moves.";
+                };
+                readonly endBinding: {
+                    readonly $ref: "#/definitions/binding";
+                    readonly description: "Connectors only: box the end point attaches to";
+                };
+                readonly bidirectional: {
+                    readonly type: "boolean";
+                    readonly description: "Arrows only: arrowheads on both ends";
+                };
+                readonly routing: {
+                    readonly const: "elbow";
+                    readonly description: "Connectors only: right-angled auto-routed path. It leaves the box perpendicular to the attach side, avoids every box on the canvas and minimises bends. Ignored when waypoints are present.";
+                };
+                readonly elbow: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                    readonly maximum: 1;
+                    readonly description: "Elbow override: position of the middle segment as a fraction of the span. Applied only when the routed path is a simple three-segment Z.";
+                };
+                readonly waypoints: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/definitions/point";
+                    };
+                    readonly description: "Connectors only: intermediate path points in canvas coordinates, ordered start to end. Takes precedence over routing.";
+                };
+            };
+        };
+    };
+};
+
+type Rect = Readonly<{
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}>;
+
+/** Topmost box under a point, if any; smaller boxes win over enclosing ones */
+declare function findNodeShapeAt(shapes: readonly DrawingShape[], point: Point, excludeId?: string, tolerance?: number): DrawingShape | null;
+declare function createBinding(box: DrawingShape, point: Point): Binding;
+
+type TextField = 'text' | 'label' | 'footer';
+/**
+ * Geometry of a box type, kept free of React so the router, bindings,
+ * skeleton expansion and exporters can use it without a DOM.
+ */
+type NodeShapeDefinition = Readonly<{
+    type: NodeShapeType;
+    label: string;
+    /** Size used when a shape is created without explicit dimensions */
+    defaultSize: Readonly<{
+        w: number;
+        h: number;
+    }>;
+    /** Text slots the shape renders (and offers for editing) */
+    textSlots: readonly TextField[];
+    /** Fill applied when the tool is picked with the default (transparent) fill */
+    defaultFill?: string;
+    /** Closed outline used for hit-testing and binding endpoints */
+    outline: (shape: DrawingShape) => Point[];
+    /** Area the text slots lay out in */
+    textArea: (shape: DrawingShape) => Rect;
+}>;
+declare const NODE_SHAPE_DEFINITIONS: Record<NodeShapeType, NodeShapeDefinition>;
+
+/**
+ * Skeleton (intent) layer: a compact, LLM-friendly description of a diagram
+ * — boxes, connectors between them and loose texts — that expands into a
+ * full `DrawingData` document. Sizes, positions and connector geometry are
+ * derived, so a generator only needs to say *what* is on the canvas.
+ */
+
+type ColorName = 'plain' | 'black' | 'gray' | 'red' | 'green' | 'blue' | 'orange' | 'purple';
+declare const COLOR_PRESETS: Record<ColorName, {
+    stroke: string;
+    fill: string;
+}>;
+type SkeletonBox = Readonly<{
+    id: string;
+    /** Default `'rect'` */
+    type?: NodeShapeType;
+    label?: string;
+    text?: string;
+    footer?: string;
+    /** Omitted → auto layout */
+    x?: number;
+    y?: number;
+    /** Omitted → measured from the text, never smaller than the type's default size */
+    w?: number;
+    h?: number;
+    /** Preset → stroke + fill (fill only when `fill` isn't given) */
+    color?: ColorName;
+    stroke?: string;
+    fill?: string;
+}>;
+type SkeletonEnd = string | Readonly<{
+    id: string;
+    side?: BindingSide;
+}>;
+type SkeletonConnector = Readonly<{
+    id?: string;
+    /** Default `'arrow'` */
+    type?: ConnectorType;
+    from: SkeletonEnd;
+    to: SkeletonEnd;
+    text?: string;
+    bidirectional?: boolean;
+    /** Default `'straight'` */
+    routing?: 'elbow' | 'straight';
+    color?: ColorName;
+    stroke?: string;
+}>;
+type SkeletonText = Readonly<{
+    id?: string;
+    x: number;
+    y: number;
+    text: string;
+    color?: ColorName;
+    stroke?: string;
+}>;
+type DrawingSkeleton = Readonly<{
+    /** Auto-layout flow direction, default `'right'` */
+    direction?: 'right' | 'down';
+    canvasWidth?: number;
+    canvasHeight?: number;
+    /** Block width of the expanded drawing; omit for `full` */
+    width?: BlockWidth;
+    boxes: readonly SkeletonBox[];
+    connectors?: readonly SkeletonConnector[];
+    texts?: readonly SkeletonText[];
+}>;
+/** Structural check: an object with a `boxes` array */
+declare function isDrawingSkeleton(value: unknown): value is DrawingSkeleton;
+/**
+ * Parse a skeleton JSON payload into drawing data. Lenient: invalid boxes,
+ * connectors and texts are dropped individually, and a malformed document
+ * yields an empty canvas. Never throws.
+ */
+declare function parseDrawingSkeleton(json: string): DrawingData;
+declare function expandDrawingSkeleton(skeleton: DrawingSkeleton): DrawingData;
+declare const DRAWING_SKELETON_JSON_SCHEMA: {
+    readonly $schema: "http://json-schema.org/draft-07/schema#";
+    readonly title: "DrawingSkeleton";
+    readonly description: "Compact intent description of a diagram. Boxes are sized from their text and laid out automatically along the connector flow; connectors are drawn between box outlines. Only say what is on the canvas — geometry is derived";
+    readonly type: "object";
+    readonly required: readonly ["boxes"];
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly direction: {
+            readonly enum: readonly ["right", "down"];
+            readonly description: "Auto-layout flow direction. Boxes connected a→b are placed in successive ranks along this axis (\"right\" = columns left to right, \"down\" = rows top to bottom). Default \"right\"";
+        };
+        readonly canvasWidth: {
+            readonly type: "number";
+            readonly minimum: 120;
+            readonly description: "Logical canvas width in px. Omit for a fluid canvas in CSS pixels";
+        };
+        readonly canvasHeight: {
+            readonly type: "number";
+            readonly minimum: 80;
+            readonly description: "Canvas height in px. Omit to fit the content";
+        };
+        readonly width: {
+            readonly enum: readonly ["full", "text", "content"];
+            readonly description: "Block width: \"text\" aligns the drawing with the text column (same as \"full\" unless the app sets a text measure); \"content\" fits the drawing to its shapes and left-aligns it with the text; omit to span the editor";
+        };
+        readonly boxes: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/definitions/box";
+            };
+            readonly description: "Card-like shapes carrying up to three text slots. Order is the render order and the stacking order within a layout rank";
+        };
+        readonly connectors: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/definitions/connector";
+            };
+            readonly description: "Arrows and lines between boxes. Connectors whose from/to id does not match a box are dropped";
+        };
+        readonly texts: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/definitions/text";
+            };
+            readonly description: "Free-floating annotations not attached to any box. Prefer box slots (label/text/footer) when the text belongs to a box";
+        };
+    };
+    readonly definitions: {
+        readonly box: {
+            readonly type: "object";
+            readonly required: readonly ["id"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly description: "Unique within the drawing; connectors reference it";
+                };
+                readonly type: {
+                    readonly enum: readonly NodeShapeType[];
+                    readonly description: "Shape: rect (default), ellipse, diamond (decision), note (sticky note, yellow by default), cylinder (database), cloud (external system), queue (message queue), actor (stick figure; only the \"text\" slot renders, below the figure)";
+                };
+                readonly label: {
+                    readonly type: "string";
+                    readonly description: "Small bold heading at the top of the box";
+                };
+                readonly text: {
+                    readonly type: "string";
+                    readonly description: "Main content, centered. Wraps automatically; \"\\n\" forces a line break";
+                };
+                readonly footer: {
+                    readonly type: "string";
+                    readonly description: "Small dim line at the bottom of the box";
+                };
+                readonly x: {
+                    readonly type: "number";
+                    readonly description: "Top-left x in px. Omit (with y) to let the layout place the box";
+                };
+                readonly y: {
+                    readonly type: "number";
+                    readonly description: "Top-left y in px. Omit (with x) to let the layout place the box";
+                };
+                readonly w: {
+                    readonly type: "number";
+                    readonly exclusiveMinimum: 0;
+                    readonly description: "Width in px. Omit to size from the text (never smaller than the type default)";
+                };
+                readonly h: {
+                    readonly type: "number";
+                    readonly exclusiveMinimum: 0;
+                    readonly description: "Height in px. Omit to size from the text (never smaller than the type default)";
+                };
+                readonly color: {
+                    readonly enum: readonly ColorName[];
+                    readonly description: "Named color preset: outline plus, for boxes, a matching fill. `plain` has no outline and a light fill, `black` is a dark card with light text, `gray` is a dark outline on transparent (the default); the rest pair a colored outline with its pastel fill.";
+                };
+                readonly stroke: {
+                    readonly type: "string";
+                    readonly description: "CSS color of the outline and text; overrides the preset";
+                };
+                readonly fill: {
+                    readonly type: "string";
+                    readonly description: "CSS color of the interior (\"transparent\" for none); overrides the preset";
+                };
+            };
+        };
+        readonly connector: {
+            readonly type: "object";
+            readonly required: readonly ["from", "to"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly description: "Optional; generated when omitted";
+                };
+                readonly type: {
+                    readonly enum: readonly ConnectorType[];
+                    readonly description: "arrow (default; arrowhead at \"to\") or line (no arrowheads)";
+                };
+                readonly from: {
+                    readonly oneOf: readonly [{
+                        readonly type: "string";
+                        readonly description: "Id of a box. The connector attaches to its outline, aimed at the other end";
+                    }, {
+                        readonly type: "object";
+                        readonly required: readonly ["id"];
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly id: {
+                                readonly type: "string";
+                                readonly description: "Id of a box";
+                            };
+                            readonly side: {
+                                readonly enum: readonly ["top", "right", "bottom", "left"];
+                                readonly description: "Pin the endpoint to the middle of this side of the box instead of auto-aiming";
+                            };
+                        };
+                    }];
+                    readonly description: "Box a connector end attaches to: a bare box id, or {id, side} to pick the attach edge";
+                };
+                readonly to: {
+                    readonly oneOf: readonly [{
+                        readonly type: "string";
+                        readonly description: "Id of a box. The connector attaches to its outline, aimed at the other end";
+                    }, {
+                        readonly type: "object";
+                        readonly required: readonly ["id"];
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly id: {
+                                readonly type: "string";
+                                readonly description: "Id of a box";
+                            };
+                            readonly side: {
+                                readonly enum: readonly ["top", "right", "bottom", "left"];
+                                readonly description: "Pin the endpoint to the middle of this side of the box instead of auto-aiming";
+                            };
+                        };
+                    }];
+                    readonly description: "Box a connector end attaches to: a bare box id, or {id, side} to pick the attach edge";
+                };
+                readonly text: {
+                    readonly type: "string";
+                    readonly description: "Label rendered at the middle of the connector";
+                };
+                readonly bidirectional: {
+                    readonly type: "boolean";
+                    readonly description: "Arrow only: arrowheads on both ends";
+                };
+                readonly routing: {
+                    readonly enum: readonly ["straight", "elbow"];
+                    readonly description: "straight (default) draws a direct line; elbow draws a right-angled path routed around the boxes";
+                };
+                readonly color: {
+                    readonly enum: readonly ColorName[];
+                    readonly description: "Named color preset: outline plus, for boxes, a matching fill. `plain` has no outline and a light fill, `black` is a dark card with light text, `gray` is a dark outline on transparent (the default); the rest pair a colored outline with its pastel fill.";
+                };
+                readonly stroke: {
+                    readonly type: "string";
+                    readonly description: "CSS color of the line and label; overrides the preset";
+                };
+            };
+        };
+        readonly text: {
+            readonly type: "object";
+            readonly required: readonly ["x", "y", "text"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly description: "Optional; generated when omitted";
+                };
+                readonly x: {
+                    readonly type: "number";
+                    readonly description: "Top-left x of the first line, in px";
+                };
+                readonly y: {
+                    readonly type: "number";
+                    readonly description: "Top-left y of the first line, in px";
+                };
+                readonly text: {
+                    readonly type: "string";
+                    readonly description: "Content; \"\\n\" forces a line break";
+                };
+                readonly color: {
+                    readonly enum: readonly ColorName[];
+                    readonly description: "Named color preset: outline plus, for boxes, a matching fill. `plain` has no outline and a light fill, `black` is a dark card with light text, `gray` is a dark outline on transparent (the default); the rest pair a colored outline with its pastel fill.";
+                };
+                readonly stroke: {
+                    readonly type: "string";
+                    readonly description: "CSS color of the text; overrides the preset";
+                };
+            };
+        };
+    };
+};
+
+type MermaidDirection = 'LR' | 'TD';
+type MermaidOptions = Readonly<{
+    direction?: MermaidDirection;
+}>;
+/**
+ * Export a drawing as a Mermaid `flowchart`. Boxes become nodes (in shape
+ * order), connectors bound at both ends become edges; unbound connectors
+ * are dropped and free text shapes are kept as `%% note:` comments so
+ * nothing is silently lost.
+ */
+declare function drawingToMermaid(data: DrawingData, options?: MermaidOptions): string;
+
+export { COLOR_PRESETS as C, DRAWING_DATA_JSON_SCHEMA as D, INSERT_DRAWING_COMMAND as I, type MermaidDirection as M, NODE_SHAPE_DEFINITIONS as N, type SkeletonBox as S, type TextField as T, type ColorName as a, DRAWING_FOCUS_COMMAND as b, DRAWING_SKELETON_JSON_SCHEMA as c, DrawingPlugin as d, type DrawingSkeleton as e, type MermaidOptions as f, type NodeShapeDefinition as g, type SkeletonConnector as h, type SkeletonEnd as i, type SkeletonText as j, createBinding as k, drawingToMermaid as l, expandDrawingSkeleton as m, findNodeShapeAt as n, isDrawingSkeleton as o, parseDrawingSkeleton as p };

package/dist/paste.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Normalisation of pasted HTML from Word, Google Docs, Confluence and
+ * browsers: structure is kept (headings, paragraphs, lists, tables, links,
+ * code, quotes, emphasis, images), presentation is dropped (styles,
+ * classes, ids, fonts, spans, Office namespaces, comments, scripts).
+ * Links whose `href` fails `isSafeUrl` (`javascript:`, `data:`, ...) keep
+ * their text only.
+ */
+type PasteNormalizeOptions = Readonly<{
+    /** Keep `<table>` structure (default `true`); `false` flattens cells to paragraphs */
+    tables?: boolean;
+    /** Keep `<a href>` (default `true`); `false` keeps the text only */
+    links?: boolean;
+    /** Keep `<img>` (default `true`) */
+    images?: boolean;
+}>;
+/**
+ * The cleaned body HTML of a pasted fragment. `<pre>` content is left as
+ * is apart from attribute stripping.
+ */
+declare function normalizePastedHtml(html: string, options?: PasteNormalizeOptions): string;
+/** Whether the HTML looks like it came from Word, Google Docs, Confluence or Outlook */
+declare function isRichSourceHtml(html: string): boolean;
+
+type PastePluginProps = PasteNormalizeOptions & Readonly<{
+    /**
+     * `'rich-sources'` (default) normalises only HTML that carries Word,
+     * Google Docs, Confluence or Outlook fingerprints; `'always'` normalises
+     * every HTML paste.
+     */
+    when?: 'rich-sources' | 'always';
+    /** Transform the cleaned HTML further before it is converted to nodes */
+    transform?: (html: string) => string;
+}>;
+/**
+ * HTML paste normalisation. Word, Google Docs and Confluence put inline
+ * styles, spans, fonts, Office namespaces and conditional comments on the
+ * clipboard; this plugin strips them and keeps headings, paragraphs,
+ * lists, tables, links, code, quotes, emphasis and images before the
+ * built-in rich-text paste converts the HTML to nodes. Plain-text pastes
+ * and pastes inside a decorator's input are untouched.
+ */
+declare function PastePlugin({ when, transform, tables, links, images }?: PastePluginProps): null;
+
+export { type PasteNormalizeOptions, PastePlugin, type PastePluginProps, isRichSourceHtml, normalizePastedHtml };

package/dist/paste.js

@@ -0,0 +1,2 @@
+'use client';
+"use client";import{a,b,c}from"./chunk-ZXZMYJ7F.js";import"./chunk-YFFSTMIR.js";export{c as PastePlugin,b as isRichSourceHtml,a as normalizePastedHtml};