@excalidraw/math 0.18.0-d2463f87d

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

@@ -0,0 +1,6 @@
+import type { OrderedExcalidrawElement } from "@excalidraw/element/types";
+import type { MakeBrand } from "@excalidraw/common/utility-types";
+import type { AppState } from "../types";
+export type ReconciledExcalidrawElement = OrderedExcalidrawElement & MakeBrand<"ReconciledElement">;
+export type RemoteExcalidrawElement = OrderedExcalidrawElement & MakeBrand<"RemoteExcalidrawElement">;
+export declare const reconcileElements: (localElements: readonly OrderedExcalidrawElement[], remoteElements: readonly RemoteExcalidrawElement[], localAppState: AppState) => ReconciledExcalidrawElement[];

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

@@ -0,0 +1,5 @@
+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;
+}>;

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

@@ -0,0 +1,21 @@
+import type { ExcalidrawElement, 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">;
+export declare const AllowedExcalidrawActiveTools: Record<AppState["activeTool"]["type"], boolean>;
+export type RestoredDataState = {
+    elements: OrderedExcalidrawElement[];
+    appState: RestoredAppState;
+    files: BinaryFiles;
+};
+export declare const restoreElements: (elements: ImportedDataState["elements"], localElements: readonly ExcalidrawElement[] | null | undefined, opts?: {
+    refreshDimensions?: boolean;
+    repairBindings?: boolean;
+} | undefined) => OrderedExcalidrawElement[];
+export declare const restoreAppState: (appState: ImportedDataState["appState"], localAppState: Partial<AppState> | null | undefined) => RestoredAppState;
+export declare const restore: (data: Pick<ImportedDataState, "appState" | "elements" | "files"> | null, localAppState: Partial<AppState> | null | undefined, localElements: readonly ExcalidrawElement[] | null | undefined, elementsConfig?: {
+    refreshDimensions?: boolean;
+    repairBindings?: boolean;
+}) => RestoredDataState;
+export declare const restoreLibraryItems: (libraryItems: ImportedDataState["libraryItems"], defaultStatus: LibraryItem["status"]) => LibraryItem[];
+export {};

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

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

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

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

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

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

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

@@ -0,0 +1,56 @@
+import { atom, createStore, type PrimitiveAtom, type WritableAtom } from "jotai";
+import { createIsolation } from "jotai-scope";
+export { atom, PrimitiveAtom, WritableAtom };
+export declare const useAtom: typeof import("jotai").useAtom, useSetAtom: typeof import("jotai").useSetAtom, useAtomValue: typeof import("jotai").useAtomValue, useStore: (options?: {
+    store?: {
+        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_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;
+        sub: (atom: import("jotai").Atom<unknown>, listener: () => void) => () => void;
+    } & {
+        dev4_get_internal_weak_map: () => WeakMap<import("jotai").Atom<unknown>, {
+            readonly d: Map<import("jotai").Atom<unknown>, number>;
+            readonly p: Set<import("jotai").Atom<unknown>>;
+            n: number;
+            m?: {
+                readonly l: Set<() => void>;
+                readonly d: Set<import("jotai").Atom<unknown>>;
+                readonly t: Set<import("jotai").Atom<unknown>>;
+                u?: (() => void) | undefined;
+            } | undefined;
+            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;
+    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;
+    sub: (atom: import("jotai").Atom<unknown>, listener: () => void) => () => void;
+} & {
+    dev4_get_internal_weak_map: () => WeakMap<import("jotai").Atom<unknown>, {
+        readonly d: Map<import("jotai").Atom<unknown>, number>;
+        readonly p: Set<import("jotai").Atom<unknown>>;
+        n: number;
+        m?: {
+            readonly l: Set<() => void>;
+            readonly d: Set<import("jotai").Atom<unknown>>;
+            readonly t: Set<import("jotai").Atom<unknown>>;
+            u?: (() => void) | undefined;
+        } | undefined;
+        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;
+});
+export declare const EditorJotaiProvider: ReturnType<typeof createIsolation>["Provider"];
+export declare const editorJotaiStore: ReturnType<typeof createStore>;

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

@@ -0,0 +1,12 @@
+import { AnimatedTrail } from "../animated-trail";
+import type { AnimationFrameHandler } from "../animation-frame-handler";
+import type App from "../components/App";
+export declare class EraserTrail extends AnimatedTrail {
+    private elementsToErase;
+    private groupsToErase;
+    constructor(animationFrameHandler: AnimationFrameHandler, app: App);
+    startPath(x: number, y: number): void;
+    addPointToPath(x: number, y: number, restore?: boolean): string[];
+    private updateElementsToBeErased;
+    endPath(): void;
+}

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

@@ -0,0 +1,29 @@
+type CANVAS_ERROR_NAMES = "CANVAS_ERROR" | "CANVAS_POSSIBLY_TOO_BIG";
+export declare class CanvasError extends Error {
+    constructor(message?: string, name?: CANVAS_ERROR_NAMES);
+}
+export declare class AbortError extends DOMException {
+    constructor(message?: string);
+}
+type ImageSceneDataErrorCode = "IMAGE_NOT_CONTAINS_SCENE_DATA" | "IMAGE_SCENE_DATA_ERROR";
+export declare class ImageSceneDataError extends Error {
+    code: ImageSceneDataErrorCode;
+    constructor(message?: string, code?: ImageSceneDataErrorCode);
+}
+type WorkerErrorCodes = "WORKER_URL_NOT_DEFINED" | "WORKER_IN_THE_MAIN_CHUNK";
+export declare class WorkerUrlNotDefinedError extends Error {
+    code: WorkerErrorCodes;
+    constructor(message?: string, code?: WorkerErrorCodes);
+}
+export declare class WorkerInTheMainChunkError extends Error {
+    code: WorkerErrorCodes;
+    constructor(message?: string, code?: WorkerErrorCodes);
+}
+/**
+ * Use this for generic, handled errors, so you can check against them
+ * and rethrow if needed
+ */
+export declare class ExcalidrawError extends Error {
+    constructor(message: string);
+}
+export {};

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

@@ -0,0 +1,2 @@
+import { type ExcalidrawFontFaceDescriptor } from "../Fonts";
+export declare const CascadiaFontFaces: ExcalidrawFontFaceDescriptor[];

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

@@ -0,0 +1,2 @@
+import { type ExcalidrawFontFaceDescriptor } from "../Fonts";
+export declare const ComicShannsFontFaces: ExcalidrawFontFaceDescriptor[];

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

@@ -0,0 +1,2 @@
+import { type ExcalidrawFontFaceDescriptor } from "../Fonts";
+export declare const EmojiFontFaces: ExcalidrawFontFaceDescriptor[];

package/dist/types/excalidraw/fonts/ExcalidrawFontFace.d.ts

@@ -0,0 +1,25 @@
+type DataURL = string;
+export declare class ExcalidrawFontFace {
+    readonly urls: URL[] | DataURL[];
+    readonly fontFace: FontFace;
+    private static readonly ASSETS_FALLBACK_URL;
+    constructor(family: string, uri: string, descriptors?: FontFaceDescriptors);
+    /**
+     * Generates CSS `@font-face` definition with the (subsetted) font source as a data url for the characters within the unicode range.
+     *
+     * Retrieves `undefined` otherwise.
+     */
+    toCSS(characters: string): Promise<string> | undefined;
+    /**
+     * Tries to fetch woff2 content, based on the registered urls (from first to last, treated as fallbacks).
+     *
+     * @returns base64 with subsetted glyphs based on the passed codepoint, last defined url otherwise
+     */
+    getContent(codePoints: Array<number>): Promise<string>;
+    fetchFont(url: URL | DataURL): Promise<ArrayBuffer>;
+    private getUnicodeRangeRegex;
+    private static createUrls;
+    private static getFormat;
+    private static normalizeBaseUrl;
+}
+export {};

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

@@ -0,0 +1,2 @@
+import { type ExcalidrawFontFaceDescriptor } from "../Fonts";
+export declare const ExcalifontFontFaces: ExcalidrawFontFaceDescriptor[];

package/dist/types/excalidraw/fonts/Fonts.d.ts

@@ -0,0 +1,79 @@
+import { type FontMetadata } from "@excalidraw/common";
+import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { Scene } from "@excalidraw/element";
+import { ExcalidrawFontFace } from "./ExcalidrawFontFace";
+export declare class Fonts {
+    static readonly loadedFontsCache: Set<string>;
+    private static _registered;
+    private static _initialized;
+    static get registered(): Map<number, {
+        metadata: FontMetadata;
+        fontFaces: ExcalidrawFontFace[];
+    }>;
+    get registered(): Map<number, {
+        metadata: FontMetadata;
+        fontFaces: ExcalidrawFontFace[];
+    }>;
+    private readonly scene;
+    constructor(scene: Scene);
+    /**
+     * Get all the font families for the given scene.
+     */
+    getSceneFamilies: () => number[];
+    /**
+     * if we load a (new) font, it's likely that text elements using it have
+     * already been rendered using a fallback font. Thus, we want invalidate
+     * their shapes and rerender. See #637.
+     *
+     * Invalidates text elements and rerenders scene, provided that at least one
+     * of the supplied fontFaces has not already been processed.
+     */
+    onLoaded: (fontFaces: readonly FontFace[]) => void;
+    /**
+     * Load font faces for a given scene and trigger scene update.
+     */
+    loadSceneFonts: () => Promise<FontFace[]>;
+    /**
+     * Load font faces for passed elements - use when the scene is unavailable (i.e. export).
+     */
+    static loadElementsFonts: (elements: readonly ExcalidrawElement[]) => Promise<FontFace[]>;
+    /**
+     * Generate CSS @font-face declarations for the given elements.
+     */
+    static generateFontFaceDeclarations(elements: readonly ExcalidrawElement[]): Promise<string[]>;
+    private static loadFontFaces;
+    private static fontFacesLoader;
+    private static fontFacesStylesGenerator;
+    /**
+     * Register a new font.
+     *
+     * @param family font family
+     * @param metadata font metadata
+     * @param fontFacesDecriptors font faces descriptors
+     */
+    private static register;
+    /**
+     * WARN: should be called just once on init, even across multiple instances.
+     */
+    private static init;
+    /**
+     * Get all the unique font families for the given elements.
+     */
+    private static getUniqueFamilies;
+    /**
+     * Get all the unique characters per font family for the given scene.
+     */
+    private static getCharsPerFamily;
+    /**
+     * Get characters for a given family.
+     */
+    private static getCharacters;
+    /**
+     * Get all registered font families.
+     */
+    private static getAllFamilies;
+}
+export interface ExcalidrawFontFaceDescriptor {
+    uri: string;
+    descriptors?: FontFaceDescriptors;
+}

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

@@ -0,0 +1,2 @@
+import { type ExcalidrawFontFaceDescriptor } from "../Fonts";
+export declare const HelveticaFontFaces: ExcalidrawFontFaceDescriptor[];

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

@@ -0,0 +1,2 @@
+import { type ExcalidrawFontFaceDescriptor } from "../Fonts";
+export declare const LiberationFontFaces: ExcalidrawFontFaceDescriptor[];

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

@@ -0,0 +1,2 @@
+import { type ExcalidrawFontFaceDescriptor } from "../Fonts";
+export declare const LilitaFontFaces: ExcalidrawFontFaceDescriptor[];

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

@@ -0,0 +1,2 @@
+import { type ExcalidrawFontFaceDescriptor } from "../Fonts";
+export declare const NunitoFontFaces: ExcalidrawFontFaceDescriptor[];

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

@@ -0,0 +1,2 @@
+import { type ExcalidrawFontFaceDescriptor } from "../Fonts";
+export declare const VirgilFontFaces: ExcalidrawFontFaceDescriptor[];

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

@@ -0,0 +1,8 @@
+import { type ExcalidrawFontFaceDescriptor } from "../Fonts";
+/**
+ * The original font was modified with the following changes:
+ * - removed non-CJK codepoints
+ * - reduced any Hangul side-bearings to 40%
+ * - centered in width of inproperly centered CJK codepoints
+ */
+export declare const XiaolaiFontFaces: ExcalidrawFontFaceDescriptor[];

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

@@ -0,0 +1 @@
+export * from "./Fonts";

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

@@ -0,0 +1,6 @@
+import type { PointerCoords } from "./types";
+export declare const getCenter: (pointers: Map<number, PointerCoords>) => {
+    x: number;
+    y: number;
+};
+export declare const getDistance: ([a, b]: readonly PointerCoords[]) => number;

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

@@ -0,0 +1,48 @@
+import { Emitter } from "@excalidraw/common";
+import { StoreDelta } from "@excalidraw/element";
+import type { StoreSnapshot, Store } from "@excalidraw/element";
+import type { SceneElementsMap } from "@excalidraw/element/types";
+import type { AppState } from "./types";
+export declare class HistoryDelta extends StoreDelta {
+    /**
+     * Apply the delta to the passed elements and appState, does not modify the snapshot.
+     */
+    applyTo(elements: SceneElementsMap, appState: AppState, snapshot: StoreSnapshot): [SceneElementsMap, AppState, boolean];
+    /**
+     * Overriding once to avoid type casting everywhere.
+     */
+    static calculate(prevSnapshot: StoreSnapshot, nextSnapshot: StoreSnapshot): HistoryDelta;
+    /**
+     * Overriding once to avoid type casting everywhere.
+     */
+    static inverse(delta: StoreDelta): HistoryDelta;
+    /**
+     * Overriding once to avoid type casting everywhere.
+     */
+    static applyLatestChanges(delta: StoreDelta, prevElements: SceneElementsMap, nextElements: SceneElementsMap, modifierOptions?: "deleted" | "inserted"): HistoryDelta;
+}
+export declare class HistoryChangedEvent {
+    readonly isUndoStackEmpty: boolean;
+    readonly isRedoStackEmpty: boolean;
+    constructor(isUndoStackEmpty?: boolean, isRedoStackEmpty?: boolean);
+}
+export declare class History {
+    private readonly store;
+    readonly onHistoryChangedEmitter: Emitter<[HistoryChangedEvent]>;
+    readonly undoStack: HistoryDelta[];
+    readonly redoStack: HistoryDelta[];
+    get isUndoStackEmpty(): boolean;
+    get isRedoStackEmpty(): boolean;
+    constructor(store: Store);
+    clear(): void;
+    /**
+     * Record a non-empty local durable increment, which will go into the undo stack..
+     * Do not re-record history entries, which were already pushed to undo / redo stack, as part of history action.
+     */
+    record(delta: StoreDelta): void;
+    undo(elements: SceneElementsMap, appState: AppState): void | [SceneElementsMap, AppState];
+    redo(elements: SceneElementsMap, appState: AppState): void | [SceneElementsMap, AppState];
+    private perform;
+    private static pop;
+    private static push;
+}

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

@@ -0,0 +1 @@
+export declare const useCallbackRefState: <T>() => readonly [T | null, (value: T | null) => void];

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

@@ -0,0 +1,5 @@
+export declare const useCopyStatus: () => {
+    copyStatus: "success" | null;
+    resetCopyStatus: () => void;
+    onCopy: () => void;
+};

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

@@ -0,0 +1,4 @@
+export declare const useCreatePortalContainer: (opts?: {
+    className?: string;
+    parentSelector?: string;
+}) => HTMLDivElement | null;

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

@@ -0,0 +1,2 @@
+import type { Emitter } from "@excalidraw/common";
+export declare const useEmitter: <TEvent extends unknown>(emitter: Emitter<[TEvent]>, initialState: TEvent) => TEvent;

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

@@ -0,0 +1,11 @@
+import type { LibraryItem } from "../types";
+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 useLibraryCache: () => {
+    clearLibraryCache: () => void;
+    deleteItemsFromLibraryCache: (items: LibraryItem["id"][]) => void;
+    svgCache: SvgCache;
+};

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

@@ -0,0 +1,20 @@
+/// <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, 
+/**
+ * Optional callback which is called on every click.
+ *
+ * Should return `true` if click should be considered as inside the container,
+ * and `false` if it falls outside and should call the `callback`.
+ *
+ * Returning `true` overrides the default behavior and `callback` won't be
+ * called.
+ *
+ * Returning `undefined` will fallback to the default behavior.
+ */
+isInside?: (event: Event & {
+    target: HTMLElement;
+}, 
+/** the element of the passed ref */
+container: T) => boolean | undefined): void;

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

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

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

@@ -0,0 +1 @@
+export declare const useStable: <T extends Record<string, any>>(value: T) => T;

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

@@ -0,0 +1,4 @@
+/**
+ * Returns a stable function of the same type.
+ */
+export declare const useStableCallback: <T extends (...args: any[]) => any>(userFn: T) => T;

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

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const useTransition: typeof React.useTransition;

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

@@ -0,0 +1,24 @@
+import type { NestedKeyOf } from "@excalidraw/common/utility-types";
+import fallbackLangData from "./locales/en.json";
+export interface Language {
+    code: string;
+    label: string;
+    rtl?: boolean;
+}
+export type TranslationKeys = NestedKeyOf<typeof fallbackLangData>;
+export declare const defaultLang: {
+    code: string;
+    label: string;
+};
+export declare const languages: Language[];
+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;
+export declare const useI18n: () => {
+    t: (path: NestedKeyOf<typeof fallbackLangData>, replacement?: {
+        [key: string]: string | number;
+    } | null | undefined, fallback?: string) => string;
+    langCode: string;
+};

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

@@ -0,0 +1,46 @@
+import React from "react";
+import Footer from "./components/footer/FooterCenter";
+import LiveCollaborationTrigger from "./components/live-collaboration/LiveCollaborationTrigger";
+import MainMenu from "./components/main-menu/MainMenu";
+import WelcomeScreen from "./components/welcome-screen/WelcomeScreen";
+import "./css/app.scss";
+import "./css/styles.scss";
+import "./fonts/fonts.css";
+import type { ExcalidrawProps } from "./types";
+export declare const Excalidraw: React.MemoExoticComponent<(props: ExcalidrawProps) => import("react/jsx-runtime").JSX.Element>;
+export { getSceneVersion, hashElementsVersion, hashString, getNonDeletedElements, } from "@excalidraw/element";
+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 { 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 { 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 { useDevice } 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 { zoomToFitBounds } from "./actions/actionCanvas";
+export { convertToExcalidrawElements } from "./data/transform";
+export { getCommonBounds, getVisibleSceneBounds } from "@excalidraw/element";
+export { elementsOverlappingBBox, isElementInsideBBox, elementPartiallyOverlapsWithOrContainsBBox, } from "@excalidraw/utils/withinBounds";
+export { DiagramToCodePlugin } from "./components/DiagramToCodePlugin/DiagramToCodePlugin";
+export { getDataURL } from "./data/blob";
+export { isElementLink } from "@excalidraw/element";
+export { setCustomTextMetricsProvider } from "@excalidraw/element";