@excalidraw/excalidraw 0.18.0-9036812b6 → 0.18.0-9ba0f5d

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

@@ -1,4 +1,5 @@
-import type { ExcalidrawElement, OrderedExcalidrawElement } from "@excalidraw/element/types";
+import { type CombineBrandsIfNeeded } from "@excalidraw/common";
+import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawSelectionElement, OrderedExcalidrawElement } from "@excalidraw/element/types";
 import type { AppState, BinaryFiles, LibraryItem } from "../types";
 import type { ImportedDataState } from "./types";
 type RestoredAppState = Omit<AppState, "offsetTop" | "offsetLeft" | "width" | "height">;
@@ -8,14 +9,33 @@ export type RestoredDataState = {
     appState: RestoredAppState;
     files: BinaryFiles;
 };
-export declare const restoreElements: (elements: ImportedDataState["elements"], localElements: readonly ExcalidrawElement[] | null | undefined, opts?: {
+export declare const restoreElement: (
+/** element to be restored */
+element: Exclude<ExcalidrawElement, ExcalidrawSelectionElement>, 
+/** all elements to be restored */
+targetElementsMap: Readonly<ElementsMap>, 
+/** used for additional context */
+existingElementsMap: Readonly<ElementsMap> | null | undefined, opts?: {
+    deleteInvisibleElements?: boolean;
+}) => typeof element | null;
+export declare const restoreElements: <T extends ExcalidrawElement>(targetElements: readonly T[] | undefined | null, 
+/** used for additional context (e.g. repairing arrow bindings) */
+existingElements: Readonly<ElementsMapOrArray> | null | undefined, opts?: {
     refreshDimensions?: boolean;
     repairBindings?: boolean;
-} | undefined) => OrderedExcalidrawElement[];
+    deleteInvisibleElements?: boolean;
+} | undefined) => CombineBrandsIfNeeded<T, OrderedExcalidrawElement>;
+/**
+ * When replacing elements that may exist locally, this bumps their versions
+ * to the local version + 1. Mainly for later reconciliation to work properly.
+ *
+ * See https://github.com/excalidraw/excalidraw/issues/3795
+ *
+ * Generally use this on editor boundaries (importing from file etc.), though
+ * it does not apply universally (e.g. we don't want to do this for collab
+ * updates).
+ */
+export declare const bumpElementVersions: <T extends ExcalidrawElement>(targetElements: readonly T[], localElements: Readonly<ElementsMapOrArray> | null | undefined) => T[];
 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/dist/types/excalidraw/data/types.d.ts

@@ -1,7 +1,7 @@
 import type { VERSIONS } from "@excalidraw/common";
 import type { ExcalidrawElement } from "@excalidraw/element/types";
 import type { cleanAppStateForExport } from "../appState";
-import type { AppState, BinaryFiles, LibraryItems, LibraryItems_anyVersion } from "../types";
+import type { AppState, BinaryFiles, LibraryItem, LibraryItems, LibraryItems_anyVersion } from "../types";
 export interface ExportedDataState {
     type: string;
     version: number;
@@ -43,3 +43,6 @@ export interface ImportedLibraryData extends Partial<ExportedLibraryData> {
     /** @deprecated v1 */
     library?: LibraryItems;
 }
+export type ExcalidrawLibraryIds = {
+    itemIds: LibraryItem["id"][];
+};

package/dist/types/excalidraw/editor-jotai.d.ts

@@ -7,8 +7,8 @@ export declare const useAtom: typeof import("jotai").useAtom, useSetAtom: typeof
         set: <Value_1, Args extends unknown[], Result>(atom: WritableAtom<Value_1, Args, Result>, ...args: Args) => Result;
         sub: (atom: import("jotai").Atom<unknown>, listener: () => void) => () => void;
     } | ({
-        get: <Value_2>(atom: import("jotai").Atom<Value_2>) => Value_2;
-        set: <Value_1_1, Args_1 extends unknown[], Result_1>(atom: WritableAtom<Value_1_1, Args_1, Result_1>, ...args: Args_1) => Result_1;
+        get: <Value>(atom: import("jotai").Atom<Value>) => Value;
+        set: <Value_1, Args extends unknown[], Result>(atom: WritableAtom<Value_1, Args, Result>, ...args: Args) => Result;
         sub: (atom: import("jotai").Atom<unknown>, listener: () => void) => () => void;
     } & {
         dev4_get_internal_weak_map: () => WeakMap<import("jotai").Atom<unknown>, {
@@ -19,21 +19,21 @@ export declare const useAtom: typeof import("jotai").useAtom, useSetAtom: typeof
                 readonly l: Set<() => void>;
                 readonly d: Set<import("jotai").Atom<unknown>>;
                 readonly t: Set<import("jotai").Atom<unknown>>;
-                u?: (() => void) | undefined;
-            } | undefined;
+                u?: () => void;
+            };
             v?: unknown;
             e?: unknown;
         }>;
         dev4_get_mounted_atoms: () => Set<import("jotai").Atom<unknown>>;
         dev4_restore_atoms: (values: Iterable<readonly [import("jotai").Atom<unknown>, unknown]>) => void;
