@excalidraw/math 0.18.0-508de2f3a → 0.18.0-51ad895

package/dist/types/common/src/constants.d.ts

@@ -1,13 +1,5 @@
 import type { ExcalidrawElement, FontFamilyValues } from "@excalidraw/element/types";
 import type { AppProps, AppState } from "@excalidraw/excalidraw/types";
-export declare const isDarwin: boolean;
-export declare const isWindows: boolean;
-export declare const isAndroid: boolean;
-export declare const isFirefox: boolean;
-export declare const isChrome: boolean;
-export declare const isSafari: boolean;
-export declare const isIOS: boolean;
-export declare const isBrave: () => boolean;
 export declare const supportsResizeObserver: boolean;
 export declare const APP_NAME = "Excalidraw";
 export declare const TEXT_AUTOWRAP_THRESHOLD = 36;
@@ -86,10 +78,13 @@ export declare const ENV: {
     PRODUCTION: string;
 };
 export declare const CLASSES: {
+    SIDEBAR: string;
     SHAPE_ACTIONS_MENU: string;
     ZOOM_ACTIONS: string;
     SEARCH_MENU_INPUT_WRAPPER: string;
     CONVERT_ELEMENT_TYPE_POPUP: string;
+    SHAPE_ACTIONS_THEME_SCOPE: string;
+    FRAME_NAME: string;
 };
 export declare const CJK_HAND_DRAWN_FALLBACK_FONT = "Xiaolai";
 export declare const WINDOWS_EMOJI_FALLBACK_FONT = "Segoe UI Emoji";
@@ -175,6 +170,14 @@ export declare const IMAGE_MIME_TYPES: {
     readonly avif: "image/avif";
     readonly jfif: "image/jfif";
 };
