@zsviczian/excalidraw 0.17.1-obsidian-55 → 0.17.1-obsidian-56

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

@@ -1,5 +1,5 @@
-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;
-}>;
+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/types/excalidraw/data/restore.d.ts

@@ -1,21 +1,21 @@
-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: OrderedExcalidrawElement[];
-    appState: RestoredAppState;
-    files: BinaryFiles;
-};
-export declare const restoreElements: (elements: ImportedDataState["elements"], localElements: readonly ExcalidrawElement[] | null | undefined, opts?: {
-    refreshDimensions?: boolean;
-    repairBindings?: boolean;
-} | 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;
-    repairBindings?: boolean;
-}) => RestoredDataState;
-export declare const restoreLibraryItems: (libraryItems: ImportedDataState["libraryItems"], defaultStatus: LibraryItem["status"]) => LibraryItem[];
-export {};
+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: OrderedExcalidrawElement[];
+    appState: RestoredAppState;
+    files: BinaryFiles;
+};
+export declare const restoreElements: (elements: ImportedDataState["elements"], localElements: readonly ExcalidrawElement[] | null | undefined, opts?: {
+    refreshDimensions?: boolean;
+    repairBindings?: boolean;
+} | 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;
+    repairBindings?: boolean;
+}) => RestoredDataState;
+export declare const restoreLibraryItems: (libraryItems: ImportedDataState["libraryItems"], defaultStatus: LibraryItem["status"]) => LibraryItem[];
+export {};

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