-    }) | undefined;
+    });
 } | undefined) => {
-    get: <Value_3>(atom: import("jotai").Atom<Value_3>) => Value_3;
-    set: <Value_1_2, Args_2 extends unknown[], Result_2>(atom: WritableAtom<Value_1_2, Args_2, Result_2>, ...args: Args_2) => Result_2;
+    get: <Value>(atom: import("jotai").Atom<Value>) => Value;
+    set: <Value_1, Args extends unknown[], Result>(atom: WritableAtom<Value_1, Args, Result>, ...args: Args) => Result;
     sub: (atom: import("jotai").Atom<unknown>, listener: () => void) => () => void;
 } | ({
-    get: <Value_4>(atom: import("jotai").Atom<Value_4>) => Value_4;
-    set: <Value_1_3, Args_3 extends unknown[], Result_3>(atom: WritableAtom<Value_1_3, Args_3, Result_3>, ...args: Args_3) => Result_3;
+    get: <Value>(atom: import("jotai").Atom<Value>) => Value;
+    set: <Value_1, Args extends unknown[], Result>(atom: WritableAtom<Value_1, Args, Result>, ...args: Args) => Result;
     sub: (atom: import("jotai").Atom<unknown>, listener: () => void) => () => void;
 } & {
     dev4_get_internal_weak_map: () => WeakMap<import("jotai").Atom<unknown>, {
@@ -44,8 +44,8 @@ export declare const useAtom: typeof import("jotai").useAtom, useSetAtom: typeof
             readonly l: Set<() => void>;
             readonly d: Set<import("jotai").Atom<unknown>>;
             readonly t: Set<import("jotai").Atom<unknown>>;
-            u?: (() => void) | undefined;
-        } | undefined;
+            u?: () => void;
+        };
         v?: unknown;
         e?: unknown;
     }>;

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

