fika-editor 3.0.0 → 3.0.1

package/dist/types/utils/pptxImportText.d.ts

@@ -0,0 +1,26 @@
+/**
+ * PPTX import HTML fixes that pptxtojson 2.2.3 does not always emit:
+ * inherited master/layout bullets arrive as hanging-indent <p> instead of <ul>,
+ * and http(s) runs may be plain text even when PowerPoint treats them as links.
+ */
+export declare const PPTX_HYPERLINK_COLOR = "#0563C1";
+/** Office theme `folHlink` (PowerPoint followed/visited hyperlink). */
+export declare const PPTX_FOLLOWED_HYPERLINK_COLOR = "#954F72";
+/** PowerPoint keeps empty body paragraphs as vertical gaps, not bullets. */
+export declare function isEmptyListParagraph(inner: string): boolean;
+/**
+ * Consecutive body paragraphs with hanging indent (master bullet indent) become
+ * a real <ul> so ProseMirror creates bullet_list and the toolbar list chip activates.
+ * Empty hanging paragraphs stay spacers (PowerPoint does not draw a bullet for them).
+ */
+export declare function wrapHangingIndentParagraphsAsLists(html: string, ratio?: number): string;
+/**
+ * Wrap leftover http(s) URLs that are not already inside <a>. OOXML hyperlinks
+ * (a:hlinkClick) are preferred; this only catches display-time / unlinked URL text.
+ */
+export declare function linkifyPlainUrls(html: string): string;
+/**
+ * Drop baked-in run colors on links so CSS `a` / `a:visited` can paint them
+ * (PowerPoint hlink blue vs folHlink purple). Keep font-size and other run props.
+ */
+export declare function styleImportedHyperlinks(html: string): string;

package/dist/types/utils/pptxSourcePackage.d.ts

@@ -0,0 +1,19 @@
+/**
+ * In-memory retain store for imported PowerPoint packages.
+ * Enables future source-preserving writeback (Mona-style) without
+ * regenerating untouched OOXML parts.
+ */
+export declare function retainSourcePackage(packageId: string, bytes: ArrayBuffer): void;
+export declare function getSourcePackage(packageId: string): ArrayBuffer | undefined;
+export declare function hasSourcePackage(packageId: string): boolean;
+export declare function clearSourcePackage(packageId: string): void;
+export declare function clearAllSourcePackages(): void;
+export declare function markSourcePackageDirty(): void;
+export declare function isSourcePackageClean(packageId?: string): boolean;
+export declare function getActiveSourcePackageId(): string | null;
+/**
+ * Hybrid export fast-path: return retained bytes when the deck is still clean.
+ */
+export declare function tryGetCleanRetainedPackage(slides: Array<{
+    sourcePackageId?: string;
+}>): ArrayBuffer | null;

package/dist/types/utils/pptxStructuredText.d.ts

@@ -0,0 +1,6 @@
+import type { StructuredTextBody } from '../types/slides';
+/**
+ * Best-effort HTML → structured text foundation.
+ * Not a full Mona StructuredTextBody; captures runs/paragraphs from imported HTML.
+ */
+export declare function htmlToStructuredText(html: string): StructuredTextBody | undefined;

package/dist/types/utils/pptxUnit.d.ts

@@ -0,0 +1,19 @@
+import type { ImageClipDataRange } from '../types/slides';
+export declare const PPTX_PX_PER_INCH = 96;
+export declare const PPTX_POINTS_PER_INCH = 72;
+export declare const PPTX_PX_PER_POINT: number;
+export declare const getPPTXImportScale: (sourceWidth: number, targetViewportSize?: number) => number;
+/**
+ * Convert editor-px crop range (percentages) into PptxGenJS image crop sizing (inches).
+ * `pxPerInch` defaults to 96; pass the export `ratioPx2Inch` when the deck viewport is scaled.
+ */
+export declare const getPPTXImageCrop: (width: number, height: number, range: ImageClipDataRange, pxPerInch?: number) => {
+    imageWidth: number;
+    imageHeight: number;
+    sizing: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+};