@@ -1,81 +1,81 @@
-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;
-    y: number;
-    label?: {
-        text: string;
-        fontSize?: number;
-        fontFamily?: FontFamilyValues;
-        textAlign?: TextAlign;
-        verticalAlign?: VerticalAlign;
-    } & MarkOptional<ElementConstructorOpts, "x" | "y">;
-    end?: (({
-        type: Exclude<ExcalidrawBindableElement["type"], "image" | "text" | "frame" | "magicframe" | "embeddable" | "iframe">;
-        id?: ExcalidrawGenericElement["id"];
-    } | {
-        id: ExcalidrawGenericElement["id"];
-        type?: Exclude<ExcalidrawBindableElement["type"], "image" | "text" | "frame" | "magicframe" | "embeddable" | "iframe">;
-    }) | (({
-        type: "text";
-        text: string;
-    } | {
-        type?: "text";
-        id: ExcalidrawTextElement["id"];
-        text: string;
-    }) & Partial<ExcalidrawTextElement>)) & MarkOptional<ElementConstructorOpts, "x" | "y">;
-    start?: (({
-        type: Exclude<ExcalidrawBindableElement["type"], "image" | "text" | "frame" | "magicframe" | "embeddable" | "iframe">;
-        id?: ExcalidrawGenericElement["id"];
-    } | {
-        id: ExcalidrawGenericElement["id"];
-        type?: Exclude<ExcalidrawBindableElement["type"], "image" | "text" | "frame" | "magicframe" | "embeddable" | "iframe">;
-    }) | (({
-        type: "text";
-        text: string;
-    } | {
-        type?: "text";
-        id: ExcalidrawTextElement["id"];
-        text: string;
-    }) & Partial<ExcalidrawTextElement>)) & MarkOptional<ElementConstructorOpts, "x" | "y">;
-} & Partial<ExcalidrawLinearElement>;
-export type ValidContainer = {
-    type: Exclude<ExcalidrawGenericElement["type"], "selection">;
-    id?: ExcalidrawGenericElement["id"];
-    label?: {
-        text: string;
-        fontSize?: number;
-        fontFamily?: FontFamilyValues;
-        textAlign?: TextAlign;
-        verticalAlign?: VerticalAlign;
-    } & MarkOptional<ElementConstructorOpts, "x" | "y">;
-} & ElementConstructorOpts;
-export type ExcalidrawElementSkeleton = Extract<Exclude<ExcalidrawElement, ExcalidrawSelectionElement>, ExcalidrawIframeLikeElement | ExcalidrawFreeDrawElement> | ({
-    type: Extract<ExcalidrawLinearElement["type"], "line">;
-    x: number;
-    y: number;
-} & Partial<ExcalidrawLinearElement>) | ValidContainer | ValidLinearElement | ({
-    type: "text";
-    text: string;
-    x: number;
-    y: number;
-    id?: ExcalidrawTextElement["id"];
-} & Partial<ExcalidrawTextElement>) | ({
-    type: Extract<ExcalidrawImageElement["type"], "image">;
-    x: number;
-    y: number;
-    fileId: FileId;
-} & Partial<ExcalidrawImageElement>) | ({
-    type: "frame";
-    children: readonly ExcalidrawElement["id"][];
-    name?: string;
-} & Partial<ExcalidrawFrameElement>) | ({
-    type: "magicframe";
-    children: readonly ExcalidrawElement["id"][];
-    name?: string;
-} & Partial<ExcalidrawMagicFrameElement>);
-export declare const convertToExcalidrawElements: (elementsSkeleton: ExcalidrawElementSkeleton[] | null, opts?: {
-    regenerateIds: boolean;
-}) => import("../element/types").OrderedExcalidrawElement[];
+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;
+    y: number;
+    label?: {
+        text: string;
+        fontSize?: number;
+        fontFamily?: FontFamilyValues;
+        textAlign?: TextAlign;
+        verticalAlign?: VerticalAlign;
+    } & MarkOptional<ElementConstructorOpts, "x" | "y">;
+    end?: (({
+        type: Exclude<ExcalidrawBindableElement["type"], "image" | "text" | "frame" | "magicframe" | "embeddable" | "iframe">;
+        id?: ExcalidrawGenericElement["id"];
+    } | {
+        id: ExcalidrawGenericElement["id"];
+        type?: Exclude<ExcalidrawBindableElement["type"], "image" | "text" | "frame" | "magicframe" | "embeddable" | "iframe">;
+    }) | (({
+        type: "text";
+        text: string;
+    } | {
+        type?: "text";
+        id: ExcalidrawTextElement["id"];
+        text: string;
+    }) & Partial<ExcalidrawTextElement>)) & MarkOptional<ElementConstructorOpts, "x" | "y">;
+    start?: (({
+        type: Exclude<ExcalidrawBindableElement["type"], "image" | "text" | "frame" | "magicframe" | "embeddable" | "iframe">;
+        id?: ExcalidrawGenericElement["id"];
+    } | {
+        id: ExcalidrawGenericElement["id"];
+        type?: Exclude<ExcalidrawBindableElement["type"], "image" | "text" | "frame" | "magicframe" | "embeddable" | "iframe">;
+    }) | (({
+        type: "text";
+        text: string;
+    } | {
+        type?: "text";
+        id: ExcalidrawTextElement["id"];
+        text: string;
+    }) & Partial<ExcalidrawTextElement>)) & MarkOptional<ElementConstructorOpts, "x" | "y">;
+} & Partial<ExcalidrawLinearElement>;
+export type ValidContainer = {
+    type: Exclude<ExcalidrawGenericElement["type"], "selection">;
+    id?: ExcalidrawGenericElement["id"];
+    label?: {
+        text: string;
+        fontSize?: number;
+        fontFamily?: FontFamilyValues;
+        textAlign?: TextAlign;
+        verticalAlign?: VerticalAlign;
+    } & MarkOptional<ElementConstructorOpts, "x" | "y">;
+} & ElementConstructorOpts;
+export type ExcalidrawElementSkeleton = Extract<Exclude<ExcalidrawElement, ExcalidrawSelectionElement>, ExcalidrawIframeLikeElement | ExcalidrawFreeDrawElement> | ({
+    type: Extract<ExcalidrawLinearElement["type"], "line">;
+    x: number;
+    y: number;
+} & Partial<ExcalidrawLinearElement>) | ValidContainer | ValidLinearElement | ({
+    type: "text";
+    text: string;
+    x: number;
+    y: number;
+    id?: ExcalidrawTextElement["id"];
+} & Partial<ExcalidrawTextElement>) | ({
+    type: Extract<ExcalidrawImageElement["type"], "image">;
+    x: number;
+    y: number;
+    fileId: FileId;
+} & Partial<ExcalidrawImageElement>) | ({
+    type: "frame";
+    children: readonly ExcalidrawElement["id"][];
+    name?: string;
+} & Partial<ExcalidrawFrameElement>) | ({
+    type: "magicframe";
+    children: readonly ExcalidrawElement["id"][];
+    name?: string;
+} & Partial<ExcalidrawMagicFrameElement>);
+export declare const convertToExcalidrawElements: (elementsSkeleton: ExcalidrawElementSkeleton[] | null, opts?: {
+    regenerateIds: boolean;
+}) => import("../element/types").OrderedExcalidrawElement[];

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

