@excalidraw/math 0.18.0-51ad895 → 0.18.0-51ca8ab

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

@@ -1,9 +1,9 @@
 import { type GlobalPoint } from "@excalidraw/math";
 import type { LineSegment, LocalPoint } from "@excalidraw/math";
 import type { AppState } from "@excalidraw/excalidraw/types";
+import type { Bounds } from "@excalidraw/common";
 import { type Heading } from "./heading";
 import type { Scene } from "./Scene";
-import type { Bounds } from "./bounds";
 import type { ElementUpdate } from "./mutateElement";
 import type { BindMode, ElementsMap, ExcalidrawArrowElement, ExcalidrawBindableElement, ExcalidrawElbowArrowElement, ExcalidrawElement, FixedPoint, FixedPointBinding, NonDeleted, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap, Ordered, PointsPositionUpdates } from "./types";
 export type BindingStrategy = {
@@ -24,23 +24,27 @@ export type BindingStrategy = {
  *
  * IMPORTANT: currently must be > 0 (this also applies to the computed gap)
  */
-export declare const BASE_BINDING_GAP = 10;
+export declare const BASE_BINDING_GAP = 5;
 export declare const BASE_BINDING_GAP_ELBOW = 5;
+export declare const BASE_ARROW_MIN_LENGTH = 10;
+export declare const FOCUS_POINT_SIZE: number;
 export declare const getBindingGap: (bindTarget: ExcalidrawBindableElement, opts: Pick<ExcalidrawArrowElement, "elbowed">) => number;
 export declare const maxBindingDistance_simple: (zoom?: AppState["zoom"]) => number;
-export declare const shouldEnableBindingForPointerEvent: (event: React.PointerEvent<HTMLElement>) => boolean;
-export declare const isBindingEnabled: (appState: AppState) => boolean;
-export declare const bindOrUnbindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, draggingPoints: PointsPositionUpdates, scene: Scene, appState: AppState, opts?: {
+export declare const isBindingEnabled: (appState: {
+    isBindingEnabled: AppState["isBindingEnabled"];
+}) => boolean;
+export declare const bindOrUnbindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, draggingPoints: PointsPositionUpdates, scenePointerX: number, scenePointerY: number, scene: Scene, appState: AppState, opts?: {
     newArrow?: boolean;
     altKey?: boolean;
+    angleLocked?: boolean;
     initialBinding?: boolean;
 }) => {
     start: BindingStrategy;
     end: BindingStrategy;
 };
-export declare const getBindingStrategyForDraggingBindingElementEndpoints: (arrow: NonDeleted<ExcalidrawArrowElement>, draggingPoints: PointsPositionUpdates, elementsMap: NonDeletedSceneElementsMap, elements: readonly Ordered<NonDeletedExcalidrawElement>[], appState: AppState, opts?: {
+export declare const getBindingStrategyForDraggingBindingElementEndpoints: (arrow: NonDeleted<ExcalidrawArrowElement>, draggingPoints: PointsPositionUpdates, screenPointerX: number, screenPointerY: number, elementsMap: NonDeletedSceneElementsMap, elements: readonly Ordered<NonDeletedExcalidrawElement>[], appState: AppState, opts?: {
     newArrow?: boolean;
-    shiftKey?: boolean;
+    angleLocked?: boolean;
     altKey?: boolean;
     finalize?: boolean;
     initialBinding?: boolean;
@@ -50,7 +54,7 @@ export declare const getBindingStrategyForDraggingBindingElementEndpoints: (arro
     end: BindingStrategy;
 };
 export declare const bindOrUnbindBindingElements: (selectedArrows: NonDeleted<ExcalidrawArrowElement>[], scene: Scene, appState: AppState) => void;
-export declare const bindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, hoveredElement: ExcalidrawBindableElement, mode: BindMode, startOrEnd: "start" | "end", scene: Scene, focusPoint?: GlobalPoint) => void;
+export declare const bindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, hoveredElement: ExcalidrawBindableElement, mode: BindMode, startOrEnd: "start" | "end", scene: Scene, focusPoint?: GlobalPoint, shouldSnapToOutline?: boolean) => void;
 export declare const unbindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, startOrEnd: "start" | "end", scene: Scene) => ExcalidrawBindableElement["id"] | null;
 export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, scene: Scene, options?: {
     simultaneouslyUpdated?: readonly ExcalidrawElement[];
@@ -64,10 +68,11 @@ export declare const updateBindings: (latestElement: ExcalidrawElement, scene: S
     };
 }) => void;
 export declare const getHeadingForElbowArrowSnap: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined | null, aabb: Bounds | undefined | null, origPoint: GlobalPoint, elementsMap: ElementsMap, zoom?: AppState["zoom"]) => Heading;
-export declare const bindPointToSnapToElementOutline: (arrowElement: ExcalidrawArrowElement, bindableElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, customIntersector?: LineSegment<GlobalPoint>) => GlobalPoint;
+export declare const bindPointToSnapToElementOutline: (arrowElement: ExcalidrawArrowElement, bindableElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, customIntersector?: LineSegment<GlobalPoint>, isMidpointSnappingEnabled?: boolean) => GlobalPoint;
 export declare const avoidRectangularCorner: (arrowElement: ExcalidrawArrowElement, bindTarget: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint) => GlobalPoint;
-export declare const updateBoundPoint: (arrow: NonDeleted<ExcalidrawArrowElement>, startOrEnd: "startBinding" | "endBinding", binding: FixedPointBinding | null | undefined, bindableElement: ExcalidrawBindableElement, elementsMap: ElementsMap, customIntersector?: LineSegment<GlobalPoint>) => LocalPoint | null;
-export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => {
+export declare const snapToMid: (bindTarget: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint, tolerance?: number, arrowElement?: ExcalidrawArrowElement) => GlobalPoint | undefined;
+export declare const updateBoundPoint: (arrow: NonDeleted<ExcalidrawArrowElement>, startOrEnd: "startBinding" | "endBinding", binding: FixedPointBinding | null | undefined, bindableElement: ExcalidrawBindableElement, elementsMap: ElementsMap, dragging?: boolean) => LocalPoint | null;
+export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, shouldSnapToOutline?: boolean, isMidpointSnappingEnabled?: boolean) => {
     fixedPoint: FixedPoint;
 };
 export declare const calculateFixedPointForNonElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, focusPoint?: GlobalPoint) => {
@@ -119,4 +124,6 @@ export declare class BindableElement {
 export declare const getGlobalFixedPointForBindableElement: (fixedPointRatio: FixedPoint, element: ExcalidrawBindableElement, elementsMap: ElementsMap) => GlobalPoint;
 export declare const getGlobalFixedPoints: (arrow: ExcalidrawArrowElement, elementsMap: ElementsMap) => [GlobalPoint, GlobalPoint];
 export declare const getArrowLocalFixedPoints: (arrow: ExcalidrawElbowArrowElement, elementsMap: ElementsMap) => LocalPoint[];
-export declare const normalizeFixedPoint: <T extends FixedPoint | null>(fixedPoint: T) => T extends null ? null : FixedPoint;
+export declare const isFixedPoint: (fixedPoint: any) => fixedPoint is FixedPointBinding["fixedPoint"];
+export declare const normalizeFixedPoint: <T extends FixedPoint>(fixedPoint: T) => FixedPoint;
+export declare const getBindingSideMidPoint: (binding: FixedPointBinding, elementsMap: ElementsMap) => GlobalPoint | LocalPoint | null;

package/dist/types/element/src/bounds.d.ts

@@ -1,7 +1,8 @@
+import { type Bounds } from "@excalidraw/common";
 import type { Degrees, GlobalPoint, LineSegment, LocalPoint } from "@excalidraw/math";
 import type { AppState } from "@excalidraw/excalidraw/types";
 import type { Drawable, Op } from "roughjs/bin/core";
-import type { Arrowhead, ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawLinearElement, NonDeleted } from "./types";
+import type { Arrowhead, ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawLinearElement, NonDeleted, NonDeletedExcalidrawElement } from "./types";
 export type RectangleBox = {
     x: number;
     y: number;
@@ -9,15 +10,6 @@ export type RectangleBox = {
     height: number;
     angle: number;
 };
-/**
- * x and y position of top left corner, x and y position of bottom right corner
- */
-export type Bounds = readonly [
-    minX: number,
-    minY: number,
-    maxX: number,
-    maxY: number
-];
 export type SceneBounds = readonly [
     sceneX: number,
     sceneY: number,
@@ -45,13 +37,13 @@ export declare const getElementLineSegments: (element: ExcalidrawElement, elemen
 export declare const getRectangleBoxAbsoluteCoords: (boxSceneCoords: RectangleBox) => number[];
 export declare const getDiamondPoints: (element: ExcalidrawElement) => number[];
 export declare const getCubicBezierCurveBound: (p0: GlobalPoint, p1: GlobalPoint, p2: GlobalPoint, p3: GlobalPoint) => Bounds;
-export declare const getMinMaxXYFromCurvePathOps: (ops: Op[], transformXY?: ((p: GlobalPoint) => GlobalPoint) | undefined) => Bounds;
-export declare const getBoundsFromPoints: (points: ExcalidrawFreeDrawElement["points"]) => Bounds;
+export declare const getMinMaxXYFromCurvePathOps: (ops: Op[], transformXY?: (p: GlobalPoint) => GlobalPoint) => Bounds;
+export declare const getBoundsFromPoints: <P extends GlobalPoint | LocalPoint>(points: readonly P[], padding?: number) => Bounds;
 /** @returns number in pixels */
 export declare const getArrowheadSize: (arrowhead: Arrowhead) => number;
 /** @returns number in degrees */
 export declare const getArrowheadAngle: (arrowhead: Arrowhead) => Degrees;
-export declare const getArrowheadPoints: (element: ExcalidrawLinearElement, shape: Drawable[], position: "start" | "end", arrowhead: Arrowhead) => number[] | null;
+export declare const getArrowheadPoints: (element: ExcalidrawLinearElement, shape: Drawable[], position: "start" | "end", arrowhead: Arrowhead, offsetMultiplier?: number) => number[] | null;
 export declare const getElementBounds: (element: ExcalidrawElement, elementsMap: ElementsMap, nonRotated?: boolean) => Bounds;
 export declare const getCommonBounds: (elements: ElementsMapOrArray, elementsMap?: ElementsMap) => Bounds;
 export declare const getDraggedElementsBounds: (elements: ExcalidrawElement[], dragOffset: {
@@ -60,10 +52,6 @@ export declare const getDraggedElementsBounds: (elements: ExcalidrawElement[], d
 }) => number[];
 export declare const getResizedElementAbsoluteCoords: (element: ExcalidrawElement, nextWidth: number, nextHeight: number, normalizePoints: boolean) => Bounds;
 export declare const getElementPointsCoords: (element: ExcalidrawLinearElement, points: readonly (readonly [number, number])[]) => Bounds;
-export declare const getClosestElementBounds: (elements: readonly ExcalidrawElement[], from: {
-    x: number;
-    y: number;
-}) => Bounds;
 export interface BoundingBox {
     minX: number;
     minY: number;
@@ -85,5 +73,24 @@ export declare const getCenterForBounds: (bounds: Bounds) => GlobalPoint;
  */
 export declare const aabbForElement: (element: Readonly<ExcalidrawElement>, elementsMap: ElementsMap, offset?: [number, number, number, number]) => Bounds;
 export declare const pointInsideBounds: <P extends GlobalPoint | LocalPoint>(p: P, bounds: Bounds) => boolean;
+export declare const pointInsideBoundsInclusive: <P extends GlobalPoint | LocalPoint>(p: P, bounds: Bounds) => boolean;
 export declare const doBoundsIntersect: (bounds1: Bounds | null, bounds2: Bounds | null) => boolean;
+export declare const boundsContainBounds: (outerBounds: Bounds, innerBounds: Bounds) => boolean;
+/**
+ * High level helper to get elements overlapping a bounding box.
+ * It can be used to get elements overlapping a selection box, for example.
+ *
+ */
+export declare const elementsOverlappingBBox: ({ elements, elementsMap, bounds, type, excludeElementsInFrames, shouldIgnoreElementFromSelection, }: {
+    elements: readonly NonDeletedExcalidrawElement[];
+    elementsMap?: ElementsMap;
+    bounds: Bounds | ExcalidrawElement;
+    /**
+     * - overlap: elements overlapping or inside bounds
+     * - contain: elements inside bounds
+     **/
+    type: "contain" | "overlap";
+    excludeElementsInFrames?: boolean;
+    shouldIgnoreElementFromSelection?: (element: NonDeletedExcalidrawElement) => boolean;
+}) => NonDeletedExcalidrawElement[];
 export declare const elementCenterPoint: (element: ExcalidrawElement, elementsMap: ElementsMap, xOffset?: number, yOffset?: number) => GlobalPoint;

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

@@ -1,6 +1,6 @@
 import type { GlobalPoint, LineSegment } from "@excalidraw/math";
 import type { FrameNameBounds } from "@excalidraw/excalidraw/types";
-import type { ElementsMap, ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap, Ordered } from "./types";
+import type { ElementsMap, ExcalidrawArrowElement, ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap, Ordered } from "./types";
 export declare const shouldTestInside: (element: ExcalidrawElement) => boolean;
 export type HitTestArgs = {
     point: GlobalPoint;
@@ -14,8 +14,9 @@ export declare const hitElementItself: ({ point, element, threshold, elementsMap
 export declare const hitElementBoundingBox: (point: GlobalPoint, element: ExcalidrawElement, elementsMap: ElementsMap, tolerance?: number) => boolean;
 export declare const hitElementBoundingBoxOnly: (hitArgs: HitTestArgs, elementsMap: ElementsMap) => boolean;
 export declare const hitElementBoundText: (point: GlobalPoint, element: ExcalidrawElement, elementsMap: ElementsMap) => boolean;
-export declare const getAllHoveredElementAtPoint: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, toleranceFn?: ((element: ExcalidrawBindableElement) => number) | undefined) => NonDeleted<ExcalidrawBindableElement>[];
-export declare const getHoveredElementForBinding: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, toleranceFn?: ((element: ExcalidrawBindableElement) => number) | undefined) => NonDeleted<ExcalidrawBindableElement> | null;
+export declare const getAllHoveredElementAtPoint: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, tolerance?: number) => NonDeleted<ExcalidrawBindableElement>[];
+export declare const getHoveredElementForBinding: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, tolerance?: number) => NonDeleted<ExcalidrawBindableElement> | null;
+export declare const getHoveredElementForFocusPoint: (point: GlobalPoint, arrow: ExcalidrawArrowElement, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, tolerance?: number) => ExcalidrawBindableElement | null;
 /**
  * Intersect a line with an element for binding test
  *

package/dist/types/element/src/comparisons.d.ts

@@ -1,8 +1,9 @@
 import type { ElementOrToolType } from "@excalidraw/excalidraw/types";
-export declare const hasBackground: (type: ElementOrToolType) => boolean;
-export declare const hasStrokeColor: (type: ElementOrToolType) => boolean;
-export declare const hasStrokeWidth: (type: ElementOrToolType) => boolean;
-export declare const hasStrokeStyle: (type: ElementOrToolType) => boolean;
-export declare const canChangeRoundness: (type: ElementOrToolType) => boolean;
-export declare const toolIsArrow: (type: ElementOrToolType) => boolean;
-export declare const canHaveArrowheads: (type: ElementOrToolType) => boolean;
+export declare const hasBackground: (type: ElementOrToolType) => type is "line" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "iframe" | "freedraw";
+export declare const hasStrokeColor: (type: ElementOrToolType) => type is "line" | "arrow" | "text" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "freedraw";
+export declare const hasStrokeWidth: (type: ElementOrToolType) => type is "line" | "arrow" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "iframe" | "freedraw";
+export declare const hasStrokeStyle: (type: ElementOrToolType) => type is "line" | "arrow" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "iframe";
+export declare const hasFreedrawMode: (type: ElementOrToolType) => type is "freedraw";
+export declare const canChangeRoundness: (type: ElementOrToolType) => type is "line" | "rectangle" | "diamond" | "embeddable" | "iframe" | "image";
+export declare const toolIsArrow: (type: ElementOrToolType) => type is "arrow";
+export declare const canHaveArrowheads: (type: ElementOrToolType) => type is "arrow";

package/dist/types/element/src/distribute.d.ts

@@ -1,7 +1,8 @@
 import type { AppState } from "@excalidraw/excalidraw/types";
+import type { Scene } from "./Scene";
 import type { ElementsMap, ExcalidrawElement } from "./types";
 export interface Distribution {
     space: "between";
     axis: "x" | "y";
 }
-export declare const distributeElements: (selectedElements: ExcalidrawElement[], elementsMap: ElementsMap, distribution: Distribution, appState: Readonly<AppState>) => ExcalidrawElement[];
+export declare const distributeElements: (selectedElements: ExcalidrawElement[], elementsMap: ElementsMap, distribution: Distribution, appState: Readonly<AppState>, scene: Scene) => ExcalidrawElement[];

package/dist/types/element/src/dragElements.d.ts

@@ -24,10 +24,10 @@ export declare const dragNewElement: ({ newElement, elementType, originX, origin
     scene: Scene;
     /** whether to keep given aspect ratio when `isResizeWithSidesSameLength` is
         true */
-    widthAspectRatio?: number | null | undefined;
+    widthAspectRatio?: number | null;
     originOffset?: {
         x: number;
         y: number;
-    } | null | undefined;
-    informMutation?: boolean | undefined;
+    } | null;
+    informMutation?: boolean;
 }) => void;

package/dist/types/element/src/duplicate.d.ts

@@ -17,12 +17,12 @@ import type { ExcalidrawElement, GroupId } from "./types";
 export declare const duplicateElement: <TElement extends ExcalidrawElement>(editingGroupId: AppState["editingGroupId"], groupIdMapForOperation: Map<GroupId, GroupId>, element: TElement, randomizeSeed?: boolean) => Readonly<TElement>;
 export declare const duplicateElements: (opts: {
     elements: readonly ExcalidrawElement[];
-    randomizeSeed?: boolean | undefined;
-    overrides?: ((data: {
+    randomizeSeed?: boolean;
+    overrides?: (data: {
         duplicateElement: ExcalidrawElement;
         origElement: ExcalidrawElement;
         origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>;
-    }) => Partial<ExcalidrawElement>) | undefined;
+    }) => Partial<ExcalidrawElement>;
 } & ({
     /**
      * Duplicates all elements in array.
@@ -31,6 +31,7 @@ export declare const duplicateElements: (opts: {
      * user interaction.
      */
     type: "everything";
+    preserveFrameChildrenOrder?: boolean;
 } | {
     /**
      * Duplicates specified elements and inserts them back into the array

package/dist/types/element/src/elbowArrow.d.ts

@@ -13,5 +13,7 @@ export declare const updateElbowArrowPoints: (arrow: Readonly<ExcalidrawElbowArr
     endBinding?: FixedPointBinding | null;
 }, options?: {
     isDragging?: boolean;
+    isBindingEnabled?: boolean;
+    isMidpointSnappingEnabled?: boolean;
 }) => ElementUpdate<ExcalidrawElbowArrowElement>;
 export declare const validateElbowPoints: <P extends GlobalPoint | LocalPoint>(points: readonly P[], tolerance?: number) => boolean;

package/dist/types/element/src/fractionalIndex.d.ts

@@ -26,11 +26,11 @@ export declare class InvalidFractionalIndexError extends Error {
 export declare const validateFractionalIndices: (elements: readonly ExcalidrawElement[], { shouldThrow, includeBoundTextValidation, ignoreLogs, reconciliationContext, }: {
     shouldThrow: boolean;
     includeBoundTextValidation: boolean;
-    ignoreLogs?: true | undefined;
+    ignoreLogs?: true;
     reconciliationContext?: {
         localElements: ReadonlyArray<ExcalidrawElement>;
         remoteElements: ReadonlyArray<ExcalidrawElement>;
-    } | undefined;
+    };
 }) => void;
 /**
  * Order the elements based on the fractional indices.

package/dist/types/element/src/frame.d.ts

@@ -36,24 +36,29 @@ export declare const omitPartialGroups: (elements: ExcalidrawElement[], frame: E
 export declare const getContainingFrame: (element: ExcalidrawElement, elementsMap: ElementsMap) => ExcalidrawFrameLikeElement | null;
 /** */
 export declare const filterElementsEligibleAsFrameChildren: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];
+export declare const getCommonFrameId: (elements: readonly ExcalidrawElement[]) => string | null;
+export declare const getFrameChildrenInsertionIndex: (elements: readonly ExcalidrawElement[], frameId: ExcalidrawFrameLikeElement["id"]) => number | null;
 /**
- * Retains (or repairs for target frame) the ordering invriant where children
- * elements come right before the parent frame:
- * [el, el, child, child, frame, el]
+ * Adds elements and their bound elements to frame. Reorders added elements to
+ * be just below frame, or just above its highest child (whichever is higher).
  *
  * @returns mutated allElements (same data structure)
  */
-export declare const addElementsToFrame: <T extends ElementsMapOrArray>(allElements: T, elementsToAdd: NonDeletedExcalidrawElement[], frame: ExcalidrawFrameLikeElement, appState: AppState) => T;
+export declare const addElementsToFrame: <T extends ElementsMapOrArray>(allElements: T, elementsToAdd: NonDeletedExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => T;
 export declare const removeElementsFromFrame: (elementsToRemove: ReadonlySetLike<NonDeletedExcalidrawElement>, elementsMap: ElementsMap) => void;
 export declare const removeAllElementsFromFrame: <T extends ExcalidrawElement>(allElements: readonly T[], frame: ExcalidrawFrameLikeElement) => readonly T[];
-export declare const replaceAllElementsInFrame: <T extends ExcalidrawElement>(allElements: readonly T[], nextElementsInFrame: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, app: AppClassProperties) => T[];
+export declare const replaceAllElementsInFrame: <T extends ExcalidrawElement>(allElements: readonly T[], nextElementsInFrame: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => T[];
 /** does not mutate elements, but returns new ones */
 export declare const updateFrameMembershipOfSelectedElements: <T extends ElementsMapOrArray>(allElements: T, appState: AppState, app: AppClassProperties) => T;
 /**
  * filters out elements that are inside groups that contain a frame element
  * anywhere in the group tree
  */
-export declare const omitGroupsContainingFrameLikes: (allElements: ElementsMapOrArray, selectedElements?: readonly ExcalidrawElement[]) => ExcalidrawElement[];
+export declare const omitGroupsContainingFrameLikes: (allElements: ElementsMapOrArray, 
+/** subset of elements you want to filter. Optional perf optimization so we
+ * don't have to filter all elements unnecessarily
+ */
+selectedElements?: readonly ExcalidrawElement[]) => ExcalidrawElement[];
 /**
  * depending on the appState, return target frame, which is the frame the given element
  * is going to be added to or remove from
@@ -66,5 +71,5 @@ export declare const isElementInFrame: (element: ExcalidrawElement, allElementsM
 export declare const shouldApplyFrameClip: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, appState: StaticCanvasAppState, elementsMap: ElementsMap, checkedGroups?: Map<string, boolean>) => boolean;
 export declare const getDefaultFrameName: (element: ExcalidrawFrameLikeElement) => "Frame" | "AI Frame";
 export declare const getFrameLikeTitle: (element: ExcalidrawFrameLikeElement) => string;
-export declare const getElementsOverlappingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => NonDeletedExcalidrawElement[];
+export declare const getElementsOverlappingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => ExcalidrawElement[];
 export declare const frameAndChildrenSelectedTogether: (selectedElements: readonly ExcalidrawElement[]) => boolean;

package/dist/types/element/src/heading.d.ts

@@ -1,3 +1,4 @@
+import { type Bounds } from "@excalidraw/common";
 import type { LocalPoint, GlobalPoint, Vector } from "@excalidraw/math";
 import type { ExcalidrawBindableElement } from "./types";
 export declare const HEADING_RIGHT: Heading;
@@ -11,5 +12,5 @@ export declare const headingForPointIsHorizontal: <P extends GlobalPoint | Local
 export declare const compareHeading: (a: Heading, b: Heading) => boolean;
 export declare const headingIsHorizontal: (a: Heading) => boolean;
 export declare const headingIsVertical: (a: Heading) => boolean;
-export declare const headingForPointFromElement: <Point extends GlobalPoint>(element: Readonly<ExcalidrawBindableElement>, aabb: readonly [minX: number, minY: number, maxX: number, maxY: number], p: Readonly<Point>) => Heading;
+export declare const headingForPointFromElement: <Point extends GlobalPoint>(element: Readonly<ExcalidrawBindableElement>, aabb: Readonly<Bounds>, p: Readonly<Point>) => Heading;
 export declare const flipHeading: (h: Heading) => Heading;

package/dist/types/element/src/image.d.ts

@@ -10,17 +10,7 @@ export declare const updateImageCache: ({ fileIds, files, imageCache, }: {
 }) => Promise<{
     imageCache: Map<FileId, {
         image: HTMLImageElement | Promise<HTMLImageElement>;
-        mimeType: import("../../common/src/utility-types").ValueOf<{
-            readonly svg: "image/svg+xml";
-            readonly png: "image/png";
-            readonly jpg: "image/jpeg";
-            readonly gif: "image/gif";
-            readonly webp: "image/webp";
-            readonly bmp: "image/bmp";
-            readonly ico: "image/x-icon";
-            readonly avif: "image/avif";
-            readonly jfif: "image/jfif";
-        }>;
+        mimeType: import("@excalidraw/common/utility-types").ValueOf<typeof import("@excalidraw/common").IMAGE_MIME_TYPES>;
     }>;
     /** includes errored files because they cache was updated nonetheless */
     updatedFiles: Map<FileId, true>;

package/dist/types/element/src/index.d.ts

@@ -27,6 +27,7 @@ export * from "./elbowArrow";
 export * from "./elementLink";
 export * from "./embeddable";
 export * from "./flowchart";
+export * from "./arrows/focus";
 export * from "./fractionalIndex";
 export * from "./frame";
 export * from "./groups";
@@ -49,7 +50,10 @@ export * from "./store";
 export * from "./textElement";
 export * from "./textMeasurements";
 export * from "./textWrapping";
+export * from "./transform";
 export * from "./transformHandles";
 export * from "./typeChecks";
 export * from "./utils";
 export * from "./zindex";
+export * from "./arrows/helpers";
+export * from "./arrowheads";

package/dist/types/element/src/linearElementEditor.d.ts

@@ -1,9 +1,8 @@
-/// <reference types="react" />
 import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
 import { type Store } from "@excalidraw/element";
 import type { AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize, Zoom } from "@excalidraw/excalidraw/types";
+import type { Bounds } from "@excalidraw/common";
 import type { Scene } from "./Scene";
-import type { Bounds } from "./bounds";
 import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, FixedPointBinding, ExcalidrawElbowArrowElement, PointsPositionUpdates } from "./types";
 export declare class LinearElementEditor {
     readonly elementId: ExcalidrawElement["id"] & {
@@ -34,6 +33,8 @@ export declare class LinearElementEditor {
     }>;
     readonly hoverPointIndex: number;
     readonly segmentMidPointHoveredCoords: GlobalPoint | null;
+    readonly hoveredFocusPointBinding: "start" | "end" | null;
+    readonly draggedFocusPointBinding: "start" | "end" | null;
     readonly elbowed: boolean;
     readonly customLineAngle: number | null;
     readonly isEditing: boolean;
@@ -54,8 +55,8 @@ export declare class LinearElementEditor {
         x: number;
         y: number;
     }, appState: AppState, elementsMap: ElementsMap) => GlobalPoint | null;
-    static isSegmentTooShort<P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, startPoint: P, endPoint: P, index: number, zoom: Zoom): boolean;
-    static getSegmentMidPoint(element: NonDeleted<ExcalidrawLinearElement>, index: number): GlobalPoint;
+    static isSegmentTooShort<P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, startPoint: P, endPoint: P, index: number, zoom: Zoom, elementsMap: ElementsMap): boolean;
+    static getSegmentMidPoint(element: NonDeleted<ExcalidrawLinearElement>, index: number, elementsMap: ElementsMap): GlobalPoint;
     static getSegmentMidPointIndex(linearElementEditor: LinearElementEditor, appState: AppState, midPoint: GlobalPoint, elementsMap: ElementsMap): number;
     static handlePointerDown(event: React.PointerEvent<HTMLElement>, app: AppClassProperties, store: Store, scenePointer: {
         x: number;
@@ -95,6 +96,9 @@ export declare class LinearElementEditor {
         startBinding?: FixedPointBinding | null;
         endBinding?: FixedPointBinding | null;
         moveMidPointsWithElement?: boolean | null;
+    }, options?: {
+        isBindingEnabled?: boolean;
+        isMidpointSnappingEnabled?: boolean;
     }): void;
     static shouldAddMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState, elementsMap: ElementsMap): boolean;
     static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, app: AppClassProperties, snapToGrid: boolean, scene: Scene): {

package/dist/types/element/src/mutateElement.d.ts

@@ -11,8 +11,12 @@ export type ElementUpdate<TElement extends ExcalidrawElement> = Omit<Partial<TEl
  */
 export declare const mutateElement: <TElement extends Mutable<ExcalidrawElement>>(element: TElement, elementsMap: ElementsMap, updates: ElementUpdate<TElement>, options?: {
     isDragging?: boolean;
+    isBindingEnabled?: boolean;
+    isMidpointSnappingEnabled?: boolean;
 }) => TElement;
-export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>, force?: boolean) => TElement;
+export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>, 
+/** pass `true` to always regenerate */
+force?: boolean) => TElement;
 /**
  * Mutates element, bumping `version`, `versionNonce`, and `updated`.
  *

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

@@ -38,6 +38,7 @@ export declare const newFreeDrawElement: (opts: {
     type: "freedraw";
     points?: ExcalidrawFreeDrawElement["points"];
     simulatePressure: boolean;
+    strokeOptions?: ExcalidrawFreeDrawElement["strokeOptions"];
     pressures?: ExcalidrawFreeDrawElement["pressures"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawFreeDrawElement>;
 export declare const newLinearElement: (opts: {
@@ -47,12 +48,12 @@ export declare const newLinearElement: (opts: {
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawLinearElement>;
 export declare const newArrowElement: <T extends boolean>(opts: {
     type: ExcalidrawArrowElement["type"];
-    startArrowhead?: Arrowhead | null | undefined;
-    endArrowhead?: Arrowhead | null | undefined;
-    points?: readonly import("@excalidraw/math").LocalPoint[] | undefined;
-    elbowed?: T | undefined;
-    fixedSegments?: readonly import("./types").FixedSegment[] | null | undefined;
-} & 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>;
+    startArrowhead?: Arrowhead | null;
+    endArrowhead?: Arrowhead | null;
+    points?: ExcalidrawArrowElement["points"];
+    elbowed?: T;
+    fixedSegments?: ExcalidrawElbowArrowElement["fixedSegments"] | null;
+} & ElementConstructorOpts) => T extends true ? NonDeleted<ExcalidrawElbowArrowElement> : NonDeleted<ExcalidrawArrowElement>;
 export declare const newImageElement: (opts: {
     type: ExcalidrawImageElement["type"];
     status?: ExcalidrawImageElement["status"];

package/dist/types/element/src/renderElement.d.ts

@@ -3,7 +3,6 @@ import type { AppState, StaticCanvasAppState, InteractiveCanvasAppState, Element
 import type { StaticCanvasRenderConfig, RenderableElementsMap, InteractiveCanvasRenderConfig } from "@excalidraw/excalidraw/scene/types";
 import type { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawImageElement, ExcalidrawFrameLikeElement, NonDeletedSceneElementsMap, ElementsMap } from "./types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
-export declare const IMAGE_INVERT_FILTER = "invert(100%) hue-rotate(180deg) saturate(1.25)";
 export declare const getRenderOpacity: (element: ExcalidrawElement, containingFrame: ExcalidrawFrameLikeElement | null, elementsPendingErasure: ElementsPendingErasure, pendingNodes: Readonly<PendingExcalidrawElements> | null, globalAlpha?: number) => number;
 export interface ExcalidrawElementWithCanvas {
     element: ExcalidrawElement | ExcalidrawTextElement;
@@ -23,9 +22,4 @@ export declare const DEFAULT_LINK_SIZE = 14;
 export declare const elementWithCanvasCache: WeakMap<ExcalidrawElement, ExcalidrawElementWithCanvas>;
 export declare const renderSelectionElement: (element: NonDeletedExcalidrawElement, context: CanvasRenderingContext2D, appState: InteractiveCanvasAppState, selectionColor: InteractiveCanvasRenderConfig["selectionColor"]) => void;
 export declare const renderElement: (element: NonDeletedExcalidrawElement, elementsMap: RenderableElementsMap, allElementsMap: NonDeletedSceneElementsMap, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: StaticCanvasRenderConfig, appState: StaticCanvasAppState | InteractiveCanvasAppState) => void;
-export declare const pathsCache: WeakMap<ExcalidrawFreeDrawElement, Path2D>;
-export declare function generateFreeDrawShape(element: ExcalidrawFreeDrawElement): Path2D;
-export declare function getFreeDrawPath2D(element: ExcalidrawFreeDrawElement): Path2D | undefined;
-export declare function getFreeDrawSvgPath(element: ExcalidrawFreeDrawElement): string;
 export declare function getFreedrawOutlineAsSegments(element: ExcalidrawFreeDrawElement, points: [number, number][], elementsMap: ElementsMap): import("@excalidraw/math").LineSegment<GlobalPoint>[];
-export declare function getFreedrawOutlinePoints(element: ExcalidrawFreeDrawElement): [number, number][];

package/dist/types/element/src/resizeElements.d.ts

@@ -17,16 +17,16 @@ export declare const resizeSingleTextElement: (origElement: NonDeleted<Excalidra
 export declare const getResizeOffsetXY: (transformHandleType: MaybeTransformHandleType, selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap, x: number, y: number) => [number, number];
 export declare const getResizeArrowDirection: (transformHandleType: MaybeTransformHandleType, element: NonDeleted<ExcalidrawLinearElement>) => "origin" | "end";
 export declare const resizeSingleElement: (nextWidth: number, nextHeight: number, latestElement: ExcalidrawElement, origElement: ExcalidrawElement, originalElementsMap: ElementsMap, scene: Scene, handleDirection: TransformHandleDirection, { shouldInformMutation, shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
-    shouldMaintainAspectRatio?: boolean | undefined;
-    shouldResizeFromCenter?: boolean | undefined;
-    shouldInformMutation?: boolean | undefined;
+    shouldMaintainAspectRatio?: boolean;
+    shouldResizeFromCenter?: boolean;
+    shouldInformMutation?: boolean;
 }) => void;
 export declare const resizeMultipleElements: (selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, handleDirection: TransformHandleDirection, scene: Scene, originalElementsMap: ElementsMap, { shouldMaintainAspectRatio, shouldResizeFromCenter, flipByX, flipByY, nextHeight, nextWidth, originalBoundingBox, }?: {
-    nextWidth?: number | undefined;
-    nextHeight?: number | undefined;
-    shouldMaintainAspectRatio?: boolean | undefined;
-    shouldResizeFromCenter?: boolean | undefined;
-    flipByX?: boolean | undefined;
-    flipByY?: boolean | undefined;
-    originalBoundingBox?: BoundingBox | undefined;
+    nextWidth?: number;
+    nextHeight?: number;
+    shouldMaintainAspectRatio?: boolean;
+    shouldResizeFromCenter?: boolean;
+    flipByX?: boolean;
+    flipByY?: boolean;
+    originalBoundingBox?: BoundingBox;
 }) => void;

package/dist/types/element/src/resizeTest.d.ts

@@ -1,7 +1,7 @@
 import { type EditorInterface } from "@excalidraw/common";
 import type { GlobalPoint, LocalPoint } from "@excalidraw/math";
 import type { AppState, Zoom } from "@excalidraw/excalidraw/types";
-import type { Bounds } from "./bounds";
+import type { Bounds } from "@excalidraw/common";
 import type { MaybeTransformHandleType } from "./transformHandles";
 import type { ExcalidrawElement, PointerType, NonDeletedExcalidrawElement, ElementsMap } from "./types";
 export declare const resizeTest: <Point extends GlobalPoint | LocalPoint>(element: NonDeletedExcalidrawElement, elementsMap: ElementsMap, appState: AppState, x: number, y: number, zoom: Zoom, pointerType: PointerType, editorInterface: EditorInterface) => MaybeTransformHandleType;

package/dist/types/element/src/selection.d.ts

@@ -1,6 +1,6 @@
-import type { AppState, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
+import type { AppState, BoxSelectionMode, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
 import { LinearElementEditor } from "./linearElementEditor";
-import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExcalidrawElement } from "./types";
+import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement } 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
@@ -8,7 +8,7 @@ import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExca
  * @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 getElementsWithinSelection: (elements: readonly NonDeletedExcalidrawElement[], selection: NonDeletedExcalidrawElement, elementsMap: ElementsMap, excludeElementsInFrames?: boolean, boxSelectionMode?: BoxSelectionMode) => 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;
@@ -27,12 +27,12 @@ export declare const makeNextSelectedElementIds: (nextSelectedElementIds: AppSta
     [id: string]: true;
 }>;
 export declare const getSelectionStateForElements: (targetElements: readonly ExcalidrawElement[], allElements: readonly NonDeletedExcalidrawElement[], appState: AppState) => {
-    editingGroupId: string | null;
-    selectedElementIds: Readonly<{
-        [id: string]: true;
-    }>;
-    selectedGroupIds: {
-        [groupId: string]: boolean;
-    };
+    editingGroupId: AppState["editingGroupId"];
+    selectedElementIds: AppState["selectedElementIds"];
+    selectedGroupIds: AppState["selectedGroupIds"];
     selectedLinearElement: LinearElementEditor | null;
 };
+/**
+ * Returns editing or single-selected text element, if any.
+ */
+export declare const getActiveTextElement: (selectedElements: readonly NonDeleted<ExcalidrawElement>[], appState: Pick<AppState, "editingTextElement">) => import("./types").ExcalidrawTextElement | null;

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

@@ -3,7 +3,7 @@ import { type LocalPoint } from "@excalidraw/math";
 import type { GlobalPoint } from "@excalidraw/math";
 import type { AppState, EmbedsValidationStatus } from "@excalidraw/excalidraw/types";
 import type { ElementShape, ElementShapes } from "@excalidraw/excalidraw/scene/types";
-import type { ExcalidrawElement, ExcalidrawLinearElement, ExcalidrawFreeDrawElement, ElementsMap, ExcalidrawLineElement } from "./types";
+import type { ExcalidrawElement, ExcalidrawSelectionElement, ExcalidrawLinearElement, ExcalidrawFreeDrawElement, ElementsMap, ExcalidrawLineElement } from "./types";
 import type { Drawable, Options } from "roughjs/bin/core";
 export declare class ShapeCache {
     private static rg;
@@ -12,22 +12,22 @@ export declare class ShapeCache {
      * Retrieves shape from cache if available. Use this only if shape
      * is optional and you have a fallback in case it's not cached.
      */
-    static get: <T extends ExcalidrawElement>(element: T) => T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined;
-    static set: <T extends ExcalidrawElement>(element: T, shape: T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable) => WeakMap<ExcalidrawElement, ElementShape>;
-    static delete: (element: ExcalidrawElement) => boolean;
+    static get: <T extends ExcalidrawElement>(element: T, theme: AppState["theme"] | null) => (T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined) | undefined;
+    static delete: (element: ExcalidrawElement) => void;
     static destroy: () => void;
     /**
      * Generates & caches shape for element if not already cached, otherwise
      * returns cached shape.
      */
-    static generateElementShape: <T extends ExcalidrawLinearElement | import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawEmbeddableElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawTextElement | ExcalidrawFreeDrawElement | import("./types").ExcalidrawArrowElement>(element: T, renderConfig: {
+    static generateElementShape: <T extends Exclude<ExcalidrawElement, ExcalidrawSelectionElement>>(element: T, renderConfig: {
         isExporting: boolean;
         canvasBackgroundColor: AppState["viewBackgroundColor"];
         embedsValidationStatus: EmbedsValidationStatus;
-    } | null) => ((T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined) & ({} | null)) | (T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable | null);
+        theme: AppState["theme"];
+    } | null) => ((T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined) & {}) | (T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable | null);
 }
-export declare const generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean) => Options;
-export declare const generateLinearCollisionShape: (element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement) => {
+export declare const generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean, isDarkMode?: boolean) => Options;
+export declare const generateLinearCollisionShape: (element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement, elementsMap: ElementsMap) => {
     op: string;
     data: number[];
 }[];
@@ -40,3 +40,4 @@ export declare const toggleLinePolygonState: (element: ExcalidrawLineElement, ne
     polygon: ExcalidrawLineElement["polygon"];
     points: ExcalidrawLineElement["points"];
 } | null;
+export declare const getFreedrawOutlinePoints: (element: ExcalidrawFreeDrawElement) => [number, number][];