@zsviczian/excalidraw 0.17.6-5 → 0.17.6-7

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

@@ -1,29 +1,29 @@
-import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "../element/types";
-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;
-    viewBackgroundColor: string;
-    exportingFrame?: ExcalidrawFrameLikeElement | null | undefined;
-}, createCanvas?: (width: number, height: number) => {
-    canvas: HTMLCanvasElement;
-    scale: number;
-}, loadFonts?: () => Promise<void>) => Promise<HTMLCanvasElement>;
-export declare const exportToSvg: (elements: readonly NonDeletedExcalidrawElement[], appState: {
-    exportBackground: boolean;
-    exportPadding?: number;
-    exportScale?: number;
-    viewBackgroundColor: string;
-    exportWithDarkMode?: boolean;
-    exportEmbedScene?: boolean;
-    frameRendering?: AppState["frameRendering"];
-    frameColor?: AppState["frameColor"];
-}, files: BinaryFiles | null, opts?: {
-    /**
-     * if true, all embeddables passed in will be rendered when possible.
-     */
-    renderEmbeddables?: boolean;
-    exportingFrame?: ExcalidrawFrameLikeElement | null;
-    skipInliningFonts?: true;
-}) => Promise<SVGSVGElement>;
-export declare const getExportSize: (elements: readonly NonDeletedExcalidrawElement[], exportPadding: number, scale: number) => [number, number];
+import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "../element/types";
+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;
+    viewBackgroundColor: string;
+    exportingFrame?: ExcalidrawFrameLikeElement | null | undefined;
+}, createCanvas?: (width: number, height: number) => {
+    canvas: HTMLCanvasElement;
+    scale: number;
+}, loadFonts?: () => Promise<void>) => Promise<HTMLCanvasElement>;
+export declare const exportToSvg: (elements: readonly NonDeletedExcalidrawElement[], appState: {
+    exportBackground: boolean;
+    exportPadding?: number;
+    exportScale?: number;
+    viewBackgroundColor: string;
+    exportWithDarkMode?: boolean;
+    exportEmbedScene?: boolean;
+    frameRendering?: AppState["frameRendering"];
+    frameColor?: AppState["frameColor"];
+}, files: BinaryFiles | null, opts?: {
+    /**
+     * if true, all embeddables passed in will be rendered when possible.
+     */
+    renderEmbeddables?: boolean;
+    exportingFrame?: ExcalidrawFrameLikeElement | null;
+    skipInliningFonts?: true;
+}) => Promise<SVGSVGElement>;
+export declare const getExportSize: (elements: readonly NonDeletedExcalidrawElement[], exportPadding: number, scale: number) => [number, number];

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

@@ -1,4 +1,4 @@
-export { isSomeElementSelected, getElementsWithinSelection, getCommonAttributeOfSelectedElements, getSelectedElements, getTargetElements, } from "./selection";
-export { calculateScrollCenter } from "./scroll";
-export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeRoundness, getElementAtPosition, getElementsAtPosition, } from "./comparisons";
-export { getNormalizedZoom, getNormalizedGridSize, getNormalizedGridStep, } from "./normalize";
+export { isSomeElementSelected, getElementsWithinSelection, getCommonAttributeOfSelectedElements, getSelectedElements, getTargetElements, } from "./selection";
+export { calculateScrollCenter } from "./scroll";
+export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeRoundness, getElementAtPosition, getElementsAtPosition, } from "./comparisons";
+export { getNormalizedZoom, getNormalizedGridSize, getNormalizedGridStep, } from "./normalize";

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

@@ -1,4 +1,4 @@
-import type { NormalizedZoomValue } from "../types";
-export declare const getNormalizedZoom: (zoom: number) => NormalizedZoomValue;
-export declare const getNormalizedGridSize: (gridStep: number) => number;
-export declare const getNormalizedGridStep: (gridStep: number) => number;
+import type { NormalizedZoomValue } from "../types";
+export declare const getNormalizedZoom: (zoom: number) => NormalizedZoomValue;
+export declare const getNormalizedGridSize: (gridStep: number) => number;
+export declare const getNormalizedGridStep: (gridStep: number) => number;

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

