@excalidraw/math 0.18.0-4ce38fb → 0.18.0-4ce8305

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

@@ -6,6 +6,12 @@ import type { EVENT } from "./constants";
 export declare const setDateTimeForTests: (dateTime: string) => void;
 export declare const getDateTime: () => string;
 export declare const capitalizeString: (str: string) => string;
+/**
+ * Resolves the window owning `target`, so that we keep working when the editor
+ * is rendered into another document. Accepts a `Document` as well, in which
+ * case its `defaultView` is used. Falls back to the module realm's window.
+ */
+export declare const getTargetWindow: (target: Element | EventTarget | Document | null) => (Window & typeof globalThis) | null;
 export declare const isToolIcon: (target: Element | EventTarget | null) => target is HTMLElement;
 export declare const isInputLike: (target: Element | EventTarget | null) => target is HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | HTMLBRElement | HTMLDivElement;
 export declare const isInteractive: (target: Element | EventTarget | null) => boolean;
@@ -25,7 +31,7 @@ export declare const debounce: <T extends any[]>(fn: (...args: T) => void, timeo
     flush(): void;
     cancel(): void;
 };
-export declare const throttleRAF: <T extends any[]>(fn: (...args: T) => void) => {
+export declare const throttleRAF: <T extends any[]>(fn: (...args: T) => void, ownerWindow?: Pick<Window, "requestAnimationFrame" | "cancelAnimationFrame">) => {
     (...args: T): void;
     flush(): void;
     cancel(): void;

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

@@ -1,8 +1,11 @@
 import type { AppState } from "@excalidraw/excalidraw/types";
+import type { RenderEnvironment } from "./renderEnvironment";
 import type { Scene } from "./Scene";
 import type { NonDeletedExcalidrawElement } from "./types";
 export interface Alignment {
     position: "start" | "center" | "end";
     axis: "x" | "y";
 }
-export declare const alignElements: (selectedElements: NonDeletedExcalidrawElement[], alignment: Alignment, scene: Scene, appState: Readonly<AppState>) => NonDeletedExcalidrawElement[];
+export declare const alignElements: (selectedElements: NonDeletedExcalidrawElement[], alignment: Alignment, scene: Scene, appState: Readonly<AppState>, 
+/** measures the labels of the bound arrows the alignment moves */
+renderEnvironment?: RenderEnvironment) => NonDeletedExcalidrawElement[];

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

@@ -3,6 +3,7 @@ import type { LineSegment, LocalPoint } from "@excalidraw/math";
 import type { AppState, NullableGridSize } from "@excalidraw/excalidraw/types";
 import type { Bounds } from "@excalidraw/common";
 import { type Heading } from "./heading";
+import type { RenderEnvironment } from "./renderEnvironment";
 import type { Scene } from "./Scene";
 import type { ElementUpdate } from "./mutateElement";
 import type { BindMode, ElementsMap, ExcalidrawArrowElement, ExcalidrawBindableElement, ExcalidrawElbowArrowElement, ExcalidrawElement, FixedPoint, FixedPointBinding, NonDeleted, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap, Ordered, PointsPositionUpdates } from "./types";
@@ -55,12 +56,45 @@ export declare const getBindingStrategyForDraggingBindingElementEndpoints: (arro
 };
 export declare const bindOrUnbindBindingElements: (selectedArrows: NonDeleted<ExcalidrawArrowElement>[], scene: Scene, appState: AppState) => void;
 export declare const bindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, hoveredElement: NonDeleted<ExcalidrawBindableElement>, mode: BindMode, startOrEnd: "start" | "end", scene: Scene, zoom: AppState["zoom"], focusPoint?: GlobalPoint, shouldSnapToOutline?: boolean, isMidpointSnappingEnabled?: boolean) => void;
+/**
+ * Whether the arrow's end is bound to an element it's beyond the binding area
+ * of, i.e. that it couldn't be bound to in the editor (e.g. a participant's
+ * header in a sequence diagram, as laid out by mermaid)
+ */
+export declare const isEndBoundBeyondBindingArea: (arrow: ExcalidrawArrowElement, startOrEnd: "start" | "end", elementsMap: NonDeletedSceneElementsMap, zoom: AppState["zoom"]) => boolean;
+/**
+ * Extends the arrow's bound end along its end segment, by the segment's length
+ * (at least MIN_BOUND_END_EXTENSION), to find where it would reach the element
+ * it's bound to, off the element by the binding gap. Moving the end there
+ * restores bindings given to arrows that just fall short of their elements.
+ *
+ * @returns where to move the end to, or null if it doesn't reach the element
+ */
+export declare const getBoundEndExtension: (arrow: ExcalidrawArrowElement, startOrEnd: "start" | "end", elementsMap: NonDeletedSceneElementsMap) => GlobalPoint | null;
 export declare const unbindBindingElement: (arrow: ExcalidrawArrowElement, startOrEnd: "start" | "end", scene: Scene) => ExcalidrawBindableElement["id"] | null;
 export declare const reanchorBindingsToOutline: (changedElement: NonDeleted<ExcalidrawBindableElement>, scene: Scene, zoom: AppState["zoom"]) => void;
+/**
+ * Places both bound ends of `arrow` where its bindings put them on the elements
+ * in `elementsMap` they're bound to, and rewraps its label along it as placed.
+ * Leaves the label's x/y as they were (the editor derives arrow labels' x/y as
+ * it renders them), so callers returning the elements as data must store them
+ * (see `LinearElementEditor.getBoundTextElementPosition`).
+ */
+export declare const updateBoundArrow: (arrow: NonDeleted<ExcalidrawArrowElement>, scene: Scene, elementsMap: ElementsMap, 
+/** measures the arrow's label */
+renderEnvironment?: RenderEnvironment, 
+/**
+ * whether it's placed as what it's bound to moved: an arrow bound to one
+ * element at both ends then moves with it whole (its midpoints with its
+ * start), rather than only at its ends
+ */
+boundElementMoved?: boolean) => void;
 export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, scene: Scene, options?: {
     /** see `getSimultaneouslyUpdatedElementIds` for how to pass it */
     simultaneouslyUpdated?: readonly NonDeletedExcalidrawElement[];
     changedElements?: Map<string, ExcalidrawElement>;
+    /** measures the labels of the arrows it updates (the host's, in the editor) */
+    renderEnvironment?: RenderEnvironment;
 }) => void;
 export declare const updateBindings: (latestElement: NonDeletedExcalidrawElement, scene: Scene, appState: AppState, options?: {
     simultaneouslyUpdated?: readonly NonDeletedExcalidrawElement[];
@@ -68,6 +102,8 @@ export declare const updateBindings: (latestElement: NonDeletedExcalidrawElement
         width: number;
         height: number;
     };
+    /** measures the labels of the bound arrows it updates */
+    renderEnvironment?: RenderEnvironment;
 }) => void;
 /**
  * The id set of `simultaneouslyUpdated`, shared by every `updateBoundElements()`

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

@@ -39,10 +39,16 @@ 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: <P extends GlobalPoint | LocalPoint>(points: readonly P[], padding?: number) => Bounds;
+export declare const CARDINALITY_ONE_OR_MANY_BAR_OFFSET = -0.25;
+export declare const CARDINALITY_INNER_BAR_OFFSET = -0.5;
+export declare const CARDINALITY_ZERO_CIRCLE_OFFSET = 1.5;
+export declare const CARDINALITY_ZERO_CIRCLE_SCALE = 0.8;
 /** @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 getArrowheadAngle: (arrowhead: Arrowhead, 
+/** size the arrowhead is drawn at, if scaled down */
+size?: number) => Degrees;
 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;