package/dist/types/utils/prosemirror/caret.d.ts

@@ -0,0 +1,22 @@
+import type { EditorView } from 'prosemirror-view';
+export type ClientCoords = {
+    left: number;
+    top: number;
+};
+export declare function registerEditorView(elementId: string, view: EditorView): void;
+export declare function unregisterEditorView(elementId: string, view?: EditorView): void;
+export declare function getEditorView(elementId: string): EditorView | undefined;
+export declare function liveEditorIds(): string[];
+export declare function setPendingCaret(elementId: string, coords: ClientCoords): void;
+export declare function clearPendingCaret(): void;
+export declare function clampPointToRect(coords: ClientCoords, rect: DOMRect): ClientCoords;
+export declare function caretDomAtPoint(left: number, top: number, doc?: Document): {
+    node: Node;
+    offset: number;
+} | null;
+/**
+ * Place the ProseMirror caret at a viewport (client) point.
+ * Uses posAtCoords so marks, wrapping, lists, and atomic nodes (math) map correctly.
+ */
+export declare function placeCaretAtClientPoint(view: EditorView, coords: ClientCoords): boolean;
+export declare function consumePendingCaret(elementId: string, view: EditorView): boolean;

package/dist/types/utils/prosemirror/commands/applyPlaceholderStyles.d.ts

@@ -0,0 +1,29 @@
+import { type Transaction } from 'prosemirror-state';
+import type { Mark, MarkType } from 'prosemirror-model';
+import type { EditorView } from 'prosemirror-view';
+import type { TextAlign } from '../../../types/slides';
+export interface PlaceholderStyleOptions {
+    fontSize: string;
+    align: string;
+    color: string;
+    fontName?: string;
+    bold?: boolean;
+    italic?: boolean;
+}
+export interface EmptyPlaceholderStylePatch {
+    placeholderFontSize?: number;
+    placeholderAlign?: TextAlign;
+    placeholderBold: boolean;
+    placeholderItalic: boolean;
+    defaultColor?: string;
+    defaultFontName?: string;
+    colorCleared: boolean;
+}
+export declare const isEmptyEditorDoc: (view: EditorView) => boolean;
+export declare const currentStoredMarks: (view: EditorView) => readonly Mark[];
+export declare const setStoredMark: (view: EditorView, mark: Mark) => void;
+export declare const clearStoredMark: (view: EditorView, type: MarkType) => void;
+export declare const readEmptyPlaceholderPatch: (view: EditorView) => EmptyPlaceholderStylePatch;
+export declare const paintFilledPlaceholderTr: (tr: Transaction, schema: EditorView['state']['schema'], options: PlaceholderStyleOptions) => Transaction;
+/** Apply placeholder typography without leaving a range selection on empty docs. */
+export declare const applyPlaceholderStyles: (view: EditorView, options: PlaceholderStyleOptions, phaseHint?: 'empty' | 'filled') => void;

package/dist/types/utils/prosemirror/commands/replaceText.d.ts

@@ -0,0 +1,2 @@
+import { EditorView } from 'prosemirror-view';
+export declare const replaceText: (view: EditorView, newText: string) => void;

package/dist/types/utils/prosemirror/commands/setListStyle.d.ts

@@ -0,0 +1,4 @@
+import type { EditorView } from 'prosemirror-view';
+type Style = Record<string, string>;
+export declare const setListStyle: (view: EditorView, style: Style | Style[]) => import("prosemirror-state").Transaction;
+export {};

package/dist/types/utils/prosemirror/commands/setTextAlign.d.ts

@@ -0,0 +1,5 @@
+import type { Schema } from 'prosemirror-model';
+import type { Transaction } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+export declare const setTextAlign: (tr: Transaction, schema: Schema, alignment: string) => Transaction;
+export declare const alignmentCommand: (view: EditorView, alignment: string) => void;

package/dist/types/utils/prosemirror/commands/setTextIndent.d.ts

