@excalidraw/excalidraw 0.17.1-1d71f84 → 0.17.1-1ed53b1

package/dist/excalidraw/constants.d.ts

@@ -1,5 +1,5 @@
-import { AppProps } from "./types";
-import { ExcalidrawElement, FontFamilyValues } from "./element/types";
+import type { AppProps } from "./types";
+import type { ExcalidrawElement, FontFamilyValues } from "./element/types";
 export declare const isDarwin: boolean;
 export declare const isWindows: boolean;
 export declare const isAndroid: boolean;
@@ -121,6 +121,8 @@ export declare const DEFAULT_TEXT_ALIGN = "left";
 export declare const DEFAULT_VERTICAL_ALIGN = "top";
 export declare const DEFAULT_VERSION = "{version}";
 export declare const DEFAULT_TRANSFORM_HANDLE_SPACING = 2;
+export declare const SIDE_RESIZING_THRESHOLD: number;
+export declare const DEFAULT_COLLISION_THRESHOLD: number;
 export declare const COLOR_WHITE = "#ffffff";
 export declare const COLOR_CHARCOAL_BLACK = "#1e1e1e";
 export declare const COLOR_VOICE_CALL = "#a2f1a6";
@@ -175,6 +177,7 @@ export declare const VERSION_TIMEOUT = 30000;
 export declare const SCROLL_TIMEOUT = 100;
 export declare const ZOOM_STEP = 0.1;
 export declare const MIN_ZOOM = 0.1;
+export declare const MAX_ZOOM = 30;
 export declare const HYPERLINK_TOOLTIP_DELAY = 300;
 export declare const IDLE_THRESHOLD = 60000;
 export declare const ACTIVE_THRESHOLD = 3000;
@@ -223,9 +226,6 @@ export declare const ROUNDNESS: {
     readonly PROPORTIONAL_RADIUS: 2;
     readonly ADAPTIVE_RADIUS: 3;
 };