@@ -1,45 +1,45 @@
-import type { ExcalidrawElement } from "../element/types";
-import type { AppState, BinaryFiles, LibraryItems, LibraryItems_anyVersion } from "../types";
-import type { cleanAppStateForExport } from "../appState";
-import type { VERSIONS } from "../constants";
-export interface ExportedDataState {
-    type: string;
-    version: number;
-    source: string;
-    elements: readonly ExcalidrawElement[];
-    appState: ReturnType<typeof cleanAppStateForExport>;
-    files: BinaryFiles | undefined;
-}
-/**
- * Map of legacy AppState keys, with values of:
- *  [<legacy type>, <new AppState proeprty>]
- *
- * This is a helper type used in downstream abstractions.
- * Don't consume on its own.
- */
-export type LegacyAppState = {
-    /** @deprecated #6213 TODO remove 23-06-01 */
-    isSidebarDocked: [boolean, "defaultSidebarDockedPreference"];
-};
-export interface ImportedDataState {
-    type?: string;
-    version?: number;
-    source?: string;
-    elements?: readonly ExcalidrawElement[] | null;
-    appState?: Readonly<Partial<AppState & {
-        [T in keyof LegacyAppState]: LegacyAppState[T][0];
-    }>> | null;
-    scrollToContent?: boolean;
-    libraryItems?: LibraryItems_anyVersion;
-    files?: BinaryFiles;
-}
-export interface ExportedLibraryData {
-    type: string;
-    version: typeof VERSIONS.excalidrawLibrary;
-    source: string;
-    libraryItems: LibraryItems;
-}
-export interface ImportedLibraryData extends Partial<ExportedLibraryData> {
-    /** @deprecated v1 */
-    library?: LibraryItems;
-}
+import type { ExcalidrawElement } from "../element/types";
+import type { AppState, BinaryFiles, LibraryItems, LibraryItems_anyVersion } from "../types";
+import type { cleanAppStateForExport } from "../appState";
+import type { VERSIONS } from "../constants";
+export interface ExportedDataState {
+    type: string;
+    version: number;
+    source: string;
+    elements: readonly ExcalidrawElement[];
+    appState: ReturnType<typeof cleanAppStateForExport>;
+    files: BinaryFiles | undefined;
+}
+/**
+ * Map of legacy AppState keys, with values of:
+ *  [<legacy type>, <new AppState proeprty>]
+ *
+ * This is a helper type used in downstream abstractions.
+ * Don't consume on its own.
+ */
+export type LegacyAppState = {
+    /** @deprecated #6213 TODO remove 23-06-01 */
+    isSidebarDocked: [boolean, "defaultSidebarDockedPreference"];
+};
+export interface ImportedDataState {
+    type?: string;
+    version?: number;
+    source?: string;
+    elements?: readonly ExcalidrawElement[] | null;
+    appState?: Readonly<Partial<AppState & {
+        [T in keyof LegacyAppState]: LegacyAppState[T][0];
+    }>> | null;
+    scrollToContent?: boolean;
+    libraryItems?: LibraryItems_anyVersion;
+    files?: BinaryFiles;
+}
+export interface ExportedLibraryData {
+    type: string;
+    version: typeof VERSIONS.excalidrawLibrary;
+    source: string;
+    libraryItems: LibraryItems;
+}
+export interface ImportedLibraryData extends Partial<ExportedLibraryData> {
+    /** @deprecated v1 */
+    library?: LibraryItems;
+}

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

