@excalidraw/excalidraw 0.17.1-7441-4e2c539 → 0.17.1-a38e82f

package/dist/excalidraw/data/index.js

@@ -1,15 +1,15 @@
 import { copyBlobToClipboardAsPng, copyTextToSystemClipboard, } from "../clipboard";
-import { DEFAULT_EXPORT_PADDING, isFirefox, MIME_TYPES } from "../constants";
+import { DEFAULT_EXPORT_PADDING, DEFAULT_FILENAME, isFirefox, MIME_TYPES, } from "../constants";
 import { getNonDeletedElements } from "../element";
 import { isFrameLikeElement } from "../element/typeChecks";
 import { t } from "../i18n";
-import { elementsOverlappingBBox } from "../../utils/export";
 import { isSomeElementSelected, getSelectedElements } from "../scene";
 import { exportToCanvas, exportToSvg } from "../scene/export";
 import { cloneJSON } from "../utils";
 import { canvasToBlob } from "./blob";
 import { fileSave } from "./filesystem";
 import { serializeAsJSON } from "./json";
+import { getElementsOverlappingFrame } from "../frame";
 export { loadFromBlob } from "./blob";
 export { loadFromJSON, saveAsJSON } from "./json";
 export const prepareElementsForExport = (elements, { selectedElementIds }, exportSelectionOnly) => {
@@ -26,11 +26,7 @@ export const prepareElementsForExport = (elements, { selectedElementIds }, expor
         if (exportedElements.length === 1 &&
             isFrameLikeElement(exportedElements[0])) {
             exportingFrame = exportedElements[0];
-            exportedElements = elementsOverlappingBBox({
-                elements,
-                bounds: exportingFrame,
-                type: "overlap",
-            });
+            exportedElements = getElementsOverlappingFrame(elements, exportingFrame);
         }
         else if (exportedElements.length > 1) {
             exportedElements = getSelectedElements(elements, { selectedElementIds }, {
@@ -44,12 +40,12 @@ export const prepareElementsForExport = (elements, { selectedElementIds }, expor
         exportedElements: cloneJSON(exportedElements),
     };
 };
-export const exportCanvas = async (type, elements, appState, files, { exportBackground, exportPadding = DEFAULT_EXPORT_PADDING, viewBackgroundColor, name, fileHandle = null, exportingFrame = null, }) => {
+export const exportCanvas = async (type, elements, appState, files, { exportBackground, exportPadding = DEFAULT_EXPORT_PADDING, viewBackgroundColor, name = appState.name || DEFAULT_FILENAME, fileHandle = null, exportingFrame = null, }) => {
     if (elements.length === 0) {
         throw new Error(t("alerts.cannotExportEmptyCanvas"));
     }
     if (type === "svg" || type === "clipboard-svg") {
-        const tempSvg = await exportToSvg(elements, {
+        const svgPromise = exportToSvg(elements, {
             exportBackground,
             exportWithDarkMode: appState.exportWithDarkMode,
             viewBackgroundColor,
@@ -58,7 +54,9 @@ export const exportCanvas = async (type, elements, appState, files, { exportBack
             exportEmbedScene: appState.exportEmbedScene && type === "svg",
         }, files, { exportingFrame });
         if (type === "svg") {
-            return await fileSave(new Blob([tempSvg.outerHTML], { type: MIME_TYPES.svg }), {
+            return fileSave(svgPromise.then((svg) => {
+                return new Blob([svg.outerHTML], { type: MIME_TYPES.svg });
+            }), {
                 description: "Export to SVG",
                 name,
                 extension: appState.exportEmbedScene ? "excalidraw.svg" : "svg",
@@ -66,7 +64,13 @@ export const exportCanvas = async (type, elements, appState, files, { exportBack
             });
         }
         else if (type === "clipboard-svg") {
-            await copyTextToSystemClipboard(tempSvg.outerHTML);
+            const svg = await svgPromise.then((svg) => svg.outerHTML);
+            try {
+                await copyTextToSystemClipboard(svg);
+            }
+            catch (e) {
+                throw new Error(t("errors.copyToSystemClipboardFailed"));
+            }
             return;
         }
     }
@@ -77,14 +81,14 @@ export const exportCanvas = async (type, elements, appState, files, { exportBack
         exportingFrame,
     });
     if (type === "png") {
-        let blob = await canvasToBlob(tempCanvas);
+        let blob = canvasToBlob(tempCanvas);
         if (appState.exportEmbedScene) {
-            blob = await (await import("./image")).encodePngMetadata({
+            blob = blob.then((blob) => import("./image").then(({ encodePngMetadata }) => encodePngMetadata({
                 blob,
                 metadata: serializeAsJSON(elements, appState, files, "local"),
-            });
+            })));
         }
-        return await fileSave(blob, {
+        return fileSave(blob, {
             description: "Export to PNG",
             name,
             // FIXME reintroduce `excalidraw.png` when most people upgrade away
@@ -101,7 +105,7 @@ export const exportCanvas = async (type, elements, appState, files, { exportBack
         catch (error) {
             console.warn(error);
             if (error.name === "CANVAS_POSSIBLY_TOO_BIG") {
-                throw error;
+                throw new Error(t("canvasError.canvasTooBig"));
             }
             // TypeError *probably* suggests ClipboardItem not defined, which
             // people on Firefox can enable through a flag, so let's tell them.

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

@@ -2,7 +2,7 @@ import { ExcalidrawElement } from "../element/types";
 import { AppState, BinaryFiles, LibraryItems } from "../types";
 import { 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) => Promise<{
+export declare const saveAsJSON: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles, name?: string) => Promise<{
     fileHandle: import("browser-fs-access").FileSystemHandle | null;
 }>;
 export declare const loadFromJSON: (localAppState: AppState, localElements: readonly ExcalidrawElement[] | null) => Promise<import("./restore").RestoredDataState>;

package/dist/excalidraw/data/json.js

@@ -1,6 +1,6 @@
 import { fileOpen, fileSave } from "./filesystem";
 import { cleanAppStateForExport, clearAppStateForDatabase } from "../appState";
-import { EXPORT_DATA_TYPES, EXPORT_SOURCE, MIME_TYPES, VERSIONS, } from "../constants";
+import { DEFAULT_FILENAME, EXPORT_DATA_TYPES, EXPORT_SOURCE, MIME_TYPES, VERSIONS, } from "../constants";
 import { clearElementsForDatabase, clearElementsForExport } from "../element";
 import { isImageFileHandle, loadFromBlob, normalizeFile } from "./blob";
 /**
@@ -36,13 +36,15 @@ export const serializeAsJSON = (elements, appState, files, type) => {
     };
     return JSON.stringify(data, null, 2);
 };
-export const saveAsJSON = async (elements, appState, files) => {
+export const saveAsJSON = async (elements, appState, files, 
+/** filename */
+name = appState.name || DEFAULT_FILENAME) => {
     const serialized = serializeAsJSON(elements, appState, files, "local");
     const blob = new Blob([serialized], {
         type: MIME_TYPES.excalidraw,
     });
     const fileHandle = await fileSave(blob, {
-        name: appState.name,
+        name,
         extension: "excalidraw",
         description: "Excalidraw file",
         fileHandle: isImageFileHandle(appState.fileHandle)

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

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

package/dist/excalidraw/data/resave.js

@@ -1,7 +1,7 @@
 import { exportCanvas, prepareElementsForExport } from ".";
 import { getFileHandleType, isImageFileHandleType } from "./blob";
-export const resaveAsImageWithScene = async (elements, appState, files) => {
-    const { exportBackground, viewBackgroundColor, name, fileHandle } = appState;
+export const resaveAsImageWithScene = async (elements, appState, files, name) => {
+    const { exportBackground, viewBackgroundColor, fileHandle } = appState;
     const fileHandleType = getFileHandleType(fileHandle);
     if (!fileHandle || !isImageFileHandleType(fileHandleType)) {
         throw new Error("fileHandle should exist and should be of type svg or png when resaving");

package/dist/excalidraw/data/restore.js

@@ -5,9 +5,9 @@ import { DEFAULT_FONT_FAMILY, DEFAULT_TEXT_ALIGN, DEFAULT_VERTICAL_ALIGN, PRECED
 import { getDefaultAppState } from "../appState";
 import { LinearElementEditor } from "../element/linearElementEditor";
 import { bumpVersion } from "../element/mutateElement";
-import { getFontString, getUpdatedTimestamp, updateActiveTool } from "../utils";
+import { getUpdatedTimestamp, updateActiveTool } from "../utils";
 import { arrayToMap } from "../utils";
-import { detectLineHeight, getDefaultLineHeight, measureBaseline, } from "../element/textElement";
+import { detectLineHeight, getContainerElement, getDefaultLineHeight, } from "../element/textElement";
 import { normalizeLink } from "./url";
 export const AllowedExcalidrawActiveTools = {
     selection: true,
@@ -94,7 +94,7 @@ const restoreElementWithProperties = (element, extra) => {
         ...extra,
     };
 };
-const restoreElement = (element, refreshDimensions = false) => {
+const restoreElement = (element) => {
     switch (element.type) {
         case "text":
             let fontSize = element.fontSize;
@@ -117,7 +117,6 @@ const restoreElement = (element, refreshDimensions = false) => {
                     : // no element height likely means programmatic use, so default
                         // to a fixed line height
                         getDefaultLineHeight(element.fontFamily));
-            const baseline = measureBaseline(element.text, getFontString(element), lineHeight);
             element = restoreElementWithProperties(element, {
                 fontSize,
                 fontFamily,
@@ -127,7 +126,6 @@ const restoreElement = (element, refreshDimensions = false) => {
                 containerId: element.containerId ?? null,
                 originalText: element.originalText || text,
                 lineHeight,
-                baseline,
             });
             // if empty text, mark as deleted. We keep in array
             // for data integrity purposes (collab etc.)
@@ -135,9 +133,6 @@ const restoreElement = (element, refreshDimensions = false) => {
                 element = { ...element, originalText: text, isDeleted: true };
                 element = bumpVersion(element);
             }
-            if (refreshDimensions) {
-                element = { ...element, ...refreshTextDimensions(element) };
-            }
             return element;
         case "freedraw": {
             return restoreElementWithProperties(element, {
@@ -190,11 +185,8 @@ const restoreElement = (element, refreshDimensions = false) => {
         case "rectangle":
         case "diamond":
         case "iframe":
-            return restoreElementWithProperties(element, {});
         case "embeddable":
-            return restoreElementWithProperties(element, {
-                validated: null,
-            });
+            return restoreElementWithProperties(element, {});
         case "magicframe":
         case "frame":
             return restoreElementWithProperties(element, {
@@ -287,7 +279,7 @@ localElements, opts) => {
         // filtering out selection, which is legacy, no longer kept in elements,
         // and causing issues if retained
         if (element.type !== "selection" && !isInvisiblySmallElement(element)) {
-            let migratedElement = restoreElement(element, opts?.refreshDimensions);
+            let migratedElement = restoreElement(element);
             if (migratedElement) {
                 const localElement = localElementsMap?.get(element.id);
                 if (localElement && localElement.version > migratedElement.version) {
@@ -317,6 +309,9 @@ localElements, opts) => {
         else if (element.boundElements) {
             repairContainerElement(element, restoredElementsMap);
         }
+        if (opts.refreshDimensions && isTextElement(element)) {
+            Object.assign(element, refreshTextDimensions(element, getContainerElement(element, restoredElementsMap), restoredElementsMap));
+        }
     }
     return restoredElements;
 };

package/dist/excalidraw/data/transform.js

@@ -3,7 +3,7 @@ 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 } from "../utils";
+import { assertNever, cloneJSON, getFontString, toBrandedType } from "../utils";
 import { getSizeFromPoints } from "../points";
 import { randomId } from "../random";
 const DEFAULT_LINEAR_ELEMENT_PROPS = {
@@ -11,7 +11,7 @@ const DEFAULT_LINEAR_ELEMENT_PROPS = {
     height: 0,
 };
 const DEFAULT_DIMENSION = 100;
-const bindTextToContainer = (container, textProps) => {
+const bindTextToContainer = (container, textProps, elementsMap) => {
     const textElement = newTextElement({
         x: 0,
         y: 0,
@@ -27,10 +27,10 @@ const bindTextToContainer = (container, textProps) => {
             id: textElement.id,
         }),
     });
-    redrawTextBoundingBox(textElement, container);
+    redrawTextBoundingBox(textElement, container, elementsMap);
     return [container, textElement];
 };
-const bindLinearElementToElement = (linearElement, start, end, elementStore) => {
+const bindLinearElementToElement = (linearElement, start, end, elementStore, elementsMap) => {
     let startBoundElement;
     let endBoundElement;
     Object.assign(linearElement, {
@@ -97,7 +97,7 @@ const bindLinearElementToElement = (linearElement, start, end, elementStore) =>
                     }
                 }
             }
-            bindLinearElement(linearElement, startBoundElement, "start");
+            bindLinearElement(linearElement, startBoundElement, "start", elementsMap);
         }
     }
     if (end) {
@@ -159,7 +159,7 @@ const bindLinearElementToElement = (linearElement, start, end, elementStore) =>
                     }
                 }
             }
-            bindLinearElement(linearElement, endBoundElement, "end");
+            bindLinearElement(linearElement, endBoundElement, "end", elementsMap);
         }
     }
     // Update start/end points by 0.5 so bindings don't overlap with start/end bound element coordinates.
@@ -208,6 +208,9 @@ class ElementStore {
     getElements = () => {
         return Array.from(this.excalidrawElements.values());
     };
+    getElementsMap = () => {
+        return toBrandedType(this.excalidrawElements);
+    };
     getElement = (id) => {
         return this.excalidrawElements.get(id);
     };
@@ -337,6 +340,7 @@ export const convertToExcalidrawElements = (elementsSkeleton, opts) => {
             }
         }
     }
+    const elementsMap = elementStore.getElementsMap();
     // Add labels and arrow bindings
     for (const [id, element] of elementsWithIds) {
         const excalidrawElement = elementStore.getElement(id);
@@ -346,7 +350,7 @@ export const convertToExcalidrawElements = (elementsSkeleton, opts) => {
             case "diamond":
             case "arrow": {
                 if (element.label?.text) {
-                    let [container, text] = bindTextToContainer(excalidrawElement, element?.label);
+                    let [container, text] = bindTextToContainer(excalidrawElement, element?.label, elementsMap);
                     elementStore.add(container);
                     elementStore.add(text);
                     if (container.type === "arrow") {
@@ -364,7 +368,7 @@ export const convertToExcalidrawElements = (elementsSkeleton, opts) => {
                                 Object.assign(originalEnd, { id: newEndId });
                             }
                         }
-                        const { linearElement, startBoundElement, endBoundElement } = bindLinearElementToElement(container, originalStart, originalEnd, elementStore);
+                        const { linearElement, startBoundElement, endBoundElement } = bindLinearElementToElement(container, originalStart, originalEnd, elementStore, elementsMap);
                         container = linearElement;
                         elementStore.add(linearElement);
                         elementStore.add(startBoundElement);
@@ -383,7 +387,7 @@ export const convertToExcalidrawElements = (elementsSkeleton, opts) => {
                                 const newEndId = oldToNewElementIdMap.get(end.id);
                                 Object.assign(end, { id: newEndId });
                             }
-                            const { linearElement, startBoundElement, endBoundElement } = bindLinearElementToElement(excalidrawElement, start, end, elementStore);
+                            const { linearElement, startBoundElement, endBoundElement } = bindLinearElementToElement(excalidrawElement, start, end, elementStore, elementsMap);
                             elementStore.add(linearElement);
                             elementStore.add(startBoundElement);
                             elementStore.add(endBoundElement);

package/dist/excalidraw/distribute.d.ts

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

package/dist/excalidraw/distribute.js

@@ -1,12 +1,12 @@
 import { newElementWith } from "./element/mutateElement";
 import { getMaximumGroups } from "./groups";
 import { getCommonBoundingBox } from "./element/bounds";
-export const distributeElements = (selectedElements, distribution) => {
+export const distributeElements = (selectedElements, elementsMap, distribution) => {
     const [start, mid, end, extent] = distribution.axis === "x"
         ? ["minX", "midX", "maxX", "width"]
         : ["minY", "midY", "maxY", "height"];
     const bounds = getCommonBoundingBox(selectedElements);
-    const groups = getMaximumGroups(selectedElements)
+    const groups = getMaximumGroups(selectedElements, elementsMap)
         .map((group) => [group, getCommonBoundingBox(group)])
         .sort((a, b) => a[1][mid] - b[1][mid]);
     let span = 0;

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

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

package/dist/excalidraw/element/ElementCanvasButtons.js

@@ -4,14 +4,14 @@ import { getElementAbsoluteCoords } from ".";
 import { useExcalidrawAppState } from "../components/App";
 import "./ElementCanvasButtons.scss";
 const CONTAINER_PADDING = 5;
-const getContainerCoords = (element, appState) => {
-    const [x1, y1] = getElementAbsoluteCoords(element);
+const getContainerCoords = (element, appState, elementsMap) => {
+    const [x1, y1] = getElementAbsoluteCoords(element, elementsMap);
     const { x: viewportX, y: viewportY } = sceneCoordsToViewportCoords({ sceneX: x1 + element.width, sceneY: y1 }, appState);
     const x = viewportX - appState.offsetLeft + 10;
     const y = viewportY - appState.offsetTop;
     return { x, y };
 };
-export const ElementCanvasButtons = ({ children, element, }) => {
+export const ElementCanvasButtons = ({ children, element, elementsMap, }) => {
     const appState = useExcalidrawAppState();
     if (appState.contextMenu ||
         appState.draggingElement ||
@@ -21,7 +21,7 @@ export const ElementCanvasButtons = ({ children, element, }) => {
         appState.viewModeEnabled) {
         return null;
     }
-    const { x, y } = getContainerCoords(element, appState);
+    const { x, y } = getContainerCoords(element, appState, elementsMap);
     return (_jsx("div", { className: "excalidraw-canvas-buttons", style: {
             top: `${y}px`,
             left: `${x}px`,

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

@@ -1,4 +1,4 @@
-import { ExcalidrawLinearElement, ExcalidrawBindableElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawElement } from "./types";
+import { ExcalidrawLinearElement, ExcalidrawBindableElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawElement, ElementsMap, NonDeletedSceneElementsMap } from "./types";
 import { AppState } from "../types";
 import Scene from "../scene/Scene";
 export type SuggestedBinding = NonDeleted<ExcalidrawBindableElement> | SuggestedPointBinding;
@@ -9,26 +9,26 @@ 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") => void;
-export declare const bindOrUnbindSelectedElements: (elements: NonDeleted<ExcalidrawElement>[]) => void;
+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: {
     x: number;
     y: number;
-}) => void;
-export declare const bindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end") => void;
+}, elementsMap: NonDeletedSceneElementsMap) => 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>[]) => void;
+export declare const unbindLinearElements: (elements: NonDeleted<ExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap) => void;
 export declare const getHoveredElementForBinding: (pointerCoords: {
     x: number;
     y: number;
-}, scene: Scene) => NonDeleted<ExcalidrawBindableElement> | null;
-export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, options?: {
+}, elements: readonly NonDeletedExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap) => NonDeleted<ExcalidrawBindableElement> | null;
+export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, elementsMap: ElementsMap, options?: {
     simultaneouslyUpdated?: readonly ExcalidrawElement[];
     newSize?: {
         width: number;
         height: number;
     };
 }) => void;
-export declare const getEligibleElementsForBinding: (elements: NonDeleted<ExcalidrawElement>[]) => SuggestedBinding[];
+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;