@@ -0,0 +1,3 @@
+import type { EditorView } from 'prosemirror-view';
+export declare const indentCommand: (view: EditorView, delta: number) => boolean;
+export declare const textIndentCommand: (view: EditorView, delta: number) => boolean;

package/dist/types/utils/prosemirror/commands/toggleList.d.ts

@@ -0,0 +1,8 @@
+import type { NodeType } from 'prosemirror-model';
+import type { Transaction, EditorState } from 'prosemirror-state';
+interface TextStyleAttr {
+    color?: string;
+    fontsize?: string;
+}
+export declare const toggleList: (listType: NodeType, itemType: NodeType, listStyleType: string, textStyleAttr?: TextStyleAttr) => (state: EditorState, dispatch: (tr: Transaction) => void) => boolean;
+export {};

package/dist/types/utils/prosemirror/commands/wrapEmptyBulletList.d.ts

@@ -0,0 +1,5 @@
+import type { EditorView } from 'prosemirror-view';
+/** Empty content placeholders must become a real `<ul>` so typing/Enter produce list items. */
+export declare const wrapEmptyInBulletList: (view: EditorView) => boolean;
+/** First typed character in an empty content placeholder becomes a list item. */
+export declare const insertTextAsBulletList: (view: EditorView, text: string) => boolean;

package/dist/types/utils/prosemirror/commitEditor.d.ts

@@ -0,0 +1,7 @@
+import { editorHtmlLooksEmpty } from './commitPolicy';
+export { editorHtmlLooksEmpty, shouldWriteEditorHtml } from './commitPolicy';
+export declare const richTextHtmlLooksEmpty: typeof editorHtmlLooksEmpty;
+/** Persist the live ProseMirror HTML. History is for explicit flushes, not every key. */
+export declare function commitLiveEditorToStore(elementId: string, options?: {
+    history?: boolean;
+}): void;

package/dist/types/utils/prosemirror/commitPolicy.d.ts

@@ -0,0 +1,11 @@
+export declare const editorHtmlLooksEmpty: (html: string) => boolean;
+/**
+ * Store owns authored HTML. A live view that has text always writes.
+ * An idle empty view must not erase store text — only the focused/editing
+ * editor may clear.
+ */
+export declare const shouldWriteEditorHtml: (opts: {
+    nextHtml: string;
+    storeHtml: string;
+    isAuthoritative: boolean;
+}) => boolean;

package/dist/types/utils/prosemirror/index.d.ts

@@ -0,0 +1,6 @@
+import { type DirectEditorProps, EditorView } from 'prosemirror-view';
+import { type PluginOptions } from './plugins/index';
+export declare const createDocument: (content: string) => import("prosemirror-model").Node;
+/** Same HTML the live editor paints, so static → edit cannot shift glyphs. */
+export declare const serializeRichTextHtml: (content: string) => string;
+export declare const initProsemirrorEditor: (dom: Element, content: string, props: Omit<DirectEditorProps, 'state'>, pluginOptions?: PluginOptions) => EditorView;

package/dist/types/utils/prosemirror/plugins/index.d.ts

@@ -0,0 +1,7 @@
+import type { Schema } from 'prosemirror-model';
+import type { PlaceholderStyleOptions } from '../commands/applyPlaceholderStyles';
+export interface PluginOptions {
+    placeholder?: string;
+    getPlaceholderFill?: () => PlaceholderStyleOptions | null;
+}
+export declare const buildPlugins: (schema: Schema, options?: PluginOptions) => import("prosemirror-state").Plugin<any>[];

package/dist/types/utils/prosemirror/plugins/inputrules.d.ts

@@ -0,0 +1,7 @@
+import type { Schema } from 'prosemirror-model';
+export declare const buildInputRules: (schema: Schema) => import("prosemirror-state").Plugin<{
+    transform: import("prosemirror-state").Transaction;
+    from: number;
+    to: number;
+    text: string;
+}>;

package/dist/types/utils/prosemirror/plugins/keymap.d.ts

@@ -0,0 +1,3 @@
+import type { Schema } from 'prosemirror-model';
+import type { Command } from 'prosemirror-state';
+export declare const buildKeymap: (schema: Schema) => Record<string, Command>;