@@ -1,23 +1,23 @@
-import type { AppState, Offsets, PointerCoords, Zoom } from "../types";
-import type { ExcalidrawElement } from "../element/types";
-export declare const centerScrollOn: ({ scenePoint, viewportDimensions, zoom, offsets, }: {
-    scenePoint: PointerCoords;
-    viewportDimensions: {
-        height: number;
-        width: number;
-    };
-    zoom: Zoom;
-    offsets?: Partial<{
-        top: number;
-        right: number;
-        bottom: number;
-        left: number;
-    }> | undefined;
-}) => {
-    scrollX: number;
-    scrollY: number;
-};
-export declare const calculateScrollCenter: (elements: readonly ExcalidrawElement[], appState: AppState) => {
-    scrollX: number;
-    scrollY: number;
-};
+import type { AppState, Offsets, PointerCoords, Zoom } from "../types";
+import type { ExcalidrawElement } from "../element/types";
+export declare const centerScrollOn: ({ scenePoint, viewportDimensions, zoom, offsets, }: {
+    scenePoint: PointerCoords;
+    viewportDimensions: {
+        height: number;
+        width: number;
+    };
+    zoom: Zoom;
+    offsets?: Partial<{
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    }> | undefined;
+}) => {
+    scrollX: number;
+    scrollY: number;
+};
+export declare const calculateScrollCenter: (elements: readonly ExcalidrawElement[], appState: AppState) => {
+    scrollX: number;
+    scrollY: number;
+};

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

@@ -1,12 +1,12 @@
-import type { InteractiveCanvasAppState } from "../types";
-import type { ScrollBars } from "./types";
-import type { ExcalidrawElement } from "../element/types";
-export declare const SCROLLBAR_MARGIN = 4;
-export declare const SCROLLBAR_WIDTH = 6;
-export declare const SCROLLBAR_COLOR = "rgba(128,128,128,0.3)";
-export declare const getScrollBars: (elements: readonly ExcalidrawElement[], viewportWidth: number, viewportHeight: number, appState: InteractiveCanvasAppState) => ScrollBars;
-export declare const isOverScrollBars: (scrollBars: ScrollBars, x: number, y: number) => {
-    isOverEither: boolean;
-    isOverHorizontal: boolean;
-    isOverVertical: boolean;
-};
+import type { InteractiveCanvasAppState } from "../types";
+import type { ScrollBars } from "./types";
+import type { ExcalidrawElement } from "../element/types";
+export declare const SCROLLBAR_MARGIN = 4;
+export declare const SCROLLBAR_WIDTH = 6;
+export declare const SCROLLBAR_COLOR = "rgba(128,128,128,0.3)";
+export declare const getScrollBars: (elements: readonly ExcalidrawElement[], viewportWidth: number, viewportHeight: number, appState: InteractiveCanvasAppState) => ScrollBars;
+export declare const isOverScrollBars: (scrollBars: ScrollBars, x: number, y: number) => {
+    isOverEither: boolean;
+    isOverHorizontal: boolean;
+    isOverVertical: boolean;
+};

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

