@excalidraw/math 0.18.0-6135548 → 0.18.0-699826

package/dist/types/common/src/versionedSnapshotStore.d.ts

@@ -0,0 +1,17 @@
+export type VersionedSnapshot<T> = Readonly<{
+    version: number;
+    value: T;
+}>;
+export declare class VersionedSnapshotStore<T> {
+    private readonly isEqual;
+    private version;
+    private value;
+    private readonly waiters;
+    private readonly subscribers;
+    constructor(initialValue: T, isEqual?: (prev: T, next: T) => boolean);
+    getSnapshot(): VersionedSnapshot<T>;
+    set(nextValue: T): boolean;
+    update(updater: (prev: T) => T): boolean;
+    subscribe(subscriber: (snapshot: VersionedSnapshot<T>) => void): () => void;
+    pull(sinceVersion?: number): Promise<VersionedSnapshot<T>>;
+}

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

@@ -63,10 +63,12 @@ export declare class Scene {
     triggerUpdate(): void;
     onUpdate(cb: SceneStateCallback): SceneStateCallbackRemover;
     destroy(): void;
-    insertElementAtIndex(element: ExcalidrawElement, index: number): void;
-    insertElementsAtIndex(elements: ExcalidrawElement[], index: number): void;
+    /** low-level - generally use app.insertNewElements() */
+    insertElementsAtIndex(elements: ExcalidrawElement[], 
+    /** null indicates end of the array */
+    index: number | null): void;
+    /** low-level - generally use app.insertNewElement() */
     insertElement: (element: ExcalidrawElement) => void;
-    insertElements: (elements: ExcalidrawElement[]) => void;
     getElementIndex(elementId: string): number;
     getContainerElement: (element: (ExcalidrawElement & {
         containerId: ExcalidrawElement["id"] | null;
@@ -75,6 +77,8 @@ export declare class Scene {
     mutateElement<TElement extends Mutable<ExcalidrawElement>>(element: TElement, updates: ElementUpdate<TElement>, options?: {
         informMutation: boolean;
         isDragging: boolean;
+        isBindingEnabled?: boolean;
+        isMidpointSnappingEnabled?: boolean;
     }): TElement;
 }
 export {};

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

@@ -0,0 +1,3 @@
+import type { Arrowhead, AnyArrowhead } from "./types";
+export declare const normalizeArrowhead: (arrowhead: AnyArrowhead | null | undefined) => Arrowhead | null;
+export declare const getArrowheadForPicker: (arrowhead: AnyArrowhead | null | undefined) => Arrowhead | null;

package/dist/types/element/src/arrows/focus.d.ts

@@ -0,0 +1,27 @@
+import { type GlobalPoint } from "@excalidraw/math";
+import type { AppState, NullableGridSize } from "@excalidraw/excalidraw/types";
+import { LinearElementEditor } from "../linearElementEditor";
+import type { ElementsMap, ExcalidrawArrowElement, ExcalidrawBindableElement, NonDeletedSceneElementsMap } from "../types";
+import type { Scene } from "../Scene";
+export declare const isFocusPointVisible: (focusPoint: GlobalPoint, arrow: ExcalidrawArrowElement, bindableElement: ExcalidrawBindableElement, elementsMap: ElementsMap, appState: {
+    isBindingEnabled: AppState["isBindingEnabled"];
+    zoom: AppState["zoom"];
+}, startOrEnd: "start" | "end", ignoreOverlap?: boolean) => boolean;
+export declare const handleFocusPointDrag: (linearElementEditor: LinearElementEditor, elementsMap: NonDeletedSceneElementsMap, pointerCoords: {
+    x: number;
+    y: number;
+}, scene: Scene, appState: AppState, gridSize: NullableGridSize, switchToInsideBinding: boolean) => void;
+export declare const handleFocusPointPointerDown: (arrow: ExcalidrawArrowElement, pointerDownState: {
+    origin: {
+        x: number;
+        y: number;
+    };
+}, elementsMap: NonDeletedSceneElementsMap, appState: AppState) => {
+    hitFocusPoint: "start" | "end" | null;
+    pointerOffset: {
+        x: number;
+        y: number;
+    };
+};
+export declare const handleFocusPointPointerUp: (linearElementEditor: LinearElementEditor, scene: Scene) => void;
+export declare const handleFocusPointHover: (arrow: ExcalidrawArrowElement, scenePointerX: number, scenePointerY: number, scene: Scene, appState: AppState) => "start" | "end" | null;

package/dist/types/element/src/arrows/helpers.d.ts

@@ -0,0 +1,5 @@
+import type { App } from "@excalidraw/excalidraw/types";
+export declare const maybeHandleArrowPointlikeDrag: ({ app, event, }: {
+    app: App;
+    event: KeyboardEvent | React.KeyboardEvent<Element> | PointerEvent;
+}) => boolean;

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

@@ -24,12 +24,15 @@ 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 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;
@@ -51,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[];
@@ -65,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) => {
@@ -120,5 +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

@@ -2,7 +2,7 @@ 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;
@@ -38,12 +38,12 @@ export declare const getRectangleBoxAbsoluteCoords: (boxSceneCoords: RectangleBo
 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) => Bounds;
-export declare const getBoundsFromPoints: (points: ExcalidrawFreeDrawElement["points"]) => 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: {
@@ -77,5 +77,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) => NonDeleted<ExcalidrawBindableElement>[];
-export declare const getHoveredElementForBinding: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, toleranceFn?: (element: ExcalidrawBindableElement) => number) => 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/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/duplicate.d.ts

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

@@ -36,17 +36,18 @@ 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;
 /**
@@ -70,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/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";
@@ -54,3 +55,5 @@ 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

@@ -33,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;
@@ -53,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;
@@ -94,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,6 +11,8 @@ 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>, 
 /** pass `true` to always regenerate */

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;
@@ -32,3 +32,7 @@ export declare const getSelectionStateForElements: (targetElements: readonly Exc
     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

@@ -27,7 +27,7 @@ export declare class ShapeCache {
     } | 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, isDarkMode?: boolean) => Options;
-export declare const generateLinearCollisionShape: (element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement) => {
+export declare const generateLinearCollisionShape: (element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement, elementsMap: ElementsMap) => {
     op: string;
     data: number[];
 }[];

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

@@ -31,7 +31,7 @@ export declare const suppportsHorizontalAlign: (selectedElements: NonDeletedExca
 declare const VALID_CONTAINER_TYPES: Set<string>;
 export declare const isValidTextContainer: (element: {
     type: ExcalidrawElementType;
-}) => boolean;
+}) => element is ExcalidrawTextContainer;
 export declare const computeContainerDimensionForBoundText: (dimension: number, containerType: ExtractSetType<typeof VALID_CONTAINER_TYPES>) => number;
 export declare const getBoundTextMaxWidth: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElement | null) => number;
 export declare const getBoundTextMaxHeight: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => number;

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

@@ -5,9 +5,35 @@ import type { FontString } from "./types";
 export declare const containsCJK: (text: string) => boolean;
 /**
  * Breaks the line into the tokens based on the found line break opporutnities.
+ *
+ * Note: tokenization normalizes to NFC first so decomposed graphemes are treated as
+ * their composed variants for wrapping. Any code that needs exact source offsets should
+ * keep in mind that this assumes the input text is already NFC-normalized.
  */
 export declare const parseTokens: (line: string) => string[];
 /**
  * Wraps the original text into the lines based on the given width.
+ *
+ * This is a convenience adapter over `getWrappedTextLines()` for call sites
+ * that only need the rendered wrapped string and not the source offsets.
  */
 export declare const wrapText: (text: string, font: FontString, maxWidth: number) => string;
+/**
+ * A single rendered visual line produced from the original text.
+ *
+ * `start` and `end` are end-exclusive code-unit offsets into the original text, and do
+ * not include synthetic soft line breaks inserted by this module. If trailing whitespace
+ * was trimmed away at a wrap boundary, `end` points to the last rendered character.
+ */
+export type WrappedTextLine = {
+    text: string;
+    start: number;
+    end: number;
+};
+/**
+ * Returns the rendered visual lines together with their source offsets.
+ *
+ * This is the source-of-truth wrapping pipeline for callers that need more than the
+ * final wrapped string, for example caret placement or future editor/rich-text mapping.
+ */
+export declare const getWrappedTextLines: (text: string, font: FontString, maxWidth: number) => WrappedTextLine[];

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

@@ -52,3 +52,4 @@ export declare const getLinearElementSubType: (element: ExcalidrawLinearElement)
  */
 export declare const isValidPolygon: (points: ExcalidrawLineElement["points"]) => boolean;
 export declare const canBecomePolygon: (points: ExcalidrawLineElement["points"]) => boolean;
+export declare const isEligibleFrameChildType: (type: ElementOrToolType) => boolean;

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

@@ -1,7 +1,7 @@
 import type { LocalPoint, Radians } from "@excalidraw/math";
 import type { FONT_FAMILY, ROUNDNESS, TEXT_ALIGN, THEME, VERTICAL_ALIGN } from "@excalidraw/common";
 import type { MakeBrand, MarkNonNullable, Merge, ValueOf } from "@excalidraw/common/utility-types";
-export type ChartType = "bar" | "line";
+export type ChartType = "bar" | "line" | "radar";
 export type FillStyle = "hachure" | "cross-hatch" | "solid" | "zigzag";
 export type FontFamilyKeys = keyof typeof FONT_FAMILY;
 export type FontFamilyValues = typeof FONT_FAMILY[FontFamilyKeys];
@@ -208,7 +208,10 @@ export type PointsPositionUpdates = Map<Index, {
     point: LocalPoint;
     isDragging?: boolean;
 }>;
-export type Arrowhead = "arrow" | "bar" | "dot" | "circle" | "circle_outline" | "triangle" | "triangle_outline" | "diamond" | "diamond_outline" | "crowfoot_one" | "crowfoot_many" | "crowfoot_one_or_many";
+export type CardinalityArrowhead = "cardinality_one" | "cardinality_many" | "cardinality_one_or_many" | "cardinality_exactly_one" | "cardinality_zero_or_one" | "cardinality_zero_or_many";
+export type ArrowheadLegacy = "dot" | "crowfoot_one" | "crowfoot_many" | "crowfoot_one_or_many";
+export type Arrowhead = "arrow" | "bar" | "circle" | "circle_outline" | "triangle" | "triangle_outline" | "diamond" | "diamond_outline" | CardinalityArrowhead;
+export type AnyArrowhead = Arrowhead | ArrowheadLegacy;
 export type ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<{
     type: "line" | "arrow";
     points: readonly LocalPoint[];

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

@@ -1,14 +1,14 @@
 import { type GlobalPoint } from "@excalidraw/math";
 import type { Curve, LineSegment } from "@excalidraw/math";
-import type { Zoom } from "@excalidraw/excalidraw/types";
-import type { ElementsMap, ExcalidrawArrowElement, ExcalidrawDiamondElement, ExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawLinearElement, ExcalidrawRectanguloidElement } from "./types";
+import type { AppState, Zoom } from "@excalidraw/excalidraw/types";
+import type { ElementsMap, ExcalidrawArrowElement, ExcalidrawBindableElement, ExcalidrawDiamondElement, ExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawLinearElement, ExcalidrawRectanguloidElement } from "./types";
 /**
  * Returns the **rotated** components of freedraw, line or arrow elements.
  *
  * @param element The linear element to deconstruct
  * @returns The rotated in components.
  */
-export declare function deconstructLinearOrFreeDrawElement(element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]];
+export declare function deconstructLinearOrFreeDrawElement(element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement, elementsMap: ElementsMap): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]];
 /**
  * Get the building components of a rectanguloid element in the form of
  * line segments and curves **unrotated**.
@@ -18,6 +18,7 @@ export declare function deconstructLinearOrFreeDrawElement(element: ExcalidrawLi
  * @returns Tuple of **unrotated** line segments (0) and curves (1)
  */
 export declare function deconstructRectanguloidElement(element: ExcalidrawRectanguloidElement, offset?: number): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]];
