@zuilib/text-editor 0.11.0 → 0.12.0

package/dist/comment-markers-BrrrAdSL.d.ts

@@ -0,0 +1,27 @@
+import { LexicalNode } from 'lexical';
+import { TextMatchTransformer } from '@lexical/markdown';
+import { MarkNode } from '@lexical/mark';
+
+declare function formatCommentMarker(ids: readonly string[], inner: string): string;
+declare function parseCommentIds(value: string): string[];
+/**
+ * Markdown transformer for commented ranges (`MarkNode`). A range is
+ * written as HTML comment markers around its text, so every other markdown
+ * renderer shows the text and hides the markers. A range spanning several
+ * blocks is one marker pair per block, all carrying the same id; overlapping
+ * comments share a pair with the ids comma-separated.
+ */
+declare const COMMENT: TextMatchTransformer;
+/** Every `MarkNode` of the document, in document order */
+declare function $getMarkNodes(): MarkNode[];
+/** Every distinct comment id present in the document, in document order */
+declare function $getCommentIds(): string[];
+/** Removes `id` from every mark; marks left without ids are unwrapped */
+declare function $removeComment(id: string): boolean;
+/**
+ * Offset of `target` in the document's plain text, counted the way
+ * `$getRoot().getTextContent()` joins nodes (two newlines between blocks).
+ */
+declare function $plainTextOffset(target: LexicalNode): number;
+
+export { $getCommentIds as $, COMMENT as C, $getMarkNodes as a, $plainTextOffset as b, $removeComment as c, formatCommentMarker as f, parseCommentIds as p };

package/dist/comments.d.ts

@@ -0,0 +1,68 @@
+export { $createMarkNode, $getMarkIDs, $isMarkNode, $unwrapMarkNode, $wrapSelectionInMarkNode, MarkNode } from '@lexical/mark';
+import { ReactNode, ReactElement } from 'react';
+import { LexicalCommand } from 'lexical';
+export { $ as $getCommentIds, a as $getMarkNodes, b as $plainTextOffset, c as $removeComment, C as COMMENT, f as formatCommentMarker, p as parseCommentIds } from './comment-markers-BrrrAdSL.js';
+import '@lexical/markdown';
+
+type CommentRange = Readonly<{
+    start: number;
+    end: number;
+}>;
+type Comment = Readonly<{
+    id: string;
+    /** Offsets of the quote in the document's plain text; informational */
+    range?: CommentRange;
+    /** The text that was selected when the comment was added */
+    quote: string;
+    resolved?: boolean;
+}>;
+type CommentsLabels = Readonly<{
+    add: string;
+    /** `aria-label` of the bubble listing the comments at the caret */
+    comments: string;
+    resolve: string;
+    reopen: string;
+    remove: string;
+    resolved: string;
+    /** Shown for a marker whose id is not in `comments` */
+    unknown: (id: string) => string;
+}>;
+declare const DEFAULT_COMMENTS_LABELS: CommentsLabels;
+/** Lexical theme classes for the marks; optional, the plugin adds `zui-comment` itself */
+declare const COMMENTS_THEME: {
+    readonly mark: "zui-comment";
+    readonly markOverlap: "zui-comment-overlap";
+};
+/** Wraps the current range selection in a new comment; `true` when one was added */
+declare const ADD_COMMENT_COMMAND: LexicalCommand<void>;
+type CommentActions = Readonly<{
+    resolve: () => void;
+    remove: () => void;
+}>;
+type CommentsPluginProps = Readonly<{
+    /** The comments the host knows; marks with other ids are listed as unknown */
+    comments: readonly Comment[];
+    /** A comment was created from the selection; its markers are already in the document */
+    onAdd?: (comment: Comment) => void;
+    /** Resolve (`true`) or reopen (`false`) was pressed */
+    onResolve?: (id: string, resolved: boolean) => void;
+    /** Delete was pressed; the markers are already removed from the document */
+    onDelete?: (id: string) => void;
+    /** Id generator for new comments (default: `crypto.randomUUID`, or a random string) */
+    createId?: () => string;
+    labels?: Partial<CommentsLabels>;
+    /** Body of one entry in the bubble; the buttons stay unless the renderer returns its own */
+    renderComment?: (comment: Comment, actions: CommentActions) => ReactNode;
+}>;
+/**
+ * Range comments on top of `@lexical/mark`. A floating "Add comment"
+ * button (or Mod+Shift+M) wraps the selection in a `MarkNode` with a fresh
+ * id and reports `{ id, quote, range }` through `onAdd`; the caret inside a
+ * commented range opens a bubble with resolve / reopen and delete. The
+ * document keeps the ranges (as `<!-- zui:comment id -->` markers in
+ * markdown); the host keeps everything else about a comment. Requires
+ * `MarkNode` in `nodes` and `COMMENT` in `transformers`.
+ */
+declare function CommentsPlugin({ comments, onAdd, onResolve, onDelete, createId, labels: labelsProp, renderComment, }: CommentsPluginProps): ReactElement | null;
+
+export { ADD_COMMENT_COMMAND, COMMENTS_THEME, type Comment, type CommentActions, type CommentRange, type CommentsLabels, CommentsPlugin, type CommentsPluginProps, DEFAULT_COMMENTS_LABELS };