package/dist/types/utils/prosemirror/plugins/placeholder.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from 'prosemirror-state';
+export declare const placeholderPlugin: (placeholder: string) => Plugin<any>;

package/dist/types/utils/prosemirror/plugins/placeholderFill.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'prosemirror-state';
+import type { PlaceholderStyleOptions } from '../commands/applyPlaceholderStyles';
+export declare const placeholderFillPlugin: (getOptions: () => PlaceholderStyleOptions | null) => Plugin<any>;

package/dist/types/utils/prosemirror/richTextAttrsFromElement.d.ts

@@ -0,0 +1,3 @@
+import type { PPTElement } from '../../types/slides';
+import { type TextAttrs } from './utils';
+export declare function richTextAttrsFromElement(element: PPTElement): TextAttrs | null;

package/dist/types/utils/prosemirror/schema/index.d.ts

@@ -0,0 +1,26 @@
+export declare const schemaNodes: {
+    doc: import("prosemirror-model").NodeSpec;
+    paragraph: import("prosemirror-model").NodeSpec;
+    blockquote: import("prosemirror-model").NodeSpec;
+    text: import("prosemirror-model").NodeSpec;
+    math: import("prosemirror-model").NodeSpec;
+    ordered_list: import("prosemirror-model").NodeSpec;
+    bullet_list: import("prosemirror-model").NodeSpec;
+    list_item: import("prosemirror-model").NodeSpec;
+};
+export declare const schemaMarks: {
+    em: import("prosemirror-model").MarkSpec;
+    strong: import("prosemirror-model").MarkSpec;
+    fontsize: import("prosemirror-model").MarkSpec;
+    fontname: import("prosemirror-model").MarkSpec;
+    code: import("prosemirror-model").MarkSpec;
+    textgradient: import("prosemirror-model").MarkSpec;
+    forecolor: import("prosemirror-model").MarkSpec;
+    backcolor: import("prosemirror-model").MarkSpec;
+    subscript: import("prosemirror-model").MarkSpec;
+    superscript: import("prosemirror-model").MarkSpec;
+    strikethrough: import("prosemirror-model").MarkSpec;
+    underline: import("prosemirror-model").MarkSpec;
+    link: import("prosemirror-model").MarkSpec;
+    mark: import("prosemirror-model").MarkSpec;
+};

package/dist/types/utils/prosemirror/schema/marks.d.ts

@@ -0,0 +1,18 @@
+import type { MarkSpec } from 'prosemirror-model';
+declare const _default: {
+    em: MarkSpec;
+    strong: MarkSpec;
+    fontsize: MarkSpec;
+    fontname: MarkSpec;
+    code: MarkSpec;
+    textgradient: MarkSpec;
+    forecolor: MarkSpec;
+    backcolor: MarkSpec;
+    subscript: MarkSpec;
+    superscript: MarkSpec;
+    strikethrough: MarkSpec;
+    underline: MarkSpec;
+    link: MarkSpec;
+    mark: MarkSpec;
+};
+export default _default;

package/dist/types/utils/prosemirror/schema/nodes.d.ts

@@ -0,0 +1,12 @@
+import type { NodeSpec } from 'prosemirror-model';
+declare const _default: {
+    doc: NodeSpec;
+    paragraph: NodeSpec;
+    blockquote: NodeSpec;
+    text: NodeSpec;
+    math: NodeSpec;
+    ordered_list: NodeSpec;
+    bullet_list: NodeSpec;
+    list_item: NodeSpec;
+};
+export default _default;

package/dist/types/utils/prosemirror/selection.d.ts

@@ -0,0 +1,15 @@
+import type { EditorView } from 'prosemirror-view';
+export declare const rememberTextSelection: (view: EditorView) => void;
+export declare const forgetTextSelection: (view: EditorView) => void;
+export declare const clampRangeToDoc: (from: number, to: number, size: number) => {
+    from: number;
+    to: number;
+};
+export declare const resolveRememberedRange: (view: EditorView) => {
+    from: number;
+    to: number;
+};
+export declare const restoreTextSelection: (view: EditorView) => boolean;
+/** Keep a selected range; only fall back to the whole box when there was never a range. */
+export declare const autoSelectAll: (view: EditorView) => void;
+export declare const richTextHtmlEqual: (a: string, b: string) => boolean;