+export declare const STRING_MIME_TYPES: {
+    readonly text: "text/plain";
+    readonly html: "text/html";
+    readonly json: "application/json";
+    readonly excalidraw: "application/vnd.excalidraw+json";
+    readonly excalidrawlib: "application/vnd.excalidrawlib+json";
+    readonly excalidrawlibIds: "application/vnd.excalidrawlib.ids+json";
+};
 export declare const MIME_TYPES: {
     readonly svg: "image/svg+xml";
     readonly png: "image/png";
@@ -185,14 +188,15 @@ export declare const MIME_TYPES: {
     readonly ico: "image/x-icon";
     readonly avif: "image/avif";
     readonly jfif: "image/jfif";
+    readonly "excalidraw.svg": "image/svg+xml";
+    readonly "excalidraw.png": "image/png";
+    readonly binary: "application/octet-stream";
     readonly text: "text/plain";
     readonly html: "text/html";
     readonly json: "application/json";
     readonly excalidraw: "application/vnd.excalidraw+json";
     readonly excalidrawlib: "application/vnd.excalidrawlib+json";
-    readonly "excalidraw.svg": "image/svg+xml";
-    readonly "excalidraw.png": "image/png";
-    readonly binary: "application/octet-stream";
+    readonly excalidrawlibIds: "application/vnd.excalidrawlib.ids+json";
 };
 export declare const ALLOWED_PASTE_MIME_TYPES: readonly ["text/plain", "text/html", ...("image/svg+xml" | "image/png" | "image/jpeg" | "image/gif" | "image/webp" | "image/bmp" | "image/x-icon" | "image/avif" | "image/jfif")[]];
 export declare const EXPORT_IMAGE_TYPES: {
@@ -227,10 +231,6 @@ export declare const URL_HASH_KEYS: {
     readonly addLibrary: "addLibrary";
 };
 export declare const DEFAULT_UI_OPTIONS: AppProps["UIOptions"];
-export declare const MQ_MAX_WIDTH_PORTRAIT = 730;
-export declare const MQ_MAX_WIDTH_LANDSCAPE = 1000;
-export declare const MQ_MAX_HEIGHT_LANDSCAPE = 500;
-export declare const MQ_RIGHT_SIDEBAR_MIN_WIDTH = 1229;
 export declare const MAX_DECIMALS_FOR_SVG_EXPORT = 2;
 export declare const EXPORT_SCALES: number[];
 export declare const DEFAULT_EXPORT_PADDING = 10;
@@ -342,3 +342,8 @@ export declare enum UserIdleState {
  * the start and end points)
  */
 export declare const LINE_POLYGON_POINT_MERGE_DISTANCE = 20;
+export declare const DOUBLE_TAP_POSITION_THRESHOLD = 35;
+export declare const BIND_MODE_TIMEOUT = 700;
+export declare const MOBILE_ACTION_BUTTON_BG: {
+    readonly background: "var(--mobile-action-button-bg)";
+};

package/dist/types/common/src/editorInterface.d.ts

@@ -0,0 +1,34 @@
+export type StylesPanelMode = "compact" | "full" | "mobile";
+export type EditorInterface = Readonly<{
+    formFactor: "phone" | "tablet" | "desktop";
+    desktopUIMode: "compact" | "full";
+    userAgent: Readonly<{
+        isMobileDevice: boolean;
+        platform: "ios" | "android" | "other" | "unknown";
+    }>;
+    isTouchScreen: boolean;
+    canFitSidebar: boolean;
+    isLandscape: boolean;
+}>;
+export declare const MQ_MAX_MOBILE = 599;
+export declare const MQ_MAX_WIDTH_LANDSCAPE = 1000;
+export declare const MQ_MAX_HEIGHT_LANDSCAPE = 500;
+export declare const MQ_MIN_TABLET: number;
+export declare const MQ_MAX_TABLET = 1400;
+export declare const MQ_MIN_WIDTH_DESKTOP = 1440;
+export declare const MQ_RIGHT_SIDEBAR_MIN_WIDTH = 1229;
+export declare const isDarwin: boolean;
+export declare const isWindows: boolean;
+export declare const isAndroid: boolean;
+export declare const isFirefox: boolean;
+export declare const isChrome: boolean;
+export declare const isSafari: boolean;
+export declare const isIOS: boolean;
+export declare const isBrave: () => boolean;
+export declare const isMobileBreakpoint: (width: number, height: number) => boolean;
+export declare const isTabletBreakpoint: (editorWidth: number, editorHeight: number) => boolean;
+export declare const getFormFactor: (editorWidth: number, editorHeight: number) => EditorInterface["formFactor"];
+export declare const deriveStylesPanelMode: (editorInterface: EditorInterface) => StylesPanelMode;
+export declare const createUserAgentDescriptor: (userAgentString: string) => EditorInterface["userAgent"];
+export declare const loadDesktopUIModePreference: () => "compact" | "full" | null;
+export declare const setDesktopUIMode: (mode: EditorInterface["desktopUIMode"]) => "compact" | "full" | undefined;

package/dist/types/common/src/index.d.ts

@@ -10,3 +10,5 @@ export * from "./random";
 export * from "./url";
 export * from "./utils";
 export * from "./emitter";
+export * from "./visualdebug";
+export * from "./editorInterface";

package/dist/types/common/src/utils.d.ts

@@ -1,4 +1,4 @@
-import type { ExcalidrawBindableElement, FontFamilyValues, FontString } from "@excalidraw/element/types";
+import type { FontFamilyValues, FontString } from "@excalidraw/element/types";
 import type { ActiveTool, AppState, ToolType, UnsubscribeCallback, Zoom } from "@excalidraw/excalidraw/types";
 import type { MaybePromise } from "./utility-types";
 import type { EVENT } from "./constants";
@@ -17,6 +17,8 @@ export declare const getFontString: ({ fontSize, fontFamily, }: {
     fontSize: number;
     fontFamily: FontFamilyValues;
 }) => FontString;
+/** executes callback in the frame that's after the current one */
+export declare const nextAnimationFrame: (cb: () => any) => Promise<void>;
 export declare const debounce: <T extends any[]>(fn: (...args: T) => void, timeout: number) => {
     (...args: T): void;
     flush(): void;
@@ -80,6 +82,7 @@ export declare const chunk: <T extends unknown>(array: readonly T[], size: numbe
 export declare const selectNode: (node: Element) => void;
 export declare const removeSelection: () => void;
 export declare const distance: (x: number, y: number) => number;
+export declare const isSelectionLikeTool: (type: ToolType | "custom") => boolean;
 export declare const updateActiveTool: (appState: Pick<AppState, "activeTool">, data: (({
     type: ToolType;
 } | {
@@ -94,7 +97,6 @@ export declare const updateActiveTool: (appState: Pick<AppState, "activeTool">,
 export declare const isFullScreen: () => boolean;
 export declare const allowFullScreen: () => Promise<void>;
 export declare const exitFullScreen: () => Promise<void>;
-export declare const getShortcutKey: (shortcut: string) => string;
 export declare const viewportCoordsToSceneCoords: ({ clientX, clientY }: {
     clientX: number;
     clientY: number;
@@ -140,7 +142,6 @@ export declare const findLastIndex: <T>(array: readonly T[], cb: (element: T, in
 /** returns the first non-null mapped value */
 export declare const mapFind: <T, K>(collection: readonly T[], iteratee: (value: T, index: number) => K | null | undefined) => K | undefined;
 export declare const isTransparent: (color: string) => boolean;
-export declare const isBindingFallthroughEnabled: (el: ExcalidrawBindableElement) => boolean;
 export type ResolvablePromise<T> = Promise<T> & {
     resolve: [T] extends [undefined] ? (value?: MaybePromise<Awaited<T>>) => void : (value: MaybePromise<Awaited<T>>) => void;
     reject: (error: Error) => void;
@@ -264,4 +265,9 @@ export declare const castArray: <T>(value: T | T[]) => T[];
 export declare const isReadonlyArray: (value?: any) => value is readonly any[];
 export declare const sizeOf: (value: readonly unknown[] | Readonly<Map<string, unknown>> | Readonly<Record<string, unknown>> | ReadonlySet<unknown>) => number;
 export declare const reduceToCommonValue: <T, R = T>(collection: ReadonlySet<T> | readonly T[], getValue?: ((item: T) => R) | undefined) => R | null;
+type FEATURE_FLAGS = {
+    COMPLEX_BINDINGS: boolean;
+};
+export declare const getFeatureFlag: <F extends "COMPLEX_BINDINGS">(flag: F) => FEATURE_FLAGS[F];
+export declare const setFeatureFlag: <F extends "COMPLEX_BINDINGS">(flag: F, value: FEATURE_FLAGS[F]) => void;
 export {};

package/dist/types/common/src/visualdebug.d.ts

@@ -0,0 +1,41 @@
+import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
+import type { Curve } from "@excalidraw/math";
+import type { LineSegment } from "@excalidraw/utils";
+import type { Bounds } from "@excalidraw/element";
+declare global {
+    interface Window {
+        visualDebug?: {
+            data: DebugElement[][];
+            currentFrame?: number;
+        };
+    }
+}
+export type DebugElement = {
+    color: string;
+    data: LineSegment<GlobalPoint> | Curve<GlobalPoint>;
+    permanent: boolean;
+};
+export declare const debugDrawCubicBezier: (c: Curve<GlobalPoint>, opts?: {
+    color?: string;
+    permanent?: boolean;
+}) => void;
+export declare const debugDrawLine: (segment: LineSegment<GlobalPoint> | LineSegment<GlobalPoint>[], opts?: {
+    color?: string;
+    permanent?: boolean;
+}) => void;
+export declare const debugDrawPoint: (p: GlobalPoint, opts?: {
+    color?: string;
+    permanent?: boolean;
+    fuzzy?: boolean;
+}) => void;
+export declare const debugDrawBounds: (box: Bounds | Bounds[], opts?: {
+    color?: string;
+    permanent?: boolean;
+}) => void;
+export declare const debugDrawPoints: ({ x, y, points, }: {
+    x: number;
+    y: number;
+    points: readonly LocalPoint[];
+}, options?: any) => void;
+export declare const debugCloseFrame: () => void;
+export declare const debugClear: () => void;

package/dist/types/element/src/binding.d.ts

@@ -1,68 +1,80 @@
 import { type GlobalPoint } from "@excalidraw/math";
-import type { LocalPoint } from "@excalidraw/math";
+import type { LineSegment, LocalPoint } from "@excalidraw/math";
 import type { AppState } from "@excalidraw/excalidraw/types";
 import { type Heading } from "./heading";
 import type { Scene } from "./Scene";
 import type { Bounds } from "./bounds";
 import type { ElementUpdate } from "./mutateElement";
-import type { ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, ExcalidrawLinearElement, NonDeletedExcalidrawElement, ElementsMap, NonDeletedSceneElementsMap, ExcalidrawElbowArrowElement, FixedPoint } from "./types";
-export type SuggestedBinding = NonDeleted<ExcalidrawBindableElement> | SuggestedPointBinding;
-export type SuggestedPointBinding = [
-    NonDeleted<ExcalidrawLinearElement>,
-    "start" | "end" | "both",
-    NonDeleted<ExcalidrawBindableElement>
-];
+import type { BindMode, ElementsMap, ExcalidrawArrowElement, ExcalidrawBindableElement, ExcalidrawElbowArrowElement, ExcalidrawElement, FixedPoint, FixedPointBinding, NonDeleted, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap, Ordered, PointsPositionUpdates } from "./types";
+export type BindingStrategy = {
+    mode: BindMode;
+    element: NonDeleted<ExcalidrawBindableElement>;
+    focusPoint: GlobalPoint;
+} | {
+    mode: null;
+    element?: undefined;
+    focusPoint?: undefined;
+} | {
+    mode: undefined;
+    element?: undefined;
+    focusPoint?: undefined;
+};
+/**
+ * gaps exclude element strokeWidth
+ *
+ * IMPORTANT: currently must be > 0 (this also applies to the computed gap)
+ */
+export declare const BASE_BINDING_GAP = 10;
+export declare const BASE_BINDING_GAP_ELBOW = 5;
+export declare const getBindingGap: (bindTarget: ExcalidrawBindableElement, opts: Pick<ExcalidrawArrowElement, "elbowed">) => number;
+export declare const maxBindingDistance_simple: (zoom?: AppState["zoom"]) => number;
 export declare const shouldEnableBindingForPointerEvent: (event: React.PointerEvent<HTMLElement>) => boolean;
 export declare const isBindingEnabled: (appState: AppState) => boolean;
-export declare const FIXED_BINDING_DISTANCE = 5;
-export declare const BINDING_HIGHLIGHT_THICKNESS = 10;
-export declare const bindOrUnbindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, startBindingElement: ExcalidrawBindableElement | null | "keep", endBindingElement: ExcalidrawBindableElement | null | "keep", scene: Scene) => void;
-export declare const bindOrUnbindLinearElements: (selectedElements: NonDeleted<ExcalidrawLinearElement>[], isBindingEnabled: boolean, draggingPoints: readonly number[] | null, scene: Scene, zoom?: AppState["zoom"]) => void;
-export declare const getSuggestedBindingsForArrows: (selectedElements: NonDeleted<ExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, zoom: AppState["zoom"]) => SuggestedBinding[];
-export declare const maybeSuggestBindingsForLinearElementAtCoords: (linearElement: NonDeleted<ExcalidrawLinearElement>, pointerCoords: {
-    x: number;
-    y: number;
-}[], scene: Scene, zoom: AppState["zoom"], oppositeBindingBoundElement?: ExcalidrawBindableElement | null) => ExcalidrawBindableElement[];
-export declare const maybeBindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, appState: AppState, pointerCoords: {
-    x: number;
-    y: number;
-}, scene: Scene) => void;
-export declare const bindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", scene: Scene) => void;
-export declare const isLinearElementSimpleAndAlreadyBound: (linearElement: NonDeleted<ExcalidrawLinearElement>, alreadyBoundToId: ExcalidrawBindableElement["id"] | undefined, bindableElement: ExcalidrawBindableElement) => boolean;
-export declare const getHoveredElementForBinding: (pointerCoords: {
-    x: number;
-    y: number;
-}, elements: readonly NonDeletedExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap, zoom?: AppState["zoom"], fullShape?: boolean, considerAllElements?: boolean) => NonDeleted<ExcalidrawBindableElement> | null;
+export declare const bindOrUnbindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, draggingPoints: PointsPositionUpdates, scene: Scene, appState: AppState, opts?: {
+    newArrow?: boolean;
+    altKey?: boolean;
+    initialBinding?: boolean;
+}) => {
+    start: BindingStrategy;
+    end: BindingStrategy;
+};
+export declare const getBindingStrategyForDraggingBindingElementEndpoints: (arrow: NonDeleted<ExcalidrawArrowElement>, draggingPoints: PointsPositionUpdates, elementsMap: NonDeletedSceneElementsMap, elements: readonly Ordered<NonDeletedExcalidrawElement>[], appState: AppState, opts?: {
+    newArrow?: boolean;
+    shiftKey?: boolean;
+    altKey?: boolean;
+    finalize?: boolean;
+    initialBinding?: boolean;
+    zoom?: AppState["zoom"];
+}) => {
+    start: BindingStrategy;
+    end: BindingStrategy;
+};
+export declare const bindOrUnbindBindingElements: (selectedArrows: NonDeleted<ExcalidrawArrowElement>[], scene: Scene, appState: AppState) => void;
+export declare const bindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, hoveredElement: ExcalidrawBindableElement, mode: BindMode, startOrEnd: "start" | "end", scene: Scene, focusPoint?: GlobalPoint) => void;
+export declare const unbindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, startOrEnd: "start" | "end", scene: Scene) => ExcalidrawBindableElement["id"] | null;
 export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, scene: Scene, options?: {
     simultaneouslyUpdated?: readonly ExcalidrawElement[];
-    newSize?: {
-        width: number;
-        height: number;
-    };
     changedElements?: Map<string, ExcalidrawElement>;
 }) => void;
-export declare const updateBindings: (latestElement: ExcalidrawElement, scene: Scene, options?: {
+export declare const updateBindings: (latestElement: ExcalidrawElement, scene: Scene, appState: AppState, options?: {
     simultaneouslyUpdated?: readonly ExcalidrawElement[];
     newSize?: {
         width: number;
         height: number;
     };
-    zoom?: AppState["zoom"];
 }) => void;
 export declare const getHeadingForElbowArrowSnap: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined | null, aabb: Bounds | undefined | null, origPoint: GlobalPoint, elementsMap: ElementsMap, zoom?: AppState["zoom"]) => Heading;
-export declare const bindPointToSnapToElementOutline: (arrow: ExcalidrawElbowArrowElement, bindableElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => GlobalPoint;
-export declare const avoidRectangularCorner: (element: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint) => GlobalPoint;
-export declare const snapToMid: (element: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint, tolerance?: number) => GlobalPoint;
+export declare const bindPointToSnapToElementOutline: (arrowElement: ExcalidrawArrowElement, bindableElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, customIntersector?: LineSegment<GlobalPoint>) => GlobalPoint;
+export declare const avoidRectangularCorner: (arrowElement: ExcalidrawArrowElement, bindTarget: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint) => GlobalPoint;
+export declare const updateBoundPoint: (arrow: NonDeleted<ExcalidrawArrowElement>, startOrEnd: "startBinding" | "endBinding", binding: FixedPointBinding | null | undefined, bindableElement: ExcalidrawBindableElement, elementsMap: ElementsMap, customIntersector?: LineSegment<GlobalPoint>) => LocalPoint | null;
 export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => {
     fixedPoint: FixedPoint;
 };
+export declare const calculateFixedPointForNonElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, focusPoint?: GlobalPoint) => {
+    fixedPoint: FixedPoint;
+};
 export declare const fixDuplicatedBindingsAfterDuplication: (duplicatedElements: ExcalidrawElement[], origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicateElementsMap: NonDeletedSceneElementsMap) => void;
 export declare const fixBindingsAfterDeletion: (sceneElements: readonly ExcalidrawElement[], deletedElements: readonly ExcalidrawElement[]) => void;
-export declare const bindingBorderTest: (element: NonDeleted<ExcalidrawBindableElement>, { x, y }: {
-    x: number;
-    y: number;
-}, elementsMap: NonDeletedSceneElementsMap, zoom?: AppState["zoom"], fullShape?: boolean) => boolean;
-export declare const maxBindingGap: (element: ExcalidrawElement, elementWidth: number, elementHeight: number, zoom?: AppState["zoom"]) => number;
 export declare const bindingProperties: Set<BindableProp | BindingProp>;
 export type BindableProp = "boundElements";
 export type BindingProp = "frameId" | "containerId" | "startBinding" | "endBinding";
@@ -104,7 +116,7 @@ export declare class BindableElement {
      */
     static rebindAffected: (elements: ElementsMap, bindableElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void) => void;
 }
-export declare const getGlobalFixedPointForBindableElement: (fixedPointRatio: [number, number], element: ExcalidrawBindableElement, elementsMap: ElementsMap) => GlobalPoint;
-export declare const getGlobalFixedPoints: (arrow: ExcalidrawElbowArrowElement, elementsMap: ElementsMap) => [GlobalPoint, GlobalPoint];
+export declare const getGlobalFixedPointForBindableElement: (fixedPointRatio: FixedPoint, element: ExcalidrawBindableElement, elementsMap: ElementsMap) => GlobalPoint;
+export declare const getGlobalFixedPoints: (arrow: ExcalidrawArrowElement, elementsMap: ElementsMap) => [GlobalPoint, GlobalPoint];
 export declare const getArrowLocalFixedPoints: (arrow: ExcalidrawElbowArrowElement, elementsMap: ElementsMap) => LocalPoint[];
 export declare const normalizeFixedPoint: <T extends FixedPoint | null>(fixedPoint: T) => T extends null ? null : FixedPoint;

package/dist/types/element/src/bounds.d.ts

@@ -74,7 +74,7 @@ export interface BoundingBox {
     width: number;
     height: number;
 }
-export declare const getCommonBoundingBox: (elements: ExcalidrawElement[] | readonly NonDeleted<ExcalidrawElement>[]) => BoundingBox;
+export declare const getCommonBoundingBox: (elements: readonly ExcalidrawElement[] | readonly NonDeleted<ExcalidrawElement>[]) => BoundingBox;
 /**
  * returns scene coords of user's editor viewport (visible canvas area) bounds
  */

package/dist/types/element/src/collision.d.ts

@@ -1,6 +1,6 @@
 import type { GlobalPoint, LineSegment } from "@excalidraw/math";
 import type { FrameNameBounds } from "@excalidraw/excalidraw/types";
-import type { ElementsMap, ExcalidrawElement } from "./types";
+import type { ElementsMap, ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap, Ordered } from "./types";
 export declare const shouldTestInside: (element: ExcalidrawElement) => boolean;
 export type HitTestArgs = {
     point: GlobalPoint;
@@ -8,11 +8,14 @@ export type HitTestArgs = {
     threshold: number;
     elementsMap: ElementsMap;
     frameNameBound?: FrameNameBounds | null;
+    overrideShouldTestInside?: boolean;
 };
-export declare const hitElementItself: ({ point, element, threshold, elementsMap, frameNameBound, }: HitTestArgs) => boolean;
+export declare const hitElementItself: ({ point, element, threshold, elementsMap, frameNameBound, overrideShouldTestInside, }: HitTestArgs) => boolean;
 export declare const hitElementBoundingBox: (point: GlobalPoint, element: ExcalidrawElement, elementsMap: ElementsMap, tolerance?: number) => boolean;
 export declare const hitElementBoundingBoxOnly: (hitArgs: HitTestArgs, elementsMap: ElementsMap) => boolean;
 export declare const hitElementBoundText: (point: GlobalPoint, element: ExcalidrawElement, elementsMap: ElementsMap) => boolean;
+export declare const getAllHoveredElementAtPoint: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, toleranceFn?: ((element: ExcalidrawBindableElement) => number) | undefined) => NonDeleted<ExcalidrawBindableElement>[];
+export declare const getHoveredElementForBinding: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, toleranceFn?: ((element: ExcalidrawBindableElement) => number) | undefined) => NonDeleted<ExcalidrawBindableElement> | null;
 /**
  * Intersect a line with an element for binding test
  *
@@ -30,3 +33,4 @@ export declare const intersectElementWithLineSegment: (element: ExcalidrawElemen
  * @returns
  */
 export declare const isPointInElement: (point: GlobalPoint, element: ExcalidrawElement, elementsMap: ElementsMap) => boolean;
+export declare const isBindableElementInsideOtherBindable: (innerElement: ExcalidrawBindableElement, outerElement: ExcalidrawBindableElement, elementsMap: ElementsMap) => boolean;

package/dist/types/element/src/delta.d.ts

@@ -32,13 +32,13 @@ export declare class Delta<T> {
     /**
      * Merges two deltas into a new one.
      */
-    static merge<T>(delta1: Delta<T>, delta2: Delta<T>): Delta<T>;
+    static merge<T>(delta1: Delta<T>, delta2: Delta<T>, delta3?: Delta<T>): Delta<T>;
     /**
      * Merges deleted and inserted object partials.
      */
     static mergeObjects<T extends {
         [key: string]: unknown;
-    }>(prev: T, added: T, removed: T): T;
+    }>(prev: T, added: T, removed?: T): T;
     /**
      * Merges deleted and inserted array partials.
      */
@@ -105,7 +105,7 @@ export interface DeltaContainer<T> {
      *
      * @returns a tuple of the next object `T` with applied `Delta`s, and `boolean`, indicating whether the applied deltas resulted in a visible change.
      */
-    applyTo(previous: T, ...options: unknown[]): [T, boolean, ...unknown[]];
+    applyTo(previous: T, ...options: unknown[]): [T, boolean];
     /**
      * Squashes the current delta with the given one.
      */
@@ -146,7 +146,6 @@ export declare class AppStateDelta implements DeltaContainer<AppState> {
 type ElementPartial<TElement extends ExcalidrawElement = ExcalidrawElement> = Omit<Partial<Ordered<TElement>>, "id" | "updated" | "seed">;
 export type ApplyToOptions = {
     excludedProperties?: Set<keyof ElementPartial>;
-    skipRedraw?: true;
 };
 /**
  * Elements change is a low level primitive to capture a change between two sets of elements.
@@ -165,6 +164,7 @@ export declare class ElementsDelta implements DeltaContainer<SceneElementsMap> {
     private static satisfiesRemoval;
     private static satisfiesUpdate;
     private static satisfiesCommmonInvariants;
+    private static satisfiesUniqueInvariants;
     private static validate;
     /**
      * Calculates the `Delta`s between the previous and next set of elements.
@@ -224,6 +224,5 @@ export declare class ElementsDelta implements DeltaContainer<SceneElementsMap> {
      */
     private static postProcess;
     private static stripIrrelevantProps;
-    private static stripVersionProps;
 }
 export {};

package/dist/types/element/src/index.d.ts

@@ -11,9 +11,6 @@ export declare const hashString: (s: string) => number;
 export declare const getVisibleElements: (elements: readonly ExcalidrawElement[]) => readonly NonDeletedExcalidrawElement[];
 export declare const getNonDeletedElements: <T extends ExcalidrawElement>(elements: readonly T[]) => readonly NonDeleted<T>[];
 export declare const isNonDeletedElement: <T extends ExcalidrawElement>(element: T) => element is NonDeleted<T>;
-export declare const clearElementsForDatabase: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
-export declare const clearElementsForExport: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
-export declare const clearElementsForLocalStorage: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
 export * from "./align";
 export * from "./binding";
 export * from "./bounds";
@@ -38,6 +35,7 @@ export * from "./image";
 export * from "./linearElementEditor";
 export * from "./mutateElement";
 export * from "./newElement";
+export * from "./positionElementsOnGrid";
 export * from "./renderElement";
 export * from "./resizeElements";
 export * from "./resizeTest";

package/dist/types/element/src/linearElementEditor.d.ts

@@ -4,42 +4,40 @@ import { type Store } from "@excalidraw/element";
 import type { AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize, Zoom } from "@excalidraw/excalidraw/types";
 import type { Scene } from "./Scene";
 import type { Bounds } from "./bounds";
-import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, ExcalidrawElbowArrowElement, PointsPositionUpdates } from "./types";
+import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, FixedPointBinding, ExcalidrawElbowArrowElement, PointsPositionUpdates } from "./types";
 export declare class LinearElementEditor {
     readonly elementId: ExcalidrawElement["id"] & {
         _brand: "excalidrawLinearElementId";
     };
     /** indices */
     readonly selectedPointsIndices: readonly number[] | null;
-    readonly pointerDownState: Readonly<{
+    readonly initialState: Readonly<{
         prevSelectedPointsIndices: readonly number[] | null;
         /** index */
         lastClickedPoint: number;
-        lastClickedIsEndPoint: boolean;
-        origin: Readonly<{
-            x: number;
-            y: number;
-        }> | null;
+        origin: Readonly<GlobalPoint> | null;
         segmentMidpoint: {
             value: GlobalPoint | null;
             index: number | null;
             added: boolean;
         };
+        arrowStartIsInside: boolean;
+        altFocusPoint: Readonly<GlobalPoint> | null;
     }>;
     /** whether you're dragging a point */
     readonly isDragging: boolean;
     readonly lastUncommittedPoint: LocalPoint | null;
+    readonly lastCommittedPoint: LocalPoint | null;
     readonly pointerOffset: Readonly<{
         x: number;
         y: number;
     }>;
-    readonly startBindingElement: ExcalidrawBindableElement | null | "keep";
-    readonly endBindingElement: ExcalidrawBindableElement | null | "keep";
     readonly hoverPointIndex: number;
     readonly segmentMidPointHoveredCoords: GlobalPoint | null;
     readonly elbowed: boolean;
     readonly customLineAngle: number | null;
     readonly isEditing: boolean;
+    readonly pointerDownState: never;
     constructor(element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, isEditing?: boolean);
     static POINT_HANDLE_SIZE: number;
     /**
@@ -48,10 +46,8 @@ export declare class LinearElementEditor {
      */
     static getElement<T extends ExcalidrawLinearElement>(id: InstanceType<typeof LinearElementEditor>["elementId"], elementsMap: ElementsMap): T | null;
     static handleBoxSelection(event: PointerEvent, appState: AppState, setState: React.Component<any, AppState>["setState"], elementsMap: NonDeletedSceneElementsMap): false | undefined;
-    /**
-     * @returns whether point was dragged
-     */
-    static handlePointDragging(event: PointerEvent, app: AppClassProperties, scenePointerX: number, scenePointerY: number, linearElementEditor: LinearElementEditor): Pick<AppState, keyof AppState> | null;
+    static handlePointerMove(event: PointerEvent, app: AppClassProperties, scenePointerX: number, scenePointerY: number, linearElementEditor: LinearElementEditor): Pick<AppState, "suggestedBinding" | "selectedLinearElement"> | null;
+    static handlePointDragging(event: PointerEvent, app: AppClassProperties, scenePointerX: number, scenePointerY: number, linearElementEditor: LinearElementEditor): Pick<AppState, "suggestedBinding" | "selectedLinearElement"> | null;
     static handlePointerUp(event: PointerEvent, editingLinearElement: LinearElementEditor, appState: AppState, scene: Scene): LinearElementEditor;
     static getEditorMidPoints: (element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, appState: InteractiveCanvasAppState) => (GlobalPoint | null)[];
     static getSegmentMidpointHitCoords: (linearElementEditor: LinearElementEditor, scenePointer: {
@@ -70,7 +66,7 @@ export declare class LinearElementEditor {
         linearElementEditor: LinearElementEditor | null;
     };
     static arePointsEqual<Point extends LocalPoint | GlobalPoint>(point1: Point | null, point2: Point | null): boolean;
-    static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, app: AppClassProperties): LinearElementEditor | null;
+    static handlePointerMoveInEditMode(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, app: AppClassProperties): LinearElementEditor | null;
     /** scene coords */
     static getPointGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, p: LocalPoint, elementsMap: ElementsMap): GlobalPoint;
     /** scene coords */
@@ -96,12 +92,13 @@ export declare class LinearElementEditor {
     static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, app: AppClassProperties, pointIndices: readonly number[]): void;
     static addPoints(element: NonDeleted<ExcalidrawLinearElement>, scene: Scene, addedPoints: LocalPoint[]): void;
     static movePoints(element: NonDeleted<ExcalidrawLinearElement>, scene: Scene, pointUpdates: PointsPositionUpdates, otherUpdates?: {
-        startBinding?: PointBinding | null;
-        endBinding?: PointBinding | null;
+        startBinding?: FixedPointBinding | null;
+        endBinding?: FixedPointBinding | null;
+        moveMidPointsWithElement?: boolean | null;
     }): void;
     static shouldAddMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState, elementsMap: ElementsMap): boolean;
     static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, app: AppClassProperties, snapToGrid: boolean, scene: Scene): {
-        pointerDownState: LinearElementEditor["pointerDownState"];
+        pointerDownState: LinearElementEditor["initialState"];
         selectedPointsIndices: LinearElementEditor["selectedPointsIndices"];
     } | undefined;
     private static _updatePoints;
@@ -112,6 +109,6 @@ export declare class LinearElementEditor {
     };
     static getMinMaxXYWithBoundText: (element: ExcalidrawLinearElement, elementsMap: ElementsMap, elementBounds: Bounds, boundTextElement: ExcalidrawTextElementWithContainer) => [number, number, number, number, number, number];
     static getElementAbsoluteCoords: (element: ExcalidrawLinearElement, elementsMap: ElementsMap, includeBoundText?: boolean) => [number, number, number, number, number, number];
-    static moveFixedSegment(linearElement: LinearElementEditor, index: number, x: number, y: number, scene: Scene): LinearElementEditor;
+    static moveFixedSegment(linearElement: LinearElementEditor, index: number, x: number, y: number, scene: Scene): Pick<LinearElementEditor, "segmentMidPointHoveredCoords" | "initialState">;
     static deleteFixedSegment(element: ExcalidrawElbowArrowElement, scene: Scene, index: number): void;
 }

package/dist/types/element/src/mutateElement.d.ts

@@ -11,7 +11,6 @@ export type ElementUpdate<TElement extends ExcalidrawElement> = Omit<Partial<TEl
  */
 export declare const mutateElement: <TElement extends Mutable<ExcalidrawElement>>(element: TElement, elementsMap: ElementsMap, updates: ElementUpdate<TElement>, options?: {
     isDragging?: boolean;
-    force?: boolean;
 }) => TElement;
 export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>, force?: boolean) => TElement;
 /**

package/dist/types/element/src/positionElementsOnGrid.d.ts

@@ -0,0 +1,2 @@
+import type { ExcalidrawElement } from "./types";
+export declare const positionElementsOnGrid: <TElement extends ExcalidrawElement>(elements: TElement[] | TElement[][], centerX: number, centerY: number, padding?: number) => TElement[];

package/dist/types/element/src/renderElement.d.ts

@@ -1,6 +1,7 @@
+import { type GlobalPoint } from "@excalidraw/math";
 import type { AppState, StaticCanvasAppState, InteractiveCanvasAppState, ElementsPendingErasure, PendingExcalidrawElements } from "@excalidraw/excalidraw/types";
 import type { StaticCanvasRenderConfig, RenderableElementsMap, InteractiveCanvasRenderConfig } from "@excalidraw/excalidraw/scene/types";
-import type { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawImageElement, ExcalidrawFrameLikeElement, NonDeletedSceneElementsMap } from "./types";
+import type { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawImageElement, ExcalidrawFrameLikeElement, NonDeletedSceneElementsMap, ElementsMap } from "./types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
 export declare const IMAGE_INVERT_FILTER = "invert(100%) hue-rotate(180deg) saturate(1.25)";
 export declare const getRenderOpacity: (element: ExcalidrawElement, containingFrame: ExcalidrawFrameLikeElement | null, elementsPendingErasure: ElementsPendingErasure, pendingNodes: Readonly<PendingExcalidrawElements> | null, globalAlpha?: number) => number;
@@ -21,8 +22,10 @@ export interface ExcalidrawElementWithCanvas {
 export declare const DEFAULT_LINK_SIZE = 14;
 export declare const elementWithCanvasCache: WeakMap<ExcalidrawElement, ExcalidrawElementWithCanvas>;
 export declare const renderSelectionElement: (element: NonDeletedExcalidrawElement, context: CanvasRenderingContext2D, appState: InteractiveCanvasAppState, selectionColor: InteractiveCanvasRenderConfig["selectionColor"]) => void;
-export declare const renderElement: (element: NonDeletedExcalidrawElement, elementsMap: RenderableElementsMap, allElementsMap: NonDeletedSceneElementsMap, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: StaticCanvasRenderConfig, appState: StaticCanvasAppState) => void;
+export declare const renderElement: (element: NonDeletedExcalidrawElement, elementsMap: RenderableElementsMap, allElementsMap: NonDeletedSceneElementsMap, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: StaticCanvasRenderConfig, appState: StaticCanvasAppState | InteractiveCanvasAppState) => void;
 export declare const pathsCache: WeakMap<ExcalidrawFreeDrawElement, Path2D>;
 export declare function generateFreeDrawShape(element: ExcalidrawFreeDrawElement): Path2D;
 export declare function getFreeDrawPath2D(element: ExcalidrawFreeDrawElement): Path2D | undefined;
 export declare function getFreeDrawSvgPath(element: ExcalidrawFreeDrawElement): string;
+export declare function getFreedrawOutlineAsSegments(element: ExcalidrawFreeDrawElement, points: [number, number][], elementsMap: ElementsMap): import("@excalidraw/math").LineSegment<GlobalPoint>[];
+export declare function getFreedrawOutlinePoints(element: ExcalidrawFreeDrawElement): [number, number][];

package/dist/types/element/src/resizeTest.d.ts

@@ -1,14 +1,15 @@
+import { type EditorInterface } from "@excalidraw/common";
 import type { GlobalPoint, LocalPoint } from "@excalidraw/math";
-import type { AppState, Device, Zoom } from "@excalidraw/excalidraw/types";
+import type { AppState, Zoom } from "@excalidraw/excalidraw/types";
 import type { Bounds } from "./bounds";
 import type { MaybeTransformHandleType } from "./transformHandles";
 import type { ExcalidrawElement, PointerType, NonDeletedExcalidrawElement, ElementsMap } from "./types";
-export declare const resizeTest: <Point extends GlobalPoint | LocalPoint>(element: NonDeletedExcalidrawElement, elementsMap: ElementsMap, appState: AppState, x: number, y: number, zoom: Zoom, pointerType: PointerType, device: Device) => MaybeTransformHandleType;
-export declare const getElementWithTransformHandleType: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType, elementsMap: ElementsMap, device: Device) => {
+export declare const resizeTest: <Point extends GlobalPoint | LocalPoint>(element: NonDeletedExcalidrawElement, elementsMap: ElementsMap, appState: AppState, x: number, y: number, zoom: Zoom, pointerType: PointerType, editorInterface: EditorInterface) => MaybeTransformHandleType;
+export declare const getElementWithTransformHandleType: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType, elementsMap: ElementsMap, editorInterface: EditorInterface) => {
     element: NonDeletedExcalidrawElement;
     transformHandleType: MaybeTransformHandleType;
 } | null;
-export declare const getTransformHandleTypeFromCoords: <Point extends GlobalPoint | LocalPoint>([x1, y1, x2, y2]: Bounds, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType, device: Device) => MaybeTransformHandleType;
+export declare const getTransformHandleTypeFromCoords: <Point extends GlobalPoint | LocalPoint>([x1, y1, x2, y2]: Bounds, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType, editorInterface: EditorInterface) => MaybeTransformHandleType;
 export declare const getCursorForResizingElement: (resizingElement: {
     element?: ExcalidrawElement;
     transformHandleType: MaybeTransformHandleType;

package/dist/types/element/src/store.d.ts

@@ -170,6 +170,10 @@ export declare class StoreDelta {
      * Parse and load the delta from the remote payload.
      */
     static load({ id, elements: { added, removed, updated }, appState: { delta: appStateDelta }, }: DTO<StoreDelta>): StoreDelta;
+    /**
+     * Squash the passed deltas into the aggregated delta instance.
+     */
+    static squash(...deltas: StoreDelta[]): StoreDelta;
     /**
      * Inverse store delta, creates new instance of `StoreDelta`.
      */
@@ -182,6 +186,7 @@ export declare class StoreDelta {
      * Apply latest (remote) changes to the delta, creates new instance of `StoreDelta`.
      */
     static applyLatestChanges(delta: StoreDelta, prevElements: SceneElementsMap, nextElements: SceneElementsMap, modifierOptions?: "deleted" | "inserted"): StoreDelta;
+    static empty(): StoreDelta;
     isEmpty(): boolean;
 }
 /**