package/dist/comments.js

@@ -0,0 +1,2 @@
+'use client';
+"use client";import{a,b as s,c as C,d as p}from"./chunk-C7VEINKX.js";import{a as e,b as o,c as m,d as t,e as r,f as n,g as M}from"./chunk-A7MCBSAZ.js";import"./chunk-SDICQI2B.js";import{MarkNode as i,$createMarkNode as l,$isMarkNode as $,$unwrapMarkNode as f,$wrapSelectionInMarkNode as g,$getMarkIDs as k}from"@lexical/mark";export{l as $createMarkNode,r as $getCommentIds,k as $getMarkIDs,t as $getMarkNodes,$ as $isMarkNode,M as $plainTextOffset,n as $removeComment,f as $unwrapMarkNode,g as $wrapSelectionInMarkNode,C as ADD_COMMENT_COMMAND,m as COMMENT,s as COMMENTS_THEME,p as CommentsPlugin,a as DEFAULT_COMMENTS_LABELS,i as MarkNode,e as formatCommentMarker,o as parseCommentIds};

package/dist/drawing-data-EWzEQ1_i.d.ts

@@ -0,0 +1,111 @@
+import { a as BlockWidth } from './presets-BtNPH0pa.js';
+
+/** Card-like shapes: fillable, bindable, carrying the three text slots */
+type NodeShapeType = 'rect' | 'ellipse' | 'diamond' | 'note' | 'cylinder' | 'cloud' | 'queue' | 'actor';
+type ConnectorType = 'arrow' | 'line';
+type DrawingShapeType = NodeShapeType | ConnectorType | 'text';
+declare const NODE_SHAPE_TYPES: readonly NodeShapeType[];
+declare const CONNECTOR_TYPES: readonly ConnectorType[];
+declare const SHAPE_TYPES: readonly DrawingShapeType[];
+declare function isNodeShapeType(type: string): type is NodeShapeType;
+type Point = Readonly<{
+    x: number;
+    y: number;
+}>;
+type BindingSide = 'top' | 'right' | 'bottom' | 'left';
+/**
+ * Where a connector endpoint attaches to a box.
+ *
+ * `fixedPoint` is a ratio inside the box's bounding box (`[0,0]` top-left,
+ * `[1,1]` bottom-right). Omitted = the box center, which makes the endpoint
+ * auto-aim at the other end. `mode: 'inside'` pins the endpoint exactly on
+ * the fixed point; the default (`'orbit'`) projects it onto the outline with
+ * a small gap.
+ */
+type Binding = Readonly<{
+    id: string;
+    fixedPoint?: readonly [number, number];
+    mode?: 'orbit' | 'inside';
+}>;
+type DrawingShape = Readonly<{
+    id: string;
+    type: DrawingShapeType;
+    /** Top-left corner (boxes/text) or start point (connectors) */
+    x: number;
+    y: number;
+    /** Size (boxes/text) or delta to the end point (connectors) */
+    width: number;
+    height: number;
+    stroke: string;
+    fill: string;
+    strokeWidth: number;
+    /** Standalone text, main (center) content of a box, or connector label */
+    text?: string;
+    /** Small heading rendered at the top of a box */
+    label?: string;
+    /** Small line rendered at the bottom of a box */
+    footer?: string;
+    /** Connector: box the start point is attached to */
+    startBinding?: Binding;
+    /** Connector: box the end point is attached to */
+    endBinding?: Binding;
+    /** Arrow: arrowheads on both ends */
+    bidirectional?: boolean;
+    /** Connector routing: right-angled auto-routed path instead of a straight line */
+    routing?: 'elbow';
+    /**
+     * 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.
+     */
+    elbow?: number;
+    /**
+     * Connector: intermediate path points between start and end (absolute
+     * canvas coordinates). Takes precedence over `routing`.
+     */
+    waypoints?: readonly Point[];
+}>;
+type DrawingData = Readonly<{
+    version: 3;
+    /**
+     * Logical canvas width. When set the drawing is scaled to fit narrower
+     * layouts (SVG viewBox); when omitted the canvas is fluid and shapes are
+     * in CSS pixels.
+     */
+    canvasWidth?: number;
+    canvasHeight: number;
+    /**
+     * Block width: `full` (default) spans the editor; `text` aligns with the
+     * text column; `content` fits the shapes' horizontal extent. The editor
+     * omits `full` unless it was written explicitly (an insertion default or
+     * the source payload); unknown values are dropped.
+     */
+    width?: BlockWidth;
+    /** Accessible name of the drawing (SVG `aria-label`) */
+    title?: string;
+    /** Longer accessible description of the drawing */
+    description?: string;
+    shapes: readonly DrawingShape[];
+}>;
+declare const EMPTY_DRAWING: DrawingData;
+declare const STROKE_COLORS: readonly ["#1e1e1e", "#e03131", "#2f9e44", "#1971c2", "#f08c00", "#7048e8"];
+declare const FILL_COLORS: readonly ["transparent", "#ffc9c9", "#b2f2bb", "#a5d8ff", "#ffec99", "#d0bfff"];
+/** Edge midpoints, used by the ```diagram skeleton's `side` option */
+declare const SIDE_FIXED_POINTS: Record<BindingSide, readonly [number, number]>;
+declare function serializeDrawingData(data: DrawingData): string;
+/**
+ * Parse a ```drawing payload. Version 3 is the format the editor writes;
+ * version 2 (shape sizes as `w`/`h`) is migrated on read so persisted
+ * drawings keep loading (the ```diagram skeleton is a separate block type,
+ * see skeleton.ts). Shapes that fail validation are dropped and a malformed
+ * document yields an empty canvas. Never throws.
+ */
+declare function deserializeDrawingData(json: string): DrawingData;
+/**
+ * Normalize a parsed payload. Version 2 payloads are migrated to version 3
+ * (`w`/`h` → `width`/`height`). Payloads over `MAX_SHAPES` are truncated;
+ * `onWarn` hears about it (default: one `console.warn` per session, since
+ * the node re-parses on every read).
+ */
+declare function normalizeDrawingData(parsed: unknown, onWarn?: (message: string) => void): DrawingData;
+
+export { type Binding as B, CONNECTOR_TYPES as C, type DrawingData as D, EMPTY_DRAWING as E, FILL_COLORS as F, NODE_SHAPE_TYPES as N, type Point as P, SHAPE_TYPES as S, type BindingSide as a, type ConnectorType as b, type DrawingShape as c, type DrawingShapeType as d, type NodeShapeType as e, SIDE_FIXED_POINTS as f, STROKE_COLORS as g, deserializeDrawingData as h, isNodeShapeType as i, normalizeDrawingData as n, serializeDrawingData as s };