@@ -1,32 +1,32 @@
-import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
-import type { AppState, InteractiveCanvasAppState } from "../types";
-/**
- * Frames and their containing elements are not to be selected at the same time.
- * Given an array of selected elements, if there are frames and their containing elements
- * we only keep the frames.
- * @param selectedElements
- */
-export declare const excludeElementsInFramesFromSelection: <T extends ExcalidrawElement>(selectedElements: readonly T[]) => T[];
-export declare const getElementsWithinSelection: (elements: readonly NonDeletedExcalidrawElement[], selection: NonDeletedExcalidrawElement, elementsMap: ElementsMap, excludeElementsInFrames?: boolean) => NonDeletedExcalidrawElement[];
-export declare const getVisibleAndNonSelectedElements: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: readonly NonDeletedExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => NonDeletedExcalidrawElement[];
-export declare const isSomeElementSelected: {
-    (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">): boolean;
-    clearCache(): void;
-};
-/**
- * Returns common attribute (picked by `getAttribute` callback) of selected
- *  elements. If elements don't share the same value, returns `null`.
- */
-export declare const getCommonAttributeOfSelectedElements: <T>(elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">, getAttribute: (element: ExcalidrawElement) => T) => T | null;
-export declare const getSelectedElements: (elements: ElementsMapOrArray, appState: Pick<InteractiveCanvasAppState, "selectedElementIds">, opts?: {
-    includeBoundTextElement?: boolean;
-    includeElementsInFrames?: boolean;
-}) => ExcalidrawElement[];
-export declare const getTargetElements: (elements: ElementsMapOrArray, appState: Pick<AppState, "selectedElementIds" | "editingTextElement" | "newElement">) => ExcalidrawElement[];
-/**
- * returns prevState's selectedElementids if no change from previous, so as to
- * retain reference identity for memoization
- */
-export declare const makeNextSelectedElementIds: (nextSelectedElementIds: AppState["selectedElementIds"], prevState: Pick<AppState, "selectedElementIds">) => Readonly<{
-    [id: string]: true;
-}>;
+import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
+import type { AppState, InteractiveCanvasAppState } from "../types";
+/**
+ * Frames and their containing elements are not to be selected at the same time.
+ * Given an array of selected elements, if there are frames and their containing elements
+ * we only keep the frames.
+ * @param selectedElements
+ */
+export declare const excludeElementsInFramesFromSelection: <T extends ExcalidrawElement>(selectedElements: readonly T[]) => T[];
+export declare const getElementsWithinSelection: (elements: readonly NonDeletedExcalidrawElement[], selection: NonDeletedExcalidrawElement, elementsMap: ElementsMap, excludeElementsInFrames?: boolean) => NonDeletedExcalidrawElement[];
+export declare const getVisibleAndNonSelectedElements: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: readonly NonDeletedExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => NonDeletedExcalidrawElement[];
+export declare const isSomeElementSelected: {
+    (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">): boolean;
+    clearCache(): void;
+};
+/**
+ * Returns common attribute (picked by `getAttribute` callback) of selected
+ *  elements. If elements don't share the same value, returns `null`.
+ */
+export declare const getCommonAttributeOfSelectedElements: <T>(elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">, getAttribute: (element: ExcalidrawElement) => T) => T | null;
+export declare const getSelectedElements: (elements: ElementsMapOrArray, appState: Pick<InteractiveCanvasAppState, "selectedElementIds">, opts?: {
+    includeBoundTextElement?: boolean;
+    includeElementsInFrames?: boolean;
+}) => ExcalidrawElement[];
+export declare const getTargetElements: (elements: ElementsMapOrArray, appState: Pick<AppState, "selectedElementIds" | "editingTextElement" | "newElement">) => ExcalidrawElement[];
+/**
+ * returns prevState's selectedElementids if no change from previous, so as to
+ * retain reference identity for memoization
+ */
+export declare const makeNextSelectedElementIds: (nextSelectedElementIds: AppState["selectedElementIds"], prevState: Pick<AppState, "selectedElementIds">) => Readonly<{
+    [id: string]: true;
+}>;

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

@@ -1,112 +1,112 @@
-import type { RoughCanvas } from "roughjs/bin/canvas";
-import type { Drawable } from "roughjs/bin/core";
-import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "../element/types";
-import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, UserIdleState, Device, PendingExcalidrawElements } from "../types";
-import type { MakeBrand } from "../utility-types";
-export type RenderableElementsMap = NonDeletedElementsMap & MakeBrand<"RenderableElementsMap">;
-export type StaticCanvasRenderConfig = {
-    canvasBackgroundColor: AppState["viewBackgroundColor"];
-    imageCache: AppClassProperties["imageCache"];
-    renderGrid: boolean;
-    /** when exporting the behavior is slightly different (e.g. we can't use
-     CSS filters), and we disable render optimizations for best output */
-    isExporting: boolean;
-    embedsValidationStatus: EmbedsValidationStatus;
-    elementsPendingErasure: ElementsPendingErasure;
-    pendingFlowchartNodes: PendingExcalidrawElements | null;
-    isHighlighterPenDrawing?: boolean;
-};
-export type SVGRenderConfig = {
-    offsetX: number;
-    offsetY: number;
-    isExporting: boolean;
-    exportWithDarkMode: boolean;
-    renderEmbeddables: boolean;
-    frameRendering: AppState["frameRendering"];
-    canvasBackgroundColor: AppState["viewBackgroundColor"];
-    frameColor?: AppState["frameColor"];
-    embedsValidationStatus: EmbedsValidationStatus;
-};
-export type InteractiveCanvasRenderConfig = {
-    remoteSelectedElementIds: Map<ExcalidrawElement["id"], SocketId[]>;
-    remotePointerViewportCoords: Map<SocketId, {
-        x: number;
-        y: number;
-    }>;
-    remotePointerUserStates: Map<SocketId, UserIdleState>;
-    remotePointerUsernames: Map<SocketId, string>;
-    remotePointerButton: Map<SocketId, string | undefined>;
-    selectionColor: string;
-    renderScrollbars?: boolean;
-};
-export type RenderInteractiveSceneCallback = {
-    atLeastOneVisibleElement: boolean;
-    elementsMap: RenderableElementsMap;
-    scrollBars?: ScrollBars;
-};
-export type StaticSceneRenderConfig = {
-    canvas: HTMLCanvasElement;
-    rc: RoughCanvas;
-    elementsMap: RenderableElementsMap;
-    allElementsMap: NonDeletedSceneElementsMap;
-    visibleElements: readonly NonDeletedExcalidrawElement[];
-    scale: number;
-    appState: StaticCanvasAppState;
-    renderConfig: StaticCanvasRenderConfig;
-};
-export type InteractiveSceneRenderConfig = {
-    canvas: HTMLCanvasElement | null;
-    elementsMap: RenderableElementsMap;
-    visibleElements: readonly NonDeletedExcalidrawElement[];
-    selectedElements: readonly NonDeletedExcalidrawElement[];
-    allElementsMap: NonDeletedSceneElementsMap;
-    scale: number;
-    appState: InteractiveCanvasAppState;
-    renderConfig: InteractiveCanvasRenderConfig;
-    device: Device;
-    callback: (data: RenderInteractiveSceneCallback) => void;
-};
-export type NewElementSceneRenderConfig = {
-    canvas: HTMLCanvasElement | null;
-    rc: RoughCanvas;
-    newElement: ExcalidrawElement | null;
-    elementsMap: RenderableElementsMap;
-    allElementsMap: NonDeletedSceneElementsMap;
-    scale: number;
-    appState: AppState;
-    renderConfig: StaticCanvasRenderConfig;
-};
-export type SceneScroll = {
-    scrollX: number;
-    scrollY: number;
-};
-export type ExportType = "png" | "clipboard" | "clipboard-svg" | "backend" | "svg";
-export type ScrollBars = {
-    horizontal: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    } | null;
-    vertical: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    } | null;
-};
-export type ElementShape = Drawable | Drawable[] | null;
-export type ElementShapes = {
-    rectangle: Drawable;
-    ellipse: Drawable;
-    diamond: Drawable;
-    iframe: Drawable;
-    embeddable: Drawable;
-    freedraw: Drawable | null;
-    arrow: Drawable[];
-    line: Drawable[];
-    text: null;
-    image: null;
-    frame: null;
-    magicframe: null;
-};
+import type { RoughCanvas } from "roughjs/bin/canvas";
+import type { Drawable } from "roughjs/bin/core";
+import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "../element/types";
+import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, UserIdleState, Device, PendingExcalidrawElements } from "../types";
+import type { MakeBrand } from "../utility-types";
+export type RenderableElementsMap = NonDeletedElementsMap & MakeBrand<"RenderableElementsMap">;
+export type StaticCanvasRenderConfig = {
+    canvasBackgroundColor: AppState["viewBackgroundColor"];
+    imageCache: AppClassProperties["imageCache"];
+    renderGrid: boolean;
+    /** when exporting the behavior is slightly different (e.g. we can't use
+     CSS filters), and we disable render optimizations for best output */
+    isExporting: boolean;
+    embedsValidationStatus: EmbedsValidationStatus;
+    elementsPendingErasure: ElementsPendingErasure;
+    pendingFlowchartNodes: PendingExcalidrawElements | null;
+    isHighlighterPenDrawing?: boolean;
+};
+export type SVGRenderConfig = {
+    offsetX: number;
+    offsetY: number;
+    isExporting: boolean;
+    exportWithDarkMode: boolean;
+    renderEmbeddables: boolean;
+    frameRendering: AppState["frameRendering"];
+    canvasBackgroundColor: AppState["viewBackgroundColor"];
+    frameColor?: AppState["frameColor"];
+    embedsValidationStatus: EmbedsValidationStatus;
+};
+export type InteractiveCanvasRenderConfig = {
+    remoteSelectedElementIds: Map<ExcalidrawElement["id"], SocketId[]>;
+    remotePointerViewportCoords: Map<SocketId, {
+        x: number;
+        y: number;
+    }>;
+    remotePointerUserStates: Map<SocketId, UserIdleState>;
+    remotePointerUsernames: Map<SocketId, string>;
+    remotePointerButton: Map<SocketId, string | undefined>;
+    selectionColor: string;
+    renderScrollbars?: boolean;
+};
+export type RenderInteractiveSceneCallback = {
+    atLeastOneVisibleElement: boolean;
+    elementsMap: RenderableElementsMap;
+    scrollBars?: ScrollBars;
+};
+export type StaticSceneRenderConfig = {
+    canvas: HTMLCanvasElement;
+    rc: RoughCanvas;
+    elementsMap: RenderableElementsMap;
+    allElementsMap: NonDeletedSceneElementsMap;
+    visibleElements: readonly NonDeletedExcalidrawElement[];
+    scale: number;
+    appState: StaticCanvasAppState;
+    renderConfig: StaticCanvasRenderConfig;
+};
+export type InteractiveSceneRenderConfig = {
+    canvas: HTMLCanvasElement | null;
+    elementsMap: RenderableElementsMap;
+    visibleElements: readonly NonDeletedExcalidrawElement[];
+    selectedElements: readonly NonDeletedExcalidrawElement[];
+    allElementsMap: NonDeletedSceneElementsMap;
+    scale: number;
+    appState: InteractiveCanvasAppState;
+    renderConfig: InteractiveCanvasRenderConfig;
+    device: Device;
+    callback: (data: RenderInteractiveSceneCallback) => void;
+};
+export type NewElementSceneRenderConfig = {
+    canvas: HTMLCanvasElement | null;
+    rc: RoughCanvas;
+    newElement: ExcalidrawElement | null;
+    elementsMap: RenderableElementsMap;
+    allElementsMap: NonDeletedSceneElementsMap;
+    scale: number;
+    appState: AppState;
+    renderConfig: StaticCanvasRenderConfig;
+};
+export type SceneScroll = {
+    scrollX: number;
+    scrollY: number;
+};
+export type ExportType = "png" | "clipboard" | "clipboard-svg" | "backend" | "svg";
+export type ScrollBars = {
+    horizontal: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    vertical: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+};
+export type ElementShape = Drawable | Drawable[] | null;
+export type ElementShapes = {
+    rectangle: Drawable;
+    ellipse: Drawable;
+    diamond: Drawable;
+    iframe: Drawable;
+    embeddable: Drawable;
+    freedraw: Drawable | null;
+    arrow: Drawable[];
+    line: Drawable[];
+    text: null;
+    image: null;
+    frame: null;
+    magicframe: null;
+};

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

