@excalidraw/excalidraw 0.18.0-c141960 → 0.18.0-c158187

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/restore.d.ts

@@ -1,4 +1,5 @@
-import type { ElementsMap, 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>, elementsMap: Readonly<ElementsMap>, 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: (targetElements: 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/hooks/useOutsideClick.d.ts

@@ -1,4 +1,3 @@
-/// <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 & {
@@ -16,7 +15,7 @@ callback: (event: Event & {
  * 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/index.d.ts

@@ -12,12 +12,11 @@ export { getSceneVersion, hashElementsVersion, hashString, getNonDeletedElements
 export { getTextFromElements } from "@excalidraw/element";
 export { isInvisiblySmallElement } from "@excalidraw/element";
 export { defaultLang, useI18n, languages } from "./i18n";
-export { restore, restoreAppState, restoreElement, 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, sceneCoordsToViewportCoords, viewportCoordsToSceneCoords, getFormFactor, } from "@excalidraw/common";
@@ -37,8 +36,7 @@ export { DefaultSidebar } from "./components/DefaultSidebar";
 export { TTDDialog } from "./components/TTDDialog/TTDDialog";
 export { TTDDialogTrigger } from "./components/TTDDialog/TTDDialogTrigger";
 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/helpers.d.ts

@@ -7,8 +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 strokeRectWithRotation_simple: (context: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, cx: number, cy: number, angle: number, fill?: boolean, radius?: number) => 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,12 +1,14 @@
 import { getScrollBars } from "../scene/scrollbars";
 import type { InteractiveSceneRenderConfig, RenderableElementsMap } from "../scene/types";
+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 ({ app, canvas, elementsMap, visibleElements, selectedElements, allElementsMap, scale, appState, renderConfig, editorInterface, animationState, deltaTime, }: InteractiveSceneRenderConfig) => {
-    scrollBars?: import("../scene/types").ScrollBars | undefined;
-    atLeastOneVisibleElement: boolean;
-    elementsMap: RenderableElementsMap;
-    animationState?: import("../scene/types").InteractiveSceneRenderAnimationState | undefined;
-}>(renderConfig: InteractiveSceneRenderConfig) => 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

@@ -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[]>;
@@ -115,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/types.d.ts

@@ -375,7 +375,7 @@ export type SearchMatch = {
         showOnCanvas: boolean;
     }[];
 };
-export type UIAppState = Omit<AppState, "suggestedBinding" | "startBoundElement" | "cursorButton" | "scrollX" | "scrollY">;
+export type UIAppState = Omit<AppState, "startBoundElement" | "cursorButton" | "scrollX" | "scrollY">;
 export type NormalizedZoomValue = number & {
     _brand: "normalizedZoom";
 };

package/dist/types/excalidraw/wysiwyg/textWysiwyg.d.ts

@@ -9,7 +9,7 @@ export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords,
      * Note: `text`, which can be wrapped and therefore different from `originalText`,
      *       is derived from `originalText`
      */
-    onChange?: ((nextOriginalText: string) => void) | undefined;
+    onChange?: (nextOriginalText: string) => void;
     onSubmit: (data: {
         viaKeyboard: boolean;
         nextOriginalText: string;
@@ -19,6 +19,6 @@ export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords,
     canvas: HTMLCanvasElement;
     excalidrawContainer: HTMLDivElement | null;
     app: App;
-    autoSelect?: boolean | undefined;
+    autoSelect?: boolean;
 }) => SubmitHandler;
 export {};

package/dist/types/math/src/polygon.d.ts

@@ -1,6 +1,6 @@
 import type { GlobalPoint, LocalPoint, Polygon } from "./types";
 export declare function polygon<Point extends GlobalPoint | LocalPoint>(...points: Point[]): Polygon<Point>;
 export declare function polygonFromPoints<Point extends GlobalPoint | LocalPoint>(points: Point[]): Polygon<Point>;
-export declare const polygonIncludesPoint: <Point extends GlobalPoint | LocalPoint>(point: Point, polygon: Polygon<Point>) => boolean;
+export declare const polygonIncludesPoint: <Point extends LocalPoint | GlobalPoint>(point: Point, polygon: Polygon<Point>) => boolean;
 export declare const polygonIncludesPointNonZero: <Point extends [number, number]>(point: Point, polygon: Point[]) => boolean;
-export declare const pointOnPolygon: <Point extends GlobalPoint | LocalPoint>(p: Point, poly: Polygon<Point>, threshold?: number) => boolean;
+export declare const pointOnPolygon: <Point extends LocalPoint | GlobalPoint>(p: Point, poly: Polygon<Point>, threshold?: number) => boolean;

package/dist/types/math/src/range.d.ts

@@ -13,9 +13,7 @@ export declare function rangeInclusive(start: number, end: number): InclusiveRan
  * @param pair The number pair to convert to an inclusive range
  * @returns The new inclusive range
  */
-export declare function rangeInclusiveFromPair(pair: [start: number, end: number]): [number, number] & {
-    _brand: "excalimath_degree";
-};
+export declare function rangeInclusiveFromPair(pair: [start: number, end: number]): InclusiveRange;
 /**
  * Given two ranges, return if the two ranges overlap with each other e.g.
  * [1, 3] overlaps with [2, 4] while [1, 3] does not overlap with [4, 5].

package/dist/types/math/src/segment.d.ts

@@ -21,14 +21,14 @@ export declare const isLineSegment: <Point extends GlobalPoint | LocalPoint>(seg
  * @param origin
  * @returns
  */
-export declare const lineSegmentRotate: <Point extends GlobalPoint | LocalPoint>(l: LineSegment<Point>, angle: Radians, origin?: Point | undefined) => LineSegment<Point>;
+export declare const lineSegmentRotate: <Point extends LocalPoint | GlobalPoint>(l: LineSegment<Point>, angle: Radians, origin?: Point) => LineSegment<Point>;
 /**
  * Calculates the point two line segments with a definite start and end point
  * intersect at.
  */
 export declare const segmentsIntersectAt: <Point extends GlobalPoint | LocalPoint>(a: Readonly<LineSegment<Point>>, b: Readonly<LineSegment<Point>>) => Point | null;
-export declare const pointOnLineSegment: <Point extends GlobalPoint | LocalPoint>(point: Point, line: LineSegment<Point>, threshold?: number) => boolean;
-export declare const distanceToLineSegment: <Point extends GlobalPoint | LocalPoint>(point: Point, line: LineSegment<Point>) => number;
+export declare const pointOnLineSegment: <Point extends LocalPoint | GlobalPoint>(point: Point, line: LineSegment<Point>, threshold?: number) => boolean;
+export declare const distanceToLineSegment: <Point extends LocalPoint | GlobalPoint>(point: Point, line: LineSegment<Point>) => number;
 /**
  * Returns the intersection point of a segment and a line
  *

package/dist/types/utils/src/bbox.d.ts

@@ -1,5 +1,5 @@
 import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
-import type { Bounds } from "@excalidraw/element";
+import type { Bounds } from "@excalidraw/common";
 export type LineSegment<P extends LocalPoint | GlobalPoint> = [P, P];
 export declare function getBBox<P extends LocalPoint | GlobalPoint>(line: LineSegment<P>): Bounds;
 export declare function doBBoxesIntersect(a: Bounds, b: Bounds): boolean;

package/dist/types/utils/src/export.d.ts

@@ -15,7 +15,7 @@ type ExportOpts = {
     };
 };
 export declare const exportToCanvas: ({ elements, appState, files, maxWidthOrHeight, getDimensions, exportPadding, exportingFrame, }: ExportOpts & {
-    exportPadding?: number | undefined;
+    exportPadding?: number;
 }) => Promise<HTMLCanvasElement>;
 export declare const exportToBlob: (opts: ExportOpts & {
     mimeType?: string;
@@ -23,10 +23,10 @@ export declare const exportToBlob: (opts: ExportOpts & {
     exportPadding?: number;
 }) => Promise<Blob>;
 export declare const exportToSvg: ({ elements, appState, files, exportPadding, renderEmbeddables, exportingFrame, skipInliningFonts, reuseImages, }: Omit<ExportOpts, "getDimensions"> & {
-    exportPadding?: number | undefined;
-    renderEmbeddables?: boolean | undefined;
-    skipInliningFonts?: true | undefined;
-    reuseImages?: boolean | undefined;
+    exportPadding?: number;
+    renderEmbeddables?: boolean;
+    skipInliningFonts?: true;
+    reuseImages?: boolean;
 }) => Promise<SVGSVGElement>;
 export declare const exportToClipboard: (opts: ExportOpts & {
     mimeType?: string;

package/dist/types/utils/src/shape.d.ts

@@ -46,13 +46,13 @@ export declare const getClosedCurveShape: <Point extends GlobalPoint | LocalPoin
  * @param gap Optional value to inflate the shape before testing
  * @returns An array of intersections
  */
-export declare const segmentIntersectRectangleElement: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawBindableElement, segment: LineSegment<Point>, gap?: number) => Point[];
-export declare const pointOnEllipse: <Point extends GlobalPoint | LocalPoint>(point: Point, ellipse: Ellipse<Point>, threshold?: number) => boolean;
-export declare const pointInEllipse: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => boolean;
-export declare const ellipseAxes: <Point extends GlobalPoint | LocalPoint>(ellipse: Ellipse<Point>) => {
+export declare const segmentIntersectRectangleElement: <Point extends LocalPoint | GlobalPoint>(element: ExcalidrawBindableElement, segment: LineSegment<Point>, gap?: number) => Point[];
+export declare const pointOnEllipse: <Point extends LocalPoint | GlobalPoint>(point: Point, ellipse: Ellipse<Point>, threshold?: number) => boolean;
+export declare const pointInEllipse: <Point extends LocalPoint | GlobalPoint>(p: Point, ellipse: Ellipse<Point>) => boolean;
+export declare const ellipseAxes: <Point extends LocalPoint | GlobalPoint>(ellipse: Ellipse<Point>) => {
     majorAxis: number;
     minorAxis: number;
 };
-export declare const ellipseFocusToCenter: <Point extends GlobalPoint | LocalPoint>(ellipse: Ellipse<Point>) => number;
-export declare const ellipseExtremes: <Point extends GlobalPoint | LocalPoint>(ellipse: Ellipse<Point>) => import("@excalidraw/math").Vector[];
+export declare const ellipseFocusToCenter: <Point extends LocalPoint | GlobalPoint>(ellipse: Ellipse<Point>) => number;
+export declare const ellipseExtremes: <Point extends LocalPoint | GlobalPoint>(ellipse: Ellipse<Point>) => import("@excalidraw/math").Vector[];
 export {};

package/dist/types/utils/src/withinBounds.d.ts

@@ -1,4 +1,4 @@
-import type { Bounds } from "@excalidraw/element";
+import { type Bounds } from "@excalidraw/common";
 import type { ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 type Element = NonDeletedExcalidrawElement;
 type Elements = readonly NonDeletedExcalidrawElement[];
@@ -8,7 +8,7 @@ export declare const elementsOverlappingBBox: ({ elements, bounds, type, errorMa
     elements: Elements;
     bounds: Bounds | ExcalidrawElement;
     /** safety offset. Defaults to 0. */
-    errorMargin?: number | undefined;
+    errorMargin?: number;
     /**
      * - overlap: elements overlapping or inside bounds
      * - contain: elements inside bounds or bounds inside elements

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@excalidraw/excalidraw",
-  "version": "0.18.0-c141960",
+  "version": "0.18.0-c158187",
   "type": "module",
   "types": "./dist/types/excalidraw/index.d.ts",
   "main": "./dist/prod/index.js",
@@ -79,10 +79,10 @@
   },
   "dependencies": {
     "@braintree/sanitize-url": "6.0.2",
-    "@excalidraw/common": "0.18.0-c141960",
-    "@excalidraw/element": "0.18.0-c141960",
+    "@excalidraw/common": "0.18.0-c158187",
+    "@excalidraw/element": "0.18.0-c158187",
     "@excalidraw/laser-pointer": "1.3.1",
-    "@excalidraw/math": "0.18.0-c141960",
+    "@excalidraw/math": "0.18.0-c158187",
     "@excalidraw/mermaid-to-excalidraw": "1.1.3",
     "@excalidraw/random-username": "1.1.0",
     "@radix-ui/react-popover": "1.1.6",
@@ -133,6 +133,6 @@
     "fonteditor-core": "2.4.1",
     "harfbuzzjs": "0.3.6",
     "jest-diff": "29.7.0",
-    "typescript": "4.9.4"
+    "typescript": "5.9.3"
   }
 }