package/dist/drawing-preset-Ag7a7F9h.d.ts

@@ -0,0 +1,69 @@
+import * as lexical from 'lexical';
+import { DecoratorNode, NodeKey, Spread, SerializedLexicalNode, EditorConfig, DOMExportOutput, DOMConversionMap, LexicalEditor, LexicalNode } from 'lexical';
+import { MultilineElementTransformer, Transformer } from '@lexical/markdown';
+import { ReactElement } from 'react';
+import { a as BlockWidth, E as EditorPreset } from './presets-BtNPH0pa.js';
+import { D as DrawingData } from './drawing-data-EWzEQ1_i.js';
+
+type SerializedDrawingNode = Spread<{
+    data: string;
+}, SerializedLexicalNode>;
+/**
+ * A block-level decorator node embedding a vector diagram (cards, connectors,
+ * text) edited on a canvas.
+ *
+ * The drawing is stored as a JSON string and round-trips through markdown as
+ * a ```drawing fenced code block, so documents remain plain markdown.
+ */
+declare class DrawingNode extends DecoratorNode<ReactElement> {
+    __data: string;
+    static getType(): string;
+    static clone(node: DrawingNode): DrawingNode;
+    constructor(data: string, key?: NodeKey);
+    static importJSON(serializedNode: SerializedDrawingNode): DrawingNode;
+    exportJSON(): SerializedDrawingNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): false;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    /**
+     * The parsed payload. Parsing is memoized on the JSON string, so repeated
+     * reads of an unchanged node (every toolbar update, every decorate) cost
+     * one map lookup.
+     */
+    getData(): DrawingData;
+    setData(data: DrawingData): void;
+    /** Block width of the drawing (`full` when the payload leaves it implicit) */
+    getBlockWidth(): BlockWidth;
+    /** Resize the block; `full` picked by hand stays implicit in the payload */
+    setBlockWidth(width: BlockWidth): void;
+    isInline(): false;
+    decorate(_editor: LexicalEditor, _config: EditorConfig): ReactElement;
+}
+declare function $createDrawingNode(data?: string): DrawingNode;
+declare function $isDrawingNode(node: LexicalNode | null | undefined): node is DrawingNode;
+/**
+ * Markdown transformer persisting drawings as fenced ```drawing blocks with a
+ * JSON payload. Must be ordered before the built-in CODE transformer so it
+ * claims the fence first on import.
+ */
+declare const DRAWING: MultilineElementTransformer;
+/**
+ * Import-only transformer for ```diagram blocks: a compact skeleton
+ * (boxes, connectors by id, auto layout) that expands into a full drawing.
+ * Once in the editor the node is a regular drawing and exports as
+ * ```drawing, so the expansion is one-way.
+ */
+declare const DIAGRAM: MultilineElementTransformer;
+
+/** Every node class of the default entry */
+declare const DRAWING_PRESET_NODES: (lexical.KlassConstructor<typeof lexical.LexicalNode> | typeof DrawingNode)[];
+/**
+ * Full markdown import / export set of the default entry: CORE plus the
+ * drawing transformers, which sit right after FRONTMATTER so they claim
+ * their fences before CODE_BLOCK.
+ */
+declare const DRAWING_PRESET_TRANSFORMERS: Transformer[];
+declare const DRAWING_PRESET: EditorPreset;
+
+export { $createDrawingNode as $, DIAGRAM as D, type SerializedDrawingNode as S, $isDrawingNode as a, DRAWING as b, DRAWING_PRESET as c, DRAWING_PRESET_NODES as d, DRAWING_PRESET_TRANSFORMERS as e, DrawingNode as f };