package/dist/types/utils/prosemirror/utils.d.ts

@@ -0,0 +1,69 @@
+import type { Node, NodeType, Mark, MarkType, Schema } from 'prosemirror-model';
+import type { EditorState, Selection } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+import type { TextAlign } from '../../types/slides';
+export { rememberTextSelection, forgetTextSelection, clampRangeToDoc, resolveRememberedRange, restoreTextSelection, autoSelectAll, richTextHtmlEqual } from './selection';
+export declare const isList: (node: Node, schema: Schema) => boolean;
+export declare const addMark: (editorView: EditorView, mark: Mark, selection?: {
+    from: number;
+    to: number;
+}) => void;
+export declare const findNodesWithSameMark: (doc: Node, from: number, to: number, markType: MarkType) => {
+    mark: any;
+    from: {
+        node: any;
+        pos: number;
+    };
+    to: {
+        node: any;
+        pos: number;
+    };
+};
+export declare const findParentNode: (predicate: (node: Node) => boolean) => (_ref: Selection) => {
+    pos: number;
+    start: number;
+    depth: number;
+    node: Node;
+};
+export declare const findParentNodeOfType: (nodeType: NodeType) => (selection: Selection) => {
+    pos: number;
+    start: number;
+    depth: number;
+    node: Node;
+};
+export declare const isActiveOfParentNodeType: (nodeType: string, state: EditorState) => boolean;
+export declare const getLastTextNode: (node: Node | null) => Node | null;
+export declare const getMarkAttrs: (view: EditorView) => readonly Mark[];
+export declare const getAttrValue: (marks: readonly Mark[], markType: string, attr: string) => string | null;
+export declare const isActiveMark: (marks: readonly Mark[], markType: string) => boolean;
+export declare const markActive: (state: EditorState, type: MarkType) => boolean | Mark;
+export declare const getAttrValueInSelection: (view: EditorView, attr: string) => string;
+interface DefaultAttrs {
+    color: string;
+    backcolor: string;
+    fontsize: string;
+    fontname: string;
+    align: TextAlign;
+}
+export declare const getTextAttrs: (view: EditorView, attrs?: Partial<DefaultAttrs>) => {
+    bold: boolean;
+    em: boolean;
+    underline: boolean;
+    strikethrough: boolean;
+    superscript: boolean;
+    subscript: boolean;
+    code: boolean;
+    color: string;
+    backcolor: string;
+    fontsize: string;
+    fontname: string;
+    link: string;
+    align: TextAlign;
+    bulletList: boolean;
+    orderedList: boolean;
+    blockquote: boolean;
+};
+export type TextAttrs = ReturnType<typeof getTextAttrs>;
+export declare const getFontsize: (view: EditorView) => number;
+export declare const getTextAttrsFromDoc: (doc: Node, attrs?: Partial<DefaultAttrs>) => TextAttrs;
+export declare const defaultRichTextAttrs: TextAttrs;

package/dist/types/utils/scribbleJoin.d.ts

@@ -0,0 +1,27 @@
+import { type MagicalInkId } from '../configs/inkPaint';
+import type { Gradient } from '../types/slides';
+import { type FreehandPoint } from './freehand';
+export type ScribbleInkStroke = {
+    points: FreehandPoint[];
+    size: number;
+    color: string;
+    gradient?: Gradient;
+    gradientId?: MagicalInkId;
+    simulatePressure?: boolean;
+};
+export type JoinedScribbleShape = {
+    path: string;
+    viewBox: [number, number];
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    color: string;
+    gradient?: Gradient;
+    groupId?: string;
+};
+/**
+ * Nearby strokes become one shape. Same-paint strokes in a cluster are merged
+ * into a compound path; different colors/gradients in the same cluster share a groupId.
+ */
+export declare const joinScribbleInk: (strokes: ScribbleInkStroke[]) => JoinedScribbleShape[];