-/** key containt id of precedeing elemnt id we use in reconciliation during
- * collaboration */
-export declare const PRECEDING_ELEMENT_KEY = "__precedingElement__";
 export declare const ROUGHNESS: {
     readonly architect: 0;
     readonly artist: 1;

package/dist/excalidraw/constants.js

@@ -128,6 +128,11 @@ export const DEFAULT_TEXT_ALIGN = "left";
 export const DEFAULT_VERTICAL_ALIGN = "top";
 export const DEFAULT_VERSION = "{version}";
 export const DEFAULT_TRANSFORM_HANDLE_SPACING = 2;
+export const SIDE_RESIZING_THRESHOLD = 2 * DEFAULT_TRANSFORM_HANDLE_SPACING;
+// a small epsilon to make side resizing always take precedence
+// (avoids an increase in renders and changes to tests)
+const EPSILON = 0.00001;
+export const DEFAULT_COLLISION_THRESHOLD = 2 * SIDE_RESIZING_THRESHOLD - EPSILON;
 export const COLOR_WHITE = "#ffffff";
 export const COLOR_CHARCOAL_BLACK = "#1e1e1e";
 // keep this in sync with CSS
@@ -180,6 +185,7 @@ export const VERSION_TIMEOUT = 30000;
 export const SCROLL_TIMEOUT = 100;
 export const ZOOM_STEP = 0.1;
 export const MIN_ZOOM = 0.1;
+export const MAX_ZOOM = 30.0;
 export const HYPERLINK_TOOLTIP_DELAY = 300;
 // Report a user inactive after IDLE_THRESHOLD milliseconds
 export const IDLE_THRESHOLD = 60_000;
@@ -264,9 +270,6 @@ export const ROUNDNESS = {
     // (see DEFAULT_ADAPTIVE_RADIUS constant)
     ADAPTIVE_RADIUS: 3,
 };
-/** key containt id of precedeing elemnt id we use in reconciliation during
- * collaboration */
-export const PRECEDING_ELEMENT_KEY = "__precedingElement__";
 export const ROUGHNESS = {
     architect: 0,
     artist: 1,

package/dist/excalidraw/context/ui-appState.d.ts

@@ -1,4 +1,4 @@
 import React from "react";
-import { UIAppState } from "../types";
+import type { UIAppState } from "../types";
 export declare const UIAppStateContext: React.Context<UIAppState>;
 export declare const useUIAppState: () => UIAppState;

package/dist/excalidraw/cursor.d.ts

@@ -1,4 +1,4 @@
-import { AppState } from "./types";
+import type { AppState } from "./types";
 export declare const resetCursor: (interactiveCanvas: HTMLCanvasElement | null) => void;
 export declare const setCursor: (interactiveCanvas: HTMLCanvasElement | null, cursor: string) => void;
 export declare const setEraserCursor: (interactiveCanvas: HTMLCanvasElement | null, theme: AppState["theme"]) => void;

package/dist/excalidraw/data/EditorLocalStorage.d.ts

@@ -1,5 +1,5 @@
-import { EDITOR_LS_KEYS } from "../constants";
-import { JSONValue } from "../types";
+import type { EDITOR_LS_KEYS } from "../constants";
+import type { JSONValue } from "../types";
 export declare class EditorLocalStorage {
     static has(key: typeof EDITOR_LS_KEYS[keyof typeof EDITOR_LS_KEYS]): boolean;
     static get<T extends JSONValue>(key: typeof EDITOR_LS_KEYS[keyof typeof EDITOR_LS_KEYS]): T | null;

package/dist/excalidraw/data/blob.d.ts

@@ -1,9 +1,9 @@
 import { IMAGE_MIME_TYPES, MIME_TYPES } from "../constants";
-import { ExcalidrawElement, FileId } from "../element/types";
-import { AppState, DataURL, LibraryItem } from "../types";
-import { ValueOf } from "../utility-types";
-import { FileSystemHandle } from "./filesystem";
-import { ImportedLibraryData } from "./types";
+import type { ExcalidrawElement, FileId } from "../element/types";
+import type { AppState, DataURL, LibraryItem } from "../types";
+import type { ValueOf } from "../utility-types";
+import type { FileSystemHandle } from "./filesystem";
+import type { ImportedLibraryData } from "./types";
 export declare const getMimeType: (blob: Blob | string) => string;
 export declare const getFileHandleType: (handle: FileSystemHandle | null) => string | null;
 export declare const isImageFileHandleType: (type: string | null) => type is "png" | "svg";

package/dist/excalidraw/data/filesystem.d.ts

@@ -1,4 +1,5 @@
-import { FileSystemHandle, supported as nativeFileSystemSupported } from "browser-fs-access";
+import type { FileSystemHandle } from "browser-fs-access";
+import { supported as nativeFileSystemSupported } from "browser-fs-access";
 import { MIME_TYPES } from "../constants";
 type FILE_EXTENSION = Exclude<keyof typeof MIME_TYPES, "binary">;
 export declare const fileOpen: <M extends boolean | undefined = false>(opts: {

package/dist/excalidraw/data/index.d.ts

@@ -1,7 +1,7 @@
-import { ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "../element/types";
-import { ExportType } from "../scene/types";
-import { AppState, BinaryFiles } from "../types";
-import { FileSystemHandle } from "./filesystem";
+import type { ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "../element/types";
+import type { ExportType } from "../scene/types";
+import type { AppState, BinaryFiles } from "../types";
+import type { FileSystemHandle } from "./filesystem";
 export { loadFromBlob } from "./blob";
 export { loadFromJSON, saveAsJSON } from "./json";
 export type ExportedElements = readonly NonDeletedExcalidrawElement[] & {

package/dist/excalidraw/data/json.d.ts

@@ -1,6 +1,6 @@
-import { ExcalidrawElement } from "../element/types";
-import { AppState, BinaryFiles, LibraryItems } from "../types";
-import { ImportedDataState, ImportedLibraryData } from "./types";
+import type { ExcalidrawElement } from "../element/types";
+import type { AppState, BinaryFiles, LibraryItems } from "../types";
+import type { ImportedDataState, ImportedLibraryData } from "./types";
 export declare const serializeAsJSON: (elements: readonly ExcalidrawElement[], appState: Partial<AppState>, files: BinaryFiles, type: "local" | "database") => string;
 export declare const saveAsJSON: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles, name?: string) => Promise<{
     fileHandle: import("browser-fs-access").FileSystemHandle | null;

package/dist/excalidraw/data/library.d.ts

@@ -1,7 +1,7 @@
-import { LibraryItems, ExcalidrawImperativeAPI, LibraryItemsSource, LibraryItems_anyVersion } from "../types";
+import type { LibraryItems, ExcalidrawImperativeAPI, LibraryItemsSource, LibraryItems_anyVersion } from "../types";
 import type App from "../components/App";
-import { ExcalidrawElement } from "../element/types";
-import { MaybePromise } from "../utility-types";
+import type { ExcalidrawElement } from "../element/types";
+import type { MaybePromise } from "../utility-types";
 export type LibraryPersistedData = {
     libraryItems: LibraryItems;
 };

package/dist/excalidraw/data/magic.d.ts

@@ -1,6 +1,6 @@
-import { Theme } from "../element/types";
-import { DataURL } from "../types";
-import { OpenAIOutput } from "./ai/types";
+import type { Theme } from "../element/types";
+import type { DataURL } from "../types";
+import type { OpenAIOutput } from "./ai/types";
 export type MagicCacheData = {
     status: "pending";
 } | {

package/dist/excalidraw/data/magic.js

@@ -1,3 +1,4 @@
+import { THEME } from "../constants";
 const SYSTEM_PROMPT = `You are a skilled front-end developer who builds interactive prototypes from wireframes, and is an expert at CSS Grid and Flex design.
 Your role is to transform low-fidelity wireframes into working front-end HTML code.
 
@@ -19,7 +20,7 @@ If the wireframes, diagrams, or text is unclear or unreadable, refer to provided
 Your goal is a production-ready prototype that brings the wireframes to life.
 
 Please output JUST THE HTML file containing your best attempt at implementing the provided wireframes.`;
-export async function diagramToHTML({ image, apiKey, text, theme = "light", }) {
+export async function diagramToHTML({ image, apiKey, text, theme = THEME.LIGHT, }) {
     const body = {
         model: "gpt-4-vision-preview",
         // 4096 are max output tokens allowed for `gpt-4-vision-preview` currently

package/dist/excalidraw/data/reconcile.d.ts

@@ -0,0 +1,6 @@
+import type { OrderedExcalidrawElement } from "../element/types";
+import type { AppState } from "../types";
+import type { MakeBrand } from "../utility-types";
+export type ReconciledExcalidrawElement = OrderedExcalidrawElement & MakeBrand<"ReconciledElement">;
+export type RemoteExcalidrawElement = OrderedExcalidrawElement & MakeBrand<"RemoteExcalidrawElement">;
+export declare const reconcileElements: (localElements: readonly OrderedExcalidrawElement[], remoteElements: readonly RemoteExcalidrawElement[], localAppState: AppState) => ReconciledExcalidrawElement[];

package/dist/excalidraw/data/reconcile.js

@@ -0,0 +1,49 @@
+import { orderByFractionalIndex, syncInvalidIndices } from "../fractionalIndex";
+import { arrayToMap } from "../utils";
+const shouldDiscardRemoteElement = (localAppState, local, remote) => {
+    if (local &&
+        // local element is being edited
+        (local.id === localAppState.editingElement?.id ||
+            local.id === localAppState.resizingElement?.id ||
+            local.id === localAppState.draggingElement?.id || // TODO: Is this still valid? As draggingElement is selection element, which is never part of the elements array
+            // local element is newer
+            local.version > remote.version ||
+            // resolve conflicting edits deterministically by taking the one with
+            // the lowest versionNonce
+            (local.version === remote.version &&
+                local.versionNonce < remote.versionNonce))) {
+        return true;
+    }
+    return false;
+};
+export const reconcileElements = (localElements, remoteElements, localAppState) => {
+    const localElementsMap = arrayToMap(localElements);
+    const reconciledElements = [];
+    const added = new Set();
+    // process remote elements
+    for (const remoteElement of remoteElements) {
+        if (!added.has(remoteElement.id)) {
+            const localElement = localElementsMap.get(remoteElement.id);
+            const discardRemoteElement = shouldDiscardRemoteElement(localAppState, localElement, remoteElement);
+            if (localElement && discardRemoteElement) {
+                reconciledElements.push(localElement);
+                added.add(localElement.id);
+            }
+            else {
+                reconciledElements.push(remoteElement);
+                added.add(remoteElement.id);
+            }
+        }
+    }
+    // process remaining local elements
+    for (const localElement of localElements) {
+        if (!added.has(localElement.id)) {
+            reconciledElements.push(localElement);
+            added.add(localElement.id);
+        }
+    }
+    const orderedElements = orderByFractionalIndex(reconciledElements);
+    // de-duplicate indices
+    syncInvalidIndices(orderedElements);
+    return orderedElements;
+};

package/dist/excalidraw/data/resave.d.ts

@@ -1,5 +1,5 @@
-import { ExcalidrawElement } from "../element/types";
-import { AppState, BinaryFiles } from "../types";
+import type { ExcalidrawElement } from "../element/types";
+import type { AppState, BinaryFiles } from "../types";
 export declare const resaveAsImageWithScene: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles, name: string) => Promise<{
     fileHandle: import("browser-fs-access").FileSystemHandle;
 }>;

package/dist/excalidraw/data/restore.d.ts

@@ -1,17 +1,17 @@
-import { ExcalidrawElement } from "../element/types";
-import { AppState, BinaryFiles, LibraryItem } from "../types";
-import { ImportedDataState } from "./types";
+import type { ExcalidrawElement, OrderedExcalidrawElement } from "../element/types";
+import type { AppState, BinaryFiles, LibraryItem } from "../types";
+import type { ImportedDataState } from "./types";
 type RestoredAppState = Omit<AppState, "offsetTop" | "offsetLeft" | "width" | "height">;
 export declare const AllowedExcalidrawActiveTools: Record<AppState["activeTool"]["type"], boolean>;
 export type RestoredDataState = {
-    elements: ExcalidrawElement[];
+    elements: OrderedExcalidrawElement[];
     appState: RestoredAppState;
     files: BinaryFiles;
 };
 export declare const restoreElements: (elements: ImportedDataState["elements"], localElements: readonly ExcalidrawElement[] | null | undefined, opts?: {
     refreshDimensions?: boolean;
     repairBindings?: boolean;
-} | undefined) => ExcalidrawElement[];
+} | undefined) => OrderedExcalidrawElement[];
 export declare const restoreAppState: (appState: ImportedDataState["appState"], localAppState: Partial<AppState> | null | undefined) => RestoredAppState;
 export declare const restore: (data: Pick<ImportedDataState, "appState" | "elements" | "files"> | null, localAppState: Partial<AppState> | null | undefined, localElements: readonly ExcalidrawElement[] | null | undefined, elementsConfig?: {
     refreshDimensions?: boolean;

package/dist/excalidraw/data/restore.js

@@ -1,7 +1,7 @@
 import { getNonDeletedElements, getNormalizedDimensions, isInvisiblySmallElement, refreshTextDimensions, } from "../element";
 import { isTextElement, isUsingAdaptiveRadius } from "../element/typeChecks";
 import { randomId } from "../random";
-import { DEFAULT_FONT_FAMILY, DEFAULT_TEXT_ALIGN, DEFAULT_VERTICAL_ALIGN, PRECEDING_ELEMENT_KEY, FONT_FAMILY, ROUNDNESS, DEFAULT_SIDEBAR, DEFAULT_ELEMENT_PROPS, } from "../constants";
+import { DEFAULT_FONT_FAMILY, DEFAULT_TEXT_ALIGN, DEFAULT_VERTICAL_ALIGN, FONT_FAMILY, ROUNDNESS, DEFAULT_SIDEBAR, DEFAULT_ELEMENT_PROPS, } from "../constants";
 import { getDefaultAppState } from "../appState";
 import { LinearElementEditor } from "../element/linearElementEditor";
 import { bumpVersion } from "../element/mutateElement";
@@ -9,6 +9,7 @@ import { getUpdatedTimestamp, updateActiveTool } from "../utils";
 import { arrayToMap } from "../utils";
 import { detectLineHeight, getContainerElement, getDefaultLineHeight, } from "../element/textElement";
 import { normalizeLink } from "./url";
+import { syncInvalidIndices } from "../fractionalIndex";
 export const AllowedExcalidrawActiveTools = {
     selection: true,
     text: true,
@@ -46,6 +47,7 @@ const restoreElementWithProperties = (element, extra) => {
         // newly added elements
         version: element.version || 1,
         versionNonce: element.versionNonce ?? 0,
+        index: element.index ?? null,
         isDeleted: element.isDeleted ?? false,
         id: element.id || randomId(),
         fillStyle: element.fillStyle || DEFAULT_ELEMENT_PROPS.fillStyle,
@@ -85,9 +87,6 @@ const restoreElementWithProperties = (element, extra) => {
         base.customData =
             "customData" in extra ? extra.customData : element.customData;
     }
-    if (PRECEDING_ELEMENT_KEY in element) {
-        base[PRECEDING_ELEMENT_KEY] = element[PRECEDING_ELEMENT_KEY];
-    }
     return {
         ...base,
         ...getNormalizedDimensions(base),
@@ -199,7 +198,7 @@ const restoreElement = (element) => {
     return null;
 };
 /**
- * Repairs contaienr element's boundElements array by removing duplicates and
+ * Repairs container element's boundElements array by removing duplicates and
  * fixing containerId of bound elements if not present. Also removes any
  * bound elements that do not exist in the elements array.
  *
@@ -275,7 +274,7 @@ localElements, opts) => {
     // used to detect duplicate top-level element ids
     const existingIds = new Set();
     const localElementsMap = localElements ? arrayToMap(localElements) : null;
-    const restoredElements = (elements || []).reduce((elements, element) => {
+    const restoredElements = syncInvalidIndices((elements || []).reduce((elements, element) => {
         // filtering out selection, which is legacy, no longer kept in elements,
         // and causing issues if retained
         if (element.type !== "selection" && !isInvisiblySmallElement(element)) {
@@ -293,7 +292,7 @@ localElements, opts) => {
             }
         }
         return elements;
-    }, []);
+    }, []));
     if (!opts?.repairBindings) {
         return restoredElements;
     }

package/dist/excalidraw/data/transform.d.ts

@@ -1,6 +1,6 @@
-import { ElementConstructorOpts } from "../element/newElement";
-import { ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawFrameElement, ExcalidrawFreeDrawElement, ExcalidrawGenericElement, ExcalidrawIframeLikeElement, ExcalidrawImageElement, ExcalidrawLinearElement, ExcalidrawMagicFrameElement, ExcalidrawSelectionElement, ExcalidrawTextElement, FileId, FontFamilyValues, TextAlign, VerticalAlign } from "../element/types";
-import { MarkOptional } from "../utility-types";
+import type { ElementConstructorOpts } from "../element/newElement";
+import type { ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawFrameElement, ExcalidrawFreeDrawElement, ExcalidrawGenericElement, ExcalidrawIframeLikeElement, ExcalidrawImageElement, ExcalidrawLinearElement, ExcalidrawMagicFrameElement, ExcalidrawSelectionElement, ExcalidrawTextElement, FileId, FontFamilyValues, TextAlign, VerticalAlign } from "../element/types";
+import type { MarkOptional } from "../utility-types";
 export type ValidLinearElement = {
     type: "arrow" | "line";
     x: number;
@@ -78,4 +78,4 @@ export type ExcalidrawElementSkeleton = Extract<Exclude<ExcalidrawElement, Excal
 } & Partial<ExcalidrawMagicFrameElement>);
 export declare const convertToExcalidrawElements: (elementsSkeleton: ExcalidrawElementSkeleton[] | null, opts?: {
     regenerateIds: boolean;
-}) => ExcalidrawElement[];
+}) => import("../element/types").OrderedExcalidrawElement[];

package/dist/excalidraw/data/transform.js

@@ -3,9 +3,10 @@ import { getCommonBounds, newElement, newLinearElement, redrawTextBoundingBox, }
 import { bindLinearElement } from "../element/binding";
 import { newFrameElement, newImageElement, newMagicFrameElement, newTextElement, } from "../element/newElement";
 import { getDefaultLineHeight, measureText, normalizeText, } from "../element/textElement";
-import { assertNever, cloneJSON, getFontString, toBrandedType } from "../utils";
+import { arrayToMap, assertNever, cloneJSON, getFontString, toBrandedType, } from "../utils";
 import { getSizeFromPoints } from "../points";
 import { randomId } from "../random";
+import { syncInvalidIndices } from "../fractionalIndex";
 const DEFAULT_LINEAR_ELEMENT_PROPS = {
     width: 100,
     height: 0,
@@ -162,6 +163,14 @@ const bindLinearElementToElement = (linearElement, start, end, elementStore, ele
             bindLinearElement(linearElement, endBoundElement, "end", elementsMap);
         }
     }
+    // Safe check to early return for single point
+    if (linearElement.points.length < 2) {
+        return {
+            linearElement,
+            startBoundElement,
+            endBoundElement,
+        };
+    }
     // Update start/end points by 0.5 so bindings don't overlap with start/end bound element coordinates.
     const endPointIndex = linearElement.points.length - 1;
     const delta = 0.5;
@@ -206,10 +215,10 @@ class ElementStore {
         this.excalidrawElements.set(ele.id, ele);
     };
     getElements = () => {
-        return Array.from(this.excalidrawElements.values());
+        return syncInvalidIndices(Array.from(this.excalidrawElements.values()));
     };
     getElementsMap = () => {
-        return toBrandedType(this.excalidrawElements);
+        return toBrandedType(arrayToMap(this.getElements()));
     };
     getElement = (id) => {
         return this.excalidrawElements.get(id);

package/dist/excalidraw/data/types.d.ts

@@ -1,7 +1,7 @@
-import { ExcalidrawElement } from "../element/types";
-import { AppState, BinaryFiles, LibraryItems, LibraryItems_anyVersion } from "../types";
+import type { ExcalidrawElement } from "../element/types";
+import type { AppState, BinaryFiles, LibraryItems, LibraryItems_anyVersion } from "../types";
 import type { cleanAppStateForExport } from "../appState";
-import { VERSIONS } from "../constants";
+import type { VERSIONS } from "../constants";
 export interface ExportedDataState {
     type: string;
     version: number;

package/dist/excalidraw/data/url.d.ts

@@ -1,3 +1,4 @@
+export declare const sanitizeHTMLAttribute: (html: string) => string;
 export declare const normalizeLink: (link: string) => string;
 export declare const isLocalLink: (link: string | null) => boolean;
 /**

package/dist/excalidraw/data/url.js

@@ -1,10 +1,13 @@
 import { sanitizeUrl } from "@braintree/sanitize-url";
+export const sanitizeHTMLAttribute = (html) => {
+    return html.replace(/"/g, """);
+};
 export const normalizeLink = (link) => {
     link = link.trim();
     if (!link) {
         return link;
     }
-    return sanitizeUrl(link);
+    return sanitizeUrl(sanitizeHTMLAttribute(link));
 };
 export const isLocalLink = (link) => {
     return !!(link?.includes(location.origin) || link?.startsWith("/"));

package/dist/excalidraw/element/ElementCanvasButtons.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { ElementsMap, NonDeletedExcalidrawElement } from "./types";
+import type { ElementsMap, NonDeletedExcalidrawElement } from "./types";
 import "./ElementCanvasButtons.scss";
 export declare const ElementCanvasButtons: ({ children, element, elementsMap, }: {
     children: React.ReactNode;

package/dist/excalidraw/element/binding.d.ts

@@ -1,6 +1,6 @@
-import { ExcalidrawLinearElement, ExcalidrawBindableElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawElement, ElementsMap, NonDeletedSceneElementsMap } from "./types";
-import { AppState } from "../types";
-import Scene from "../scene/Scene";
+import type { ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, ExcalidrawLinearElement, NonDeletedExcalidrawElement, ElementsMap, NonDeletedSceneElementsMap } from "./types";
+import type { AppClassProperties, AppState } from "../types";
+import type { ElementUpdate } from "./mutateElement";
 export type SuggestedBinding = NonDeleted<ExcalidrawBindableElement> | SuggestedPointBinding;
 export type SuggestedPointBinding = [
     NonDeleted<ExcalidrawLinearElement>,
@@ -10,18 +10,18 @@ export type SuggestedPointBinding = [
 export declare const shouldEnableBindingForPointerEvent: (event: React.PointerEvent<HTMLElement>) => boolean;
 export declare const isBindingEnabled: (appState: AppState) => boolean;
 export declare const bindOrUnbindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, startBindingElement: ExcalidrawBindableElement | null | "keep", endBindingElement: ExcalidrawBindableElement | null | "keep", elementsMap: NonDeletedSceneElementsMap) => void;
-export declare const bindOrUnbindSelectedElements: (selectedElements: NonDeleted<ExcalidrawElement>[], elements: readonly ExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap) => void;
-export declare const maybeBindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, appState: AppState, scene: Scene, pointerCoords: {
+export declare const bindOrUnbindLinearElements: (selectedElements: NonDeleted<ExcalidrawLinearElement>[], app: AppClassProperties, isBindingEnabled: boolean, draggingPoints: readonly number[] | null) => void;
+export declare const getSuggestedBindingsForArrows: (selectedElements: NonDeleted<ExcalidrawElement>[], app: AppClassProperties) => SuggestedBinding[];
+export declare const maybeBindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, appState: AppState, pointerCoords: {
     x: number;
     y: number;
-}, elementsMap: NonDeletedSceneElementsMap) => void;
+}, app: AppClassProperties) => void;
 export declare const bindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: NonDeletedSceneElementsMap) => void;
 export declare const isLinearElementSimpleAndAlreadyBound: (linearElement: NonDeleted<ExcalidrawLinearElement>, alreadyBoundToId: ExcalidrawBindableElement["id"] | undefined, bindableElement: ExcalidrawBindableElement) => boolean;
-export declare const unbindLinearElements: (elements: NonDeleted<ExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap) => void;
 export declare const getHoveredElementForBinding: (pointerCoords: {
     x: number;
     y: number;
-}, elements: readonly NonDeletedExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap) => NonDeleted<ExcalidrawBindableElement> | null;
+}, app: AppClassProperties) => NonDeleted<ExcalidrawBindableElement> | null;
 export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, elementsMap: ElementsMap, options?: {
     simultaneouslyUpdated?: readonly ExcalidrawElement[];
     newSize?: {
@@ -29,6 +29,47 @@ export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawE
         height: number;
     };
 }) => void;
-export declare const getEligibleElementsForBinding: (selectedElements: NonDeleted<ExcalidrawElement>[], elements: readonly ExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap) => SuggestedBinding[];
 export declare const fixBindingsAfterDuplication: (sceneElements: readonly ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicatesServeAsOld?: "duplicatesServeAsOld" | undefined) => void;
 export declare const fixBindingsAfterDeletion: (sceneElements: readonly ExcalidrawElement[], deletedElements: readonly ExcalidrawElement[]) => void;
+export declare const maxBindingGap: (element: ExcalidrawElement, elementWidth: number, elementHeight: number) => number;
+export declare const bindingProperties: Set<BindableProp | BindingProp>;
+export type BindableProp = "boundElements";
+export type BindingProp = "frameId" | "containerId" | "startBinding" | "endBinding";
+/**
+ * Bound element containing bindings to `frameId`, `containerId`, `startBinding` or `endBinding`.
+ */
+export declare class BoundElement {
+    /**
+     * Unbind the affected non deleted bindable elements (removing element from `boundElements`).
+     * - iterates non deleted bindable elements (`containerId` | `startBinding.elementId` | `endBinding.elementId`) of the current element
+     * - prepares updates to unbind each bindable element's `boundElements` from the current element
+     */
+    static unbindAffected(elements: ElementsMap, boundElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void): void;
+    /**
+     * Rebind the next affected non deleted bindable elements (adding element to `boundElements`).
+     * - iterates non deleted bindable elements (`containerId` | `startBinding.elementId` | `endBinding.elementId`) of the current element
+     * - prepares updates to rebind each bindable element's `boundElements` to the current element
+     *
+     * NOTE: rebind expects that affected elements were previously unbound with `BoundElement.unbindAffected`
+     */
+    static rebindAffected: (elements: ElementsMap, boundElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void) => void;
+}
+/**
+ * Bindable element containing bindings to `boundElements`.
+ */
+export declare class BindableElement {
+    /**
+     * Unbind the affected non deleted bound elements (resetting `containerId`, `startBinding`, `endBinding` to `null`).
+     * - iterates through non deleted `boundElements` of the current element
+     * - prepares updates to unbind each bound element from the current element
+     */
+    static unbindAffected(elements: ElementsMap, bindableElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void): void;
+    /**
+     * Rebind the affected non deleted bound elements (for now setting only `containerId`, as we cannot rebind arrows atm).
+     * - iterates through non deleted `boundElements` of the current element
+     * - prepares updates to rebind each bound element to the current element or unbind it from `boundElements` in case of conflicts
+     *
+     * NOTE: rebind expects that affected elements were previously unbound with `BindaleElement.unbindAffected`
+     */
+    static rebindAffected: (elements: ElementsMap, bindableElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void) => void;
+}