package/dist/drawing.d.ts

@@ -0,0 +1,7 @@
+export { $ as $createDrawingNode, a as $isDrawingNode, D as DIAGRAM, b as DRAWING, c as DRAWING_PRESET, d as DRAWING_PRESET_NODES, e as DRAWING_PRESET_TRANSFORMERS, f as DrawingNode, S as SerializedDrawingNode } from './drawing-preset-Ag7a7F9h.js';
+export { C as COLOR_PRESETS, a as ColorName, D as DRAWING_DATA_JSON_SCHEMA, b as DRAWING_FOCUS_COMMAND, c as DRAWING_SKELETON_JSON_SCHEMA, d as DrawingPlugin, e as DrawingSkeleton, I as INSERT_DRAWING_COMMAND, M as MermaidDirection, f as MermaidOptions, N as NODE_SHAPE_DEFINITIONS, g as NodeShapeDefinition, S as SkeletonBox, h as SkeletonConnector, i as SkeletonEnd, j as SkeletonText, T as TextField, k as createBinding, l as drawingToMermaid, m as expandDrawingSkeleton, n as findNodeShapeAt, o as isDrawingSkeleton, p as parseDrawingSkeleton } from './mermaid-BwGHjwpk.js';
+export { B as Binding, a as BindingSide, C as CONNECTOR_TYPES, b as ConnectorType, D as DrawingData, c as DrawingShape, d as DrawingShapeType, E as EMPTY_DRAWING, F as FILL_COLORS, N as NODE_SHAPE_TYPES, e as NodeShapeType, P as Point, S as SHAPE_TYPES, f as SIDE_FIXED_POINTS, g as STROKE_COLORS, h as deserializeDrawingData, i as isNodeShapeType, n as normalizeDrawingData, s as serializeDrawingData } from './drawing-data-EWzEQ1_i.js';
+export { D as DrawingStyle } from './presets-BtNPH0pa.js';
+import 'lexical';
+import '@lexical/markdown';
+import 'react';

package/dist/drawing.js