package/dist/types/utils/selection.d.ts

@@ -0,0 +1 @@
+export declare const removeAllRanges: () => void;

package/dist/types/utils/slideOrder.d.ts

@@ -0,0 +1,3 @@
+import type { Slide } from '../types/slides';
+/** Reorder slides without cloning unchanged slide objects (elements/background stay referentially equal). */
+export declare const reorderSlidesPreservingIdentity: (slides: readonly Slide[], oldIndex: number, newIndex: number) => Slide[];

package/dist/types/utils/snap.d.ts

@@ -0,0 +1,69 @@
+import { type SnapIndex } from './spatial';
+export declare const SNAP_THRESHOLD = 8;
+export declare const FINE_GRID_SIZE = 8;
+export declare const GUIDE_PAD = 14;
+export declare const SNAP_MATCH = 0.51;
+export declare const SLIDE_MARGIN = 40;
+export declare const RELATED_GAP = 240;
+export declare const MAX_CTRL_MEASURES = 8;
+export type SnapKind = 'edge' | 'center' | 'canvas' | 'spacing' | 'size' | 'grid' | 'measure';
+export type SnapMode = 'smart' | 'grid';
+export interface SnapGuide {
+    type: 'vertical' | 'horizontal';
+    kind?: SnapKind;
+    axis: {
+        x: number;
+        y: number;
+    };
+    length: number;
+    marks?: number[];
+    label?: string;
+}
+export interface SnapBox {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+}
+export interface SnapCanvas {
+    width: number;
+    height: number;
+}
+export interface SnapOptions {
+    mode: SnapMode;
+    canvas: SnapCanvas;
+    gridSize: number;
+    threshold?: number;
+    index?: SnapIndex;
+}
+/** Search pad for the per-move Flatbush query: snap threshold or related-object reach. */
+export declare const snapQueryPad: (threshold?: number) => number;
+export declare const sameSnapGuides: (a: SnapGuide[], b: SnapGuide[]) => boolean;
+export interface SnapResult {
+    offsetX: number;
+    offsetY: number;
+    guides: SnapGuide[];
+}
+export declare const boxWidth: (box: SnapBox) => number;
+export declare const boxHeight: (box: SnapBox) => number;
+export declare const boxCenterX: (box: SnapBox) => number;
+export declare const boxCenterY: (box: SnapBox) => number;
+export declare const translateBox: (box: SnapBox, dx: number, dy: number) => SnapBox;
+export declare const snapToGrid: (value: number, gridSize: number) => number;
+/** Alt uses the visible layout grid, or an 8px fine grid when none is shown. */
+export declare const resolveGridSize: (visibleGridSize: number, forceGrid: boolean) => number;
+export declare const formatSnapLabel: (value: number) => string;
+export declare const formatMeasureLabel: (value: number) => string;
+export declare const unionBoxes: (boxes: SnapBox[]) => SnapBox | null;
+export declare const snapMovingBox: (moving: SnapBox, others: SnapBox[], options: SnapOptions) => SnapResult;
+export interface ResizeSnapOptions extends SnapOptions {
+    moving?: SnapBox;
+    resizeWidth?: boolean;
+    resizeHeight?: boolean;
+}
+export declare const snapResizePoint: (currentX: number | null, currentY: number | null, others: SnapBox[], options: ResizeSnapOptions) => SnapResult;
+/**
+ * Ctrl-held distance badges: adjacent gaps along live guides, both axes to
+ * the most related object, nearest same-row/column neighbors, and slide margins.
+ */
+export declare const collectCtrlMeasures: (moving: SnapBox, others: SnapBox[], canvas: SnapCanvas, guides?: SnapGuide[]) => SnapGuide[];

package/dist/types/utils/spatial/hitIndex.d.ts

