@excalidraw/element 0.18.0-d1f3982 → 0.18.0-d9e8a33

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

@@ -74,16 +74,31 @@ declare class Library {
     getLatestLibrary: () => Promise<LibraryItems>;
     updateLibrary: ({ libraryItems, prompt, merge, openLibraryMenu, defaultStatus, }: {
         libraryItems: LibraryItemsSource;
-        merge?: boolean | undefined;
-        prompt?: boolean | undefined;
-        openLibraryMenu?: boolean | undefined;
-        defaultStatus?: "published" | "unpublished" | undefined;
+        merge?: boolean;
+        prompt?: boolean;
+        openLibraryMenu?: boolean;
+        defaultStatus?: "unpublished" | "published";
     }) => Promise<LibraryItems>;
-    setLibrary: (libraryItems: LibraryItems | Promise<LibraryItems> | ((latestLibraryItems: LibraryItems) => LibraryItems | Promise<LibraryItems>)) => Promise<LibraryItems>;
+    setLibrary: (
+    /**
+     * LibraryItems that will replace current items. Can be a function which
+     * will be invoked after all previous tasks are resolved
+     * (this is the prefered way to update the library to avoid race conditions,
+     * but you'll want to manually merge the library items in the callback
+     *  - which is what we're doing in Library.importLibrary()).
+     *
+     * If supplied promise is rejected with AbortError, we swallow it and
+     * do not update the library.
+     */
+    libraryItems: LibraryItems | Promise<LibraryItems> | ((latestLibraryItems: LibraryItems) => LibraryItems | Promise<LibraryItems>)) => Promise<LibraryItems>;
 }
 export default Library;
 export declare const distributeLibraryItemsOnSquareGrid: (libraryItems: LibraryItems) => ExcalidrawElement[];
-export declare const validateLibraryUrl: (libraryUrl: string, validator?: string[] | ((libraryUrl: string) => boolean)) => true;
+export declare const validateLibraryUrl: (libraryUrl: string, 
+/**
+ * @returns `true` if the URL is valid, throws otherwise.
+ */
+validator?: ((libraryUrl: string) => boolean) | string[]) => true;
 export declare const parseLibraryTokensFromUrl: () => {
     libraryUrl: string;
     idToken: string | null;
@@ -95,10 +110,10 @@ export declare const useHandleLibrary: (opts: {
      * Return `true` if the library install url should be allowed.
      * If not supplied, only the excalidraw.com base domain is allowed.
      */
-    validateLibraryUrl?: ((libraryUrl: string) => boolean) | undefined;
+    validateLibraryUrl?: (libraryUrl: string) => boolean;
 } & ({
     /** @deprecated we recommend using `opts.adapter` instead */
-    getInitialLibraryItems?: (() => MaybePromise<LibraryItemsSource>) | undefined;
+    getInitialLibraryItems?: () => MaybePromise<LibraryItemsSource>;
 } | {
     adapter: LibraryPersistenceAdapter;
     /**
@@ -108,5 +123,5 @@ export declare const useHandleLibrary: (opts: {
      *
      * Can be a different LibraryPersistenceAdapter.
      */
-    migrationAdapter?: LibraryMigrationAdapter | undefined;
+    migrationAdapter?: LibraryMigrationAdapter;
 })) => void;

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

@@ -1,5 +1,10 @@
+import type { MaybePromise } from "@excalidraw/common/utility-types";
 import type { ExcalidrawElement } from "@excalidraw/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;
+export declare const resaveAsImageWithScene: (data: MaybePromise<{
+    elements: readonly ExcalidrawElement[];
+    appState: AppState;
+    files: BinaryFiles;
+}>, fileHandle: FileSystemFileHandle, filename: string) => Promise<{
+    fileHandle: FileSystemFileHandle;
 }>;

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

@@ -1,4 +1,5 @@
-import type { ExcalidrawArrowElement, ExcalidrawElement, ExcalidrawLinearElement, ExcalidrawSelectionElement, ExcalidrawTextElement, 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,19 +9,33 @@ export type RestoredDataState = {
     appState: RestoredAppState;
     files: BinaryFiles;
 };
-export declare const restoreElement: (element: Exclude<ExcalidrawElement, ExcalidrawSelectionElement>, 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;
-}) => ExcalidrawLinearElement | import("@excalidraw/element/types").ExcalidrawRectangleElement | import("@excalidraw/element/types").ExcalidrawDiamondElement | import("@excalidraw/element/types").ExcalidrawEllipseElement | import("@excalidraw/element/types").ExcalidrawEmbeddableElement | import("@excalidraw/element/types").ExcalidrawIframeElement | import("@excalidraw/element/types").ExcalidrawImageElement | import("@excalidraw/element/types").ExcalidrawFrameElement | import("@excalidraw/element/types").ExcalidrawMagicFrameElement | ExcalidrawTextElement | import("@excalidraw/element/types").ExcalidrawFreeDrawElement | ExcalidrawArrowElement | null;
-export declare const restoreElements: (elements: ImportedDataState["elements"], localElements: readonly ExcalidrawElement[] | null | undefined, opts?: {
+}) => 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;
     deleteInvisibleElements?: boolean;
-} | undefined) => OrderedExcalidrawElement[];
+} | 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;
-    deleteInvisibleElements?: boolean;
-}) => RestoredDataState;
 export declare const restoreLibraryItems: (libraryItems: ImportedDataState["libraryItems"], defaultStatus: LibraryItem["status"]) => LibraryItem[];
 export {};

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/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/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/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, editorInterface, }: 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("../../common/src/utility-types").MakeBrand<"NonDeletedElementsMap"> & import("../../common/src/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

@@ -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[];
@@ -71,6 +83,8 @@ export type InteractiveSceneRenderConfig = {
     renderConfig: InteractiveCanvasRenderConfig;
     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/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;

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

@@ -0,0 +1,15 @@
+import { type GlobalPoint } from "@excalidraw/math";
+import type { EditorInterface } from "@excalidraw/common";
+import type { ExcalidrawTextElement } from "@excalidraw/element/types";
+export declare const getTextBoxPadding: (zoomValue: number) => number;
+export declare const getTextAutoResizeHandle: (textElement: ExcalidrawTextElement, zoomValue: number, formFactor: EditorInterface["formFactor"]) => {
+    center: GlobalPoint | import("@excalidraw/math").LocalPoint;
+    start: GlobalPoint;
+    end: GlobalPoint;
+    hitboxWidth: number;
+    hitboxHeight: number;
+} | null;
+export declare const isPointHittingTextAutoResizeHandle: (point: Readonly<{
+    x: number;
+    y: number;
+}>, textElement: ExcalidrawTextElement, zoomValue: number, formFactor: EditorInterface["formFactor"]) => boolean;