@@ -0,0 +1,2 @@
+'use client';
+"use client";import{a as G}from"./chunk-32RX4GZF.js";import{A as M,B as y,C as k,a as o,b as i,c as n,d as a,e as t,f as S,g as D,h as p,i as d,j as N,k as E,l as g,m as _,n as w,o as m,p as R,q as T,r as A,s as O,t as f,u as x,v as l,w as I,x as s,y as P,z as C}from"./chunk-3TZVOXWX.js";import"./chunk-N5JWZ2VW.js";import{r as e,s as r}from"./chunk-LDVPFZCN.js";export{l as $createDrawingNode,I as $isDrawingNode,R as COLOR_PRESETS,i as CONNECTOR_TYPES,P as DIAGRAM,s as DRAWING,G as DRAWING_DATA_JSON_SCHEMA,e as DRAWING_FOCUS_COMMAND,k as DRAWING_PRESET,M as DRAWING_PRESET_NODES,y as DRAWING_PRESET_TRANSFORMERS,f as DRAWING_SKELETON_JSON_SCHEMA,x as DrawingNode,C as DrawingPlugin,t as EMPTY_DRAWING,D as FILL_COLORS,r as INSERT_DRAWING_COMMAND,g as NODE_SHAPE_DEFINITIONS,o as NODE_SHAPE_TYPES,n as SHAPE_TYPES,p as SIDE_FIXED_POINTS,S as STROKE_COLORS,w as createBinding,N as deserializeDrawingData,m as drawingToMermaid,O as expandDrawingSkeleton,_ as findNodeShapeAt,T as isDrawingSkeleton,a as isNodeShapeType,E as normalizeDrawingData,A as parseDrawingSkeleton,d as serializeDrawingData};

package/dist/image-node-kR1Zf5kz.d.ts

@@ -0,0 +1,70 @@
+import { ReactElement } from 'react';
+import { DecoratorNode, NodeKey, Spread, SerializedLexicalNode, EditorConfig, DOMExportOutput, DOMConversionMap, LexicalNode } from 'lexical';
+import { TextMatchTransformer } from '@lexical/markdown';
+
+type ImagesLabels = Readonly<{
+    /** `aria-label` of the alt-text input */
+    altText: string;
+    altPlaceholder: string;
+    /** `aria-label` of the upload placeholder */
+    uploading: string;
+    /** `aria-label` of `ImageButton` */
+    insertImage: string;
+}>;
+declare const DEFAULT_IMAGES_LABELS: ImagesLabels;
+type SerializedImageNode = Spread<{
+    src: string;
+    alt: string;
+    title?: string;
+}, SerializedLexicalNode>;
+/**
+ * An inline image: `![alt](src)` in markdown. Click selects it (Backspace
+ * removes it) and shows an alt-text input. While an upload is in flight the
+ * node is *pending*: it renders a progress placeholder and exports as
+ * nothing until `ImagesPlugin` fills in the uploaded `src`.
+ */
+declare class ImageNode extends DecoratorNode<ReactElement> {
+    __src: string;
+    __alt: string;
+    __title: string | undefined;
+    __pending: boolean;
+    static getType(): string;
+    static clone(node: ImageNode): ImageNode;
+    constructor(src: string, alt?: string, title?: string, pending?: boolean, key?: NodeKey);
+    static importJSON(json: SerializedImageNode): ImageNode;
+    exportJSON(): SerializedImageNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): false;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    isInline(): true;
+    isKeyboardSelectable(): boolean;
+    getSrc(): string;
+    getAlt(): string;
+    getTitle(): string | undefined;
+    isPending(): boolean;
+    setSrc(src: string): this;
+    setAlt(alt: string): this;
+    setPending(pending: boolean): this;
+    /** Plain-text value: the alt text (empty while pending) */
+    getTextContent(): string;
+    decorate(): ReactElement;
+}
+declare function $createImageNode({ src, alt, title, pending }: {
+    src: string;
+    alt?: string;
+    title?: string;
+    pending?: boolean;
+}): ImageNode;
+declare function $isImageNode(node: LexicalNode | null | undefined): node is ImageNode;
+/** The selected image, when the selection is exactly one image node */
+declare function $getSelectedImage(): ImageNode | null;
+/**
+ * Markdown transformer for images: `![alt](src)` and `![alt](src "title")`.
+ * A pending upload exports as an empty string. Sources with script-capable
+ * schemes are left as text. Put it before the built-ins so it claims the
+ * syntax ahead of `LINK`.
+ */
+declare const IMAGE: TextMatchTransformer;
+
+export { $createImageNode as $, DEFAULT_IMAGES_LABELS as D, type ImagesLabels as I, type SerializedImageNode as S, $getSelectedImage as a, $isImageNode as b, IMAGE as c, ImageNode as d };