+export declare function getDiamondBaseCorners(element: ExcalidrawDiamondElement, offset?: number): Curve<GlobalPoint>[];
 /**
  * Get the **unrotated** building components of a diamond element
  * in the form of line segments and curves as a tuple, in this order.
@@ -31,4 +32,5 @@ export declare const isPathALoop: (points: ExcalidrawLinearElement["points"],
 /** supply if you want the loop detection to account for current zoom */
 zoomValue?: Zoom["value"]) => boolean;
 export declare const getCornerRadius: (x: number, element: ExcalidrawElement) => number;
-export declare const projectFixedPointOntoDiagonal: (arrow: ExcalidrawArrowElement, point: GlobalPoint, element: ExcalidrawElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => GlobalPoint | null;
+export declare const getSnapOutlineMidPoint: (point: GlobalPoint, element: ExcalidrawBindableElement, elementsMap: ElementsMap, zoom: AppState["zoom"]) => GlobalPoint | undefined;
+export declare const projectFixedPointOntoDiagonal: (arrow: ExcalidrawArrowElement, point: GlobalPoint, element: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, zoom: AppState["zoom"], isMidpointSnappingEnabled?: boolean) => GlobalPoint | null;

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

@@ -6,7 +6,7 @@ import type { ExcalidrawArrowElement, ExcalidrawElement, NonDeletedExcalidrawEle
  * Moves the arrow element above any bindable elements it intersects with or
  * hovers over.
  */
-export declare const moveArrowAboveBindable: (point: GlobalPoint, arrow: ExcalidrawArrowElement, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, scene: Scene) => readonly OrderedExcalidrawElement[];
+export declare const moveArrowAboveBindable: (point: GlobalPoint, arrow: ExcalidrawArrowElement, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, scene: Scene, hit?: NonDeletedExcalidrawElement) => readonly OrderedExcalidrawElement[];
 export declare const moveOneLeft: (allElements: readonly ExcalidrawElement[], appState: AppState, scene: Scene) => readonly ExcalidrawElement[];
 export declare const moveOneRight: (allElements: readonly ExcalidrawElement[], appState: AppState, scene: Scene) => readonly ExcalidrawElement[];
 export declare const moveAllLeft: (allElements: readonly ExcalidrawElement[], appState: AppState) => readonly ExcalidrawElement[] | ExcalidrawElement[];