@@ -1,8 +1,8 @@
-export declare const sanitizeHTMLAttribute: (html: string) => string;
-export declare const normalizeLink: (link: string) => string;
-export declare const isLocalLink: (link: string | null) => boolean;
-/**
- * Returns URL sanitized and safe for usage in places such as
- * iframe's src attribute or <a> href attributes.
- */
-export declare const toValidURL: (link: string) => string;
+export declare const sanitizeHTMLAttribute: (html: string) => string;
+export declare const normalizeLink: (link: string) => string;
+export declare const isLocalLink: (link: string | null) => boolean;
+/**
+ * Returns URL sanitized and safe for usage in places such as
+ * iframe's src attribute or <a> href attributes.
+ */
+export declare const toValidURL: (link: string) => string;

package/types/excalidraw/deburr.d.ts

@@ -1 +1 @@
-export declare const deburr: (str: string) => string;
+export declare const deburr: (str: string) => string;

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

@@ -1,2 +1,2 @@
-export = __WEBPACK_EXTERNAL_MODULE_react_dom__;
-export = __WEBPACK_EXTERNAL_MODULE_react_dom__;
+export = __WEBPACK_EXTERNAL_MODULE_react_dom__;
+export = __WEBPACK_EXTERNAL_MODULE_react_dom__;

package/types/excalidraw/dist/excalidraw.production.min.d.ts

@@ -1 +1 @@
-export const ExcalidrawLib: {};
+export const ExcalidrawLib: {};

package/types/excalidraw/distribute.d.ts

@@ -1,6 +1,6 @@
-import type { ElementsMap, ExcalidrawElement } from "./element/types";
-export interface Distribution {
-    space: "between";
-    axis: "x" | "y";
-}
-export declare const distributeElements: (selectedElements: ExcalidrawElement[], elementsMap: ElementsMap, distribution: Distribution) => ExcalidrawElement[];
+import type { ElementsMap, ExcalidrawElement } from "./element/types";
+export interface Distribution {
+    space: "between";
+    axis: "x" | "y";
+}
+export declare const distributeElements: (selectedElements: ExcalidrawElement[], elementsMap: ElementsMap, distribution: Distribution) => ExcalidrawElement[];

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

@@ -1,7 +1,7 @@
-import type { ElementsMap, NonDeletedExcalidrawElement } from "./types";
-import "./ElementCanvasButtons.scss";
-export declare const ElementCanvasButtons: ({ children, element, elementsMap, }: {
-    children: React.ReactNode;
-    element: NonDeletedExcalidrawElement;
-    elementsMap: ElementsMap;
-}) => JSX.Element | null;
+import type { ElementsMap, NonDeletedExcalidrawElement } from "./types";
+import "./ElementCanvasButtons.scss";
+export declare const ElementCanvasButtons: ({ children, element, elementsMap, }: {
+    children: React.ReactNode;
+    element: NonDeletedExcalidrawElement;
+    elementsMap: ElementsMap;
+}) => JSX.Element | null;

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