package/dist/images.d.ts

@@ -0,0 +1,66 @@
+import { I as ImagesLabels } from './image-node-kR1Zf5kz.js';
+export { $ as $createImageNode, a as $getSelectedImage, b as $isImageNode, D as DEFAULT_IMAGES_LABELS, c as IMAGE, d as ImageNode, S as SerializedImageNode } from './image-node-kR1Zf5kz.js';
+import { ReactElement } from 'react';
+import { LexicalCommand } from 'lexical';
+import '@lexical/markdown';
+
+type UploadedImage = Readonly<{
+    src: string;
+    alt?: string;
+}>;
+type ImageError = Readonly<{
+    type: 'too-large';
+    file: File;
+    maxSize: number;
+}> | Readonly<{
+    type: 'unsupported';
+    file: File;
+}> | Readonly<{
+    type: 'upload';
+    file: File;
+    error: unknown;
+}> | Readonly<{
+    type: 'unsafe-src';
+    src: string;
+}>;
+type InsertImagePayload = Readonly<{
+    src: string;
+    alt?: string;
+    title?: string;
+}>;
+/** Inserts an image at the selection; the src must pass `isSafeUrl` */
+declare const INSERT_IMAGE_COMMAND: LexicalCommand<InsertImagePayload>;
+/** Uploads the files (as a paste or drop would) and inserts the results */
+declare const UPLOAD_IMAGES_COMMAND: LexicalCommand<readonly File[]>;
+type ImagesPluginProps = Readonly<{
+    /**
+     * Stores a pasted or dropped file and returns where it lives. A pending
+     * placeholder stands in the document until the promise settles; a
+     * rejection removes it and reports `{ type: 'upload' }`.
+     */
+    upload: (file: File) => Promise<UploadedImage>;
+    /** Largest file accepted, in bytes; bigger ones are reported as `too-large` */
+    maxSize?: number;
+    /** MIME types accepted (default: any `image/*`) */
+    accept?: readonly string[];
+    onError?: (error: ImageError) => void;
+    labels?: Partial<ImagesLabels>;
+}>;
+/**
+ * Pasted, dropped and programmatic images. Files arriving through
+ * `DRAG_DROP_PASTE` (what `RichTextPlugin` dispatches for a paste or drop
+ * of files) are checked against `accept` and `maxSize`, shown as a
+ * pending placeholder at the caret and replaced by the uploaded image.
+ * Requires `ImageNode` in `nodes` and `IMAGE` in `transformers`.
+ */
+declare function ImagesPlugin({ upload, maxSize, accept, onError, labels: labelsProp }: ImagesPluginProps): null;
+/**
+ * Toolbar button opening a file picker; the chosen files go through
+ * `UPLOAD_IMAGES_COMMAND`, so `ImagesPlugin` must be mounted.
+ */
+declare function ImageButton({ accept, labels: labelsProp }: Readonly<{
+    accept?: string;
+    labels?: Partial<ImagesLabels>;
+}>): ReactElement;
+
+export { INSERT_IMAGE_COMMAND, ImageButton, type ImageError, ImagesLabels, ImagesPlugin, type ImagesPluginProps, type InsertImagePayload, UPLOAD_IMAGES_COMMAND, type UploadedImage };

package/dist/images.js

@@ -0,0 +1,2 @@
+'use client';
+"use client";import{a as r,b as t,c as d,d as s}from"./chunk-QKHMJQO3.js";import{a as e,c as a,d as g,e as o,f as m,g as I}from"./chunk-7Z3CW6Q3.js";import"./chunk-AGTPMKLK.js";import"./chunk-LDVPFZCN.js";import"./chunk-XRJNLGI4.js";import"./chunk-YFFSTMIR.js";export{g as $createImageNode,m as $getSelectedImage,o as $isImageNode,e as DEFAULT_IMAGES_LABELS,I as IMAGE,r as INSERT_IMAGE_COMMAND,s as ImageButton,a as ImageNode,d as ImagesPlugin,t as UPLOAD_IMAGES_COMMAND};