@@ -1,12 +1,12 @@
-import type { AppState, NormalizedZoomValue } from "../types";
-export declare const getStateForZoom: ({ viewportX, viewportY, nextZoom, }: {
-    viewportX: number;
-    viewportY: number;
-    nextZoom: NormalizedZoomValue;
-}, appState: AppState) => {
-    scrollX: number;
-    scrollY: number;
-    zoom: {
-        value: NormalizedZoomValue;
-    };
-};
+import type { AppState, NormalizedZoomValue } from "../types";
+export declare const getStateForZoom: ({ viewportX, viewportY, nextZoom, }: {
+    viewportX: number;
+    viewportY: number;
+    nextZoom: NormalizedZoomValue;
+}, appState: AppState) => {
+    scrollX: number;
+    scrollY: number;
+    zoom: {
+        value: NormalizedZoomValue;
+    };
+};

package/types/excalidraw/shapes.d.ts

@@ -1,85 +1,85 @@
-import { type GlobalPoint, type LocalPoint } from "../math";
-import { type GeometricShape } from "../utils/geometry/shape";
-import type { Bounds } from "./element/bounds";
-import type { ElementsMap, ExcalidrawElement, ExcalidrawLinearElement, NonDeleted } from "./element/types";
-import type { Zoom } from "./types";
-export declare const SHAPES: readonly [{
-    readonly icon: JSX.Element;
-    readonly value: "selection";
-    readonly key: "v";
-    readonly numericKey: "1";
-    readonly fillable: true;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "rectangle";
-    readonly key: "r";
-    readonly numericKey: "2";
-    readonly fillable: true;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "diamond";
-    readonly key: "d";
-    readonly numericKey: "3";
-    readonly fillable: true;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "ellipse";
-    readonly key: "o";
-    readonly numericKey: "4";
-    readonly fillable: true;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "arrow";
-    readonly key: "a";
-    readonly numericKey: "5";
-    readonly fillable: true;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "line";
-    readonly key: "l";
-    readonly numericKey: "6";
-    readonly fillable: true;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "freedraw";
-    readonly key: readonly ["p", "x"];
-    readonly numericKey: "7";
-    readonly fillable: false;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "text";
-    readonly key: "t";
-    readonly numericKey: "8";
-    readonly fillable: false;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "image";
-    readonly key: null;
-    readonly numericKey: "9";
-    readonly fillable: false;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "eraser";
-    readonly key: "e";
-    readonly numericKey: "0";
-    readonly fillable: false;
-}];
-export declare const findShapeByKey: (key: string) => "line" | "text" | "arrow" | "diamond" | "selection" | "rectangle" | "ellipse" | "freedraw" | "image" | "eraser" | null;
-/**
- * get the pure geometric shape of an excalidraw element
- * which is then used for hit detection
- */
-export declare const getElementShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape<Point>;
-export declare const getBoundTextShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape<Point> | null;
-export declare const getControlPointsForBezierCurve: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P) => P[] | null;
-export declare const getBezierXY: <P extends GlobalPoint | LocalPoint>(p0: P, p1: P, p2: P, p3: P, t: number) => P;
-export declare const getBezierCurveLength: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P) => number;
-export declare const mapIntervalToBezierT: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P, interval: number) => number;
-/**
- * Get the axis-aligned bounding box for a given element
- */
-export declare const aabbForElement: (element: Readonly<ExcalidrawElement>, offset?: [number, number, number, number]) => Bounds;
-export declare const pointInsideBounds: <P extends GlobalPoint | LocalPoint>(p: P, bounds: Bounds) => boolean;
-export declare const aabbsOverlapping: (a: Bounds, b: Bounds) => boolean;
-export declare const getCornerRadius: (x: number, element: ExcalidrawElement) => number;
-export declare const isPathALoop: (points: ExcalidrawLinearElement["points"], zoomValue?: Zoom["value"]) => boolean;
+import { type GlobalPoint, type LocalPoint } from "../math";
+import { type GeometricShape } from "../utils/geometry/shape";
+import type { Bounds } from "./element/bounds";
+import type { ElementsMap, ExcalidrawElement, ExcalidrawLinearElement, NonDeleted } from "./element/types";
+import type { Zoom } from "./types";
+export declare const SHAPES: readonly [{
+    readonly icon: JSX.Element;
+    readonly value: "selection";
+    readonly key: "v";
+    readonly numericKey: "1";
+    readonly fillable: true;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "rectangle";
+    readonly key: "r";
+    readonly numericKey: "2";
+    readonly fillable: true;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "diamond";
+    readonly key: "d";
+    readonly numericKey: "3";
+    readonly fillable: true;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "ellipse";
+    readonly key: "o";
+    readonly numericKey: "4";
+    readonly fillable: true;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "arrow";
+    readonly key: "a";
+    readonly numericKey: "5";
+    readonly fillable: true;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "line";
+    readonly key: "l";
+    readonly numericKey: "6";
+    readonly fillable: true;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "freedraw";
+    readonly key: readonly ["p", "x"];
+    readonly numericKey: "7";
+    readonly fillable: false;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "text";
+    readonly key: "t";
+    readonly numericKey: "8";
+    readonly fillable: false;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "image";
+    readonly key: null;
+    readonly numericKey: "9";
+    readonly fillable: false;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "eraser";
+    readonly key: "e";
+    readonly numericKey: "0";
+    readonly fillable: false;
+}];
+export declare const findShapeByKey: (key: string) => "line" | "text" | "arrow" | "diamond" | "selection" | "rectangle" | "ellipse" | "freedraw" | "image" | "eraser" | null;
+/**
+ * get the pure geometric shape of an excalidraw element
+ * which is then used for hit detection
+ */
+export declare const getElementShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape<Point>;
+export declare const getBoundTextShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape<Point> | null;
+export declare const getControlPointsForBezierCurve: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P) => P[] | null;
+export declare const getBezierXY: <P extends GlobalPoint | LocalPoint>(p0: P, p1: P, p2: P, p3: P, t: number) => P;
+export declare const getBezierCurveLength: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P) => number;
+export declare const mapIntervalToBezierT: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P, interval: number) => number;
+/**
+ * Get the axis-aligned bounding box for a given element
+ */
+export declare const aabbForElement: (element: Readonly<ExcalidrawElement>, offset?: [number, number, number, number]) => Bounds;
+export declare const pointInsideBounds: <P extends GlobalPoint | LocalPoint>(p: P, bounds: Bounds) => boolean;
+export declare const aabbsOverlapping: (a: Bounds, b: Bounds) => boolean;
+export declare const getCornerRadius: (x: number, element: ExcalidrawElement) => number;
+export declare const isPathALoop: (points: ExcalidrawLinearElement["points"], zoomValue?: Zoom["value"]) => boolean;