@@ -1,99 +1,99 @@
-import type { ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, ExcalidrawLinearElement, NonDeletedExcalidrawElement, ElementsMap, NonDeletedSceneElementsMap, OrderedExcalidrawElement, ExcalidrawElbowArrowElement, FixedPoint, SceneElementsMap } from "./types";
-import type { Bounds } from "./bounds";
-import type { AppState } from "../types";
-import type { ElementUpdate } from "./mutateElement";
-import type Scene from "../scene/Scene";
-import { type Heading } from "./heading";
-import type { LocalPoint } from "../../math";
-import { type GlobalPoint } from "../../math";
-export type SuggestedBinding = NonDeleted<ExcalidrawBindableElement> | SuggestedPointBinding;
-export type SuggestedPointBinding = [
-    NonDeleted<ExcalidrawLinearElement>,
-    "start" | "end" | "both",
-    NonDeleted<ExcalidrawBindableElement>
-];
-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 bindOrUnbindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, startBindingElement: ExcalidrawBindableElement | null | "keep", endBindingElement: ExcalidrawBindableElement | null | "keep", elementsMap: NonDeletedSceneElementsMap, scene: Scene) => void;
-export declare const bindOrUnbindLinearElements: (selectedElements: NonDeleted<ExcalidrawLinearElement>[], elementsMap: NonDeletedSceneElementsMap, elements: readonly NonDeletedExcalidrawElement[], scene: Scene, isBindingEnabled: boolean, draggingPoints: readonly number[] | null) => void;
-export declare const getSuggestedBindingsForArrows: (selectedElements: NonDeleted<ExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap) => SuggestedBinding[];
-export declare const maybeBindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, appState: AppState, pointerCoords: {
-    x: number;
-    y: number;
-}, elementsMap: NonDeletedSceneElementsMap, elements: readonly NonDeletedExcalidrawElement[]) => 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 getHoveredElementForBinding: (pointerCoords: {
-    x: number;
-    y: number;
-}, elements: readonly NonDeletedExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap, fullShape?: boolean) => NonDeleted<ExcalidrawBindableElement> | null;
-export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, options?: {
-    simultaneouslyUpdated?: readonly ExcalidrawElement[];
-    oldSize?: {
-        width: number;
-        height: number;
-    };
-    changedElements?: Map<string, OrderedExcalidrawElement>;
-}) => void;
-export declare const getHeadingForElbowArrowSnap: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined | null, aabb: Bounds | undefined | null, elementsMap: ElementsMap, origPoint: GlobalPoint) => Heading;
-export declare const bindPointToSnapToElementOutline: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined, elementsMap: ElementsMap) => GlobalPoint;
-export declare const avoidRectangularCorner: (element: ExcalidrawBindableElement, p: GlobalPoint) => GlobalPoint;
-export declare const snapToMid: (element: ExcalidrawBindableElement, p: GlobalPoint, tolerance?: number) => GlobalPoint;
-export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => {
-    fixedPoint: FixedPoint;
-};
-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 bindingBorderTest: (element: NonDeleted<ExcalidrawBindableElement>, { x, y }: {
-    x: number;
-    y: number;
-}, elementsMap: NonDeletedSceneElementsMap, fullShape?: boolean) => boolean;
-export declare const maxBindingGap: (element: ExcalidrawElement, elementWidth: number, elementHeight: number) => number;
-export declare const distanceToBindableElement: (element: ExcalidrawBindableElement, point: GlobalPoint, elementsMap: ElementsMap) => number;
-export declare const determineFocusDistance: (element: ExcalidrawBindableElement, a: GlobalPoint, b: GlobalPoint, elementsMap: ElementsMap) => number;
-export declare const intersectElementWithLine: (element: ExcalidrawBindableElement, a: GlobalPoint, b: GlobalPoint, gap: number | undefined, elementsMap: ElementsMap) => GlobalPoint[] | undefined;
-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;
-}
-export declare const getGlobalFixedPointForBindableElement: (fixedPointRatio: [number, number], element: ExcalidrawBindableElement) => 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;
+import type { ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, ExcalidrawLinearElement, NonDeletedExcalidrawElement, ElementsMap, NonDeletedSceneElementsMap, OrderedExcalidrawElement, ExcalidrawElbowArrowElement, FixedPoint, SceneElementsMap } from "./types";
+import type { Bounds } from "./bounds";
+import type { AppState } from "../types";
+import type { ElementUpdate } from "./mutateElement";
+import type Scene from "../scene/Scene";
+import { type Heading } from "./heading";
+import type { LocalPoint } from "../../math";
+import { type GlobalPoint } from "../../math";
+export type SuggestedBinding = NonDeleted<ExcalidrawBindableElement> | SuggestedPointBinding;
+export type SuggestedPointBinding = [
+    NonDeleted<ExcalidrawLinearElement>,
+    "start" | "end" | "both",
+    NonDeleted<ExcalidrawBindableElement>
+];
+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 bindOrUnbindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, startBindingElement: ExcalidrawBindableElement | null | "keep", endBindingElement: ExcalidrawBindableElement | null | "keep", elementsMap: NonDeletedSceneElementsMap, scene: Scene) => void;
+export declare const bindOrUnbindLinearElements: (selectedElements: NonDeleted<ExcalidrawLinearElement>[], elementsMap: NonDeletedSceneElementsMap, elements: readonly NonDeletedExcalidrawElement[], scene: Scene, isBindingEnabled: boolean, draggingPoints: readonly number[] | null) => void;
+export declare const getSuggestedBindingsForArrows: (selectedElements: NonDeleted<ExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap) => SuggestedBinding[];
+export declare const maybeBindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, appState: AppState, pointerCoords: {
+    x: number;
+    y: number;
+}, elementsMap: NonDeletedSceneElementsMap, elements: readonly NonDeletedExcalidrawElement[]) => 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 getHoveredElementForBinding: (pointerCoords: {
+    x: number;
+    y: number;
+}, elements: readonly NonDeletedExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap, fullShape?: boolean) => NonDeleted<ExcalidrawBindableElement> | null;
+export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, options?: {
+    simultaneouslyUpdated?: readonly ExcalidrawElement[];
+    oldSize?: {
+        width: number;
+        height: number;
+    };
+    changedElements?: Map<string, OrderedExcalidrawElement>;
+}) => void;
+export declare const getHeadingForElbowArrowSnap: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined | null, aabb: Bounds | undefined | null, elementsMap: ElementsMap, origPoint: GlobalPoint) => Heading;
+export declare const bindPointToSnapToElementOutline: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined, elementsMap: ElementsMap) => GlobalPoint;
+export declare const avoidRectangularCorner: (element: ExcalidrawBindableElement, p: GlobalPoint) => GlobalPoint;
+export declare const snapToMid: (element: ExcalidrawBindableElement, p: GlobalPoint, tolerance?: number) => GlobalPoint;
+export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => {
+    fixedPoint: FixedPoint;
+};
+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 bindingBorderTest: (element: NonDeleted<ExcalidrawBindableElement>, { x, y }: {
+    x: number;
+    y: number;
+}, elementsMap: NonDeletedSceneElementsMap, fullShape?: boolean) => boolean;
+export declare const maxBindingGap: (element: ExcalidrawElement, elementWidth: number, elementHeight: number) => number;
+export declare const distanceToBindableElement: (element: ExcalidrawBindableElement, point: GlobalPoint, elementsMap: ElementsMap) => number;
+export declare const determineFocusDistance: (element: ExcalidrawBindableElement, a: GlobalPoint, b: GlobalPoint, elementsMap: ElementsMap) => number;
+export declare const intersectElementWithLine: (element: ExcalidrawBindableElement, a: GlobalPoint, b: GlobalPoint, gap: number | undefined, elementsMap: ElementsMap) => GlobalPoint[] | undefined;
+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;
+}
+export declare const getGlobalFixedPointForBindableElement: (fixedPointRatio: [number, number], element: ExcalidrawBindableElement) => 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;