@@ -81,7 +87,7 @@ export declare const boundsContainBounds: (outerBounds: Bounds, innerBounds: Bou
  * It can be used to get elements overlapping a selection box, for example.
  *
  */
-export declare const elementsOverlappingBBox: <T extends ExcalidrawElement>({ elements, elementsMap, bounds, type, excludeElementsInFrames, shouldIgnoreElementFromSelection, }: {
+export declare const elementsOverlappingBBox: <T extends ExcalidrawElement>({ elements, elementsMap, bounds, type, excludeElementsInFrames, shouldIgnoreElementFromSelection, includeStroke, }: {
     elements: readonly T[];
     elementsMap?: ElementsMap;
     bounds: Bounds | ExcalidrawElement;
@@ -92,5 +98,7 @@ export declare const elementsOverlappingBBox: <T extends ExcalidrawElement>({ el
     type: "contain" | "overlap";
     excludeElementsInFrames?: boolean;
     shouldIgnoreElementFromSelection?: (element: T) => boolean;
+    /** whether elements extend by their stroke, as they render */
+    includeStroke?: boolean;
 }) => T[];
 export declare const elementCenterPoint: (element: ExcalidrawElement, elementsMap: ElementsMap, xOffset?: number, yOffset?: number) => GlobalPoint;

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

@@ -14,6 +14,13 @@ 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;
+/**
+ * Whether an arrow endpoint at the point could bind to the element: inside it,
+ * or within binding distance of its outline. Unlike `getBindingCandidates`,
+ * it ignores frame clipping, as frames may not be sized yet (e.g. while
+ * converting skeletons, where frames are sized around their children last)
+ */
+export declare const isPointInBindingArea: (point: GlobalPoint, element: NonDeleted<ExcalidrawBindableElement>, elementsMap: ElementsMap, zoom: AppState["zoom"]) => boolean;
 /**
  * Whether the element hides what is behind it from binding — an arrow's or a
  * text label's. Images count as opaque, and frames once they support a

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

@@ -1,13 +1,45 @@
-import type { TransformHandleType } from "./transformHandles";
-import type { ElementsMap, ExcalidrawImageElement, ImageCrop } from "./types";
+import type { TransformHandleDirection } from "./transformHandles";
+import type { ElementsMap, ExcalidrawImageElement } from "./types";
 export declare const MINIMAL_CROP_SIZE = 10;
-export declare const cropElement: (element: ExcalidrawImageElement, elementsMap: ElementsMap, transformHandle: TransformHandleType, naturalWidth: number, naturalHeight: number, pointerX: number, pointerY: number, widthAspectRatio?: number) => {
+/**
+ * Crops the image (as it was at the drag's start) as resizing it would
+ * resize it, as far as the image reaches.
+ */
+export declare const cropElement: (element: ExcalidrawImageElement, elementsMap: ElementsMap, transformHandle: TransformHandleDirection, naturalWidth: number, naturalHeight: number, pointerX: number, pointerY: number, { shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
+    shouldMaintainAspectRatio?: boolean;
+    shouldResizeFromCenter?: boolean;
+}) => {
     x: number;
     y: number;
     width: number;
     height: number;
-    crop: ImageCrop | null;
+    crop: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        naturalWidth: number;
+        naturalHeight: number;
+    } | null;
 };
+/**
+ * Uncrops the image on the handle's side (a corner's two); mirrored, on the
+ * opposite side(s) too.
+ */
+export declare const uncropElementSides: (element: ExcalidrawImageElement, elementsMap: ElementsMap, handle: TransformHandleDirection, mirrored?: boolean) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    crop: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        naturalWidth: number;
+        naturalHeight: number;
+    } | null;
+} | null;
 export declare const getUncroppedImageElement: (element: ExcalidrawImageElement, elementsMap: ElementsMap) => ExcalidrawImageElement;
 export declare const getUncroppedWidthAndHeight: (element: ExcalidrawImageElement) => {
     width: number;

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

@@ -2,6 +2,7 @@ import type { ExcalidrawElement, Ordered, OrderedExcalidrawElement, SceneElement
 import type { DTO, ValueOf } from "@excalidraw/common/utility-types";
 import type { AppState, ObservedAppState } from "@excalidraw/excalidraw/types";
 import { StoreSnapshot } from "./store";
+import type { RenderEnvironment } from "./renderEnvironment";
 /**
  * Represents the difference between two objects of the same type.
  *
@@ -146,6 +147,11 @@ export declare class AppStateDelta implements DeltaContainer<AppState> {
 type ElementPartial<TElement extends ExcalidrawElement = ExcalidrawElement> = Omit<Partial<Ordered<TElement>>, "id" | "updated" | "seed">;
 export type ApplyToOptions = {
     excludedProperties?: Set<keyof ElementPartial>;
+    /**
+     * measures the labels re-laid out after applying (bound texts, and the
+     * labels of bound arrows) -- the editor passes the host's
+     */
+    renderEnvironment?: RenderEnvironment;
 };
 /**
  * Elements change is a low level primitive to capture a change between two sets of elements.
@@ -236,7 +242,7 @@ export declare class ElementsDelta implements DeltaContainer<SceneElementsMap> {
      * should be rebound (if possible) with the current element ~ bindings should be bidirectional.
      */
     private static rebindAffected;
-    static redrawElements(nextElements: SceneElementsMap, changedElements: Map<string, OrderedExcalidrawElement>): SceneElementsMap;
+    static redrawElements(nextElements: SceneElementsMap, changedElements: Map<string, OrderedExcalidrawElement>, renderEnvironment?: RenderEnvironment): SceneElementsMap;
     private static redrawTextBoundingBoxes;
     private static redrawBoundArrows;
     private static reorderElements;

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

@@ -1,8 +1,11 @@
 import type { AppState } from "@excalidraw/excalidraw/types";
+import type { RenderEnvironment } from "./renderEnvironment";
 import type { Scene } from "./Scene";
 import type { ElementsMap, NonDeletedExcalidrawElement } from "./types";
 export interface Distribution {
     space: "between";
     axis: "x" | "y";
 }
-export declare const distributeElements: (selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap, distribution: Distribution, appState: Readonly<AppState>, scene: Scene) => NonDeletedExcalidrawElement[];
+export declare const distributeElements: (selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap, distribution: Distribution, appState: Readonly<AppState>, scene: Scene, 
+/** measures the labels of the bound arrows the distribution moves */
+renderEnvironment?: RenderEnvironment) => NonDeletedExcalidrawElement[];

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

@@ -1,5 +1,6 @@
 import type { AppState, NormalizedZoomValue, NullableGridSize, PointerDownState } from "@excalidraw/excalidraw/types";
 import type { NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { RenderEnvironment } from "./renderEnvironment";
 import type { Scene } from "./Scene";
 import type { ExcalidrawTextElement } from "./types";
 export declare const dragSelectedElements: (pointerDownState: PointerDownState, _selectedElements: NonDeletedExcalidrawElement[], offset: {
@@ -8,7 +9,9 @@ export declare const dragSelectedElements: (pointerDownState: PointerDownState,
 }, scene: Scene, snapOffset: {
     x: number;
     y: number;
-}, gridSize: NullableGridSize) => void;
+}, gridSize: NullableGridSize, 
+/** measures the labels of the bound arrows the drag moves */
+renderEnvironment?: RenderEnvironment) => void;
 export declare const getDragOffsetXY: (selectedElements: NonDeletedExcalidrawElement[], x: number, y: number) => [number, number];
 /**
  * Sizes a text element as it is dragged out.
@@ -24,7 +27,7 @@ export declare const getDragOffsetXY: (selectedElements: NonDeletedExcalidrawEle
  * over the arrow, since dragging that way makes no progress rather than
  * flipping the box around.
  */
-export declare const dragNewTextElement: ({ newElement, anchorX, anchorRatio, pointerX, nextY, zoom, scene, informMutation, }: {
+export declare const dragNewTextElement: ({ newElement, anchorX, anchorRatio, pointerX, nextY, zoom, scene, renderEnvironment, informMutation, }: {
     newElement: ExcalidrawTextElement;
     anchorX: number;
     /** 0 = anchored by its left edge, 1 = by its right, 0.5 = by its centre */
@@ -34,9 +37,10 @@ export declare const dragNewTextElement: ({ newElement, anchorX, anchorRatio, po
     nextY?: number;
     zoom: NormalizedZoomValue;
     scene: Scene;
+    renderEnvironment?: RenderEnvironment;
     informMutation?: boolean;
 }) => void;
-export declare const dragNewElement: ({ newElement, elementType, originX, originY, x, y, width, height, shouldMaintainAspectRatio, shouldResizeFromCenter, zoom, scene, widthAspectRatio, originOffset, informMutation, }: {
+export declare const dragNewElement: ({ newElement, elementType, originX, originY, x, y, width, height, shouldMaintainAspectRatio, shouldResizeFromCenter, zoom, scene, renderEnvironment, widthAspectRatio, originOffset, informMutation, }: {
     newElement: NonDeletedExcalidrawElement;
     elementType: AppState["activeTool"]["type"];
     originX: number;
@@ -49,6 +53,7 @@ export declare const dragNewElement: ({ newElement, elementType, originX, origin
     shouldResizeFromCenter: boolean;
     zoom: NormalizedZoomValue;
     scene: Scene;
+    renderEnvironment?: RenderEnvironment;
     /** whether to keep given aspect ratio when `isResizeWithSidesSameLength` is
         true */
     widthAspectRatio?: number | null;

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

@@ -16,4 +16,9 @@ export declare const updateElbowArrowPoints: (arrow: Readonly<ExcalidrawElbowArr
     isBindingEnabled?: boolean;
     isMidpointSnappingEnabled?: boolean;
 }) => ElementUpdate<ExcalidrawElbowArrowElement>;
+/**
+ * The update routing an elbow arrow again where it is, e.g. once its
+ * arrowheads change, as its route makes room for them
+ */
+export declare const updateElbowArrowRoute: <T extends ExcalidrawElbowArrowElement>(arrow: Readonly<T>, elementsMap: NonDeletedSceneElementsMap) => ElementUpdate<T>;
 export declare const validateElbowPoints: <P extends GlobalPoint | LocalPoint>(points: readonly P[], tolerance?: number) => boolean;

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

@@ -1,10 +1,11 @@
 import type { ExcalidrawProps } from "@excalidraw/excalidraw/types";
 import type { MarkRequired } from "@excalidraw/common/utility-types";
+import type { RenderEnvironment } from "./renderEnvironment";
 import type { ExcalidrawIframeLikeElement, IframeData, NonDeletedExcalidrawElement } from "./types";
 type IframeDataWithSandbox = MarkRequired<IframeData, "sandbox">;
 export declare const createSrcDoc: (body: string) => string;
 export declare const getEmbedLink: (link: string | null | undefined) => IframeDataWithSandbox | null;
-export declare const createPlaceholderEmbeddableLabel: (element: ExcalidrawIframeLikeElement) => NonDeletedExcalidrawElement;
+export declare const createPlaceholderEmbeddableLabel: (element: ExcalidrawIframeLikeElement, renderEnvironment?: RenderEnvironment) => NonDeletedExcalidrawElement;
 export declare const maybeParseEmbedSrc: (str: string) => string;
 export declare const embeddableURLValidator: (url: string | null | undefined, validateEmbeddable: ExcalidrawProps["validateEmbeddable"]) => boolean;
 export {};

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

@@ -1,11 +1,6 @@
-import type { AppClassProperties, AppState, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
-import type { Mutable } from "@excalidraw/common/utility-types";
+import type { AppState, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
 import type { GroupId, ExcalidrawElement, NonDeleted, ElementsMapOrArray, ElementsMap, NonDeletedExcalidrawElement, NonDeletedElementsMapOrArray } from "./types";
 export declare const selectGroup: (groupId: GroupId, appState: InteractiveCanvasAppState, elements: readonly NonDeletedExcalidrawElement[]) => Pick<InteractiveCanvasAppState, "selectedGroupIds" | "selectedElementIds" | "editingGroupId">;
-export declare const selectGroupsForSelectedElements: {
-    (appState: Pick<AppState, "selectedElementIds" | "editingGroupId">, elements: readonly NonDeletedExcalidrawElement[], prevAppState: InteractiveCanvasAppState, app: AppClassProperties | null): Mutable<Pick<InteractiveCanvasAppState, "selectedGroupIds" | "editingGroupId" | "selectedElementIds">>;
-    clearCache(): void;
-};
 /**
  * If the element's group is selected, don't render an individual
  * selection border around it.

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

@@ -1,12 +1,15 @@
 import type { AppClassProperties, DataURL, BinaryFiles } from "@excalidraw/excalidraw/types";
 import type { ExcalidrawElement, FileId, InitializedExcalidrawImageElement } from "./types";
-export declare const loadHTMLImageElement: (dataURL: DataURL) => Promise<HTMLImageElement>;
+export declare const loadHTMLImageElement: (dataURL: DataURL, createImage?: () => HTMLImageElement) => Promise<HTMLImageElement>;
 /** NOTE: updates cache even if already populated with given image. Thus,
  * you should filter out the images upstream if you want to optimize this. */
-export declare const updateImageCache: ({ fileIds, files, imageCache, }: {
+export declare const updateImageCache: ({ fileIds, files, imageCache, createImage, }: {
     fileIds: FileId[];
     files: BinaryFiles;
     imageCache: AppClassProperties["imageCache"];
+    /** creates images in the owner window so cross-document scenes keep
+     * runtime ownership of their HTMLImageElements */
+    createImage?: () => HTMLImageElement;
 }) => Promise<{
     imageCache: Map<FileId, {
         image: HTMLImageElement | Promise<HTMLImageElement>;

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

@@ -41,6 +41,7 @@ export * from "./mutateElement";
 export * from "./newElement";
 export * from "./positionElementsOnGrid";
 export * from "./renderElement";
+export * from "./renderEnvironment";
 export * from "./resizeElements";
 export * from "./resizeTest";
 export * from "./Scene";

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

@@ -103,10 +103,10 @@ export declare class LinearElementEditor {
     static movePoints(element: NonDeleted<ExcalidrawLinearElement>, scene: Scene, pointUpdates: PointsPositionUpdates, otherUpdates?: {
         startBinding?: FixedPointBinding | null;
         endBinding?: FixedPointBinding | null;
-        moveMidPointsWithElement?: boolean | null;
     }, options?: {
         isBindingEnabled?: boolean;
         isMidpointSnappingEnabled?: boolean;
+        moveMidPointsWithElement?: 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): {
@@ -122,6 +122,9 @@ export declare class LinearElementEditor {
      */
     static getBoundTextElementCenter: (element: ExcalidrawLinearElement, elementsMap: ElementsMap) => GlobalPoint;
     static handleBoundTextDragging(linearElementEditor: LinearElementEditor, scene: Scene, pointerX: number, pointerY: number): LinearElementEditor | null;
+    static getPathLength(element: ExcalidrawLinearElement, elementsMap: ElementsMap): number;
+    /** the path parameter (0-1) of the point on the path closest to `point` */
+    static getPathParameterAtPoint(element: ExcalidrawLinearElement, point: GlobalPoint, elementsMap: ElementsMap): number | null;
     static getPointAtPathParameter(container: ExcalidrawLinearElement, pathParameter: number, elementsMap: ElementsMap): GlobalPoint | null;
     static getBoundTextElementPosition: (element: ExcalidrawLinearElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
         x: number;

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

@@ -1,3 +1,4 @@
+import type { RenderEnvironment } from "./renderEnvironment";
 import type { Scene } from "./Scene";
 import type { ExcalidrawElement, ExcalidrawTextElement } from "./types";
 /** a list marker advanced by duplication, to go back and forth */
@@ -27,8 +28,12 @@ export type ListMarkerAdvance = {
  * Only if nothing but list items (texts, or containers with list item labels)
  * is duplicated.
  */
-export declare const advanceDuplicatedListMarkers: (duplicatedElements: readonly ExcalidrawElement[], scene: Scene) => ListMarkerAdvance[];
+export declare const advanceDuplicatedListMarkers: (duplicatedElements: readonly ExcalidrawElement[], scene: Scene, 
+/** measures the re-numbered texts */
+renderEnvironment?: RenderEnvironment) => ListMarkerAdvance[];
 /**
  * Sets the advanced list markers back (`"prev"`), or forth again (`"next"`).
  */
-export declare const applyListMarkerAdvances: (advances: readonly ListMarkerAdvance[], direction: "prev" | "next", scene: Scene) => void;
+export declare const applyListMarkerAdvances: (advances: readonly ListMarkerAdvance[], direction: "prev" | "next", scene: Scene, 
+/** measures the re-numbered texts */
+renderEnvironment?: RenderEnvironment) => void;

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

@@ -1,4 +1,5 @@
 import type { MarkOptional } from "@excalidraw/common/utility-types";
+import type { RenderEnvironment } from "./renderEnvironment";
 import type { ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawIframeElement, ElementsMap, ExcalidrawArrowElement, ExcalidrawElbowArrowElement, ExcalidrawLineElement, ExcalidrawStickyNoteElement } from "./types";
 export type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "frameId" | "index" | "boundElements" | "seed" | "version" | "versionNonce" | "link" | "strokeStyle" | "fillStyle" | "strokeColor" | "backgroundColor" | "roughness" | "strokeWidth" | "roundness" | "locked" | "opacity" | "customData" | "created">;
 export declare const newElement: (opts: {
@@ -61,6 +62,7 @@ export declare const newTextElement: (opts: {
     autoResize?: ExcalidrawTextElement["autoResize"];
     labelPosition?: ExcalidrawTextElement["labelPosition"];
     baseFontSize?: ExcalidrawTextElement["baseFontSize"];
+    renderEnvironment?: RenderEnvironment;
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawTextElement>;
 export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null, elementsMap: ElementsMap, text?: string, 
 /**
@@ -69,7 +71,7 @@ export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement,
  * width from then on (`autoResize: false`), anchored as its growth was. A
  * text that is already wider keeps growing.
  */
-maxWidth?: number) => {
+maxWidth?: number, renderEnvironment?: RenderEnvironment) => {
     x: number;
     y: number;
     width: number;

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

@@ -1,6 +1,7 @@
 import { type GlobalPoint } from "@excalidraw/math";
 import type { AppState, StaticCanvasAppState, InteractiveCanvasAppState, ElementRenderOverrides } from "@excalidraw/excalidraw/types";
 import type { StaticCanvasRenderConfig, RenderableElementsMap, InteractiveCanvasRenderConfig } from "@excalidraw/excalidraw/scene/types";
+import type { RenderEnvironment } from "./renderEnvironment";
 import type { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawImageElement, NonDeletedSceneElementsMap, ElementsMap } from "./types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
 export type RenderPositionOffset = Readonly<{
@@ -22,6 +23,9 @@ export interface ExcalidrawElementWithCanvas {
     canvas: HTMLCanvasElement;
     theme: AppState["theme"];
     scale: number;
+    /** backing-store scale the bitmap was rasterized at, see StaticCanvasRenderConfig["scale"] */
+    deviceScale: number;
+    environment: RenderEnvironment;
     zoomValue: AppState["zoom"]["value"];
     canvasOffsetX: number;
     canvasOffsetY: number;
@@ -29,6 +33,12 @@ export interface ExcalidrawElementWithCanvas {
     containingFrameOpacity: number;
 }
 export declare const DEFAULT_LINK_SIZE = 14;
+/**
+ * `save()`s the context around `draw`, restoring it even when `draw` throws:
+ * the scene renderer logs a failing element and carries on, and the element
+ * mustn't leave its transforms and clips behind for the next one.
+ */
+export declare const withSavedContext: (context: CanvasRenderingContext2D, draw: () => void) => void;
 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, renderState?: Readonly<{

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

@@ -0,0 +1,66 @@
+/**
+ * Host environment used by the renderer and export pipeline.
+ *
+ * The default is the browser's. An explicit environment (see
+ * `StaticCanvasRenderConfig["renderEnvironment"]`) scopes canvas and image
+ * creation to one render target -- e.g. the editor's owner window, so that
+ * one process can host editors in multiple realms (popouts, multi-tenant
+ * embeds), or an export running where `document`/`window` don't exist (Node
+ * with `node-canvas` / `@napi-rs/canvas`, passed in `config.environment`).
+ * There is deliberately no process-wide override: every render and export
+ * takes its environment explicitly.
+ *
+ * `document` is the DOM side of the same host: what SVG exports are built in
+ * (a DOM implementation such as `linkedom` under Node).
+ */
+import type { TextMetricsProvider } from "./textMeasurements";
+export type RenderEnvironment = {
+    /** Creates a blank canvas. Callers set `width`/`height` themselves. */
+    createCanvas: () => HTMLCanvasElement;
+    /**
+     * Creates an image to be decoded from a data URL and later used as a
+     * `drawImage` source.
+     *
+     * NOTE: typed as `HTMLImageElement` because the renderer is typed against
+     * the DOM lib throughout. Non-DOM implementations (node-canvas et al) need
+     * to cast; they must support `src`, `onload`, `onerror`, `naturalWidth`,
+     * `naturalHeight` and be accepted by their canvas' `drawImage`.
+     */
+    createImage: () => HTMLImageElement;
+    /**
+     * Creates a fillable path from an SVG path string -- freedraw elements are
+     * filled through one.
+     *
+     * Optional, because browsers always have the global `Path2D` this falls back
+     * to. A Node host MUST supply it (e.g. `@napi-rs/canvas`'s `Path2D`) or
+     * install `globalThis.Path2D` itself: Node has no such global, and without
+     * one every freedraw element fails to render.
+     */
+    createPath?: (svgPath: string) => Path2D;
+    /**
+     * The document SVG exports are built in: the editor's owner document, or
+     * outside the browser a DOM implementation's (e.g. `linkedom`).
+     *
+     * Optional; falls back to the global `document`.
+     */
+    document?: Document;
+    /**
+     * Measures text (line widths, for wrapping and layout).
+     *
+     * Optional; falls back to the global provider set with
+     * `setCustomTextMetricsProvider`, else to measuring on a canvas from
+     * `createCanvas`.
+     */
+    textMetrics?: TextMetricsProvider;
+};
+/**
+ * Resolves the host environment for a render: the explicitly scoped one (e.g.
+ * the editor's owner window, or an export's), else the browser default.
+ */
+export declare const getRenderEnvironment: (env?: RenderEnvironment) => RenderEnvironment;
+/**
+ * Resolves the path factory for a render. `createPath` is the one optional
+ * member of the contract, so this fills in the global-`Path2D` default for
+ * environments that omit it.
+ */
+export declare const getCreatePath: (env?: RenderEnvironment) => ((svgPath: string) => Path2D);

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

@@ -1,10 +1,11 @@
 import { type LocalPoint } from "@excalidraw/math";
 import type { PointerDownState } from "@excalidraw/excalidraw/types";
+import type { RenderEnvironment } from "./renderEnvironment";
 import type { Scene } from "./Scene";
 import type { BoundingBox } from "./bounds";
 import type { MaybeTransformHandleType, TransformHandleDirection } from "./transformHandles";
-import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ElementsMap } from "./types";
-export declare const transformElements: (originalElements: PointerDownState["originalElements"], transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], scene: Scene, shouldRotateWithDiscreteAngle: boolean, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number, centerX: number, centerY: number) => boolean;
+import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawElement, ElementsMap } from "./types";
+export declare const transformElements: (originalElements: PointerDownState["originalElements"], transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], scene: Scene, shouldRotateWithDiscreteAngle: boolean, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number, centerX: number, centerY: number, renderEnvironment?: RenderEnvironment) => boolean;
 export declare const rescalePointsInElement: (element: NonDeletedExcalidrawElement, width: number, height: number, normalizePoints: boolean) => {
     points: LocalPoint[];
 } | {
@@ -13,15 +14,23 @@ export declare const rescalePointsInElement: (element: NonDeletedExcalidrawEleme
 export declare const measureFontSizeFromWidth: (element: NonDeleted<ExcalidrawTextElement>, elementsMap: ElementsMap, nextWidth: number) => {
     size: number;
 } | null;
-export declare const resizeSingleTextElement: (origElement: NonDeleted<ExcalidrawTextElement>, element: NonDeleted<ExcalidrawTextElement>, scene: Scene, transformHandleType: TransformHandleDirection, shouldResizeFromCenter: boolean, nextWidth: number, nextHeight: number) => void;
+export declare const resizeSingleTextElement: (origElement: NonDeleted<ExcalidrawTextElement>, element: NonDeleted<ExcalidrawTextElement>, scene: Scene, transformHandleType: TransformHandleDirection, shouldResizeFromCenter: boolean, nextWidth: number, nextHeight: number, renderEnvironment?: RenderEnvironment) => void;
 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: NonDeletedExcalidrawElement, origElement: NonDeletedExcalidrawElement, originalElementsMap: ElementsMap, scene: Scene, handleDirection: TransformHandleDirection, { shouldInformMutation, shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
+export declare const resizeSingleElement: (nextWidth: number, nextHeight: number, latestElement: NonDeletedExcalidrawElement, origElement: NonDeletedExcalidrawElement, originalElementsMap: ElementsMap, scene: Scene, handleDirection: TransformHandleDirection, { shouldInformMutation, shouldMaintainAspectRatio, shouldResizeFromCenter, renderEnvironment, }?: {
     shouldMaintainAspectRatio?: boolean;
     shouldResizeFromCenter?: boolean;
     shouldInformMutation?: boolean;
+    renderEnvironment?: RenderEnvironment;
 }) => void;
-export declare const resizeMultipleElements: (selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, handleDirection: TransformHandleDirection, scene: Scene, originalElementsMap: ElementsMap, { shouldMaintainAspectRatio, shouldResizeFromCenter, flipByX, flipByY, nextHeight, nextWidth, originalBoundingBox, }?: {
+export declare const getNextSingleWidthAndHeightFromPointer: (latestElement: ExcalidrawElement, origElement: ExcalidrawElement, handleDirection: TransformHandleDirection, pointerX: number, pointerY: number, { shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
+    shouldMaintainAspectRatio?: boolean;
+    shouldResizeFromCenter?: boolean;
+}) => {
+    nextWidth: number;
+    nextHeight: number;
+};
+export declare const resizeMultipleElements: (selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, handleDirection: TransformHandleDirection, scene: Scene, originalElementsMap: ElementsMap, { shouldMaintainAspectRatio, shouldResizeFromCenter, flipByX, flipByY, nextHeight, nextWidth, originalBoundingBox, renderEnvironment, }?: {
     nextWidth?: number;
     nextHeight?: number;
     shouldMaintainAspectRatio?: boolean;
@@ -29,4 +38,5 @@ export declare const resizeMultipleElements: (selectedElements: readonly NonDele
     flipByX?: boolean;
     flipByY?: boolean;
     originalBoundingBox?: BoundingBox;
+    renderEnvironment?: RenderEnvironment;
 }) => void;

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

@@ -1,6 +1,6 @@
 import type { AppState, BoxSelectionMode, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
-import { LinearElementEditor } from "./linearElementEditor";
 import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement } from "./types";
+export declare const shouldIgnoreElementFromSelection: (element: ExcalidrawElement) => boolean;
 /**
  * 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
@@ -26,12 +26,6 @@ export declare const getTargetElements: (elements: ElementsMapOrArray, appState:
 export declare const makeNextSelectedElementIds: (nextSelectedElementIds: AppState["selectedElementIds"], prevState: Pick<AppState, "selectedElementIds">) => Readonly<{
     [id: string]: true;
 }>;
-export declare const getSelectionStateForElements: (targetElements: readonly NonDeletedExcalidrawElement[], allElements: readonly NonDeletedExcalidrawElement[], appState: AppState) => {
-    editingGroupId: AppState["editingGroupId"];
-    selectedElementIds: AppState["selectedElementIds"];
-    selectedGroupIds: AppState["selectedGroupIds"];
-    selectedLinearElement: LinearElementEditor | null;
-};
 /**
  * Returns editing or single-selected text element, if any.
  */

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

@@ -36,6 +36,8 @@ export declare const generateLinearCollisionShape: (element: ExcalidrawLinearEle
     op: string;
     data: number[];
 }[];
+export declare const ELBOW_ARROW_CORNER_RADIUS = 16;
+export declare const generateElbowArrowShape: (routePoints: readonly LocalPoint[], radius: number) => string;
 /**
  * get the pure geometric shape of an excalidraw elementw
  * which is then used for hit detection