@mocanvas/mocanvas 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1969 @@
+import * as _mocanvas_editor from '@mocanvas/editor';
+import { BaseShape, GeoShapeKind, DefaultColorStyle, DefaultFillStyle, DefaultDashStyle, DefaultSizeStyle, DefaultFontStyle, DefaultHorizontalAlignStyle, DefaultVerticalAlignStyle, BaseBoxShapeUtil, Geometry2d, StyleWords, ShapeUtil, ResizeInfo, VecLike, ShapeHandle, Vec, Editor, UnknownShape, AssetId, BookmarkAsset, EnumStyleProp, ShapeUtilConstructor, BaseBinding, BindingUtil, BindingOnShapeChangeOptions, BindingOnShapeDeleteOptions, BindingOnShapeIsolateOptions, BindingUtilConstructor, StateNode, StateNodeConstructor, EditorStore, CanvasProps, Box, ShapeId, ShapeSvgContext, ShapeSvgResult, ExternalContent, ImageAsset } from '@mocanvas/editor';
+export * from '@mocanvas/editor';
+import * as react from 'react';
+import { ReactNode, CSSProperties, ReactElement, RefObject } from 'react';
+import * as _mocanvas_state from '@mocanvas/state';
+import { ParseTldrFileResult } from '@mocanvas/store';
+
+interface GeoShapeProps {
+    geo: GeoShapeKind;
+    w: number;
+    h: number;
+    color: DefaultColorStyle;
+    labelColor: DefaultColorStyle;
+    fill: DefaultFillStyle;
+    dash: DefaultDashStyle;
+    size: DefaultSizeStyle;
+    font: DefaultFontStyle;
+    align: DefaultHorizontalAlignStyle;
+    verticalAlign: DefaultVerticalAlignStyle;
+    growY: number;
+    url: string;
+    text: string;
+    scale: number;
+}
+type GeoShape = BaseShape<"geo", GeoShapeProps>;
+declare const GEO_LABEL_PADDING = 16;
+declare function horizontalAlignToFlex(align: DefaultHorizontalAlignStyle): CSSProperties["justifyContent"];
+declare function horizontalAlignToTextAlign(align: DefaultHorizontalAlignStyle): CSSProperties["textAlign"];
+declare function verticalAlignToFlex(align: DefaultVerticalAlignStyle): CSSProperties["alignItems"];
+/**
+ * `shape.props` with every declared prop present and of the declared type.
+ * Geometry and rendering read through this so a record that arrived without a
+ * prop (or with a value from another editor's vocabulary) still draws.
+ */
+declare function readGeoProps(shape: {
+    props?: unknown;
+}): GeoShapeProps;
+/** Measured size of a geo label (padding included), wrapped at the shape width. */
+declare function measureGeoLabel(props: Pick<GeoShapeProps, "text" | "font" | "size" | "scale" | "w">): TextMeasurement;
+/** `growY` a geo shape needs so its label fits inside `h`. Empty labels never grow the shape. */
+declare function getGeoGrowY(props: Pick<GeoShapeProps, "text" | "font" | "size" | "scale" | "w" | "h">): number;
+declare class GeoShapeUtil extends BaseBoxShapeUtil<GeoShape> {
+    static type: "geo";
+    static props: {
+        geo: _mocanvas_editor.EnumStyleProp<"rectangle" | "ellipse" | "triangle" | "diamond" | "pentagon" | "hexagon" | "octagon" | "star" | "rhombus" | "rhombus-2" | "oval" | "trapezoid" | "arrow-right" | "arrow-left" | "arrow-up" | "arrow-down" | "x-box" | "check-box" | "cloud" | "heart">;
+        color: _mocanvas_editor.EnumStyleProp<"black" | "grey" | "light-violet" | "violet" | "blue" | "light-blue" | "yellow" | "orange" | "green" | "light-green" | "light-red" | "red" | "white">;
+        labelColor: _mocanvas_editor.EnumStyleProp<"black" | "grey" | "light-violet" | "violet" | "blue" | "light-blue" | "yellow" | "orange" | "green" | "light-green" | "light-red" | "red" | "white">;
+        fill: _mocanvas_editor.EnumStyleProp<"fill" | "none" | "semi" | "solid" | "pattern">;
+        dash: _mocanvas_editor.EnumStyleProp<"solid" | "draw" | "dashed" | "dotted">;
+        size: _mocanvas_editor.EnumStyleProp<"s" | "m" | "l" | "xl">;
+        font: _mocanvas_editor.EnumStyleProp<"draw" | "sans" | "serif" | "mono">;
+        align: _mocanvas_editor.EnumStyleProp<"start" | "middle" | "end" | "start-legacy" | "end-legacy" | "middle-legacy">;
+        verticalAlign: _mocanvas_editor.EnumStyleProp<"start" | "middle" | "end">;
+    };
+    getDefaultProps(): GeoShapeProps;
+    getGeometry(shape: GeoShape): Geometry2d;
+    /** Where the text label sits inside the body, in shape-local space. */
+    private getLabelRect;
+    getRenderStyle(shape: GeoShape): StyleWords;
+    component(shape: GeoShape): ReactNode;
+    indicator(shape: GeoShape): ReactNode;
+    /** The GPU keeps drawing the body while editing; only the label lives in the DOM. */
+    needsOverlay(_shape: GeoShape): boolean;
+    hasOverlayLabel(shape: GeoShape): boolean;
+    canEdit(_shape: GeoShape): boolean;
+    getText(shape: GeoShape): string;
+    onBeforeCreate(next: GeoShape): GeoShape | void;
+    onBeforeUpdate(prev: GeoShape, next: GeoShape): GeoShape | void;
+    onEditEnd(shape: GeoShape): void;
+}
+
+interface DrawPoint {
+    x: number;
+    y: number;
+    z?: number;
+}
+interface DrawSegment {
+    type: "free" | "straight";
+    points: DrawPoint[];
+}
+interface DrawShapeProps {
+    segments: DrawSegment[];
+    color: DefaultColorStyle;
+    fill: DefaultFillStyle;
+    dash: DefaultDashStyle;
+    size: DefaultSizeStyle;
+    isComplete: boolean;
+    isClosed: boolean;
+    isPen: boolean;
+    scale: number;
+}
+type DrawShape = BaseShape<"draw", DrawShapeProps>;
+/**
+ * The shape's segments in a usable form. A segment that carries no decoded
+ * `points` array — an encoding the load path could not read, say — reads as an
+ * empty run and contributes nothing, rather than throwing.
+ */
+declare function readDrawSegments(shape: {
+    props?: unknown;
+}): DrawSegment[];
+/** Flatten a draw shape's segments to one outline, smoothing freehand runs. */
+declare function getDrawOutlinePoints(shape: DrawShape): VecLike[];
+declare class DrawShapeUtil extends ShapeUtil<DrawShape> {
+    static type: "draw";
+    static props: {
+        color: _mocanvas_editor.EnumStyleProp<"black" | "grey" | "light-violet" | "violet" | "blue" | "light-blue" | "yellow" | "orange" | "green" | "light-green" | "light-red" | "red" | "white">;
+        fill: _mocanvas_editor.EnumStyleProp<"fill" | "none" | "semi" | "solid" | "pattern">;
+        dash: _mocanvas_editor.EnumStyleProp<"solid" | "draw" | "dashed" | "dotted">;
+        size: _mocanvas_editor.EnumStyleProp<"s" | "m" | "l" | "xl">;
+    };
+    getDefaultProps(): DrawShapeProps;
+    getGeometry(shape: DrawShape): Geometry2d;
+    getRenderStyle(shape: DrawShape): StyleWords;
+    component(_shape: DrawShape): ReactNode;
+    indicator(shape: DrawShape): ReactNode;
+    canResize(_shape: DrawShape): boolean;
+    hideResizeHandles(_shape: DrawShape): boolean;
+    onResize(shape: DrawShape, info: ResizeInfo<DrawShape>): Partial<DrawShape>;
+}
+
+interface LinePoint {
+    id: string;
+    index: string;
+    x: number;
+    y: number;
+}
+interface LineShapeProps {
+    color: DefaultColorStyle;
+    dash: DefaultDashStyle;
+    size: DefaultSizeStyle;
+    spline: "line" | "cubic";
+    points: Record<string, LinePoint>;
+    scale: number;
+}
+type LineShape = BaseShape<"line", LineShapeProps>;
+/** The line's points in drawing order, skipping any entry that is not a point. */
+declare function getLinePoints(shape: {
+    props?: unknown;
+}): LinePoint[];
+declare class LineShapeUtil extends ShapeUtil<LineShape> {
+    static type: "line";
+    static props: {
+        color: _mocanvas_editor.EnumStyleProp<"black" | "grey" | "light-violet" | "violet" | "blue" | "light-blue" | "yellow" | "orange" | "green" | "light-green" | "light-red" | "red" | "white">;
+        dash: _mocanvas_editor.EnumStyleProp<"solid" | "draw" | "dashed" | "dotted">;
+        size: _mocanvas_editor.EnumStyleProp<"s" | "m" | "l" | "xl">;
+    };
+    getDefaultProps(): LineShapeProps;
+    getGeometry(shape: LineShape): Geometry2d;
+    getRenderStyle(shape: LineShape): StyleWords;
+    component(_shape: LineShape): ReactNode;
+    indicator(shape: LineShape): ReactNode;
+    getHandles(shape: LineShape): ShapeHandle[];
+    onHandleDrag(shape: LineShape, info: {
+        handle: ShapeHandle;
+    }): Partial<LineShape>;
+}
+
+/**
+ * Arrow body and arrowhead math.
+ *
+ * A body is a straight run, an arc, or — for an elbow arrow — the polyline
+ * routed by `elbow-helpers`. Everything below works on all three, so callers
+ * ask for a point, a tangent or a length without caring which one they hold.
+ *
+ * Bend convention: `bend` is the signed perpendicular offset of the arc's
+ * midpoint from the chord midpoint. The perpendicular is `Per(Uni(end-start))`
+ * = (-dy, dx), so for a left-to-right arrow a positive bend bows the arc toward
+ * +y (down in screen space).
+ */
+
+type ArrowheadKind = "none" | "arrow" | "triangle" | "square" | "dot" | "diamond" | "inverted" | "bar" | "pipe";
+interface StraightBody {
+    kind: "straight";
+    start: Vec;
+    end: Vec;
+}
+interface ArcBody {
+    kind: "arc";
+    center: Vec;
+    radius: number;
+    startAngle: number;
+    /** Signed sweep in radians. */
+    sweep: number;
+}
+/**
+ * A body made of straight runs: the elbow arrow's axis-aligned route with its
+ * corners already rounded. Built by `getElbowBody` in `elbow-helpers`; every
+ * body operation below treats it as a polyline parameterized by arc length.
+ */
+interface ElbowBody {
+    kind: "elbow";
+    points: Vec[];
+}
+type ArrowBody = StraightBody | ArcBody | ElbowBody;
+/** Describe the body running from `start` to `end`, bowed by `bend`. */
+declare function getArrowBody(start: VecLike, end: VecLike, bend: number): ArrowBody;
+declare function getBodyLength(body: ArrowBody): number;
+/** Point at parameter `t` in [0, 1] along the body. */
+declare function getPointOnBody(body: ArrowBody, t: number): Vec;
+/**
+ * Unit direction of travel at parameter `t`. On an elbow that is the direction
+ * of the leg `t` falls on, so `t = 1` gives the direction of the final leg —
+ * which is where the end arrowhead points.
+ */
+declare function getTangentOnBody(body: ArrowBody, t: number): Vec;
+/** Trim `startBy` / `endBy` page units from either end of the body. */
+declare function shortenBody(body: ArrowBody, startBy: number, endBy: number): ArrowBody;
+/** Geometry for the body: a polyline (straight or elbow) or a cubic approximation of the arc. */
+declare function bodyToGeometry(body: ArrowBody): Geometry2d;
+/** Arrowhead length for a stroke width, capped so two heads never overlap. */
+declare function getArrowheadLength(strokeWidth: number, bodyLength: number): number;
+/** How far the body must retreat from the tip so it ends at the head's base. */
+declare function getArrowheadInset(kind: ArrowheadKind, length: number): number;
+/**
+ * Arrowhead geometry with its tip at `tip`, pointing along unit `dir` (from
+ * the body outward). Closed heads are filled; open ones are polylines.
+ */
+declare function getArrowheadGeometry(kind: ArrowheadKind, tip: VecLike, dir: VecLike, length: number): Geometry2d | null;
+/** Signed bend for a dragged midpoint handle at `point`. */
+declare function getBendFromPoint(start: VecLike, end: VecLike, point: VecLike): number;
+
+interface ArrowShapeProps {
+    /**
+     * How the body is routed: `"arc"` bows from start to end by `bend`,
+     * `"elbow"` runs in axis-aligned legs (and ignores `bend`).
+     */
+    kind: ArrowKind;
+    /** Static start terminal in arrow-local space; ignored while the terminal is bound. */
+    start: {
+        x: number;
+        y: number;
+    };
+    /** Static end terminal in arrow-local space; ignored while the terminal is bound. */
+    end: {
+        x: number;
+        y: number;
+    };
+    bend: number;
+    /** Where an elbow's middle leg sits along the routing axis, `0..1`; unused by `"arc"`. */
+    elbowMidPoint: number;
+    color: DefaultColorStyle;
+    labelColor: DefaultColorStyle;
+    fill: DefaultFillStyle;
+    dash: DefaultDashStyle;
+    size: DefaultSizeStyle;
+    arrowheadStart: ArrowheadKind;
+    arrowheadEnd: ArrowheadKind;
+    font: DefaultFontStyle;
+    text: string;
+    labelPosition: number;
+    scale: number;
+}
+type ArrowShape = BaseShape<"arrow", ArrowShapeProps>;
+declare const ARROW_LABEL_PADDING = 8;
+/** Routing kinds an arrow can have. */
+declare const ARROW_KINDS: readonly ["arc", "elbow"];
+type ArrowKind = (typeof ARROW_KINDS)[number];
+/**
+ * The shape with every declared prop present and of the declared type. Terminal
+ * resolution and binding code read the arrow as a whole, so the normalized copy
+ * is a whole shape rather than a loose props bag.
+ */
+declare function readArrowShape(shape: ArrowShape): ArrowShape;
+/**
+ * `shape.props` with every declared prop present and of the declared type, so
+ * geometry and rendering survive a record that arrived without one.
+ */
+declare function readArrowProps(shape: {
+    props?: unknown;
+}): ArrowShapeProps;
+declare class ArrowShapeUtil extends ShapeUtil<ArrowShape> {
+    static type: "arrow";
+    /**
+     * `kind` is deliberately not among these. A style is shared across shape
+     * types, remembered for the next shape and applied to a whole selection at
+     * once; arc-versus-elbow is routing that belongs to the one arrow, and
+     * declaring it a style would put it in every mixed selection's shared styles
+     * (and in the style panel) with nothing else to share it with.
+     */
+    static props: {
+        color: _mocanvas_editor.EnumStyleProp<"black" | "grey" | "light-violet" | "violet" | "blue" | "light-blue" | "yellow" | "orange" | "green" | "light-green" | "light-red" | "red" | "white">;
+        labelColor: _mocanvas_editor.EnumStyleProp<"black" | "grey" | "light-violet" | "violet" | "blue" | "light-blue" | "yellow" | "orange" | "green" | "light-green" | "light-red" | "red" | "white">;
+        fill: _mocanvas_editor.EnumStyleProp<"fill" | "none" | "semi" | "solid" | "pattern">;
+        dash: _mocanvas_editor.EnumStyleProp<"solid" | "draw" | "dashed" | "dotted">;
+        size: _mocanvas_editor.EnumStyleProp<"s" | "m" | "l" | "xl">;
+        font: _mocanvas_editor.EnumStyleProp<"draw" | "sans" | "serif" | "mono">;
+    };
+    getDefaultProps(): ArrowShapeProps;
+    /**
+     * The arrow's terminals and the body running between them, in arrow-local
+     * space. `"arc"` bows by `bend`; `"elbow"` routes axis-aligned legs, leaving
+     * a bound shape along its nearest edge's normal, with corners rounded in
+     * proportion to the stroke. The elbow's route is handed back as well, for the
+     * midpoint handle.
+     */
+    private resolveBody;
+    getGeometry(shape: ArrowShape): Geometry2d;
+    getRenderStyle(shape: ArrowShape): StyleWords;
+    component(shape: ArrowShape): ReactNode;
+    indicator(shape: ArrowShape): ReactNode;
+    /** The GPU keeps drawing the arrow while its label is edited. */
+    needsOverlay(_shape: ArrowShape): boolean;
+    hasOverlayLabel(shape: ArrowShape): boolean;
+    canEdit(_shape: ArrowShape): boolean;
+    /** Nothing binds to an arrow (no arrow-to-arrow bindings). */
+    canBind(_opts: {
+        fromShapeType: string;
+        toShapeType: string;
+        bindingType: string;
+    }): boolean;
+    /** A selected arrow shows its handles instead of a selection box. */
+    hideSelectionBoundsBg(_shape: ArrowShape): boolean;
+    hideSelectionBoundsFg(_shape: ArrowShape): boolean;
+    hideResizeHandles(_shape: ArrowShape): boolean;
+    getText(shape: ArrowShape): string;
+    onEditEnd(shape: ArrowShape): void;
+    /**
+     * Start and end handles move (and bind) the terminals. Between them sits one
+     * virtual handle: an arc's `bend` handle rides the middle of the curve, while
+     * an elbow's `midpoint` handle sits on its middle leg and slides that leg.
+     * An elbow with no middle leg (an L route, or a straight run) has neither.
+     */
+    getHandles(shape: ArrowShape): ShapeHandle[];
+    onHandleDrag(shape: ArrowShape, info: {
+        handle: ShapeHandle;
+        isPrecise: boolean;
+        initial?: ArrowShape;
+    }): Partial<ArrowShape> | void;
+    /**
+     * Move a terminal handle. When the handle lands on a bindable shape the
+     * terminal is bound to it (centered, or at the precise point under the
+     * pointer); otherwise any existing binding is dropped. The static point is
+     * always written so the arrow renders sensibly if the binding goes away.
+     * Holding Ctrl suppresses binding. Targets are found by hit-testing shape
+     * geometry directly (not `editor.getShapeAtPoint`) because the engine treats
+     * unfilled shapes as hollow, and arrows must bind into hollow shapes too.
+     */
+    private dragTerminal;
+    /**
+     * Dragging the arrow on its own detaches it: bindings to shapes that are not
+     * part of the selection are dropped and their terminals frozen in place.
+     * Bindings to shapes moving along with the arrow are kept.
+     */
+    onTranslateStart(shape: ArrowShape): void;
+}
+
+type TextTextureAlign = "start" | "middle" | "end";
+interface TextTextureSpec {
+    text: string;
+    fontFamily: string;
+    fontSize: number;
+    /** Any CSS color string. */
+    color: string;
+    align: TextTextureAlign;
+    verticalAlign: TextTextureAlign;
+    /** Unitless line-height multiplier. */
+    lineHeight: number;
+    /** The box the texture covers, in page units — the shape's local geometry bounds. */
+    width: number;
+    height: number;
+    /** Soft-wrap width in page units. Omit for no wrapping (one line per paragraph). */
+    maxWidth?: number;
+    /**
+     * Device pixels per page unit the canvas is rasterized at, i.e.
+     * `dpr × min(4, zoom)`. Callers bucket it to a power of two
+     * (`bucketTextureResolution` / `editor.getTextureResolution()`) so zooming
+     * does not re-rasterize every frame.
+     */
+    resolution: number;
+    /** Padding inside the box, in page units. */
+    padding?: number;
+}
+/** Hard cap on either canvas dimension, so a huge label cannot blow up the GPU. */
+declare const MAX_TEXT_TEXTURE_PX = 4096;
+/**
+ * Cache key for a spec. Stable for equal specs and different for every field
+ * that changes the pixels — the resolution bucket included.
+ */
+declare function getTextTextureKey(spec: TextTextureSpec): string;
+/**
+ * Break `spec.text` into the lines the label renders as: hard newlines always,
+ * plus greedy word wrapping at `maxWidth` (breaking inside a word only when a
+ * single word does not fit), mirroring `overflow-wrap: break-word`. Unlike the
+ * SVG exporter's `wrapTextLines`, widths come from the shared `TextMeasure`, so
+ * the raster matches the DOM label it replaces.
+ */
+declare function wrapTextTextureLines(spec: TextTextureSpec): string[];
+/** Effective resolution after clamping the canvas to `MAX_TEXT_TEXTURE_PX`. */
+declare function getTextTextureScale(spec: TextTextureSpec): number;
+/**
+ * Draw the label onto a canvas covering the whole `width × height` box, so the
+ * engine's uv `0..1` quad over the shape's local bounds lands pixel-for-pixel.
+ * Throws where there is no `document` (Node, SSR) — callers keep the DOM path.
+ */
+declare function renderTextToCanvas(spec: TextTextureSpec): HTMLCanvasElement;
+
+interface TextShapeProps {
+    color: DefaultColorStyle;
+    size: DefaultSizeStyle;
+    font: DefaultFontStyle;
+    textAlign: "start" | "middle" | "end";
+    w: number;
+    text: string;
+    scale: number;
+    autoSize: boolean;
+}
+type TextShape = BaseShape<"text", TextShapeProps>;
+/**
+ * `shape.props` with every declared prop present and of the declared type, so
+ * measuring and rendering survive a record that arrived without one.
+ */
+declare function readTextProps(shape: {
+    props?: unknown;
+}): TextShapeProps;
+/** Measured size of a text shape: intrinsic when `autoSize`, else wrapped at `w`. */
+declare function getTextShapeSizeFor(shape: TextShape): {
+    w: number;
+    h: number;
+    lineCount: number;
+};
+/** Height of the text block at its current width. */
+declare function getTextShapeHeight(shape: TextShape): number;
+/** The box `getGeometry` produces: what a texture for this shape must cover. */
+declare function getTextShapeBox(shape: TextShape): {
+    w: number;
+    h: number;
+};
+/** The rasterization spec for a text shape at the editor's current resolution bucket. */
+declare function getTextShapeTextureSpec(editor: Editor, shape: TextShape): TextTextureSpec;
+declare class TextShapeUtil extends ShapeUtil<TextShape> {
+    static type: "text";
+    static props: {
+        color: _mocanvas_editor.EnumStyleProp<"black" | "grey" | "light-violet" | "violet" | "blue" | "light-blue" | "yellow" | "orange" | "green" | "light-green" | "light-red" | "red" | "white">;
+        size: _mocanvas_editor.EnumStyleProp<"s" | "m" | "l" | "xl">;
+        font: _mocanvas_editor.EnumStyleProp<"draw" | "sans" | "serif" | "mono">;
+        textAlign: _mocanvas_editor.EnumStyleProp<"start" | "middle" | "end" | "start-legacy" | "end-legacy" | "middle-legacy">;
+    };
+    getDefaultProps(): TextShapeProps;
+    getGeometry(shape: TextShape): Geometry2d;
+    /**
+     * A texture of the rasterized label, so the GPU draws the text instead of the
+     * DOM. The shape being edited (and any environment without a canvas) keeps
+     * the DOM path; `fill` is the text colour so the level-of-detail quad the
+     * engine draws below a few pixels still looks right.
+     */
+    getRenderStyle(shape: TextShape): StyleWords | null;
+    /** The DOM label stands in while editing and until the texture is ready. */
+    needsOverlay(shape: TextShape): boolean;
+    private getTextureKey;
+    component(shape: TextShape): ReactNode;
+    indicator(shape: TextShape): ReactNode;
+    canEdit(_shape: TextShape): boolean;
+    isAspectRatioLocked(_shape: TextShape): boolean;
+    getText(shape: TextShape): string;
+    /** Auto-sized text keeps `w` in sync with its measured width. */
+    onBeforeCreate(next: TextShape): TextShape | void;
+    onBeforeUpdate(prev: TextShape, next: TextShape): TextShape | void;
+    private fitWidth;
+    /** A text shape left empty after editing is removed. */
+    onEditEnd(shape: TextShape): void;
+    /** Resizing a text shape changes its wrap width and turns auto-size off. */
+    onResize(shape: TextShape, info: ResizeInfo<TextShape>): Partial<TextShape>;
+}
+
+interface NoteShapeProps {
+    color: DefaultColorStyle;
+    labelColor: DefaultColorStyle;
+    size: DefaultSizeStyle;
+    font: DefaultFontStyle;
+    fontSizeAdjustment: number;
+    align: DefaultHorizontalAlignStyle;
+    verticalAlign: DefaultVerticalAlignStyle;
+    growY: number;
+    url: string;
+    text: string;
+    scale: number;
+}
+type NoteShape = BaseShape<"note", NoteShapeProps>;
+declare const NOTE_SIZE = 200;
+declare const NOTE_PADDING = 16;
+/**
+ * `shape.props` with every declared prop present and of the declared type, so
+ * geometry and rendering survive a record that arrived without one.
+ */
+declare function readNoteProps(shape: {
+    props?: unknown;
+}): NoteShapeProps;
+/**
+ * Effective font size: an explicit adjustment (auto-shrunk text) wins over the
+ * size style.
+ *
+ * `fontSizeAdjustment` is an absolute size in px, written when a label had to
+ * shrink to fit; `0` means "unset". Files exist that write a small placeholder
+ * there instead (a `1` on a note that was never shrunk), which would render the
+ * label at one pixel, so anything too small to be a font size is also read as
+ * unset and the size style takes over.
+ */
+declare function getNoteFontSize(shape: NoteShape): number;
+/** `growY` a note needs so its (centered) text fits; the note keeps its square width. */
+declare function getNoteGrowY(shape: NoteShape): number;
+declare class NoteShapeUtil extends ShapeUtil<NoteShape> {
+    static type: "note";
+    static props: {
+        color: _mocanvas_editor.EnumStyleProp<"black" | "grey" | "light-violet" | "violet" | "blue" | "light-blue" | "yellow" | "orange" | "green" | "light-green" | "light-red" | "red" | "white">;
+        labelColor: _mocanvas_editor.EnumStyleProp<"black" | "grey" | "light-violet" | "violet" | "blue" | "light-blue" | "yellow" | "orange" | "green" | "light-green" | "light-red" | "red" | "white">;
+        size: _mocanvas_editor.EnumStyleProp<"s" | "m" | "l" | "xl">;
+        font: _mocanvas_editor.EnumStyleProp<"draw" | "sans" | "serif" | "mono">;
+        align: _mocanvas_editor.EnumStyleProp<"start" | "middle" | "end" | "start-legacy" | "end-legacy" | "middle-legacy">;
+        verticalAlign: _mocanvas_editor.EnumStyleProp<"start" | "middle" | "end">;
+    };
+    getDefaultProps(): NoteShapeProps;
+    getGeometry(shape: NoteShape): Geometry2d;
+    getRenderStyle(shape: NoteShape): StyleWords;
+    component(shape: NoteShape): ReactNode;
+    indicator(shape: NoteShape): ReactNode;
+    /**
+     * The GPU draws the sticky background even while editing; the overlay adds
+     * the gradient and the shadow over it (see `component`).
+     */
+    needsOverlay(_shape: NoteShape): boolean;
+    hasOverlayLabel(_shape: NoteShape): boolean;
+    canEdit(_shape: NoteShape): boolean;
+    hideResizeHandles(_shape: NoteShape): boolean;
+    getText(shape: NoteShape): string;
+    onBeforeCreate(next: NoteShape): NoteShape | void;
+    onBeforeUpdate(prev: NoteShape, next: NoteShape): NoteShape | void;
+    onEditEnd(shape: NoteShape): void;
+}
+
+interface FrameShapeProps {
+    w: number;
+    h: number;
+    name: string;
+    color?: DefaultColorStyle;
+}
+type FrameShape = BaseShape<"frame", FrameShapeProps>;
+declare class FrameShapeUtil extends BaseBoxShapeUtil<FrameShape> {
+    static type: "frame";
+    getDefaultProps(): FrameShapeProps;
+    getGeometry(shape: FrameShape): Geometry2d;
+    getRenderStyle(_shape: FrameShape): StyleWords;
+    component(shape: FrameShape): ReactNode;
+    indicator(shape: FrameShape): ReactNode;
+    /** The GPU draws the frame body while its name is edited. */
+    needsOverlay(_shape: FrameShape): boolean;
+    hasOverlayLabel(_shape: FrameShape): boolean;
+    /** Descendants are clipped to the frame's bounds, on the GPU and in the overlay. */
+    isClipShape(_shape: FrameShape): boolean;
+    canEdit(_shape: FrameShape): boolean;
+    canReceiveNewChildrenOfType(_shape: FrameShape, _type: string): boolean;
+    canDropShapes(_shape: FrameShape, _shapes: UnknownShape[]): boolean;
+    getText(shape: FrameShape): string;
+    onEditEnd(shape: FrameShape): void;
+}
+
+/** Normalized crop window: both corners in [0, 1] of the source image. */
+interface ImageCrop {
+    topLeft: {
+        x: number;
+        y: number;
+    };
+    bottomRight: {
+        x: number;
+        y: number;
+    };
+    isCircle?: boolean;
+}
+interface ImageShapeProps {
+    w: number;
+    h: number;
+    /** The image asset holding the pixels; `null` while nothing is attached. */
+    assetId: AssetId | null;
+    /** Whether an animated image plays. */
+    playing: boolean;
+    /** A hyperlink attached to the shape (not the image source). */
+    url: string;
+    crop: ImageCrop | null;
+    flipX: boolean;
+    flipY: boolean;
+    altText: string;
+}
+type ImageShape = BaseShape<"image", ImageShapeProps>;
+declare const IMAGE_PLACEHOLDER_FILL = "#eceff3";
+declare const IMAGE_PLACEHOLDER_STROKE = "#9fa8b2";
+/**
+ * The source the shape's pixels come from: the asset's `src` (a URL or data URL),
+ * or `null` when the shape has no asset yet or the asset is still uploading.
+ * `getImageTextureKey` turns it into a GPU texture; `component` draws the same
+ * source in the DOM overlay while that texture loads (and for crops/flips).
+ */
+declare function getImageTextureSource(editor: Editor, shape: ImageShape): string | null;
+/**
+ * Texture cache key for the shape's pixels, or `null` when it must stay on the
+ * DOM overlay.
+ *
+ * The GPU path only covers the plain case. The engine maps uv `0..1` over the
+ * shape's local geometry bounds, so a crop window or a flip would need the quad
+ * to carry its own uvs; until the bridge does, cropped and flipped images (and
+ * anything without a decoded source) are drawn by `component`.
+ *
+ * Assets are treated as immutable, so the key is the asset id: replacing an
+ * asset's `src` in place keeps the cached texture.
+ */
+declare function getImageTextureKey(editor: Editor, shape: ImageShape): string | null;
+/** Whether this environment can decode an image into a texture source at all. */
+declare function canUploadImageTextures(): boolean;
+/** Decode an image `src` (URL or data URL) into something the GPU can sample. */
+declare function loadImageTextureSource(src: string): Promise<TexImageSource>;
+/** CSS for the `<img>` so the crop window fills the shape's box; `null` crop shows the whole image. */
+declare function getImageCropStyle(shape: ImageShape): CSSProperties;
+declare class ImageShapeUtil extends BaseBoxShapeUtil<ImageShape> {
+    static type: "image";
+    getDefaultProps(): ImageShapeProps;
+    getGeometry(shape: ImageShape): Geometry2d;
+    /** A white textured quad over the shape's bounds, or `null` for the DOM overlay path. */
+    getRenderStyle(shape: ImageShape): StyleWords | null;
+    /** The DOM overlay draws the image until (and unless) its texture is ready. */
+    needsOverlay(shape: ImageShape): boolean;
+    component(shape: ImageShape): ReactNode;
+    indicator(shape: ImageShape): ReactNode;
+    isAspectRatioLocked(_shape: ImageShape): boolean;
+}
+
+interface BookmarkShapeProps {
+    w: number;
+    h: number;
+    /** The `bookmark` asset holding the scraped preview; `null` when nothing was scraped. */
+    assetId: AssetId | null;
+    /** The page the card points at. Kept on the shape so a card survives a missing asset. */
+    url: string;
+}
+type BookmarkShape = BaseShape<"bookmark", BookmarkShapeProps>;
+declare const BOOKMARK_WIDTH = 300;
+declare const BOOKMARK_HEIGHT = 320;
+declare const BOOKMARK_FILL = "#ffffff";
+declare const BOOKMARK_STROKE = "#e8e9ea";
+declare const BOOKMARK_STROKE_WIDTH = 1;
+declare const BOOKMARK_RADIUS = 8;
+/** The banner strip behind the asset's preview image (and its colour when there is none). */
+declare const BOOKMARK_BANNER_HEIGHT = 160;
+declare const BOOKMARK_BANNER_FILL = "#eceff3";
+declare const BOOKMARK_PADDING = 12;
+declare const BOOKMARK_GAP = 6;
+declare const BOOKMARK_TITLE_HEIGHT = 38;
+declare const BOOKMARK_META_HEIGHT = 16;
+declare const BOOKMARK_FAVICON_SIZE = 14;
+declare const BOOKMARK_TITLE_FONT_SIZE = 14;
+declare const BOOKMARK_TEXT_FONT_SIZE = 12;
+declare const BOOKMARK_META_FONT_SIZE = 11;
+declare const BOOKMARK_TITLE_COLOR = "#1d1d1d";
+declare const BOOKMARK_TEXT_COLOR = "#666666";
+declare const BOOKMARK_META_COLOR = "#8f8f8f";
+/** Body left under the banner even on a short card, so the text never disappears. */
+declare const BOOKMARK_MIN_BODY_HEIGHT = 80;
+/** A rectangle in shape-local space. */
+interface BookmarkRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** Where each part of the card sits, in shape-local space. Shared by the overlay and the SVG export. */
+interface BookmarkLayout {
+    banner: BookmarkRect;
+    title: BookmarkRect;
+    description: BookmarkRect;
+    favicon: BookmarkRect;
+    hostname: BookmarkRect;
+}
+declare function getBookmarkLayout(w: number, h: number): BookmarkLayout;
+/**
+ * The host a bookmark points at, without a `www.` prefix — the one line of a
+ * link card that is always available, since it comes from the shape's own url
+ * rather than from a scrape. An unparseable url reads as `""`.
+ */
+declare function getBookmarkHostname(url: string): string;
+/** The shape's `bookmark` asset, or `null` when it has none (or one of another type). */
+declare function getBookmarkAsset(editor: Editor, shape: BookmarkShape): BookmarkAsset | null;
+/** Everything the card draws, with each field falling back to something renderable. */
+interface BookmarkCard {
+    title: string;
+    description: string;
+    image: string;
+    favicon: string;
+    hostname: string;
+    url: string;
+    /** Whether the card has a scraped asset behind it; `false` renders the placeholder. */
+    hasAsset: boolean;
+}
+declare function getBookmarkCard(editor: Editor, shape: BookmarkShape): BookmarkCard;
+declare class BookmarkShapeUtil extends BaseBoxShapeUtil<BookmarkShape> {
+    static type: "bookmark";
+    getDefaultProps(): BookmarkShapeProps;
+    getGeometry(shape: BookmarkShape): Geometry2d;
+    /**
+     * The card is html — a banner image over wrapped, ellipsised text — which no
+     * single textured quad can stand in for, so the shape always renders through
+     * the DOM overlay.
+     */
+    getRenderStyle(_shape: BookmarkShape): StyleWords | null;
+    component(shape: BookmarkShape): ReactNode;
+    /** The scraped card: banner, title, description, favicon and host. */
+    private renderCard;
+    /** No asset: an empty banner and the host, so the shape still reads as a link to somewhere. */
+    private renderPlaceholder;
+    indicator(shape: BookmarkShape): ReactNode;
+}
+
+interface EmbedShapeProps {
+    w: number;
+    h: number;
+    /** The page being embedded, as the document stored it (not the iframe's src). */
+    url: string;
+}
+type EmbedShape = BaseShape<"embed", EmbedShapeProps>;
+declare const EMBED_WIDTH = 720;
+declare const EMBED_HEIGHT = 500;
+declare const EMBED_PLACEHOLDER_FILL = "#f5f6f8";
+declare const EMBED_PLACEHOLDER_STROKE = "#9fa8b2";
+declare const EMBED_PLACEHOLDER_TEXT = "#5f6670";
+declare const EMBED_PLACEHOLDER_FONT_SIZE = 13;
+declare const EMBED_PLACEHOLDER_PADDING = 16;
+declare const EMBED_RADIUS = 6;
+/**
+ * The sandbox an embedded page runs in. Scripts and same-origin are what makes
+ * a player work at all; popups let a "watch on the site" button escape. Nothing
+ * else is granted — no forms, no top-level navigation, no pointer lock.
+ */
+declare const EMBED_SANDBOX = "allow-scripts allow-same-origin allow-popups";
+/**
+ * One embeddable service: the exact hosts it is recognised by, and how one of
+ * its page urls becomes an embeddable one.
+ *
+ * `hostnames` are matched exactly (case-insensitively, with a leading `www.`
+ * ignored), never as a suffix — `youtube.com.evil.test` is a different host and
+ * is not on the list. `toEmbedUrl` receives the parsed url and returns an
+ * absolute `https:` url, or `null` when this particular page of the service is
+ * not embeddable (a channel page rather than a video, say).
+ */
+interface EmbedDefinition {
+    /** Stable id for the service, e.g. `"youtube"`. */
+    type: string;
+    /** Human-readable name, shown on the placeholder card. */
+    title: string;
+    hostnames: readonly string[];
+    toEmbedUrl(url: URL): string | null;
+}
+/** A url that matched the permit list. */
+interface EmbedMatch {
+    definition: EmbedDefinition;
+    /** Absolute `https:` url for the iframe's `src`. */
+    embedUrl: string;
+}
+/** The services recognised out of the box. */
+declare const DEFAULT_EMBED_DEFINITIONS: readonly EmbedDefinition[];
+/**
+ * The permit list `getEmbedDefinition` consults. It starts as the defaults and
+ * is meant to be extended by the app:
+ *
+ * ```ts
+ * embedDefinitions.push({
+ *   type: "intranet",
+ *   title: "Intranet",
+ *   hostnames: ["wiki.example.com"],
+ *   toEmbedUrl: (url) => `https://wiki.example.com${url.pathname}?embed=1`,
+ * })
+ * ```
+ *
+ * Nothing outside the list is ever put in an iframe.
+ */
+declare const embedDefinitions: EmbedDefinition[];
+/**
+ * The permit-list entry for `url`, with the url to actually put in the iframe,
+ * or `null` when the url is not one we embed.
+ *
+ * Rejects anything that is not `http(s)` (a `javascript:` or `data:` url never
+ * reaches an iframe), and matches hosts exactly, so a lookalike host that
+ * merely *contains* a permitted one is not embedded.
+ */
+declare function getEmbedDefinition(url: string, definitions?: readonly EmbedDefinition[]): EmbedMatch | null;
+declare class EmbedShapeUtil extends BaseBoxShapeUtil<EmbedShape> {
+    static type: "embed";
+    getDefaultProps(): EmbedShapeProps;
+    getGeometry(shape: EmbedShape): Geometry2d;
+    /** An iframe is not a quad: embeds always render through the DOM overlay. */
+    getRenderStyle(_shape: EmbedShape): StyleWords | null;
+    component(shape: EmbedShape): ReactNode;
+    indicator(shape: EmbedShape): ReactNode;
+    /** There is nothing to type into an embed; the shape has no text of its own. */
+    canEdit(_shape: EmbedShape): boolean;
+}
+
+interface VideoShapeProps {
+    w: number;
+    h: number;
+    /** The `video` asset holding the file; `null` while nothing is attached. */
+    assetId: AssetId | null;
+    /** Playhead position, in seconds. */
+    time: number;
+    playing: boolean;
+    /** A hyperlink attached to the shape (not the video source). */
+    url: string;
+    altText: string;
+}
+type VideoShape = BaseShape<"video", VideoShapeProps>;
+declare const VIDEO_WIDTH = 640;
+declare const VIDEO_HEIGHT = 360;
+declare const VIDEO_PLACEHOLDER_FILL = "#eceff3";
+declare const VIDEO_PLACEHOLDER_STROKE = "#9fa8b2";
+/** The play triangle drawn on the placeholder (and in an SVG export). */
+declare const VIDEO_PLAY_COLOR = "#5f6670";
+declare const VIDEO_PLAY_SIZE = 48;
+/** Seeking to within this many seconds of the stored time is treated as already there. */
+declare const VIDEO_TIME_EPSILON = 0.1;
+/**
+ * The file the shape plays: the asset's `src`, or `null` when there is no
+ * asset yet, the asset is still uploading, or it is not a video.
+ */
+declare function getVideoSource(editor: Editor, shape: VideoShape): string | null;
+/** The play triangle's points, centred in a `w`×`h` box. */
+declare function getVideoPlayTriangle(w: number, h: number, size?: number): {
+    x: number;
+    y: number;
+}[];
+declare class VideoShapeUtil extends BaseBoxShapeUtil<VideoShape> {
+    static type: "video";
+    getDefaultProps(): VideoShapeProps;
+    getGeometry(shape: VideoShape): Geometry2d;
+    /** A moving picture is not a texture the engine owns: video renders in the DOM overlay. */
+    getRenderStyle(_shape: VideoShape): StyleWords | null;
+    component(shape: VideoShape): ReactNode;
+    indicator(shape: VideoShape): ReactNode;
+    /** Editing a video means taking its controls, not typing into it. */
+    canEdit(_shape: VideoShape): boolean;
+    isAspectRatioLocked(_shape: VideoShape): boolean;
+}
+
+/**
+ * Theme lookups shared by the default shapes. Everything resolves against the
+ * light theme for now; a theme-aware variant can be threaded through later.
+ */
+
+/** Engine RGBA for a shape's stroke. */
+declare function getStrokeRgba(color: DefaultColorStyle): number;
+/**
+ * Engine RGBA for a shape's interior. `0` means "no fill".
+ *
+ * The fill *styles* and the palette *tokens* share names but are one step
+ * apart, which is easy to get wrong: `semi` paints the paper colour with a
+ * barely-there tint, `solid` paints the hue's pale tint (the `semi` token),
+ * and only `fill` paints the hue at full strength (the `solid` token). Reading
+ * the token whose name matches the style makes every filled shape a step too
+ * saturated. The stroke always uses the full-strength colour, so a `solid`
+ * fill reads as a pale body inside a saturated outline.
+ */
+declare function getFillRgba(color: DefaultColorStyle, fill: DefaultFillStyle): number;
+/** Engine RGBA for a sticky note's background. */
+declare function getNoteFillRgba(color: DefaultColorStyle): number;
+/** CSS color string for text drawn in the DOM overlay. */
+declare function getTextCssColor(color: DefaultColorStyle): string;
+/** CSS color string for text on a sticky note. */
+declare function getNoteTextCssColor(color: DefaultColorStyle): string;
+/** Local-only font stacks; no web fonts are loaded. */
+declare function getFontFamily(font: DefaultFontStyle): string;
+/** Engine dash pattern id for a dash style (see `mocanvas-render::dash`). */
+declare function getDashId(dash: string): number;
+/** A frame's body. */
+declare const FRAME_FILL = "#ffffff";
+/**
+ * A frame's border.
+ *
+ * Measured off a reference render: a neutral grey hairline, not the blue-grey
+ * (`#9fa8b2`) this used to be. The difference reads as a colour cast along
+ * every frame edge, so it is worth being exact about.
+ */
+declare const FRAME_STROKE = "#717171";
+/** Width of that border, in page units. */
+declare const FRAME_STROKE_WIDTH = 1;
+/**
+ * The frame's name, drawn in the strip above it. A shade darker than the
+ * border so the caption carries more weight than the hairline it labels.
+ */
+declare const FRAME_NAME_COLOR = "#5f5f5f";
+declare const FRAME_NAME_FONT_SIZE = 12;
+/** Height of the strip above the frame that the name is laid out in. */
+declare const FRAME_NAME_OFFSET = 24;
+/**
+ * Gap between the bottom of that strip and the frame's top edge. The name is
+ * bottom-aligned in the strip, so this is what sets how far above the frame it
+ * sits — measured two pixels higher than the four this used to be.
+ */
+declare const FRAME_NAME_GAP = 6;
+/** Box the frame name is laid out in: the strip above the frame, minus the gap. */
+declare const FRAME_NAME_HEIGHT: number;
+/**
+ * A note body is not flat. It runs from a slightly deeper tint at the top to
+ * the palette's `note.fill` at the bottom — `#f7dc99` → `#fce19c` for the
+ * default yellow, i.e. the fill scaled by this factor channel-wise, which is
+ * the ratio measured off the reference render and holds for every hue.
+ */
+declare const NOTE_GRADIENT_TOP_SCALE = 0.9785;
+/**
+ * The soft shadow that falls below a note. Chosen so the darkest pixel just
+ * under the body composites to `#c0c4c5` over the `#f9fafb` page and fades out
+ * about twelve pixels down, matching the reference.
+ *
+ * The shadow is decoration *outside* the body: it is drawn by the DOM overlay
+ * (and by a filter in SVG export) and never enters the shape's geometry,
+ * bounds or hit-testing.
+ */
+declare const NOTE_SHADOW_COLOR = "#152223";
+declare const NOTE_SHADOW_OPACITY = 0.36;
+/**
+ * A note's shadow falls almost entirely *below* it. A wide blur with no spread
+ * haloes the note on every side, which reads as a glow rather than as paper
+ * lifted off the page; the negative spread pulls the shadow rect in so the
+ * sides stay tight while the offset keeps the soft falloff underneath.
+ */
+declare const NOTE_SHADOW_OFFSET_Y = 12;
+declare const NOTE_SHADOW_BLUR = 13;
+declare const NOTE_SHADOW_SPREAD = -9;
+/** `#rrggbb` as a CSS `rgba()` string at `alpha`. */
+declare function hexToCssRgba(hex: string, alpha: number): string;
+/** CSS colour at the bottom of a note's body gradient (the palette's note fill). */
+declare function getNoteFillCssColor(color: DefaultColorStyle): string;
+/**
+ * Top of a note's body gradient, derived from the colour at its bottom. Takes
+ * a `#rrggbb`; anything else (an `#rrggbbaa`, a named colour) is returned
+ * unchanged, so the gradient degrades to a flat body rather than to garbage.
+ */
+declare function getNoteGradientTopFrom(fill: string): string;
+/** CSS colour at the top of a note's body gradient. */
+declare function getNoteGradientTopCssColor(color: DefaultColorStyle): string;
+/** CSS `background` for a note body: the vertical gradient, top to bottom. */
+declare function getNoteBodyGradientCss(color: DefaultColorStyle): string;
+/** CSS `box-shadow` for a note body, in shape-local units at `scale`. */
+declare function getNoteShadowCss(scale?: number): string;
+/**
+ * The note shadow's geometry for an SVG export, in shape-local units.
+ * `feDropShadow` has no spread, so the exporter draws the shadow as its own
+ * rect — the body inset by the spread and offset down — behind the body, and
+ * blurs just that rect.
+ */
+declare function getNoteShadowSvgRect(w: number, h: number, scale?: number): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    stdDeviation: number;
+};
+
+/** Curve construction shared by the line, arrow and geo shapes. */
+
+interface CubicSegment {
+    p0: VecLike;
+    c1: VecLike;
+    c2: VecLike;
+    p1: VecLike;
+}
+/** A straight line expressed as a cubic (control points at 1/3 and 2/3). */
+declare function lineSegment(a: VecLike, b: VecLike): CubicSegment;
+/**
+ * Approximate a circular arc with `count` cubic béziers.
+ * `sweep` is signed: positive sweeps toward increasing angle (clockwise in
+ * screen space where +y points down).
+ */
+declare function arcToCubicSegments(center: VecLike, radius: number, startAngle: number, sweep: number, count?: number): CubicSegment[];
+/**
+ * Convert a polyline into a smooth cubic spline that passes through every
+ * point (uniform Catmull-Rom, tension 0.5, converted to bézier handles).
+ * Endpoints are clamped so the curve starts and ends exactly on the first and
+ * last points.
+ */
+declare function catmullRomToBezier(points: readonly VecLike[], closed?: boolean): CubicSegment[];
+/** Evaluate a cubic segment at `t`. */
+declare function pointOnCubic(s: CubicSegment, t: number): Vec;
+
+/**
+ * Outline math for the `geo` shape. Every polygon is inscribed in the w×h box
+ * so that its bounds are exactly the shape's bounds.
+ */
+
+/**
+ * Inner radius of the five-pointed star, as a fraction of the outer radius.
+ * Measured off a reference render (interior-IoU and outline least-squares fits
+ * of the same star both put it at 0.51 ± 0.02, calibrated against a render of
+ * known ratio); a plain half reads the same to well under a pixel at any
+ * sensible size. A smaller ratio makes the arms too thin.
+ */
+declare const STAR_INNER_RATIO = 0.5;
+/**
+ * Fraction of the box height spanned by the hexagon's two vertical sides. They
+ * are centred, so they run from `(1 - span) / 2` to `(1 + span) / 2` of the
+ * height, and the distance across them is the full box width.
+ */
+declare const HEXAGON_FLAT_SIDE_SPAN = 0.5;
+/** Affinely stretch points so their bounding box becomes exactly [0,w]×[0,h]. */
+declare function fitPointsToBox(points: readonly VecLike[], w: number, h: number): VecLike[];
+/**
+ * Polygon vertices for the polygonal geo kinds, or `null` for the curved kinds
+ * (ellipse, oval, cloud, heart). `x-box` and `check-box` return their frame;
+ * see `getGeoDecorations` for the marks inside.
+ */
+declare function getGeoPolygonPoints(kind: GeoShapeKind, w: number, h: number): VecLike[] | null;
+/** Open polylines drawn inside the outline (the X of an x-box, the tick of a check-box). */
+declare function getGeoDecorations(kind: GeoShapeKind, w: number, h: number): VecLike[][];
+/** Stadium / capsule: two semicircles joined by straight sides. */
+declare function getStadiumSegments(w: number, h: number): CubicSegment[];
+/** A ring of round bumps around an inner ellipse, fitted to the box. */
+declare function getCloudSegments(w: number, h: number): CubicSegment[];
+/** Classic two-lobed heart, six cubics, bounds exactly w×h. */
+declare function getHeartSegments(w: number, h: number): CubicSegment[];
+/** Build the outline geometry for a geo kind inside a w×h box. */
+declare function getGeoGeometry(kind: GeoShapeKind, w: number, h: number, isFilled: boolean): Geometry2d;
+
+/**
+ * One pass of a light 1-2-1 moving average over a freehand stroke. Endpoints
+ * are kept fixed so the stroke still starts and ends where the pen did.
+ * Extra properties on each point (e.g. pressure `z`) are preserved.
+ */
+declare function smoothPoints<P extends VecLike>(points: readonly P[]): P[];
+
+/** Cheap text metrics used until real measurement lands (phase 2 text layout). */
+declare const LINE_HEIGHT = 1.3;
+/** Average glyph advance as a fraction of the font size. */
+declare const AVG_CHAR_WIDTH = 0.6;
+interface TextSizeEstimate {
+    w: number;
+    h: number;
+    lines: number;
+}
+/**
+ * Estimate the box a run of text occupies at `fontSize`, wrapping each
+ * paragraph at `maxWidth` using an average character width.
+ */
+declare function estimateTextSize(text: string, fontSize: number, maxWidth?: number): TextSizeEstimate;
+
+/**
+ * Tolerant prop reads for the default shape utils.
+ *
+ * A shape can reach a util with props that do not match its declared shape:
+ * a file written by another editor, a record hand-built by an integrator, a
+ * partial update. Geometry and rendering must survive that, so the utils read
+ * through these helpers rather than trusting the declared types (and rather
+ * than sprinkling `?.` and `??` over every access).
+ *
+ * Each helper takes the shape's props object and returns a usable value of the
+ * expected kind, falling back to the util's default when the stored value is
+ * missing or of the wrong type.
+ */
+
+type Props = Record<string, unknown>;
+/** A shape's props as a bag of unknowns, tolerating a missing or non-object `props`. */
+declare function propsOf(shape: {
+    props?: unknown;
+}): Props;
+declare function readString(props: unknown, key: string, fallback: string): string;
+/** A string prop constrained to a known set; anything else falls back. */
+declare function readEnum<T extends string>(props: unknown, key: string, allowed: readonly T[], fallback: T): T;
+/** A style prop's value, validated against the style's own set of values. */
+declare function readStyle<T extends string>(props: unknown, key: string, style: EnumStyleProp<T>, fallback?: T): T;
+declare function readNumber(props: unknown, key: string, fallback: number): number;
+declare function readBoolean(props: unknown, key: string, fallback: boolean): boolean;
+/**
+ * A shape's label. Prefers `props.text`; a record that still carries a
+ * rich-text document (one that skipped the load-time normalization) is
+ * flattened here so it renders rather than throwing.
+ */
+declare function readText(props: unknown, key?: string): string;
+/** A `{ x, y }` prop, with each coordinate falling back independently. */
+declare function readPoint(props: unknown, key: string, fallback: {
+    x: number;
+    y: number;
+}): {
+    x: number;
+    y: number;
+};
+/** An array prop; a missing or non-array value reads as empty. */
+declare function readArray(props: unknown, key: string): unknown[];
+/** A record-of-objects prop (a line's points, say); anything else reads as empty. */
+declare function readRecord(props: unknown, key: string): Record<string, unknown>;
+
+/** Convert the engine's flat path encoding to an SVG `d` attribute (for indicators). */
+declare function pathWordsToSvgD(words: readonly number[]): string;
+
+type GroupShape = BaseShape<"group", Record<string, never>>;
+/** A container with no visuals of its own; its bounds are the union of its children. */
+declare class GroupShapeUtil extends ShapeUtil<GroupShape> {
+    static type: "group";
+    getDefaultProps(): GroupShape["props"];
+    getGeometry(shape: GroupShape): Geometry2d;
+    getRenderStyle(_shape: GroupShape): StyleWords;
+    canResize(): boolean;
+    hideResizeHandles(): boolean;
+    hideSelectionBoundsBg(): boolean;
+    canReceiveNewChildrenOfType(): boolean;
+    component(): null;
+    indicator(shape: GroupShape): react.JSX.Element;
+}
+
+/**
+ * Elbow arrow routing.
+ *
+ * An elbow arrow runs from its start terminal to its end terminal along
+ * axis-aligned legs instead of an arc. The route is decided by two axes — the
+ * axis the body leaves the start on and the axis it arrives at the end on:
+ *
+ * - same axis on both ends: three legs (H-V-H or V-H-V), with the middle leg
+ *   placed at `midPoint` along that axis (0 hard against the start, 1 against
+ *   the end);
+ * - different axes: two legs (an L, H-V or V-H).
+ *
+ * A free terminal uses the *dominant* axis — whichever of `|dx|` and `|dy|` is
+ * larger — so a wide, short arrow leaves horizontally and a tall, narrow one
+ * leaves vertically. A bound terminal uses the axis of the bound shape's
+ * nearest edge normal (see `getBoundElbowAxes`), so the arrow leaves the shape
+ * square-on rather than diagonally.
+ *
+ * Corners are then rounded with a quarter-turn whose radius is clamped to half
+ * of each adjacent leg, so two corners sharing a leg can never overlap.
+ */
+
+/** Which coordinate a leg varies: `"x"` for a horizontal leg, `"y"` for a vertical one. */
+type ElbowAxis = "x" | "y";
+/** Corner radius as a multiple of the stroke width. */
+declare const ELBOW_CORNER_STROKES = 2.5;
+interface ElbowRouteOptions {
+    /** Where the middle leg sits along the shared axis, clamped to `0..1`. */
+    midPoint?: number;
+    /** Axis the body must leave the start on; defaults to the dominant axis. */
+    startAxis?: ElbowAxis | undefined;
+    /** Axis the body must arrive at the end on; defaults to the dominant axis. */
+    endAxis?: ElbowAxis | undefined;
+    /** Corner radius before per-corner clamping. */
+    cornerRadius?: number;
+}
+interface ElbowRoute {
+    /** Corner points from start to end, before the corners are rounded. */
+    corners: Vec[];
+    /** The drawn polyline: `corners` with each corner replaced by a fillet. */
+    points: Vec[];
+    /** The middle leg, when the route has one; `null` for an L or a straight run. */
+    midLeg: [Vec, Vec] | null;
+    /** The axis the middle leg slides along, `null` when there is no middle leg. */
+    slideAxis: ElbowAxis | null;
+}
+/** The axis a free terminal leaves on: the one the terminals are further apart on. */
+declare function getDominantAxis(start: VecLike, end: VecLike): ElbowAxis;
+/** `corners` with every interior corner replaced by a fillet of `radius`. */
+declare function roundElbowCorners(corners: Vec[], radius: number): Vec[];
+/**
+ * Route an elbow from `start` to `end`. See the module comment for the rule.
+ */
+declare function getElbowRoute(start: VecLike, end: VecLike, options?: ElbowRouteOptions): ElbowRoute;
+/** The elbow body for an arrow: the rounded route as a polyline body. */
+declare function getElbowBody(start: VecLike, end: VecLike, options?: ElbowRouteOptions): ElbowBody;
+/**
+ * `elbowMidPoint` for a midpoint handle dragged to `point`: how far along
+ * `axis` it sits between the terminals, clamped to `0..1`.
+ */
+declare function getElbowMidPointFromPoint(start: VecLike, end: VecLike, point: VecLike, axis: ElbowAxis): number;
+
+declare const defaultShapeUtils: ShapeUtilConstructor[];
+
+type ArrowTerminal = "start" | "end";
+/**
+ * Props of an `arrow` binding. The record layout matches what `.tldr` files
+ * store for arrow bindings so documents round-trip.
+ */
+interface ArrowBindingProps {
+    /** Which end of the arrow (`fromId`) is attached to the bound shape (`toId`). */
+    terminal: ArrowTerminal;
+    /** Anchor inside the bound shape's geometry bounds, normalized to `[0, 1]`. */
+    normalizedAnchor: {
+        x: number;
+        y: number;
+    };
+    /** When true the terminal sits exactly on the anchor instead of on the shape's outline. */
+    isExact: boolean;
+    /** When true the anchor was placed deliberately (Alt or a lingering drag) rather than snapped to the center. */
+    isPrecise: boolean;
+}
+type ArrowBinding = BaseBinding<"arrow", ArrowBindingProps>;
+/**
+ * Keeps arrows attached to the shapes their terminals are bound to.
+ *
+ * - When the bound shape changes, the arrow is rewritten so its geometry is
+ *   re-derived (and its static fallback stays current).
+ * - When the bound shape goes away, or the binding is deleted with
+ *   `isolateShapes`, the terminal is frozen at its current page position.
+ */
+declare class ArrowBindingUtil extends BindingUtil<ArrowBinding> {
+    static type: "arrow";
+    getDefaultProps(): ArrowBindingProps;
+    onAfterChangeToShape({ binding }: BindingOnShapeChangeOptions<ArrowBinding>): void;
+    onAfterChangeFromShape({ binding, shapeBefore, shapeAfter }: BindingOnShapeChangeOptions<ArrowBinding>): void;
+    onBeforeDeleteToShape({ binding }: BindingOnShapeDeleteOptions<ArrowBinding>): void;
+    onBeforeIsolateFromShape({ binding }: BindingOnShapeIsolateOptions<ArrowBinding>): void;
+    onBeforeIsolateToShape({ binding }: BindingOnShapeIsolateOptions<ArrowBinding>): void;
+    /** Write the resolved terminals into the arrow so its geometry is rebuilt. */
+    private refreshArrow;
+    /**
+     * Convert the bound terminal into a static point at its current resolved
+     * position. Idempotent: calling it twice for the same binding is a no-op the
+     * second time.
+     */
+    private freezeTerminal;
+}
+
+/**
+ * Arrow terminal resolution.
+ *
+ * An arrow terminal is either static (`props.start` / `props.end`, in
+ * arrow-local space) or bound to another shape through an `arrow` binding.
+ * A bound terminal is derived from the bound shape every time it is read, so
+ * the arrow follows the shape without anyone copying coordinates around.
+ */
+
+/** Affine transform components as returned by `Editor.getShapePageTransform`. */
+interface TransformLike {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+}
+declare function applyTransform(m: TransformLike, p: VecLike): Vec;
+interface ArrowBindings {
+    start?: ArrowBinding;
+    end?: ArrowBinding;
+}
+/** The arrow's terminal bindings, keyed by terminal. */
+declare function getArrowBindings(editor: Editor, arrow: ArrowShape): ArrowBindings;
+/** Map a normalized anchor `(0..1, 0..1)` into a shape's geometry bounds (shape-local space). */
+declare function getAnchorInShapeSpace(editor: Editor, shape: UnknownShape, normalizedAnchor: VecLike): Vec;
+/**
+ * The topmost shape an arrow terminal dropped at `pagePoint` should bind to,
+ * or `undefined`. Candidates must accept arrow bindings, may not be arrows,
+ * the arrow itself, or one of the arrow's ancestors, and are hit inside their
+ * outline (or within the hit-test margin of it) regardless of fill, so an arrow
+ * can attach to a hollow rectangle by pointing into it.
+ */
+declare function getArrowBindingTargetAtPoint(editor: Editor, arrow: UnknownShape, pagePoint: VecLike): UnknownShape | undefined;
+/** Normalize a page point into a shape's geometry bounds, clamped to `[0, 1]`. */
+declare function getNormalizedAnchor(editor: Editor, shape: UnknownShape, pagePoint: VecLike): Vec;
+/**
+ * Flattened outline of a geometry as line segments, in the geometry's own
+ * space. Groups are walked recursively; label geometry is skipped so arrows
+ * end on the shape body rather than on its text box.
+ */
+declare function getOutlineSegments(geometry: Geometry2d): [Vec, Vec][];
+/**
+ * Intersection point of segments `a1-a2` and `b1-b2`, or `null` when they do
+ * not cross. Parallel and degenerate segments never intersect.
+ */
+declare function intersectSegments(a1: VecLike, a2: VecLike, b1: VecLike, b2: VecLike): Vec | null;
+interface ArrowTerminals {
+    start: Vec;
+    end: Vec;
+}
+/** Which axis an elbow arrow leaves a terminal on, when that terminal is bound. */
+interface ElbowTerminalAxes {
+    start?: "x" | "y";
+    end?: "x" | "y";
+}
+/**
+ * For each bound terminal, the axis of the normal of the bound shape's nearest
+ * edge: `"x"` on a left or right edge, `"y"` on a top or bottom one. An elbow
+ * arrow routes its first and last leg along these, so it leaves and enters a
+ * bound shape square-on instead of diagonally. A free terminal is absent from
+ * the result and the router falls back to the dominant axis.
+ *
+ * The bound shape's bounds are measured in arrow space, so a rotated shape is
+ * compared against the box it occupies from the arrow's point of view — which
+ * is the frame the route itself is built in.
+ */
+declare function getBoundElbowAxes(editor: Editor, arrow: ArrowShape, terminals: ArrowTerminals): ElbowTerminalAxes;
+/**
+ * How far a bound arrow stops short of the shape it points at, as a multiple
+ * of its stroke width. An arrowhead resting on a shape's border reads as part
+ * of that border; a small gap reads as pointing at it.
+ */
+declare const ARROW_TERMINAL_GAP_STROKES = 2.7;
+/** The gap in page units for an arrow of a given size style. */
+declare function getArrowTerminalGap(size: DefaultSizeStyle, scale?: number): number;
+/**
+ * Resolve both terminals of an arrow in arrow-local space.
+ *
+ * Unbound terminals come straight from `props`. A bound terminal starts at
+ * its anchor inside the bound shape's bounds; unless the binding is exact it
+ * is then pulled back to where the arrow body first crosses the bound shape's
+ * outline on its way from the opposite terminal. If the body never crosses
+ * the outline (e.g. the other terminal is inside the shape) the anchor is used.
+ */
+declare function getArrowTerminalsInArrowSpace(editor: Editor, arrow: ArrowShape): ArrowTerminals;
+
+/** The built-in binding utils, in the order they are registered. */
+declare const defaultBindingUtils: BindingUtilConstructor[];
+
+/** Drag to draw an arrow; dropping the end on a shape binds it to that shape. */
+declare class ArrowTool extends StateNode {
+    static id: string;
+    static initial: string;
+    static children: () => StateNodeConstructor[];
+}
+
+/** Freehand drawing. */
+declare class DrawTool extends StateNode {
+    static id: string;
+    static initial: string;
+    static children: () => StateNodeConstructor[];
+}
+
+/** Delete shapes by dragging over them. */
+declare class EraserTool extends StateNode {
+    static id: string;
+    static initial: string;
+    static children: () => StateNodeConstructor[];
+}
+
+/** Drag out a frame, or click to place a default-sized one. */
+declare class FrameTool extends StateNode {
+    static id: string;
+    static initial: string;
+    static children: () => StateNodeConstructor[];
+}
+
+/** Draw a geo shape (rectangle, ellipse, ...) by dragging. Pick the kind with `editor.setCurrentTool('geo', { geo })`. */
+declare class GeoTool extends StateNode {
+    static id: string;
+    static initial: string;
+    static children: () => StateNodeConstructor[];
+    geo: GeoShapeKind;
+    onEnter(info: Record<string, unknown>): void;
+}
+
+/** Pan the camera by dragging. */
+declare class HandTool extends StateNode {
+    static id: string;
+    static initial: string;
+    static children: () => StateNodeConstructor[];
+}
+
+/** Drag for a straight line, or click repeatedly for a multi-segment one. */
+declare class LineTool extends StateNode {
+    static id: string;
+    static initial: string;
+    static children: () => StateNodeConstructor[];
+}
+
+/** Click to place a sticky note. */
+declare class NoteTool extends StateNode {
+    static id: string;
+    static initial: string;
+    static children: () => StateNodeConstructor[];
+}
+
+/** Selection, brush select, drag-to-move, resize, rotate, and shape handle dragging. */
+declare class SelectTool extends StateNode {
+    static id: string;
+    static initial: string;
+    static children: () => StateNodeConstructor[];
+}
+
+/** Click to place a text shape and start typing. */
+declare class TextTool extends StateNode {
+    static id: string;
+    static initial: string;
+    static children: () => StateNodeConstructor[];
+}
+
+declare const defaultTools: StateNodeConstructor[];
+
+interface TextMeasureOptions {
+    fontFamily: string;
+    fontSize: number;
+    fontWeight?: string | number;
+    /** Unitless line height (multiplier of the font size). */
+    lineHeight: number;
+    /** Wrap width in CSS px, including `padding`. Omit for a single unwrapped run per paragraph. */
+    maxWidth?: number;
+    /** Padding applied on every side; included in the returned `w`/`h`. */
+    padding?: number;
+}
+interface TextMeasurement {
+    w: number;
+    h: number;
+    lineCount: number;
+}
+/** Text exactly as the static label / measuring element must render it to occupy the right box. */
+declare function toDisplayText(text: string): string;
+/**
+ * Measures runs of text with a hidden DOM element, mirroring the CSS the
+ * `<TextLabel>` component uses (pre-wrap + break-word, border-box padding).
+ * Falls back to `estimateTextSize` where no `document` exists (tests, SSR).
+ */
+declare class TextMeasure {
+    private element;
+    private readonly cache;
+    measureText(text: string, opts: TextMeasureOptions): TextMeasurement;
+    /** Number of cached measurements (for tests and debugging). */
+    get cacheSize(): number;
+    clearCache(): void;
+    dispose(): void;
+    private estimate;
+    private measureDom;
+    private getElement;
+}
+/** The shared measurer. */
+declare function getTextMeasure(): TextMeasure;
+
+/** Pure text layout helpers shared by the label-bearing shapes. DOM-free so they are testable in Node. */
+
+/**
+ * Extra height a box needs so its label fits: `labelHeight - boxHeight`,
+ * never negative. `growY` is stored on the shape and added to `h`.
+ */
+declare function computeGrowY(labelHeight: number, boxHeight: number): number;
+/** Trim whitespace at the end of a label (kept inside the run, e.g. indentation on later lines). */
+declare function trimTrailingWhitespace(text: string): string;
+interface LabelMeasureOptions {
+    font: DefaultFontStyle;
+    fontSize: number;
+    /** Wrap width in px including padding; omit for no soft wrapping. */
+    maxWidth?: number;
+    padding?: number;
+}
+/** Measure a shape label with the shared measurer using the default label typography. */
+declare function measureLabel(text: string, opts: LabelMeasureOptions): TextMeasurement;
+/** Minimum width of an auto-sized text shape so an empty one still shows a caret area. */
+declare const TEXT_SHAPE_MIN_WIDTH = 8;
+interface TextShapeSizeInput {
+    text: string;
+    font: DefaultFontStyle;
+    fontSize: number;
+    autoSize: boolean;
+    /** Current wrap width, used when `autoSize` is off. */
+    w: number;
+}
+/** Width and height of a text shape: measured (auto-size) or wrapped at `w`. */
+declare function getTextShapeSize(input: TextShapeSizeInput): {
+    w: number;
+    h: number;
+    lineCount: number;
+};
+
+interface TextLabelProps {
+    shape: UnknownShape;
+    text: string;
+    isEditing: boolean;
+    font: DefaultFontStyle;
+    fontSize: number;
+    /** CSS color of the text. */
+    color: string;
+    align: DefaultHorizontalAlignStyle;
+    verticalAlign: DefaultVerticalAlignStyle;
+    /** Soft-wrap at `width`. When false the label only breaks at explicit newlines. */
+    wrap: boolean;
+    /** Box the label is laid out in, in shape-local px. Omit for an intrinsically sized label. */
+    width?: number;
+    height?: number;
+    /** Padding on every side of the text, in px (default 0). */
+    padding?: number;
+    /** Shown in place of an empty label when not editing. */
+    placeholder?: string;
+    /** Single-line labels commit on Enter and never contain newlines (frame names). */
+    singleLine?: boolean;
+    /** Called with the new text; at most once per animation frame while typing. */
+    onChange(text: string): void;
+}
+declare function alignToJustify(align: DefaultHorizontalAlignStyle): CSSProperties["justifyContent"];
+declare function alignToTextAlign(align: DefaultHorizontalAlignStyle): CSSProperties["textAlign"];
+declare function verticalAlignToAlignItems(align: DefaultVerticalAlignStyle): CSSProperties["alignItems"];
+/**
+ * A shape's text label. Static text when idle; while editing, a plain-text
+ * `<textarea>` overlays an invisible copy of the text so the box keeps the
+ * exact size the static label would have.
+ */
+declare function TextLabel(props: TextLabelProps): ReactNode;
+
+/** Side of the drawing grid. */
+declare const ICON_GRID = 24;
+/** Longest side of the box a geo outline is fitted into, centred in the grid. */
+declare const GEO_BOX = 16;
+/** The box a geo icon's outline is fitted into, in grid units. */
+declare function getGeoIconBox(kind: GeoShapeKind): readonly [number, number];
+/** `d` attribute for each geo kind, fitted to its icon box. */
+declare const GEO_ICON_PATHS: Record<GeoShapeKind, string>;
+/** Every icon in the set, keyed by name. */
+declare const ICONS: {
+    "geo-rectangle": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-ellipse": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-triangle": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-diamond": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-pentagon": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-hexagon": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-octagon": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-star": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-rhombus": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-rhombus-2": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-oval": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-trapezoid": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-arrow-right": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-arrow-left": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-arrow-up": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-arrow-down": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-x-box": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-check-box": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-cloud": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "geo-heart": ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+    "fill-none": react.JSX.Element;
+    "fill-semi": react.JSX.Element;
+    "fill-solid": react.JSX.Element;
+    "fill-pattern": react.JSX.Element;
+    "dash-draw": react.JSX.Element;
+    "dash-solid": react.JSX.Element;
+    "dash-dashed": react.JSX.Element;
+    "dash-dotted": react.JSX.Element;
+    "size-s": react.JSX.Element;
+    "size-m": react.JSX.Element;
+    "size-l": react.JSX.Element;
+    "size-xl": react.JSX.Element;
+    "align-left": react.JSX.Element;
+    "align-center": react.JSX.Element;
+    "align-right": react.JSX.Element;
+    "valign-top": react.JSX.Element;
+    "valign-middle": react.JSX.Element;
+    "valign-bottom": react.JSX.Element;
+    "font-draw": react.JSX.Element;
+    "font-sans": react.JSX.Element;
+    "font-serif": react.JSX.Element;
+    "font-mono": react.JSX.Element;
+    "zoom-in": react.JSX.Element;
+    "zoom-out": react.JSX.Element;
+    "zoom-fit": react.JSX.Element;
+    undo: react.JSX.Element;
+    redo: react.JSX.Element;
+    lock: react.JSX.Element;
+    unlock: react.JSX.Element;
+    duplicate: react.JSX.Element;
+    trash: react.JSX.Element;
+    group: react.JSX.Element;
+    ungroup: react.JSX.Element;
+    "bring-forward": react.JSX.Element;
+    "send-backward": react.JSX.Element;
+    "chevron-down": react.JSX.Element;
+    "chevron-up": react.JSX.Element;
+    check: react.JSX.Element;
+    close: react.JSX.Element;
+    mixed: react.JSX.Element;
+    select: react.JSX.Element;
+    hand: react.JSX.Element;
+    draw: react.JSX.Element;
+    eraser: react.JSX.Element;
+    text: react.JSX.Element;
+    note: react.JSX.Element;
+    frame: react.JSX.Element;
+    arrow: react.JSX.Element;
+    line: react.JSX.Element;
+    image: react.JSX.Element;
+};
+type IconName = keyof typeof ICONS;
+/** All icon names, sorted — handy for tests and galleries. */
+declare const ICON_NAMES: IconName[];
+interface IconProps {
+    name: IconName;
+    /** Rendered size in px; the artwork is scaled from the 24×24 grid. */
+    size?: number;
+    className?: string;
+}
+/** Renders one icon from the set. Decorative by default: label the button instead. */
+declare function Icon({ name, size, className }: IconProps): react.JSX.Element;
+
+/** Accelerator prefix for tooltips: `⌘` on Apple platforms, `Ctrl+` elsewhere. */
+declare const MOD_KEY: string;
+interface ToolbarItem {
+    /** Unique key; also the geo kind for geo entries. */
+    id: string;
+    /** Tool id that must be registered for this entry to appear. */
+    tool: string;
+    icon: IconName;
+    label: string;
+    /** Displayed in the tooltip, next to the label. */
+    shortcut?: string;
+    /** Geo kind the entry selects, for entries driving the `geo` tool. */
+    geo?: GeoShapeKind;
+    /** Tools outside the default set: shown only when the app registers them. */
+    optional?: boolean;
+}
+/** Toolbar entries, grouped; groups are separated by a divider. */
+declare const TOOLBAR_GROUPS: readonly (readonly ToolbarItem[])[];
+/** Geo kinds that live behind the "more shapes" popover. */
+declare const PRIMARY_GEO_KINDS: readonly GeoShapeKind[];
+declare const MORE_GEO_KINDS: readonly GeoShapeKind[];
+/** Bottom toolbar: tools, grouped, plus a popover with the rest of the shapes. */
+declare const Toolbar: () => react.JSX.Element;
+/** Zoom controls and undo/redo. */
+declare const ZoomBar: () => react.JSX.Element;
+/** Compact frame-statistics chip. Toggled with ⌥D. */
+declare const DebugStats: ({ editor }: {
+    editor: Editor;
+}) => react.JSX.Element;
+declare function DefaultUi({ editor, showStats }: {
+    editor: Editor;
+    showStats?: boolean;
+}): react.JSX.Element;
+
+/**
+ * The style rows the panel renders, in order, grouped as the panel groups them.
+ *
+ * With a selection this is exactly what the selected shapes declare, so a line
+ * (colour, dash, size) never offers Font or Align; with nothing selected it is
+ * what the active drawing tool is about to create. Exported so the rule can be
+ * tested without a DOM.
+ */
+interface StylePanelSections {
+    /** The geo picker. */
+    shape: boolean;
+    /** Colour swatch grids. */
+    color: boolean;
+    labelColor: boolean;
+    /** Stroke and fill. */
+    fill: boolean;
+    dash: boolean;
+    size: boolean;
+    /** Text. */
+    font: boolean;
+    align: boolean;
+    verticalAlign: boolean;
+    /** Shape-level, not a style: only with a selection. */
+    opacity: boolean;
+}
+/** Decide which rows the style panel shows for the editor's current state. */
+declare function getStylePanelSections(editor: Editor): StylePanelSections;
+/** Whether any row at all is on. */
+declare function hasAnyStyleSection(s: StylePanelSections): boolean;
+/**
+ * Style controls for the selection (or, with nothing selected, for the next
+ * shape the active drawing tool creates). Sits in the top-right corner.
+ *
+ * Rows are grouped — shape, colour, stroke and fill, text, opacity — and every
+ * group is omitted when the selection cannot carry it.
+ */
+declare const StylePanel: () => react.JSX.Element | null;
+
+interface Placement {
+    left: number;
+    top: number;
+}
+/**
+ * Centre `box` on `anchor`, on the preferred side if it fits there and on the
+ * other side if it does not, then clamp the result inside the viewport.
+ */
+declare function placeNear(anchor: DOMRect, box: {
+    width: number;
+    height: number;
+}, prefer: "above" | "below", vw: number, vh: number): Placement;
+/**
+ * The single tooltip for the whole UI. Mount it once; it labels any element
+ * carrying `data-tooltip` (and, optionally, `data-shortcut`) by delegation, so
+ * buttons stay plain buttons.
+ */
+declare function UiTooltip(): react.JSX.Element | null;
+interface PopoverProps {
+    /** The control the popover belongs to; also the click target that keeps it open. */
+    anchorRef: RefObject<HTMLElement | null>;
+    open: boolean;
+    onClose: () => void;
+    label: string;
+    /** Columns in the popover grid. */
+    cols?: number;
+    prefer?: "above" | "below";
+    children: ReactNode;
+}
+/** A dismissable floating grid anchored to a button. */
+declare function Popover({ anchorRef, open, onClose, label, cols, prefer, children }: PopoverProps): react.JSX.Element | null;
+
+/** Whether the frame-statistics chip is visible. Toggled with ⌥D. */
+declare const debugStatsOpen: _mocanvas_state.Atom<boolean>;
+/** Default keyboard shortcuts: tool switching, undo/redo, select all, zoom, clipboard. */
+declare function useKeyboardShortcuts(editor: Editor | null): void;
+
+/** Serialize the editor's document to `.tldr` JSON text. */
+declare function serializeMocanvasFile(editor: Editor): string;
+/**
+ * The parse result plus whatever the load could not read cleanly.
+ *
+ * `warnings` is always present (empty when the file needed nothing unusual)
+ * and is worth surfacing: it names shapes whose props were repaired, segments
+ * that had to be dropped, and shape types with no registered util.
+ */
+type LoadMocanvasFileResult = ParseTldrFileResult & {
+    warnings: string[];
+};
+/**
+ * Load a `.tldr` file (text or parsed JSON) into the editor, replacing the
+ * document.
+ *
+ * Records are normalized before they reach the store, so shapes written by
+ * another generation of the format — a rich-text label, a packed freehand
+ * path, a prop this build did not exist for — arrive in the form the shape
+ * utils expect. `records` in the result are the normalized ones.
+ */
+declare function loadMocanvasFile(editor: Editor, json: unknown): LoadMocanvasFileResult;
+
+interface MocanvasProps {
+    /** Reuse a store (e.g. for persistence or collaboration). */
+    store?: EditorStore;
+    /** Extra shape utils beyond the defaults. */
+    shapeUtils?: readonly ShapeUtilConstructor[];
+    /** Extra binding utils beyond the defaults. */
+    bindingUtils?: readonly BindingUtilConstructor[];
+    /** Extra tools beyond the defaults. */
+    tools?: readonly StateNodeConstructor[];
+    initialState?: string;
+    onMount?: (editor: Editor) => void | (() => void);
+    /** Hide the default toolbar and zoom bar. */
+    hideUi?: boolean;
+    showStats?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    children?: ReactNode;
+    components?: CanvasProps["components"];
+    /** Editor config overrides. */
+    options?: ConstructorParameters<typeof Editor>[0]["options"];
+}
+/** Batteries-included canvas: default shapes, tools, shortcuts and UI. */
+declare function Mocanvas(props: MocanvasProps): react.JSX.Element;
+
+/**
+ * Export shapes to a standalone SVG document string.
+ */
+
+interface SvgExportOptions {
+    /** Page units added around the shapes' bounds. Default 32. */
+    padding?: number;
+    /** Paint a full-size background rectangle. Default false. */
+    background?: boolean;
+    /** Multiplier applied to the output `width`/`height`. Default 1. */
+    scale?: number;
+    /** Use the dark background colour. Default false. */
+    darkMode?: boolean;
+}
+interface SvgExportResult {
+    svg: string;
+    /** Output size in CSS pixels (bounds × scale). */
+    width: number;
+    height: number;
+}
+declare const SVG_EXPORT_DEFAULT_PADDING = 32;
+declare const SVG_LIGHT_BACKGROUND = "#f9fafb";
+declare const SVG_DARK_BACKGROUND = "#101011";
+/**
+ * The shapes an export covers: the given ids (or the selection, or the whole
+ * page when nothing is selected) together with all of their descendants, in
+ * page draw order.
+ */
+declare function getExportShapes(editor: Editor, ids?: readonly ShapeId[]): UnknownShape[];
+/** Common page bounds of the shapes, or `undefined` when there are none. */
+declare function getExportBounds(editor: Editor, shapes: readonly UnknownShape[]): Box | undefined;
+/**
+ * Serialize shapes to an SVG string. Returns `undefined` when there is
+ * nothing to export.
+ */
+declare function getSvgString(editor: Editor, ids?: readonly ShapeId[], opts?: SvgExportOptions): SvgExportResult | undefined;
+
+/**
+ * Export-wide settings a renderer may consult. Same shape as the context a
+ * `ShapeUtil.toSvg` receives, so the two paths cannot drift apart.
+ */
+interface SvgExportContext extends ShapeSvgContext {
+}
+/** Renders one shape to SVG markup in shape-local coordinates. */
+type ShapeSvgRenderer<T extends UnknownShape = UnknownShape> = (editor: Editor, shape: T, ctx: SvgExportContext) => string;
+/** Outline drawn with the render style, or a hairline in the theme text colour when the shape has none. */
+declare function geometryFallbackSvg(editor: Editor, shape: UnknownShape): string;
+/** Fallback renderer applied to shape types without a registry entry. */
+declare const defaultShapeSvgRenderer: ShapeSvgRenderer;
+/**
+ * Registry of per-type renderers. Custom shapes can register their own entry;
+ * anything missing falls back to `defaultShapeSvgRenderer`.
+ */
+declare const shapeSvgRenderers: Map<string, ShapeSvgRenderer<UnknownShape>>;
+/** Register (or replace) the SVG renderer for a shape type. */
+declare function registerShapeSvgRenderer<T extends UnknownShape>(type: T["type"], renderer: ShapeSvgRenderer<T>): void;
+/**
+ * Markup for a value returned by `toSvg` / `toBackgroundSvg`: a string is used
+ * verbatim, a React node is serialized, and React's empty values become
+ * `undefined` so the caller can fall through to the next renderer.
+ */
+declare function svgResultToMarkup(value: ShapeSvgResult): string | undefined;
+/**
+ * Render a shape to SVG markup in shape-local space.
+ *
+ * Precedence, highest first:
+ *
+ *  1. `ShapeUtil.toSvg` — the shape's own opinion about itself. A custom shape
+ *     is exportable by implementing one method, with nothing to register.
+ *  2. `shapeSvgRenderers` — the registry, which carries the built-in shapes and
+ *     lets an app override a type whose util it does not own (see
+ *     `registerShapeSvgRenderer`).
+ *  3. The shape's geometry stroked with its render style — the last resort, so
+ *     an unknown type still exports as something rather than as nothing.
+ */
+declare function shapeToSvg(editor: Editor, shape: UnknownShape, ctx: SvgExportContext): string;
+/**
+ * A shape's backdrop in shape-local space, drawn behind *every* exported
+ * shape. Only `ShapeUtil.toBackgroundSvg` produces one; there is no registry
+ * behind it and no geometry fallback, because a shape that says nothing here
+ * wants nothing drawn.
+ */
+declare function shapeToBackgroundSvg(editor: Editor, shape: UnknownShape, ctx: SvgExportContext): string | undefined;
+
+/**
+ * Export shapes to a `Blob` (SVG or raster), plus small browser helpers to
+ * download or copy the result. Raster export needs a DOM; the functions guard
+ * for Node and fail with a clear error instead of a reference error.
+ */
+
+type ExportFormat = "svg" | "png" | "jpeg" | "webp";
+interface ExportToBlobOptions extends SvgExportOptions {
+    ids?: readonly ShapeId[];
+    format: ExportFormat;
+    /** Encoder quality for lossy formats (0..1). */
+    quality?: number;
+    /** Device pixel ratio multiplier for raster output. Defaults to `window.devicePixelRatio`. */
+    pixelRatio?: number;
+}
+/** Render the export to a `Blob`. SVG works anywhere; raster formats need a browser. */
+declare function exportToBlob(editor: Editor, opts: ExportToBlobOptions): Promise<Blob>;
+/** Trigger a download of `blob` as `filename`. No-op outside a browser. */
+declare function downloadBlob(blob: Blob, filename: string): void;
+/**
+ * Copy `blob` to the system clipboard. Images go through `ClipboardItem`;
+ * SVG (which clipboards do not accept as an image) is copied as text.
+ */
+declare function copyBlobToClipboard(blob: Blob): Promise<void>;
+
+/**
+ * Text labels as `<text>` elements. Layout mirrors the DOM label: paragraphs
+ * split on newlines, soft-wrapped at an average glyph advance (the same
+ * estimate the Node-side text measurer uses), one `<tspan>` per line.
+ */
+
+interface SvgTextBox {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+interface SvgTextOptions {
+    fontFamily: string;
+    fontSize: number;
+    /** CSS colour for the glyphs. */
+    color: string;
+    align: DefaultHorizontalAlignStyle | "start" | "middle" | "end";
+    verticalAlign: DefaultVerticalAlignStyle;
+    /** Inset from the box edges on every side. */
+    padding?: number;
+    /** Soft-wrap paragraphs at the box width (minus padding). */
+    wrap?: boolean;
+    fontWeight?: string | number;
+}
+/** Split `text` into rendered lines: hard breaks on `\n`, soft wraps at `maxWidth` when given. */
+declare function wrapTextLines(text: string, fontSize: number, maxWidth?: number): string[];
+/**
+ * Render `text` inside `box`. Returns an empty string for empty text. Lines
+ * are positioned with `dominant-baseline="central"` so vertical centring does
+ * not depend on font metrics.
+ */
+declare function textToSvg(text: string, box: SvgTextBox, opts: SvgTextOptions): string;
+
+/**
+ * Small, DOM-free helpers shared by the SVG exporter: number formatting,
+ * colour conversion from the engine's `0xRRGGBBAA` words, XML escaping and
+ * dash patterns.
+ */
+
+/** Affine transform components as returned by `Editor.getShapePageTransform`. */
+interface SvgTransform {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+}
+/** Escape text for use inside an element or a double-quoted attribute. */
+declare function escapeXml(text: string): string;
+/**
+ * Convert an engine `0xRRGGBBAA` word to `#rrggbb` (opaque) or `#rrggbbaa`.
+ * Returns `undefined` when the colour is fully transparent ("none").
+ */
+declare function rgbaToHex(word: number): string | undefined;
+/** `matrix(a b c d e f)` for a `transform` attribute. */
+declare function matrixAttr(m: SvgTransform): string;
+/**
+ * `stroke-dasharray` for an engine dash id (0 solid, 1 dashed, 2 dotted,
+ * 3 draw). Solid and draw strokes have no dash array.
+ */
+declare function dashArray(dash: number, strokeWidth: number): string | undefined;
+/**
+ * One `<path>` per leaf geometry, filled only where the leaf is a closed,
+ * filled outline and stroked with the shape's stroke. Empty leaves are skipped.
+ */
+declare function geometryToSvgPaths(geometry: Geometry2d, style: StyleWords): string;
+
+interface ImageSize {
+    w: number;
+    h: number;
+}
+/** Resolves an image's pixel size from its source; injectable so tests can run without a DOM. */
+type ImageSizeLoader = (src: string, file?: File) => Promise<ImageSize>;
+interface ExternalContentOptions {
+    /** Longest side an inserted image may have, in page units. */
+    maxImageDimension?: number;
+    /** Fallback size when an image's dimensions cannot be read. */
+    fallbackImageSize?: ImageSize;
+    loadImageSize?: ImageSizeLoader;
+    readFileAsDataUrl?: (file: File) => Promise<string>;
+    /** Offset between shapes when several are inserted at the same point. */
+    stackOffset?: number;
+}
+declare const DEFAULT_MAX_IMAGE_DIMENSION = 1000;
+/** Scale `size` down (never up) so both sides fit within `max`, keeping the aspect ratio. */
+declare function fitImageSize(size: ImageSize, max?: number): ImageSize;
+declare function isImageFile(file: File): boolean;
+declare function isSvgFile(file: File): boolean;
+declare function isAnimatedImageType(mimeType: string): boolean;
+declare function looksLikeUrl(text: string): boolean;
+declare function looksLikeSvg(text: string): boolean;
+/** Read a file into a `data:` URL, via `FileReader` where present and `arrayBuffer()` elsewhere. */
+declare function readFileAsDataUrl(file: File): Promise<string>;
+/** A `data:` URL for an SVG document string. */
+declare function svgTextToDataUrl(text: string): string;
+/** Pixel size declared by an SVG's root `width`/`height` or `viewBox`, or `null` when neither is usable. */
+declare function getSvgTextSize(text: string): ImageSize | null;
+/** Default size loader: `createImageBitmap` when available, else an `Image` element. */
+declare const loadImageSizeInBrowser: ImageSizeLoader;
+/** Build (without storing) an image asset for a file; `undefined` for non-image files. */
+declare function createImageAssetFromFile(file: File, opts?: ExternalContentOptions): Promise<ImageAsset | undefined>;
+/** Build (without storing) an image asset from SVG markup. */
+declare function createImageAssetFromSvgText(text: string, opts?: ExternalContentOptions): ImageAsset;
+/** Store `assets` and create one image shape per asset, centered on `point` and stacked by `stackOffset`. */
+declare function createImageShapesForAssets(editor: Editor, assets: readonly ImageAsset[], point: VecLike | undefined, stackOffset?: number): ShapeId[];
+/** Create a text shape whose bounds are centered on `point`. */
+declare function createTextShapeAt(editor: Editor, text: string, point: VecLike | undefined): ShapeId;
+/**
+ * Install the default drop/paste behaviour: image files become image assets +
+ * image shapes, SVG markup becomes an image asset, text and urls become text
+ * shapes. Types that already have a handler are left alone. Returns a function
+ * that removes the handlers this call installed.
+ */
+declare function registerDefaultExternalContentHandlers(editor: Editor, opts?: ExternalContentOptions): () => void;
+/** Classify pasted or dropped plain text as our own clipboard JSON (`null`), a url, svg markup, or text. */
+declare function classifyExternalText(text: string, point?: VecLike): ExternalContent | null;
+
+/**
+ * Drop and paste support for the canvas container: files, images, svg markup,
+ * urls and plain text are routed to `editor.putExternalContent`. Plain text is
+ * only taken when nothing is being edited and it is not our own
+ * `application/mocanvas` clipboard JSON (the keyboard shortcuts handle that).
+ * Also installs the default handlers for any content type without one.
+ */
+declare function useExternalContent(editor: Editor | null, containerRef: RefObject<HTMLElement | null>, options?: ExternalContentOptions): void;
+
+export { ARROW_KINDS, ARROW_LABEL_PADDING, ARROW_TERMINAL_GAP_STROKES, AVG_CHAR_WIDTH, type ArcBody, type ArrowBinding, type ArrowBindingProps, ArrowBindingUtil, type ArrowBindings, type ArrowBody, type ArrowKind, type ArrowShape, type ArrowShapeProps, ArrowShapeUtil, type ArrowTerminal, type ArrowTerminals, ArrowTool, type ArrowheadKind, BOOKMARK_BANNER_FILL, BOOKMARK_BANNER_HEIGHT, BOOKMARK_FAVICON_SIZE, BOOKMARK_FILL, BOOKMARK_GAP, BOOKMARK_HEIGHT, BOOKMARK_META_COLOR, BOOKMARK_META_FONT_SIZE, BOOKMARK_META_HEIGHT, BOOKMARK_MIN_BODY_HEIGHT, BOOKMARK_PADDING, BOOKMARK_RADIUS, BOOKMARK_STROKE, BOOKMARK_STROKE_WIDTH, BOOKMARK_TEXT_COLOR, BOOKMARK_TEXT_FONT_SIZE, BOOKMARK_TITLE_COLOR, BOOKMARK_TITLE_FONT_SIZE, BOOKMARK_TITLE_HEIGHT, BOOKMARK_WIDTH, type BookmarkCard, type BookmarkLayout, type BookmarkRect, type BookmarkShape, type BookmarkShapeProps, BookmarkShapeUtil, type CubicSegment, DEFAULT_EMBED_DEFINITIONS, DEFAULT_MAX_IMAGE_DIMENSION, DebugStats, DefaultUi, type DrawPoint, type DrawSegment, type DrawShape, type DrawShapeProps, DrawShapeUtil, DrawTool, ELBOW_CORNER_STROKES, EMBED_HEIGHT, EMBED_PLACEHOLDER_FILL, EMBED_PLACEHOLDER_FONT_SIZE, EMBED_PLACEHOLDER_PADDING, EMBED_PLACEHOLDER_STROKE, EMBED_PLACEHOLDER_TEXT, EMBED_RADIUS, EMBED_SANDBOX, EMBED_WIDTH, type ElbowAxis, type ElbowBody, type ElbowRoute, type ElbowRouteOptions, type ElbowTerminalAxes, type EmbedDefinition, type EmbedMatch, type EmbedShape, type EmbedShapeProps, EmbedShapeUtil, EraserTool, type ExportFormat, type ExportToBlobOptions, type ExternalContentOptions, FRAME_FILL, FRAME_NAME_COLOR, FRAME_NAME_FONT_SIZE, FRAME_NAME_GAP, FRAME_NAME_HEIGHT, FRAME_NAME_OFFSET, FRAME_STROKE, FRAME_STROKE_WIDTH, type FrameShape, type FrameShapeProps, FrameShapeUtil, FrameTool, GEO_BOX, GEO_ICON_PATHS, GEO_LABEL_PADDING, type GeoShape, type GeoShapeProps, GeoShapeUtil, GeoTool, type GroupShape, GroupShapeUtil, HEXAGON_FLAT_SIDE_SPAN, HandTool, ICONS, ICON_GRID, ICON_NAMES, IMAGE_PLACEHOLDER_FILL, IMAGE_PLACEHOLDER_STROKE, Icon, type IconName, type IconProps, type ImageCrop, type ImageShape, type ImageShapeProps, ImageShapeUtil, type ImageSize, type ImageSizeLoader, LINE_HEIGHT, type LabelMeasureOptions, type LinePoint, type LineShape, type LineShapeProps, LineShapeUtil, LineTool, type LoadMocanvasFileResult, MAX_TEXT_TEXTURE_PX, MOD_KEY, MORE_GEO_KINDS, Mocanvas, type MocanvasProps, NOTE_GRADIENT_TOP_SCALE, NOTE_PADDING, NOTE_SHADOW_BLUR, NOTE_SHADOW_COLOR, NOTE_SHADOW_OFFSET_Y, NOTE_SHADOW_OPACITY, NOTE_SHADOW_SPREAD, NOTE_SIZE, type NoteShape, type NoteShapeProps, NoteShapeUtil, NoteTool, PRIMARY_GEO_KINDS, type Placement, Popover, type PopoverProps, STAR_INNER_RATIO, SVG_DARK_BACKGROUND, SVG_EXPORT_DEFAULT_PADDING, SVG_LIGHT_BACKGROUND, SelectTool, type ShapeSvgRenderer, type StraightBody, StylePanel, type StylePanelSections, type SvgExportContext, type SvgExportOptions, type SvgExportResult, type SvgTextBox, type SvgTextOptions, type SvgTransform, TEXT_SHAPE_MIN_WIDTH, TOOLBAR_GROUPS, TextLabel, type TextLabelProps, TextMeasure, type TextMeasureOptions, type TextMeasurement, type TextShape, type TextShapeProps, type TextShapeSizeInput, TextShapeUtil, type TextSizeEstimate, type TextTextureAlign, type TextTextureSpec, TextTool, Toolbar, type ToolbarItem, type TransformLike, UiTooltip, VIDEO_HEIGHT, VIDEO_PLACEHOLDER_FILL, VIDEO_PLACEHOLDER_STROKE, VIDEO_PLAY_COLOR, VIDEO_PLAY_SIZE, VIDEO_TIME_EPSILON, VIDEO_WIDTH, type VideoShape, type VideoShapeProps, VideoShapeUtil, ZoomBar, alignToJustify, alignToTextAlign, applyTransform, arcToCubicSegments, bodyToGeometry, canUploadImageTextures, catmullRomToBezier, classifyExternalText, computeGrowY, copyBlobToClipboard, createImageAssetFromFile, createImageAssetFromSvgText, createImageShapesForAssets, createTextShapeAt, dashArray, debugStatsOpen, defaultBindingUtils, defaultShapeSvgRenderer, defaultShapeUtils, defaultTools, downloadBlob, embedDefinitions, escapeXml, estimateTextSize, exportToBlob, fitImageSize, fitPointsToBox, geometryFallbackSvg, geometryToSvgPaths, getAnchorInShapeSpace, getArrowBindingTargetAtPoint, getArrowBindings, getArrowBody, getArrowTerminalGap, getArrowTerminalsInArrowSpace, getArrowheadGeometry, getArrowheadInset, getArrowheadLength, getBendFromPoint, getBodyLength, getBookmarkAsset, getBookmarkCard, getBookmarkHostname, getBookmarkLayout, getBoundElbowAxes, getCloudSegments, getDashId, getDominantAxis, getDrawOutlinePoints, getElbowBody, getElbowMidPointFromPoint, getElbowRoute, getEmbedDefinition, getExportBounds, getExportShapes, getFillRgba, getFontFamily, getGeoDecorations, getGeoGeometry, getGeoGrowY, getGeoIconBox, getGeoPolygonPoints, getHeartSegments, getImageCropStyle, getImageTextureKey, getImageTextureSource, getLinePoints, getNormalizedAnchor, getNoteBodyGradientCss, getNoteFillCssColor, getNoteFillRgba, getNoteFontSize, getNoteGradientTopCssColor, getNoteGradientTopFrom, getNoteGrowY, getNoteShadowCss, getNoteShadowSvgRect, getNoteTextCssColor, getOutlineSegments, getPointOnBody, getStadiumSegments, getStrokeRgba, getStylePanelSections, getSvgString, getSvgTextSize, getTangentOnBody, getTextCssColor, getTextMeasure, getTextShapeBox, getTextShapeHeight, getTextShapeSize, getTextShapeSizeFor, getTextShapeTextureSpec, getTextTextureKey, getTextTextureScale, getVideoPlayTriangle, getVideoSource, hasAnyStyleSection, hexToCssRgba, horizontalAlignToFlex, horizontalAlignToTextAlign, intersectSegments, isAnimatedImageType, isImageFile, isSvgFile, lineSegment, loadImageSizeInBrowser, loadImageTextureSource, loadMocanvasFile, looksLikeSvg, looksLikeUrl, matrixAttr, measureGeoLabel, measureLabel, pathWordsToSvgD, placeNear, pointOnCubic, propsOf, readArray, readArrowProps, readArrowShape, readBoolean, readDrawSegments, readEnum, readFileAsDataUrl, readGeoProps, readNoteProps, readNumber, readPoint, readRecord, readString, readStyle, readText, readTextProps, registerDefaultExternalContentHandlers, registerShapeSvgRenderer, renderTextToCanvas, rgbaToHex, roundElbowCorners, serializeMocanvasFile, shapeSvgRenderers, shapeToBackgroundSvg, shapeToSvg, shortenBody, smoothPoints, svgResultToMarkup, svgTextToDataUrl, textToSvg, toDisplayText, trimTrailingWhitespace, useExternalContent, useKeyboardShortcuts, verticalAlignToAlignItems, verticalAlignToFlex, wrapTextLines, wrapTextTextureLines };