@@ -26,4 +26,18 @@ export declare class WorkerInTheMainChunkError extends Error {
 export declare class ExcalidrawError extends Error {
     constructor(message: string);
 }
+export declare class RequestError extends Error {
+    status: number;
+    data: any;
+    toObject(): {
+        name: string;
+        status: number;
+        message: string;
+    };
+    constructor({ message, status, data, }?: {
+        message?: string;
+        status?: number;
+        data?: any;
+    });
+}
 export {};

package/dist/types/excalidraw/hooks/useLibraryItemSvg.d.ts

@@ -3,7 +3,7 @@ export type SvgCache = Map<LibraryItem["id"], SVGSVGElement>;
 export declare const libraryItemSvgsCache: import("jotai/vanilla/atom").PrimitiveAtom<SvgCache> & {
     init: SvgCache;
 };
-export declare const useLibraryItemSvg: (id: LibraryItem["id"] | null, elements: LibraryItem["elements"] | undefined, svgCache: SvgCache) => SVGSVGElement | undefined;
+export declare const useLibraryItemSvg: (id: LibraryItem["id"] | null, elements: LibraryItem["elements"] | undefined, svgCache: SvgCache, ref: React.RefObject<HTMLDivElement | null>) => SVGSVGElement | undefined;
 export declare const useLibraryCache: () => {
     clearLibraryCache: () => void;
     deleteItemsFromLibraryCache: (items: LibraryItem["id"][]) => void;

package/dist/types/excalidraw/hooks/useOutsideClick.d.ts

@@ -1,7 +1,8 @@
-/// <reference types="react" />
 export declare function useOutsideClick<T extends HTMLElement>(ref: React.RefObject<T | null>, 
 /** if performance is of concern, memoize the callback */
-callback: (event: Event) => void, 
+callback: (event: Event & {
+    target: T;
+}) => void, 
 /**
  * Optional callback which is called on every click.
  *
@@ -14,7 +15,7 @@ callback: (event: Event) => void,
  * Returning `undefined` will fallback to the default behavior.
  */
 isInside?: (event: Event & {
-    target: HTMLElement;
+    target: T;
 }, 
 /** the element of the passed ref */
 container: T) => boolean | undefined): void;

package/dist/types/excalidraw/hooks/useScrollPosition.d.ts

@@ -1,2 +1 @@
-/// <reference types="react" />
-export declare const useScrollPosition: <T extends HTMLElement>(elementRef: import("react").RefObject<T | null>) => number;
+export declare const useScrollPosition: <T extends HTMLElement>(elementRef: React.RefObject<T | null>) => number;

package/dist/types/excalidraw/hooks/useTextEditorFocus.d.ts

@@ -0,0 +1,14 @@
+export type CaretPosition = {
+    start: number;
+    end: number;
+};
+export declare const saveCaretPosition: () => CaretPosition | null;
+export declare const restoreCaretPosition: (position: CaretPosition | null) => void;
+export declare const withCaretPositionPreservation: (callback: () => void, isCompactMode: boolean, isEditingText: boolean, onPreventClose?: () => void) => void;
+export declare const useTextEditorFocus: () => {
+    saveCaretPosition: () => void;
+    restoreCaretPosition: () => void;
+    clearSavedPosition: () => void;
+    hasSavedPosition: boolean;
+};
+export declare const temporarilyDisableTextEditorBlur: (duration?: number) => void;

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

@@ -15,10 +15,10 @@ export declare const setLanguage: (lang: Language) => Promise<void>;
 export declare const getLanguage: () => Language;
 export declare const t: (path: NestedKeyOf<typeof fallbackLangData>, replacement?: {
     [key: string]: string | number;
-} | null | undefined, fallback?: string) => string;
+} | null, fallback?: string) => string;
 export declare const useI18n: () => {
     t: (path: NestedKeyOf<typeof fallbackLangData>, replacement?: {
         [key: string]: string | number;
-    } | null | undefined, fallback?: string) => string;
+    } | null, fallback?: string) => string;
     langCode: string;
 };

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

