@excalidraw/excalidraw 0.18.0-rc.4 → 0.18.0-rc.5

package/dist/types/excalidraw/actions/actionCanvas.d.ts

@@ -52,6 +52,11 @@ export declare const actionClearCanvas: {
                 lastActiveTool: import("../types").ActiveTool | null;
                 locked: boolean;
             } & import("../types").ActiveTool;
+            viewModeEnabled: boolean;
+            zenModeEnabled: boolean;
+            objectsSnapModeEnabled: boolean;
+            name: string | null;
+            currentItemArrowType: "round" | "sharp" | "elbow";
             contextMenu: {
                 items: import("../components/ContextMenu").ContextMenuItems;
                 top: number;
@@ -98,13 +103,11 @@ export declare const actionClearCanvas: {
             currentItemEndArrowhead: import("../element/types").Arrowhead | null;
             currentHoveredFontFamily: number | null;
             currentItemRoundness: import("../element/types").StrokeRoundness;
-            currentItemArrowType: "round" | "sharp" | "elbow";
             viewBackgroundColor: string;
             scrollX: number;
             scrollY: number;
             cursorButton: "up" | "down";
             scrolledOutside: boolean;
-            name: string | null;
             isResizing: boolean;
             isRotating: boolean;
             zoom: Readonly<{
@@ -145,8 +148,6 @@ export declare const actionClearCanvas: {
                 closable?: boolean | undefined;
                 duration?: number | undefined;
             } | null;
-            zenModeEnabled: boolean;
-            viewModeEnabled: boolean;
             selectedGroupIds: {
                 [groupId: string]: boolean;
             };
@@ -181,7 +182,6 @@ export declare const actionClearCanvas: {
                 x: number;
                 y: number;
             } | null;
-            objectsSnapModeEnabled: boolean;
             userToFollow: import("../types").UserToFollow | null;
             followedBy: Set<import("../types").SocketId>;
             isCropping: boolean;

package/dist/types/excalidraw/actions/actionExport.d.ts

@@ -1125,6 +1125,13 @@ export declare const actionLoadScene: {
     perform: (elements: readonly import("../element/types").OrderedExcalidrawElement[], appState: Readonly<import("../types").AppState>, _: any, app: import("../types").AppClassProperties) => Promise<false | {
         elements: import("../element/types").OrderedExcalidrawElement[];
         appState: {
+            viewModeEnabled: boolean;
+            zenModeEnabled: boolean;
+            gridModeEnabled: boolean;
+            objectsSnapModeEnabled: boolean;
+            theme: Theme;
+            name: string | null;
+            currentItemArrowType: "round" | "sharp" | "elbow";
             contextMenu: {
                 items: import("../components/ContextMenu").ContextMenuItems;
                 top: number;
@@ -1179,13 +1186,11 @@ export declare const actionLoadScene: {
             currentItemEndArrowhead: import("../element/types").Arrowhead | null;
             currentHoveredFontFamily: number | null;
             currentItemRoundness: import("../element/types").StrokeRoundness;
-            currentItemArrowType: "round" | "sharp" | "elbow";
             viewBackgroundColor: string;
             scrollX: number;
             scrollY: number;
             cursorButton: "up" | "down";
             scrolledOutside: boolean;
-            name: string | null;
             isResizing: boolean;
             isRotating: boolean;
             zoom: Readonly<{
@@ -1226,12 +1231,8 @@ export declare const actionLoadScene: {
                 closable?: boolean | undefined;
                 duration?: number | undefined;
             } | null;
-            zenModeEnabled: boolean;
-            theme: Theme;
             gridSize: number;
             gridStep: number;
-            gridModeEnabled: boolean;
-            viewModeEnabled: boolean;
             selectedGroupIds: {
                 [groupId: string]: boolean;
             };
@@ -1277,7 +1278,6 @@ export declare const actionLoadScene: {
                 x: number;
                 y: number;
             } | null;
-            objectsSnapModeEnabled: boolean;
             userToFollow: import("../types").UserToFollow | null;
             followedBy: Set<import("../types").SocketId>;
             isCropping: boolean;

package/dist/types/excalidraw/actions/actionFrame.d.ts

@@ -1082,7 +1082,7 @@ export declare const actionWrapSelectionInFrame: {
         }> & Readonly<{
             type: "image";
             fileId: import("../element/types").FileId | null;
-            status: "pending" | "saved" | "error";
+            status: "error" | "pending" | "saved";
             scale: [number, number];
             crop: import("../element/types").ImageCrop | null;
         }> & {

package/dist/types/excalidraw/actions/actionZindex.d.ts

@@ -46,7 +46,7 @@ export declare const actionSendToBack: {
         category: "element";
     };
     perform: (elements: readonly import("../element/types").OrderedExcalidrawElement[], appState: Readonly<import("../types").AppState>) => {
-        elements: import("../element/types").ExcalidrawElement[] | readonly import("../element/types").ExcalidrawElement[];
+        elements: readonly import("../element/types").ExcalidrawElement[] | import("../element/types").ExcalidrawElement[];
         appState: Readonly<import("../types").AppState>;
         storeAction: "capture";
     };
@@ -64,7 +64,7 @@ export declare const actionBringToFront: {
         category: "element";
     };
     perform: (elements: readonly import("../element/types").OrderedExcalidrawElement[], appState: Readonly<import("../types").AppState>) => {
-        elements: import("../element/types").ExcalidrawElement[] | readonly import("../element/types").ExcalidrawElement[];
+        elements: readonly import("../element/types").ExcalidrawElement[] | import("../element/types").ExcalidrawElement[];
         appState: Readonly<import("../types").AppState>;
         storeAction: "capture";
     };

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

@@ -1,6 +1,12 @@
 import type { AppState, NormalizedZoomValue } from "./types";
 export declare const getDefaultAppState: () => Omit<AppState, "offsetTop" | "offsetLeft" | "width" | "height">;
 export declare const clearAppStateForLocalStorage: (appState: Partial<AppState>) => {
+    zenModeEnabled?: boolean | undefined;
+    gridModeEnabled?: boolean | undefined;
+    objectsSnapModeEnabled?: boolean | undefined;
+    theme?: import("./element/types").Theme | undefined;
+    name?: string | null | undefined;
+    currentItemArrowType?: "round" | "sharp" | "elbow" | undefined;
     showWelcomeScreen?: boolean | undefined;
     activeTool?: ({
         lastActiveTool: import("./types").ActiveTool | null;
@@ -25,13 +31,11 @@ export declare const clearAppStateForLocalStorage: (appState: Partial<AppState>)
     currentItemStartArrowhead?: import("./element/types").Arrowhead | null | undefined;
     currentItemEndArrowhead?: import("./element/types").Arrowhead | null | undefined;
     currentItemRoundness?: import("./element/types").StrokeRoundness | undefined;
-    currentItemArrowType?: "round" | "sharp" | "elbow" | undefined;
     viewBackgroundColor?: string | undefined;
     scrollX?: number | undefined;
     scrollY?: number | undefined;
     cursorButton?: "up" | "down" | undefined;
     scrolledOutside?: boolean | undefined;
-    name?: string | null | undefined;
     zoom?: Readonly<{
         value: NormalizedZoomValue;
     }> | undefined;
@@ -49,11 +53,8 @@ export declare const clearAppStateForLocalStorage: (appState: Partial<AppState>)
         [id: string]: true;
     } | undefined;
     shouldCacheIgnoreZoom?: boolean | undefined;
-    zenModeEnabled?: boolean | undefined;
-    theme?: import("./element/types").Theme | undefined;
     gridSize?: number | undefined;
     gridStep?: number | undefined;
-    gridModeEnabled?: boolean | undefined;
     selectedGroupIds?: {
         [groupId: string]: boolean;
     } | undefined;
@@ -64,19 +65,18 @@ export declare const clearAppStateForLocalStorage: (appState: Partial<AppState>)
     } | undefined;
     currentChartType?: import("./element/types").ChartType | undefined;
     selectedLinearElement?: import("./element/linearElementEditor").LinearElementEditor | null | undefined;
-    objectsSnapModeEnabled?: boolean | undefined;
 };
 export declare const cleanAppStateForExport: (appState: Partial<AppState>) => {
+    gridModeEnabled?: boolean | undefined;
     viewBackgroundColor?: string | undefined;
     gridSize?: number | undefined;
     gridStep?: number | undefined;
-    gridModeEnabled?: boolean | undefined;
 };
 export declare const clearAppStateForDatabase: (appState: Partial<AppState>) => {
+    gridModeEnabled?: boolean | undefined;
     viewBackgroundColor?: string | undefined;
     gridSize?: number | undefined;
     gridStep?: number | undefined;
-    gridModeEnabled?: boolean | undefined;
 };
 export declare const isEraserActive: ({ activeTool, }: {
     activeTool: AppState["activeTool"];

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

@@ -21,8 +21,6 @@ export declare const probablySupportsClipboardWriteText: boolean;
 export declare const probablySupportsClipboardBlob: boolean;
 export declare const createPasteEvent: ({ types, files, }: {
     types?: {
-        "text/plain"?: string | File | undefined;
-        "text/html"?: string | File | undefined;
         "image/svg+xml"?: string | File | undefined;
         "image/png"?: string | File | undefined;
         "image/jpeg"?: string | File | undefined;
@@ -32,6 +30,8 @@ export declare const createPasteEvent: ({ types, files, }: {
         "image/x-icon"?: string | File | undefined;
         "image/avif"?: string | File | undefined;
         "image/jfif"?: string | File | undefined;
+        "text/plain"?: string | File | undefined;
+        "text/html"?: string | File | undefined;
     } | undefined;
     files?: File[] | undefined;
 }) => ClipboardEvent;
@@ -45,8 +45,6 @@ export declare const copyToClipboard: (elements: readonly NonDeletedExcalidrawEl
  * Will prompt user for permission if not granted.
  */
 export declare const readSystemClipboard: () => Promise<{
-    "text/plain"?: string | File | undefined;
-    "text/html"?: string | File | undefined;
     "image/svg+xml"?: string | File | undefined;
     "image/png"?: string | File | undefined;
     "image/jpeg"?: string | File | undefined;
@@ -56,6 +54,8 @@ export declare const readSystemClipboard: () => Promise<{
     "image/x-icon"?: string | File | undefined;
     "image/avif"?: string | File | undefined;
     "image/jfif"?: string | File | undefined;
+    "text/plain"?: string | File | undefined;
+    "text/html"?: string | File | undefined;
 }>;
 /**
  * Attempts to parse clipboard event.

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

@@ -143,6 +143,7 @@ export declare const DEFAULT_VERTICAL_ALIGN = "top";
 export declare const DEFAULT_VERSION = "{version}";
 export declare const DEFAULT_TRANSFORM_HANDLE_SPACING = 2;
 export declare const SIDE_RESIZING_THRESHOLD: number;
+export declare const EPSILON = 0.00001;
 export declare const DEFAULT_COLLISION_THRESHOLD: number;
 export declare const COLOR_WHITE = "#ffffff";
 export declare const COLOR_CHARCOAL_BLACK = "#1e1e1e";

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

@@ -6,7 +6,7 @@ import type { FileSystemHandle } from "./filesystem";
 import type { ImportedLibraryData } from "./types";
 export declare const getMimeType: (blob: Blob | string) => string;
 export declare const getFileHandleType: (handle: FileSystemHandle | null) => string | null;
-export declare const isImageFileHandleType: (type: string | null) => type is "png" | "svg";
+export declare const isImageFileHandleType: (type: string | null) => type is "svg" | "png";
 export declare const isImageFileHandle: (handle: FileSystemHandle | null) => boolean;
 export declare const isSupportedImageFileType: (type: string | null | undefined) => boolean;
 export declare const isSupportedImageFile: (blob: Blob | null | undefined) => blob is Blob & {

package/dist/types/excalidraw/element/binding.d.ts

@@ -39,7 +39,7 @@ export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawE
     changedElements?: Map<string, OrderedExcalidrawElement>;
 }) => void;
 export declare const getHeadingForElbowArrowSnap: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined | null, aabb: Bounds | undefined | null, elementsMap: ElementsMap, origPoint: GlobalPoint, zoom?: AppState["zoom"]) => Heading;
-export declare const bindPointToSnapToElementOutline: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined, elementsMap: ElementsMap) => GlobalPoint;
+export declare const bindPointToSnapToElementOutline: (arrow: ExcalidrawElbowArrowElement, bindableElement: ExcalidrawBindableElement | undefined, startOrEnd: "start" | "end") => GlobalPoint;
 export declare const avoidRectangularCorner: (element: ExcalidrawBindableElement, p: GlobalPoint) => GlobalPoint;
 export declare const snapToMid: (element: ExcalidrawBindableElement, p: GlobalPoint, tolerance?: number) => GlobalPoint;
 export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => {
@@ -52,7 +52,6 @@ export declare const bindingBorderTest: (element: NonDeleted<ExcalidrawBindableE
     y: number;
 }, elementsMap: NonDeletedSceneElementsMap, zoom?: AppState["zoom"], fullShape?: boolean) => boolean;
 export declare const maxBindingGap: (element: ExcalidrawElement, elementWidth: number, elementHeight: number, zoom?: AppState["zoom"]) => number;
-export declare const distanceToBindableElement: (element: ExcalidrawBindableElement, point: GlobalPoint, elementsMap: ElementsMap) => number;
 export declare const bindingProperties: Set<BindableProp | BindingProp>;
 export type BindableProp = "boundElements";
 export type BindingProp = "frameId" | "containerId" | "startBinding" | "endBinding";

package/dist/types/excalidraw/element/collision.d.ts

@@ -1,7 +1,7 @@
 import type { ElementsMap, ExcalidrawElement } from "./types";
 import type { FrameNameBounds } from "../types";
 import type { GeometricShape } from "@excalidraw/utils/geometry/shape";
-import type { GlobalPoint, LocalPoint } from "@excalidraw/math";
+import type { GlobalPoint, LineSegment, LocalPoint } from "@excalidraw/math";
 export declare const shouldTestInside: (element: ExcalidrawElement) => boolean;
 export type HitTestArgs<Point extends GlobalPoint | LocalPoint> = {
     x: number;
@@ -15,3 +15,12 @@ export declare const hitElementItself: <Point extends GlobalPoint | LocalPoint>(
 export declare const hitElementBoundingBox: (x: number, y: number, element: ExcalidrawElement, elementsMap: ElementsMap, tolerance?: number) => boolean;
 export declare const hitElementBoundingBoxOnly: <Point extends GlobalPoint | LocalPoint>(hitArgs: HitTestArgs<Point>, elementsMap: ElementsMap) => boolean;
 export declare const hitElementBoundText: <Point extends GlobalPoint | LocalPoint>(x: number, y: number, textShape: GeometricShape<Point> | null) => boolean;
+/**
+ * Intersect a line with an element for binding test
+ *
+ * @param element
+ * @param line
+ * @param offset
+ * @returns
+ */
+export declare const intersectElementWithLineSegment: (element: ExcalidrawElement, line: LineSegment<GlobalPoint>, offset?: number) => GlobalPoint[];

package/dist/types/excalidraw/element/distance.d.ts

@@ -0,0 +1,3 @@
+import type { GlobalPoint } from "@excalidraw/math";
+import type { ExcalidrawBindableElement } from "./types";
+export declare const distanceToBindableElement: (element: ExcalidrawBindableElement, p: GlobalPoint) => number;

package/dist/types/excalidraw/element/newElement.d.ts

@@ -52,7 +52,7 @@ export declare const newArrowElement: <T extends boolean>(opts: {
     points?: readonly import("@excalidraw/math").LocalPoint[] | undefined;
     elbowed?: T | undefined;
     fixedSegments?: FixedSegment[] | null | undefined;
-} & Omit<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "angle" | "link" | "width" | "height" | "backgroundColor" | "strokeColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData"> & Partial<Pick<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "angle" | "link" | "width" | "height" | "backgroundColor" | "strokeColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData">>) => T extends true ? NonDeleted<ExcalidrawElbowArrowElement> : NonDeleted<ExcalidrawArrowElement>;
+} & Omit<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "link" | "strokeColor" | "backgroundColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "width" | "height" | "angle" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData"> & Partial<Pick<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "link" | "strokeColor" | "backgroundColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "width" | "height" | "angle" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData">>) => T extends true ? NonDeleted<ExcalidrawElbowArrowElement> : NonDeleted<ExcalidrawArrowElement>;
 export declare const newImageElement: (opts: {
     type: ExcalidrawImageElement["type"];
     status?: ExcalidrawImageElement["status"];

package/dist/types/excalidraw/element/transformHandles.d.ts

@@ -31,8 +31,8 @@ export declare const OMIT_SIDES_FOR_FRAME: {
 export declare const canResizeFromSides: (device: Device) => boolean;
 export declare const getOmitSidesForDevice: (device: Device) => {};
 export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [number, number, number, number, number, number], angle: Radians, zoom: Zoom, pointerType: PointerType, omitSides?: {
-    e?: boolean | undefined;
     s?: boolean | undefined;
+    e?: boolean | undefined;
     w?: boolean | undefined;
     n?: boolean | undefined;
     nw?: boolean | undefined;
@@ -42,8 +42,8 @@ export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [
     rotation?: boolean | undefined;
 }, margin?: number, spacing?: number) => TransformHandles;
 export declare const getTransformHandles: (element: ExcalidrawElement, zoom: Zoom, elementsMap: ElementsMap, pointerType?: PointerType, omitSides?: {
-    e?: boolean | undefined;
     s?: boolean | undefined;
+    e?: boolean | undefined;
     w?: boolean | undefined;
     n?: boolean | undefined;
     nw?: boolean | undefined;

package/dist/types/excalidraw/element/utils.d.ts

@@ -0,0 +1,21 @@
+import type { Curve, LineSegment } from "@excalidraw/math";
+import { type GlobalPoint } from "@excalidraw/math";
+import type { ExcalidrawDiamondElement, ExcalidrawRectanguloidElement } from "./types";
+/**
+ * Get the building components of a rectanguloid element in the form of
+ * line segments and curves.
+ *
+ * @param element Target rectanguloid element
+ * @param offset Optional offset to expand the rectanguloid shape
+ * @returns Tuple of line segments (0) and curves (1)
+ */
+export declare function deconstructRectanguloidElement(element: ExcalidrawRectanguloidElement, offset?: number): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]];
+/**
+ * Get the building components of a diamond element in the form of
+ * line segments and curves as a tuple, in this order.
+ *
+ * @param element The element to deconstruct
+ * @param offset An optional offset
+ * @returns Tuple of line segments (0) and curves (1)
+ */
+export declare function deconstructDiamondElement(element: ExcalidrawDiamondElement, offset?: number): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]];

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

@@ -64,7 +64,7 @@ export declare const SHAPES: readonly [{
     readonly numericKey: "0";
     readonly fillable: false;
 }];
-export declare const findShapeByKey: (key: string) => "line" | "text" | "arrow" | "diamond" | "selection" | "rectangle" | "ellipse" | "freedraw" | "image" | "eraser" | null;
+export declare const findShapeByKey: (key: string) => "text" | "line" | "arrow" | "image" | "selection" | "rectangle" | "diamond" | "ellipse" | "freedraw" | "eraser" | null;
 /**
  * get the pure geometric shape of an excalidraw element
  * which is then used for hit detection

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

@@ -6,9 +6,9 @@ export declare const setDateTimeForTests: (dateTime: string) => void;
 export declare const getDateTime: () => string;
 export declare const capitalizeString: (str: string) => string;
 export declare const isToolIcon: (target: Element | EventTarget | null) => target is HTMLElement;
-export declare const isInputLike: (target: Element | EventTarget | null) => target is HTMLBRElement | HTMLDivElement | HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
+export declare const isInputLike: (target: Element | EventTarget | null) => target is HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | HTMLBRElement | HTMLDivElement;
 export declare const isInteractive: (target: Element | EventTarget | null) => boolean;
-export declare const isWritableElement: (target: Element | EventTarget | null) => target is HTMLBRElement | HTMLDivElement | HTMLInputElement | HTMLTextAreaElement;
+export declare const isWritableElement: (target: Element | EventTarget | null) => target is HTMLInputElement | HTMLTextAreaElement | HTMLBRElement | HTMLDivElement;
 export declare const getFontFamilyString: ({ fontFamily, }: {
     fontFamily: FontFamilyValues;
 }) => string;
@@ -184,7 +184,7 @@ export declare const wrapEvent: <T extends Event>(name: EVENT, nativeEvent: T) =
 }>;
 export declare const updateObject: <T extends Record<string, any>>(obj: T, updates: Partial<T>) => T;
 export declare const isPrimitive: (val: any) => boolean;
-export declare const getFrame: () => "iframe" | "top";
+export declare const getFrame: () => "top" | "iframe";
 export declare const isRunningInIframe: () => boolean;
 export declare const isPromiseLike: (value: any) => value is Promise<any>;
 export declare const queryFocusableElements: (container: HTMLElement | null) => HTMLElement[];

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

@@ -1,33 +1,32 @@
+import type { Curve } from "@excalidraw/math";
 import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
 import type { LineSegment } from "@excalidraw/utils";
-import type { BoundingBox, Bounds } from "./element/bounds";
+import type { Bounds } from "./element/bounds";
 declare global {
     interface Window {
         visualDebug?: {
             data: DebugElement[][];
             currentFrame?: number;
         };
-        debugDrawPoint: typeof debugDrawPoint;
-        debugDrawLine: typeof debugDrawLine;
     }
 }
 export type DebugElement = {
     color: string;
-    data: LineSegment<GlobalPoint>;
+    data: LineSegment<GlobalPoint> | Curve<GlobalPoint>;
     permanent: boolean;
 };
-export declare const debugDrawLine: (segment: LineSegment<GlobalPoint> | LineSegment<GlobalPoint>[], opts?: {
+export declare const debugDrawCubicBezier: (c: Curve<GlobalPoint>, opts?: {
     color?: string;
     permanent?: boolean;
 }) => void;
-export declare const debugDrawPoint: (p: GlobalPoint, opts?: {
+export declare const debugDrawLine: (segment: LineSegment<GlobalPoint> | LineSegment<GlobalPoint>[], opts?: {
     color?: string;
     permanent?: boolean;
-    fuzzy?: boolean;
 }) => void;
-export declare const debugDrawBoundingBox: (box: BoundingBox | BoundingBox[], opts?: {
+export declare const debugDrawPoint: (p: GlobalPoint, opts?: {
     color?: string;
     permanent?: boolean;
+    fuzzy?: boolean;
 }) => void;
 export declare const debugDrawBounds: (box: Bounds | Bounds[], opts?: {
     color?: string;

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

@@ -2,5 +2,5 @@ import type { ExcalidrawElement } from "./element/types";
 import type { AppState } from "./types";
 export declare const moveOneLeft: (allElements: readonly ExcalidrawElement[], appState: AppState) => readonly ExcalidrawElement[];
 export declare const moveOneRight: (allElements: readonly ExcalidrawElement[], appState: AppState) => readonly ExcalidrawElement[];
-export declare const moveAllLeft: (allElements: readonly ExcalidrawElement[], appState: AppState) => ExcalidrawElement[] | readonly ExcalidrawElement[];
-export declare const moveAllRight: (allElements: readonly ExcalidrawElement[], appState: AppState) => ExcalidrawElement[] | readonly ExcalidrawElement[];
+export declare const moveAllLeft: (allElements: readonly ExcalidrawElement[], appState: AppState) => readonly ExcalidrawElement[] | ExcalidrawElement[];
+export declare const moveAllRight: (allElements: readonly ExcalidrawElement[], appState: AppState) => readonly ExcalidrawElement[] | ExcalidrawElement[];

package/dist/types/math/curve.d.ts

@@ -1,4 +1,4 @@
-import type { Curve, GlobalPoint, LocalPoint, Radians } from "./types";
+import type { Curve, GlobalPoint, LineSegment, LocalPoint } from "./types";
 /**
  *
  * @param a
@@ -8,25 +8,33 @@ import type { Curve, GlobalPoint, LocalPoint, Radians } from "./types";
  * @returns
  */
 export declare function curve<Point extends GlobalPoint | LocalPoint>(a: Point, b: Point, c: Point, d: Point): Curve<Point>;
-export declare const curveRotate: <Point extends GlobalPoint | LocalPoint>(curve: Curve<Point>, angle: Radians, origin: Point) => Point[];
 /**
- *
- * @param pointsIn
- * @param curveTightness
- * @returns
+ * Computes the intersection between a cubic spline and a line segment.
  */
-export declare function curveToBezier<Point extends LocalPoint | GlobalPoint>(pointsIn: readonly Point[], curveTightness?: number): Point[];
+export declare function curveIntersectLineSegment<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, l: LineSegment<Point>): Point[];
 /**
+ * Finds the closest point on the Bezier curve from another point
  *
- * @param t
- * @param controlPoints
+ * @param x
+ * @param y
+ * @param P0
+ * @param P1
+ * @param P2
+ * @param P3
+ * @param tolerance
+ * @param maxLevel
  * @returns
  */
-export declare const cubicBezierPoint: <Point extends GlobalPoint | LocalPoint>(t: number, controlPoints: Curve<Point>) => Point;
+export declare function curveClosestPoint<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point, tolerance?: number): Point | null;
 /**
+ * Determines the distance between a point and the closest point on the
+ * Bezier curve.
  *
- * @param point
- * @param controlPoints
- * @returns
+ * @param c The curve to test
+ * @param p The point to measure from
+ */
+export declare function curvePointDistance<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point): number;
+/**
+ * Determines if the parameter is a Curve
  */
-export declare const cubicBezierDistance: <Point extends GlobalPoint | LocalPoint>(point: Point, controlPoints: Curve<Point>) => number;
+export declare function isCurve<P extends GlobalPoint | LocalPoint>(v: unknown): v is Curve<P>;

package/dist/types/math/ellipse.d.ts

@@ -0,0 +1,44 @@
+import type { Ellipse, GlobalPoint, Line, LineSegment, LocalPoint } from "./types";
+/**
+ * Construct an Ellipse object from the parameters
+ *
+ * @param center The center of the ellipse
+ * @param angle The slanting of the ellipse in radians
+ * @param halfWidth Half of the width of a non-slanted version of the ellipse
+ * @param halfHeight Half of the height of a non-slanted version of the ellipse
+ * @returns The constructed Ellipse object
+ */
+export declare function ellipse<Point extends GlobalPoint | LocalPoint>(center: Point, halfWidth: number, halfHeight: number): Ellipse<Point>;
+/**
+ * Determines if a point is inside or on the ellipse outline
+ *
+ * @param p The point to test
+ * @param ellipse The ellipse to compare against
+ * @returns TRUE if the point is inside or on the outline of the ellipse
+ */
+export declare const ellipseIncludesPoint: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => boolean;
+/**
+ * Tests whether a point lies on the outline of the ellipse within a given
+ * tolerance
+ *
+ * @param point The point to test
+ * @param ellipse The ellipse to compare against
+ * @param threshold The distance to consider a point close enough to be "on" the outline
+ * @returns TRUE if the point is on the ellise outline
+ */
+export declare const ellipseTouchesPoint: <Point extends GlobalPoint | LocalPoint>(point: Point, ellipse: Ellipse<Point>, threshold?: number) => boolean;
+/**
+ * Determine the shortest euclidean distance from a point to the
+ * outline of the ellipse
+ *
+ * @param p The point to consider
+ * @param ellipse The ellipse to calculate the distance to
+ * @returns The eucledian distance
+ */
+export declare const ellipseDistanceFromPoint: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => number;
+/**
+ * Calculate a maximum of two intercept points for a line going throug an
+ * ellipse.
+ */
+export declare function ellipseSegmentInterceptPoints<Point extends GlobalPoint | LocalPoint>(e: Readonly<Ellipse<Point>>, s: Readonly<LineSegment<Point>>): Point[];
+export declare function ellipseLineIntersectionPoints<Point extends GlobalPoint | LocalPoint>({ center, halfWidth, halfHeight }: Ellipse<Point>, [g, h]: Line<Point>): Point[];

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

@@ -1,10 +1,10 @@
-export * from "./arc";
 export * from "./angle";
 export * from "./curve";
 export * from "./line";
 export * from "./point";
 export * from "./polygon";
 export * from "./range";
+export * from "./rectangle";
 export * from "./segment";
 export * from "./triangle";
 export * from "./types";

package/dist/types/math/line.d.ts

@@ -1,4 +1,4 @@
-import type { GlobalPoint, Line, LocalPoint, Radians } from "./types";
+import type { GlobalPoint, Line, LocalPoint } from "./types";
 /**
  * Create a line from two points.
  *
@@ -6,34 +6,6 @@ import type { GlobalPoint, Line, LocalPoint, Radians } from "./types";
  * @returns The line on which the points lie
  */
 export declare function line<P extends GlobalPoint | LocalPoint>(a: P, b: P): Line<P>;
-/**
- * Convenient point creation from an array of two points.
- *
- * @param param0 The array with the two points to convert to a line
- * @returns The created line
- */
-export declare function lineFromPointPair<P extends GlobalPoint | LocalPoint>([a, b]: [
-    P,
-    P
-]): Line<P>;
-/**
- * TODO
- *
- * @param pointArray
- * @returns
- */
-export declare function lineFromPointArray<P extends GlobalPoint | LocalPoint>(pointArray: P[]): Line<P> | undefined;
-/**
- * Return the coordinates resulting from rotating the given line about an
- * origin by an angle in degrees note that when the origin is not given,
- * the midpoint of the given line is used as the origin
- *
- * @param l
- * @param angle
- * @param origin
- * @returns
- */
-export declare const lineRotate: <Point extends GlobalPoint | LocalPoint>(l: Line<Point>, angle: Radians, origin?: Point | undefined) => Line<Point>;
 /**
  * Determines the intersection point (unless the lines are parallel) of two
  * lines
@@ -42,4 +14,4 @@ export declare const lineRotate: <Point extends GlobalPoint | LocalPoint>(l: Lin
  * @param b
  * @returns
  */
-export declare const linesIntersectAt: <Point extends GlobalPoint | LocalPoint>(a: Line<Point>, b: Line<Point>) => Point | null;
+export declare function linesIntersectAt<Point extends GlobalPoint | LocalPoint>(a: Line<Point>, b: Line<Point>): Point | null;

package/dist/types/math/point.d.ts

@@ -27,17 +27,7 @@ export declare function pointFromPair<Point extends GlobalPoint | LocalPoint>(pa
  * @param v The vector to convert
  * @returns The point the vector points at with origin 0,0
  */
-export declare function pointFromVector<P extends GlobalPoint | LocalPoint>(v: Vector): P;
-/**
- * Convert the coordiante object to a point.
- *
- * @param coords The coordinate object with x and y properties
- * @returns
- */
-export declare function pointFromCoords<Point extends GlobalPoint | LocalPoint>({ x, y, }: {
-    x: number;
-    y: number;
-}): Point;
+export declare function pointFromVector<P extends GlobalPoint | LocalPoint>(v: Vector, offset?: P): P;
 /**
  * Checks if the provided value has the shape of a Point.
  *
@@ -93,24 +83,6 @@ export declare function pointTranslate<From extends GlobalPoint | LocalPoint, To
  * @returns The middle point
  */
 export declare function pointCenter<P extends LocalPoint | GlobalPoint>(a: P, b: P): P;
-/**
- * Add together two points by their coordinates like you'd apply a translation
- * to a point by a vector.
- *
- * @param a One point to act as a basis
- * @param b The other point to act like the vector to translate by
- * @returns
- */
-export declare function pointAdd<Point extends LocalPoint | GlobalPoint>(a: Point, b: Point): Point;
-/**
- * Subtract a point from another point like you'd translate a point by an
- * invese vector.
- *
- * @param a The point to translate
- * @param b The point which will act like a vector
- * @returns The resulting point
- */
-export declare function pointSubtract<Point extends LocalPoint | GlobalPoint>(a: Point, b: Point): Point;
 /**
  * Calculate the distance between two points.
  *

package/dist/types/math/rectangle.d.ts

@@ -0,0 +1,3 @@
+import type { GlobalPoint, LineSegment, LocalPoint, Rectangle } from "./types";
+export declare function rectangle<P extends GlobalPoint | LocalPoint>(topLeft: P, bottomRight: P): Rectangle<P>;
+export declare function rectangleIntersectLineSegment<Point extends LocalPoint | GlobalPoint>(r: Rectangle<Point>, l: LineSegment<Point>): Point[];