@@ -0,0 +1,18 @@
+export type HitBox = {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    id: string;
+    zIndex: number;
+};
+/** Dynamic RBush of visual hit rects. load() replaces the current set. */
+export declare class HitIndex {
+    private tree;
+    clear(): void;
+    load(items: HitBox[]): void;
+    insert(item: HitBox): void;
+    remove(item: HitBox): void;
+    search(minX: number, minY: number, maxX: number, maxY: number): HitBox[];
+    hitPoint(x: number, y: number): HitBox | null;
+}

package/dist/types/utils/spatial/index.d.ts

@@ -0,0 +1,3 @@
+export { buildSnapIndex, querySnap, boxesNear, queryLinesX, queryLinesY, SNAP_NEIGHBOR_K, type SnapIndex, type SnapLine, } from './snapIndex';
+export { HitIndex, type HitBox } from './hitIndex';
+export { segmentSnapBoxes, isSmallSnapBox } from './segment';

package/dist/types/utils/spatial/segment.d.ts

@@ -0,0 +1,8 @@
+import type { SnapBox } from '../snap';
+export declare const isSmallSnapBox: (box: SnapBox) => boolean;
+/**
+ * Collapse a dense field of tiny adjacent boxes (world-map countries, icon
+ * scatter) into cluster AABBs via RBush + union-find. Large objects pass
+ * through unchanged. No-op when there aren't enough small boxes to matter.
+ */
+export declare const segmentSnapBoxes: (boxes: SnapBox[]) => SnapBox[];

package/dist/types/utils/spatial/snapIndex.d.ts

@@ -0,0 +1,24 @@
+import Flatbush from 'flatbush';
+import type { SnapBox } from '../snap';
+/** Hard cap after a wide AABB hit — Flatbush.neighbors() keeps the closest K. */
+export declare const SNAP_NEIGHBOR_K = 32;
+export type SnapLine = {
+    value: number;
+    min: number;
+    max: number;
+    kind: 'edge' | 'center';
+};
+/** Segmented Flatbush 2D index plus 1D X/Y snap-line trees. Built on pointerdown. */
+export type SnapIndex = {
+    tree: Flatbush;
+    boxes: SnapBox[];
+    linesX: Flatbush;
+    linesY: Flatbush;
+    metaX: SnapLine[];
+    metaY: SnapLine[];
+};
+export declare const buildSnapIndex: (boxes: SnapBox[]) => SnapIndex;
+export declare const querySnap: (index: SnapIndex, moving: SnapBox, pad: number) => number[];
+export declare const boxesNear: (index: SnapIndex, moving: SnapBox, pad: number) => SnapBox[];
+export declare const queryLinesX: (index: SnapIndex, value: number, threshold: number, rangeMin: number, rangeMax: number) => SnapLine[];
+export declare const queryLinesY: (index: SnapIndex, value: number, threshold: number, rangeMin: number, rangeMax: number) => SnapLine[];

package/dist/types/utils/svg2Base64.d.ts

@@ -0,0 +1 @@
+export declare const svg2Base64: (element: Element) => string;

package/dist/types/utils/svgPathParser.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Parse an SVG path and convert arc (A) segments to cubic Bézier (C) segments.
+ * @param d SVG path `d` attribute
+ */
+export declare const toPoints: (d: string) => any[];
+export declare const getSvgPathRange: (path: string) => {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};
+export type SvgPoints = ReturnType<typeof toPoints>;

package/dist/types/utils/textBoxLock.d.ts

@@ -0,0 +1,17 @@
+/** Shrink-to-fit. Only explicit fixed-height (list placeholders start this way). */
+export declare const textElementLocksSize: (el: {
+    fixedHeight?: boolean;
+    vertical?: boolean;
+}) => boolean;
+/** Shape text defaults to a locked box; `fixedHeight: false` is auto-height. */
+export declare const shapeTextLocksSize: (text?: {
+    fixedHeight?: boolean;
+} | null) => boolean;
+export declare const elementLocksTextBox: (el: {
+    type?: string;
+    fixedHeight?: boolean;
+    vertical?: boolean;
+    text?: {
+        fixedHeight?: boolean;
+    } | null;
+}) => boolean;