@@ -12,34 +12,33 @@ export { getSceneVersion, hashElementsVersion, hashString, getNonDeletedElements
 export { getTextFromElements } from "@excalidraw/element";
 export { isInvisiblySmallElement } from "@excalidraw/element";
 export { defaultLang, useI18n, languages } from "./i18n";
-export { restore, restoreAppState, restoreElements, restoreLibraryItems, } from "./data/restore";
+export { restoreAppState, restoreElement, restoreElements, restoreLibraryItems, } from "./data/restore";
 export { reconcileElements } from "./data/reconcile";
 export { exportToCanvas, exportToBlob, exportToSvg, exportToClipboard, } from "@excalidraw/utils/export";
 export { serializeAsJSON, serializeLibraryAsJSON } from "./data/json";
 export { loadFromBlob, loadSceneOrLibraryFromBlob, loadLibraryFromBlob, } from "./data/blob";
-export { getFreeDrawSvgPath } from "@excalidraw/element";
 export { mergeLibraryItems, getLibraryItemsHash } from "./data/library";
 export { isLinearElement } from "@excalidraw/element";
-export { FONT_FAMILY, THEME, MIME_TYPES, ROUNDNESS, DEFAULT_LASER_COLOR, UserIdleState, normalizeLink, } from "@excalidraw/common";
+export { FONT_FAMILY, THEME, MIME_TYPES, ROUNDNESS, DEFAULT_LASER_COLOR, UserIdleState, normalizeLink, sceneCoordsToViewportCoords, viewportCoordsToSceneCoords, getFormFactor, } from "@excalidraw/common";
 export { mutateElement, newElementWith, bumpVersion, } from "@excalidraw/element";
 export { CaptureUpdateAction } from "@excalidraw/element";
 export { parseLibraryTokensFromUrl, useHandleLibrary } from "./data/library";
-export { sceneCoordsToViewportCoords, viewportCoordsToSceneCoords, } from "@excalidraw/common";
 export { Sidebar } from "./components/Sidebar/Sidebar";
 export { Button } from "./components/Button";
 export { Footer };
 export { MainMenu };
 export { Ellipsify } from "./components/Ellipsify";
-export { useDevice } from "./components/App";
+export { useEditorInterface, useStylesPanelMode } from "./components/App";
 export { WelcomeScreen };
 export { LiveCollaborationTrigger };
 export { Stats } from "./components/Stats";
 export { DefaultSidebar } from "./components/DefaultSidebar";
 export { TTDDialog } from "./components/TTDDialog/TTDDialog";
 export { TTDDialogTrigger } from "./components/TTDDialog/TTDDialogTrigger";
+export { TTDStreamFetch } from "./components/TTDDialog/utils/TTDStreamFetch";
+export type { TTDPersistenceAdapter, SavedChat, SavedChats, } from "./components/TTDDialog/types";
 export { zoomToFitBounds } from "./actions/actionCanvas";
-export { convertToExcalidrawElements } from "./data/transform";
-export { getCommonBounds, getVisibleSceneBounds } from "@excalidraw/element";
+export { getCommonBounds, getVisibleSceneBounds, convertToExcalidrawElements, } from "@excalidraw/element";
 export { elementsOverlappingBBox, isElementInsideBBox, elementPartiallyOverlapsWithOrContainsBBox, } from "@excalidraw/utils/withinBounds";
 export { DiagramToCodePlugin } from "./components/DiagramToCodePlugin/DiagramToCodePlugin";
 export { getDataURL } from "./data/blob";

package/dist/types/excalidraw/renderer/animation.d.ts

@@ -0,0 +1,12 @@
+export type Animation<R extends object> = (params: {
+    deltaTime: number;
+    state?: R;
+}) => R | null | undefined;
+export declare class AnimationController {
+    private static isRunning;
+    private static animations;
+    static start<R extends object>(key: string, animation: Animation<R>): void;
+    private static tick;
+    static running(key: string): boolean;
+    static cancel(key: string): void;
+}

package/dist/types/excalidraw/renderer/helpers.d.ts

@@ -1,4 +1,3 @@
-import type { ElementsMap, ExcalidrawDiamondElement, ExcalidrawRectanguloidElement } from "@excalidraw/element/types";
 import type { StaticCanvasRenderConfig } from "../scene/types";
 import type { AppState, StaticCanvasAppState } from "../types";
 export declare const fillCircle: (context: CanvasRenderingContext2D, cx: number, cy: number, radius: number, stroke: boolean, fill?: boolean) => void;
@@ -8,11 +7,10 @@ export declare const bootstrapCanvas: ({ canvas, scale, normalizedWidth, normali
     scale: number;
     normalizedWidth: number;
     normalizedHeight: number;
-    theme?: import("@excalidraw/element/types").Theme | undefined;
-    isExporting?: boolean | undefined;
-    viewBackgroundColor?: string | null | undefined;
+    theme?: AppState["theme"];
+    isExporting?: StaticCanvasRenderConfig["isExporting"];
+    viewBackgroundColor?: StaticCanvasAppState["viewBackgroundColor"];
 }) => CanvasRenderingContext2D;
-export declare const drawHighlightForRectWithRotation: (context: CanvasRenderingContext2D, element: ExcalidrawRectanguloidElement, elementsMap: ElementsMap, padding: number) => void;
-export declare const strokeEllipseWithRotation: (context: CanvasRenderingContext2D, width: number, height: number, cx: number, cy: number, angle: number) => void;
-export declare const strokeRectWithRotation: (context: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, cx: number, cy: number, angle: number, fill?: boolean, radius?: number) => void;
-export declare const drawHighlightForDiamondWithRotation: (context: CanvasRenderingContext2D, padding: number, element: ExcalidrawDiamondElement, elementsMap: ElementsMap) => void;
+export declare const strokeRectWithRotation_simple: (context: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, cx: number, cy: number, angle: number, fill?: boolean, 
+/** should account for zoom */
+radius?: number) => void;

package/dist/types/excalidraw/renderer/interactiveScene.d.ts

@@ -1,20 +1,14 @@
+import { getScrollBars } from "../scene/scrollbars";
 import type { InteractiveSceneRenderConfig, RenderableElementsMap } from "../scene/types";
-/** throttled to animation framerate */
-export declare const renderInteractiveSceneThrottled: {
-    (config: InteractiveSceneRenderConfig): void;
-    flush(): void;
-    cancel(): void;
+declare const _renderInteractiveScene: ({ app, canvas, elementsMap, visibleElements, selectedElements, allElementsMap, scale, appState, renderConfig, editorInterface, animationState, deltaTime, }: InteractiveSceneRenderConfig) => {
+    scrollBars?: ReturnType<typeof getScrollBars>;
+    atLeastOneVisibleElement: boolean;
+    elementsMap: RenderableElementsMap;
+    animationState?: typeof animationState;
 };
 /**
  * Interactive scene is the ui-canvas where we render bounding boxes, selections
  * and other ui stuff.
  */
-export declare const renderInteractiveScene: <U extends ({ canvas, elementsMap, visibleElements, selectedElements, allElementsMap, scale, appState, renderConfig, device, }: InteractiveSceneRenderConfig) => {
-    atLeastOneVisibleElement: boolean;
-    elementsMap: RenderableElementsMap;
-    scrollBars?: undefined;
-} | {
-    scrollBars: import("../scene/types").ScrollBars | undefined;
-    atLeastOneVisibleElement: boolean;
-    elementsMap: RenderableElementsMap;
-}, T extends boolean = false>(renderConfig: InteractiveSceneRenderConfig, throttle?: T | undefined) => T extends true ? void : ReturnType<U>;
+export declare const renderInteractiveScene: <U extends typeof _renderInteractiveScene>(renderConfig: InteractiveSceneRenderConfig) => ReturnType<U>;
+export {};

package/dist/types/excalidraw/scene/Renderer.d.ts

@@ -1,11 +1,14 @@
 import type { ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { Scene } from "@excalidraw/element";
+import type { RenderableElementsMap } from "./types";
 import type { AppState } from "../types";
 export declare class Renderer {
     private scene;
     constructor(scene: Scene);
     getRenderableElements: ((opts: {
-        zoom: AppState["zoom"];
+        zoom: Readonly<{
+            value: import("../types").NormalizedZoomValue;
+        }>;
         offsetLeft: AppState["offsetLeft"];
         offsetTop: AppState["offsetTop"];
         scrollX: AppState["scrollX"];
@@ -18,7 +21,7 @@ export declare class Renderer {
         newElementId: ExcalidrawElement["id"] | undefined;
         sceneNonce: ReturnType<InstanceType<typeof Scene>["getSceneNonce"]>;
     }) => {
-        elementsMap: Map<string, NonDeletedExcalidrawElement> & import("@excalidraw/common/utility-types").MakeBrand<"NonDeletedElementsMap"> & import("@excalidraw/common/utility-types").MakeBrand<"RenderableElementsMap">;
+        elementsMap: RenderableElementsMap;
         visibleElements: readonly NonDeletedExcalidrawElement[];
     }) & {
         clear: () => void;

package/dist/types/excalidraw/scene/export.d.ts

@@ -2,9 +2,9 @@ import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "@e
 import type { AppState, BinaryFiles } from "../types";
 export declare const exportToCanvas: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, exportingFrame, }: {
     exportBackground: boolean;
-    exportPadding?: number | undefined;
+    exportPadding?: number;
     viewBackgroundColor: string;
-    exportingFrame?: ExcalidrawFrameLikeElement | null | undefined;
+    exportingFrame?: ExcalidrawFrameLikeElement | null;
 }, createCanvas?: (width: number, height: number) => {
     canvas: HTMLCanvasElement;
     scale: number;

package/dist/types/excalidraw/scene/scroll.d.ts

@@ -7,12 +7,7 @@ export declare const centerScrollOn: ({ scenePoint, viewportDimensions, zoom, of
         width: number;
     };
     zoom: Zoom;
-    offsets?: Partial<{
-        top: number;
-        right: number;
-        bottom: number;
-        left: number;
-    }> | undefined;
+    offsets?: Offsets;
 }) => {
     scrollX: number;
     scrollY: number;

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

@@ -1,7 +1,7 @@
-import type { UserIdleState } from "@excalidraw/common";
+import type { UserIdleState, EditorInterface } from "@excalidraw/common";
 import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
 import type { MakeBrand } from "@excalidraw/common/utility-types";
-import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, Device, PendingExcalidrawElements } from "../types";
+import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, PendingExcalidrawElements } from "../types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
 import type { Drawable } from "roughjs/bin/core";
 export type RenderableElementsMap = NonDeletedElementsMap & MakeBrand<"RenderableElementsMap">;
@@ -15,6 +15,7 @@ export type StaticCanvasRenderConfig = {
     embedsValidationStatus: EmbedsValidationStatus;
     elementsPendingErasure: ElementsPendingErasure;
     pendingFlowchartNodes: PendingExcalidrawElements | null;
+    theme: AppState["theme"];
 };
 export type SVGRenderConfig = {
     offsetX: number;
@@ -32,6 +33,7 @@ export type SVGRenderConfig = {
      * @default true
      */
     reuseImages: boolean;
+    theme: AppState["theme"];
 };
 export type InteractiveCanvasRenderConfig = {
     remoteSelectedElementIds: Map<ExcalidrawElement["id"], SocketId[]>;
@@ -43,6 +45,10 @@ export type InteractiveCanvasRenderConfig = {
     remotePointerUsernames: Map<SocketId, string>;
     remotePointerButton: Map<SocketId, string | undefined>;
     selectionColor: string;
+    lastViewportPosition: {
+        x: number;
+        y: number;
+    };
     renderScrollbars?: boolean;
 };
 export type RenderInteractiveSceneCallback = {
@@ -60,7 +66,13 @@ export type StaticSceneRenderConfig = {
     appState: StaticCanvasAppState;
     renderConfig: StaticCanvasRenderConfig;
 };
+export type InteractiveSceneRenderAnimationState = {
+    bindingHighlight: {
+        runtime: number;
+    } | undefined;
+};
 export type InteractiveSceneRenderConfig = {
+    app: AppClassProperties;
     canvas: HTMLCanvasElement | null;
     elementsMap: RenderableElementsMap;
     visibleElements: readonly NonDeletedExcalidrawElement[];
@@ -69,8 +81,10 @@ export type InteractiveSceneRenderConfig = {
     scale: number;
     appState: InteractiveCanvasAppState;
     renderConfig: InteractiveCanvasRenderConfig;
-    device: Device;
+    editorInterface: EditorInterface;
     callback: (data: RenderInteractiveSceneCallback) => void;
+    animationState?: InteractiveSceneRenderAnimationState;
+    deltaTime: number;
 };
 export type NewElementSceneRenderConfig = {
     canvas: HTMLCanvasElement | null;
@@ -103,14 +117,17 @@ export type ScrollBars = {
         deltaMultiplier: number;
     } | null;
 };
-export type ElementShape = Drawable | Drawable[] | null;
+export type SVGPathString = string & {
+    __brand: "SVGPathString";
+};
+export type ElementShape = Drawable | Drawable[] | Path2D | (Drawable | SVGPathString)[] | null;
 export type ElementShapes = {
     rectangle: Drawable;
     ellipse: Drawable;
     diamond: Drawable;
     iframe: Drawable;
     embeddable: Drawable;
-    freedraw: Drawable | null;
+    freedraw: (Drawable | SVGPathString)[];
     arrow: Drawable[];
     line: Drawable[];
     text: null;

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

@@ -0,0 +1 @@
+export declare const getShortcutKey: (shortcut: string) => string;

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

@@ -1,6 +1,6 @@
 import { type GlobalPoint } from "@excalidraw/math";
 import type { InclusiveRange } from "@excalidraw/math";
-import type { Bounds } from "@excalidraw/element";
+import type { Bounds } from "@excalidraw/common";
 import type { MaybeTransformHandleType } from "@excalidraw/element";
 import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { AppClassProperties, AppState, KeyboardModifiersObject } from "./types";
@@ -70,9 +70,9 @@ export declare const isSnappingEnabled: ({ event, app, selectedElements, }: {
 }) => boolean;
 export declare const areRoughlyEqual: (a: number, b: number, precision?: number) => boolean;
 export declare const getElementsCorners: (elements: ExcalidrawElement[], elementsMap: ElementsMap, { omitCenter, boundingBoxCorners, dragOffset, }?: {
-    omitCenter?: boolean | undefined;
-    boundingBoxCorners?: boolean | undefined;
-    dragOffset?: Vector2D | undefined;
+    omitCenter?: boolean;
+    boundingBoxCorners?: boolean;
+    dragOffset?: Vector2D;
 }) => GlobalPoint[];
 export declare const getVisibleGaps: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => {
     horizontalGaps: Gap[];
@@ -107,5 +107,5 @@ export declare const getSnapLinesAtPointer: (elements: readonly ExcalidrawElemen
     };
     snapLines: PointerSnapLine[];
 };
-export declare const isActiveToolNonLinearSnappable: (activeToolType: AppState["activeTool"]["type"]) => boolean;
+export declare const isActiveToolNonLinearSnappable: (activeToolType: AppState["activeTool"]["type"]) => activeToolType is "text" | "rectangle" | "diamond" | "ellipse" | "image" | "frame" | "magicframe";
 export {};

package/dist/types/excalidraw/subset/harfbuzz/harfbuzz-bindings.d.ts

@@ -38,7 +38,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-declare function subset(hbSubsetWasm: any, heapu8: Uint8Array, font: ArrayBuffer, codePoints: ReadonlySet<number>): Uint8Array;
+declare function subset(hbSubsetWasm: any, heapu8: Uint8Array, font: ArrayBuffer, codePoints: ReadonlySet<number>): Uint8Array<ArrayBuffer>;
 declare const _default: {
     subset: typeof subset;
 };

package/dist/types/excalidraw/subset/harfbuzz/harfbuzz-loader.d.ts

@@ -7,7 +7,7 @@
  * In the future consider separating common utils into a separate shared chunk.
  */
 declare const load: () => Promise<{
-    subset: (fontBuffer: ArrayBuffer, codePoints: ReadonlySet<number>) => Uint8Array;
+    subset: (fontBuffer: ArrayBuffer, codePoints: ReadonlySet<number>) => Uint8Array<ArrayBuffer>;
 }>;
 declare const _default: () => ReturnType<typeof load>;
 export default _default;

package/dist/types/excalidraw/subset/harfbuzz/harfbuzz-wasm.d.ts

@@ -1,2 +1,2 @@
-declare const _default: Uint8Array;
+declare const _default: Uint8Array<ArrayBuffer>;
 export default _default;

package/dist/types/excalidraw/subset/woff2/woff2-loader.d.ts

@@ -7,8 +7,8 @@
  * In the future consider separating common utils into a separate shared chunk.
  */
 declare const load: () => Promise<{
-    compress: (buffer: ArrayBuffer) => Uint8Array;
-    decompress: (buffer: ArrayBuffer) => Uint8Array;
+    compress: (buffer: ArrayBuffer) => Uint8Array<ArrayBuffer>;
+    decompress: (buffer: ArrayBuffer) => Uint8Array<ArrayBuffer>;
 }>;
 declare const _default: () => ReturnType<typeof load>;
 export default _default;

package/dist/types/excalidraw/subset/woff2/woff2-wasm.d.ts

@@ -1,2 +1,2 @@
-declare const _default: Uint8Array;
+declare const _default: Uint8Array<ArrayBuffer>;
 export default _default;