@excalidraw/element 0.18.0-063e025 → 0.18.0-1118751

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

@@ -1,6 +1,32 @@
 import type { Mutable } from "@excalidraw/common/utility-types";
 import type { AppState } from "@excalidraw/excalidraw/types";
 import type { ExcalidrawElement, GroupId, NonDeletedExcalidrawElement } from "./types";
+/**
+ * Lookups supplied to the host's `props.onDuplicate`, covering just the
+ * elements taking part in the duplication.
+ */
+export type OnDuplicateData = {
+    /** the duplicates, by their id */
+    duplicateElements: ReadonlyMap<ExcalidrawElement["id"], ExcalidrawElement>;
+    /**
+     * The elements the duplicates were made from, by their id.
+     *
+     * On paste and library insert these are the inserted elements, which aren't
+     * part of the scene (though they may share ids with the scene elements they
+     * were copied from).
+     */
+    originalElements: ReadonlyMap<ExcalidrawElement["id"], ExcalidrawElement>;
+    /**
+     * id of an original -> id of its duplicate (e.g. to remap element ids you
+     * keep in `customData`, which the duplicate copied from its original)
+     */
+    origIdToDuplicateId: ReadonlyMap<ExcalidrawElement["id"], ExcalidrawElement["id"]>;
+    /**
+     * id of a duplicate -> id of its original (e.g. to look up the original in
+     * `originalElements` while modifying the duplicate)
+     */
+    duplicateIdToOrigId: ReadonlyMap<ExcalidrawElement["id"], ExcalidrawElement["id"]>;
+};
 /**
  * Duplicate an element, often used in the alt-drag operation.
  * Note that this method has gotten a bit complicated since the
@@ -49,8 +75,42 @@ export declare const duplicateElements: (opts: {
 })) => {
     duplicatedElements: NonDeletedExcalidrawElement[];
     duplicateElementsMap: Map<string, NonDeletedExcalidrawElement>;
+    origElementsMap: Map<string, ExcalidrawElement>;
     elementsWithDuplicates: ExcalidrawElement[];
     origIdToDuplicateId: Map<string, string>;
+    duplicateIdToOrigId: Map<string, string>;
+};
+/**
+ * Folds the elements returned by the host (`props.onDuplicate`) back into the
+ * duplicates the editor created, so that everything that follows (frame
+ * assignment, bound text redraw, selection, alt-drag handover) can keep
+ * working with the editor's own objects, whether the host mutated the
+ * duplicates or returned new objects for them.
+ *
+ * - A returned element with a duplicate's id is shallow-merged into that
+ *   duplicate, which takes its place in the returned array. Properties the
+ *   host omits are kept, so that a partial element can't invalidate the
+ *   duplicate. Safe only because the duplicates are fresh (not in the scene or
+ *   the store snapshot yet), which is why nothing but the passed duplicates is
+ *   ever merged into. Since the merge goes around `mutateElement`, what may
+ *   have been cached for the duplicate by then is invalidated here.
+ * - A duplicate missing from the returned array (or returned as deleted) is
+ *   vetoed. So is the bound text of a vetoed container. What the remaining
+ *   duplicates reference of the vetoed ones is cleared, as if those were never
+ *   part of the duplication (see `fixDuplicatedBindingsAfterDuplication`).
+ * - Any other returned element is used as is (existing elements must not be
+ *   mutated, so the host replaces them).
+ * - `false` vetoes all the duplicates.
+ *
+ * @returns next elements, and the duplicates that weren't vetoed
+ */
+export declare const reconcileDuplicatedElements: <TDuplicate extends ExcalidrawElement>(
+/** what the host returned from `props.onDuplicate`, if anything */
+hostElements: readonly ExcalidrawElement[] | void | false, 
+/** elements that were passed to the host */
+nextElements: ExcalidrawElement[], duplicatedElements: TDuplicate[]) => {
+    elements: ExcalidrawElement[];
+    duplicatedElements: TDuplicate[];
 };
 /**
  * Clones ExcalidrawElement data structure. Does not regenerate id, nonce, or

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

@@ -1,10 +1,11 @@
 import type { AppState, PendingExcalidrawElements } from "@excalidraw/excalidraw/types";
-import { type NonDeleted, type ElementsMap, type ExcalidrawBindableElement, type ExcalidrawElement, type ExcalidrawFlowchartNodeElement, type NonDeletedExcalidrawElement } from "./types";
+import { type NonDeleted, type ElementsMap, type ExcalidrawElement, type ExcalidrawFlowchartNodeElement, type NonDeletedExcalidrawElement } from "./types";
 import type { Scene } from "./Scene";
-type LinkDirection = "up" | "right" | "down" | "left";
-export declare const getLinkDirectionFromKey: (key: string) => LinkDirection;
-export declare const getPredecessors: (node: ExcalidrawBindableElement, elementsMap: ElementsMap, direction: LinkDirection) => ExcalidrawBindableElement[];
-export declare const addNewNodes: (startNode: NonDeleted<ExcalidrawFlowchartNodeElement>, appState: AppState, direction: LinkDirection, scene: Scene, numberOfNodes: number) => NonDeletedExcalidrawElement[];
+export type LinkDirection = "up" | "right" | "down" | "left";
+export declare const addNewNodes: (startNode: NonDeleted<ExcalidrawFlowchartNodeElement>, appState: AppState, direction: LinkDirection, scene: Scene, numberOfNodes: number, stickyCrossStart?: number | null) => {
+    nodes: NonDeletedExcalidrawElement[];
+    crossStart: number;
+};
 export declare class FlowChartNavigator {
     isExploring: boolean;
     private sameLevelNodes;
@@ -13,14 +14,17 @@ export declare class FlowChartNavigator {
     private visitedNodes;
     clear(): void;
     exploreByDirection(element: ExcalidrawElement, elementsMap: ElementsMap, direction: LinkDirection): ExcalidrawElement["id"] | null;
+    private static getNodeRelatives;
+    private static getSuccessors;
+    private static getPredecessors;
 }
 export declare class FlowChartCreator {
     isCreatingChart: boolean;
     private numberOfNodes;
     private direction;
+    private clusterCrossStart;
     pendingNodes: PendingExcalidrawElements | null;
     createNodes(startNode: NonDeleted<ExcalidrawFlowchartNodeElement>, appState: AppState, direction: LinkDirection, scene: Scene): void;
     clear(): void;
 }
 export declare const isNodeInFlowchart: (element: ExcalidrawFlowchartNodeElement, elementsMap: ElementsMap) => boolean;
-export {};

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

@@ -31,8 +31,8 @@ export declare const getFrameLikeElements: (allElements: ExcalidrawElementsInclu
  */
 export declare const getRootElements: <T extends ExcalidrawElement>(allElements: readonly T[]) => T[];
 export declare const getElementsInResizingFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, appState: AppState, elementsMap: ElementsMap) => ExcalidrawElement[];
-export declare const getElementsInNewFrame: (elements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => (import("./types").ExcalidrawLinearElement | import("./types").ExcalidrawSelectionElement | 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 | import("./types").ExcalidrawFreeDrawElement)[];
-export declare const omitPartialGroups: (elements: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, allElementsMap: ElementsMap) => (import("./types").ExcalidrawLinearElement | import("./types").ExcalidrawSelectionElement | 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 | import("./types").ExcalidrawFreeDrawElement)[];
+export declare const getElementsInNewFrame: (elements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => (import("./types").ExcalidrawLinearElement | import("./types").ExcalidrawSelectionElement | import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawStickyNoteElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawEmbeddableElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawTextElement | import("./types").ExcalidrawFreeDrawElement)[];
+export declare const omitPartialGroups: (elements: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, allElementsMap: ElementsMap) => (import("./types").ExcalidrawLinearElement | import("./types").ExcalidrawSelectionElement | import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawStickyNoteElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawEmbeddableElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawTextElement | import("./types").ExcalidrawFreeDrawElement)[];
 export declare const getContainingFrame: (element: ExcalidrawElement, elementsMap: ElementsMap) => ExcalidrawFrameLikeElement | null;
 /** */
 export declare const filterElementsEligibleAsFrameChildren: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];

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

@@ -31,4 +31,4 @@ export declare const getNonDeletedGroupIds: (elements: ElementsMap) => Set<strin
 export declare const elementsAreInSameGroup: (elements: readonly ExcalidrawElement[]) => boolean;
 export declare const isInGroup: (element: ExcalidrawElement) => boolean;
 export declare const getNewGroupIdsForDuplication: (groupIds: ExcalidrawElement["groupIds"], editingGroupId: AppState["editingGroupId"], mapper: (groupId: GroupId) => GroupId) => string[];
-export declare const getSelectedElementsByGroup: (selectedElements: ExcalidrawElement[], elementsMap: ElementsMap, appState: Readonly<Pick<AppState, "selectedGroupIds" | "editingGroupId">>) => NonDeletedExcalidrawElement[][];
+export declare const getSelectedElementsByGroup: (selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap, appState: Readonly<Pick<AppState, "selectedGroupIds" | "editingGroupId">>) => NonDeletedExcalidrawElement[][];

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

@@ -12,8 +12,10 @@ export declare const isNonDeletedElement: <T extends ExcalidrawElement>(element:
 export declare const getVisibleElements: (elements: readonly ExcalidrawElement[]) => readonly NonDeletedExcalidrawElement[];
 export declare const getNonDeletedElements: <T extends ExcalidrawElement>(elements: readonly T[]) => readonly NonDeleted<T>[];
 export * from "./align";
+export * from "./arrowEndpointText";
 export * from "./binding";
 export * from "./bounds";
+export * from "./bucketFill";
 export * from "./collision";
 export * from "./comparisons";
 export * from "./containerCache";
@@ -47,6 +49,7 @@ export * from "./showSelectedShapeActions";
 export * from "./sizeHelpers";
 export * from "./sortElements";
 export * from "./store";
+export * from "./stickyNote";
 export * from "./textElement";
 export * from "./textMeasurements";
 export * from "./textWrapping";
@@ -57,3 +60,4 @@ export * from "./utils";
 export * from "./zindex";
 export * from "./arrows/helpers";
 export * from "./arrowheads";
+export * from "./convertToShape";

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

@@ -22,6 +22,7 @@ export declare class LinearElementEditor {
         };
         arrowStartIsInside: boolean;
         altFocusPoint: Readonly<GlobalPoint> | null;
+        arrowOtherEndpointInitialBinding: FixedPointBinding | null;
     }>;
     /** whether you're dragging a point */
     readonly isDragging: boolean;
@@ -64,6 +65,8 @@ export declare class LinearElementEditor {
     }, linearElementEditor: LinearElementEditor, scene: Scene): {
         didAddPoint: boolean;
         hitElement: NonDeleted<ExcalidrawElement> | null;
+        /** the pointer went down on the arrow's label, grabbing it for a drag */
+        hitBoundText: boolean;
         linearElementEditor: LinearElementEditor | null;
     };
     static arePointsEqual<Point extends LocalPoint | GlobalPoint>(point1: Point | null, point2: Point | null): boolean;
@@ -75,6 +78,11 @@ export declare class LinearElementEditor {
     static getPointAtIndexGlobalCoordinates(element: ExcalidrawLinearElement, indexMaybeFromEnd: number, // -1 for last element
     elementsMap: ElementsMap): GlobalPoint;
     static pointFromAbsoluteCoords(element: ExcalidrawLinearElement, absoluteCoords: GlobalPoint, elementsMap: ElementsMap): LocalPoint;
+    /**
+     * Whether the point at `index` is an interactive handle. Elbow arrows only
+     * expose their endpoints; their intermediate route points are not draggable.
+     */
+    static isPointHandle(element: ExcalidrawLinearElement, index: number): boolean;
     static getPointIndexUnderCursor(element: ExcalidrawLinearElement, elementsMap: ElementsMap, zoom: AppState["zoom"], x: number, y: number): number;
     static createPointAt(element: ExcalidrawLinearElement, elementsMap: ElementsMap, scenePointerX: number, scenePointerY: number, gridSize: NullableGridSize): LocalPoint;
     /**
@@ -107,10 +115,19 @@ export declare class LinearElementEditor {
     } | undefined;
     private static _updatePoints;
     private static _getShiftLockedDelta;
+    /**
+     * The point a bound text label is centered on — the middle of the linear
+     * element, whether that's an actual point or the midpoint of the middle
+     * segment.
+     */
+    static getBoundTextElementCenter: (element: ExcalidrawLinearElement, elementsMap: ElementsMap) => GlobalPoint;
+    static handleBoundTextDragging(linearElementEditor: LinearElementEditor, scene: Scene, pointerX: number, pointerY: number): LinearElementEditor | null;
+    static getPointAtPathParameter(container: ExcalidrawLinearElement, pathParameter: number, elementsMap: ElementsMap): GlobalPoint | null;
     static getBoundTextElementPosition: (element: ExcalidrawLinearElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
         x: number;
         y: number;
     };
+    private static computeBoundTextElementPosition;
     static getMinMaxXYWithBoundText: (element: ExcalidrawLinearElement, elementsMap: ElementsMap, elementBounds: Bounds, boundTextElement: ExcalidrawTextElementWithContainer) => [number, number, number, number, number, number];
     static getElementAbsoluteCoords: (element: ExcalidrawLinearElement, elementsMap: ElementsMap, includeBoundText?: boolean) => [number, number, number, number, number, number];
     static moveFixedSegment(linearElement: LinearElementEditor, index: number, x: number, y: number, scene: Scene): Pick<LinearElementEditor, "segmentMidPointHoveredCoords" | "initialState">;

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

@@ -1,6 +1,6 @@
 import type { Mutable } from "@excalidraw/common/utility-types";
 import type { ElementsMap, ExcalidrawElement } from "./types";
-export type ElementUpdate<TElement extends ExcalidrawElement> = Omit<Partial<TElement>, "id" | "updated">;
+export type ElementUpdate<TElement extends ExcalidrawElement> = Omit<Partial<TElement>, "id" | "updated" | "created">;
 /**
  * This function tracks updates of text elements for the purposes for collaboration.
  * The version is used to compare updates when more than one user is working in

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

@@ -1,9 +1,29 @@
 import type { MarkOptional } from "@excalidraw/common/utility-types";
-import type { ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawIframeElement, ElementsMap, ExcalidrawArrowElement, ExcalidrawElbowArrowElement, ExcalidrawLineElement } 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">;
+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: {
     type: ExcalidrawGenericElement["type"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawGenericElement>;
+/**
+ * Style invariants of a sticky note: never-transparent colors, solid fill.
+ * Applied by the constructor and by every normalization pass. Returns the
+ * same object when nothing needs fixing.
+ */
+export declare const normalizeStickyNoteStyle: <T extends ExcalidrawStickyNoteElement>(element: T) => T;
+/**
+ * Geometry invariants of a *finalized* sticky note: minimum size and
+ * `baseHeight ≤ height`. Deliberately not part of the constructor — a
+ * pointer-down draft starts at 0×0 like every other tool and is previewed at
+ * its true dragged size; pointer-up, restore, the skeleton path and the
+ * action post-passes enforce this.
+ */
+export declare const normalizeStickyNoteGeometry: <T extends ExcalidrawStickyNoteElement>(element: T) => T;
+/** all sticky note invariants (style + finalized geometry) */
+export declare const normalizeStickyNote: <T extends ExcalidrawStickyNoteElement>(element: T) => T;
+export declare const newStickyNoteElement: (opts: {
+    type: "stickynote";
+    baseHeight?: number;
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawStickyNoteElement>;
 export declare const newEmbeddableElement: (opts: {
     type: "embeddable";
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawEmbeddableElement>;
@@ -16,6 +36,19 @@ export declare const newFrameElement: (opts: {
 export declare const newMagicFrameElement: (opts: {
     name?: string;
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawMagicFrameElement>;
+/**
+ * The point of the text box its alignment pins, as ratios of width/height.
+ *
+ * This is the point that stays put as the text grows — see the sides passed to
+ * `adjustXYWithRotation` in `getAdjustedDimensions`.
+ */
+export declare const getTextAnchorRatios: (opts: {
+    textAlign: ExcalidrawTextElement["textAlign"];
+    verticalAlign: ExcalidrawTextElement["verticalAlign"];
+}) => {
+    x: number;
+    y: number;
+};
 export declare const newTextElement: (opts: {
     text: string;
     originalText?: string;
@@ -26,6 +59,8 @@ export declare const newTextElement: (opts: {
     containerId?: ExcalidrawTextContainer["id"] | null;
     lineHeight?: ExcalidrawTextElement["lineHeight"];
     autoResize?: ExcalidrawTextElement["autoResize"];
+    labelPosition?: ExcalidrawTextElement["labelPosition"];
+    baseFontSize?: ExcalidrawTextElement["baseFontSize"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawTextElement>;
 export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null, elementsMap: ElementsMap, text?: string) => {
     x: number;

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

@@ -1,9 +1,22 @@
 import { type GlobalPoint } from "@excalidraw/math";
-import type { AppState, StaticCanvasAppState, InteractiveCanvasAppState, ElementsPendingErasure, PendingExcalidrawElements } from "@excalidraw/excalidraw/types";
+import type { AppState, StaticCanvasAppState, InteractiveCanvasAppState, ElementRenderOverrides } from "@excalidraw/excalidraw/types";
 import type { StaticCanvasRenderConfig, RenderableElementsMap, InteractiveCanvasRenderConfig } from "@excalidraw/excalidraw/scene/types";
-import type { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawImageElement, ExcalidrawFrameLikeElement, NonDeletedSceneElementsMap, ElementsMap } from "./types";
+import type { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawImageElement, NonDeletedSceneElementsMap, ElementsMap } from "./types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
-export declare const getRenderOpacity: (element: ExcalidrawElement, containingFrame: ExcalidrawFrameLikeElement | null, elementsPendingErasure: ElementsPendingErasure, pendingNodes: Readonly<PendingExcalidrawElements> | null, globalAlpha?: number) => number;
+export type RenderPositionOffset = Readonly<{
+    x: number;
+    y: number;
+}>;
+/** Bound labels follow their container; a label's own offset is ignored. */
+export declare const getElementRenderOffset: (element: ExcalidrawElement, elementsMap: ElementsMap, overrides: ElementRenderOverrides | undefined) => RenderPositionOffset | undefined;
+export declare const getRenderElementWithPositionOverride: <TElement extends ExcalidrawElement>(element: TElement, positionOffset: RenderPositionOffset) => TElement;
+export type ElementRenderState = Readonly<{
+    /** Alpha including frame opacity and pending erasure; selection dimming is separate. */
+    opacity: number;
+    offset: RenderPositionOffset;
+}>;
+/** Resolve visual state at the drawing boundary, preserving document cache keys. */
+export declare const resolveElementRenderState: (element: ExcalidrawElement, elementsMap: ElementsMap, renderConfig: Pick<StaticCanvasRenderConfig, "elementRenderOverrides" | "elementsPendingErasure" | "pendingFlowchartNodes">, allElementsMap?: ElementsMap) => ElementRenderState;
 export interface ExcalidrawElementWithCanvas {
     element: ExcalidrawElement | ExcalidrawTextElement;
     canvas: HTMLCanvasElement;
@@ -18,5 +31,9 @@ export interface ExcalidrawElementWithCanvas {
 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 renderElement: (element: NonDeletedExcalidrawElement, elementsMap: RenderableElementsMap, allElementsMap: NonDeletedSceneElementsMap, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: StaticCanvasRenderConfig, appState: StaticCanvasAppState | InteractiveCanvasAppState, renderState?: Readonly<{
+    /** Alpha including frame opacity and pending erasure; selection dimming is separate. */
+    opacity: number;
+    offset: RenderPositionOffset;
+}>) => void;
 export declare function getFreedrawOutlineAsSegments(element: ExcalidrawFreeDrawElement, points: [number, number][], elementsMap: ElementsMap): import("@excalidraw/math").LineSegment<GlobalPoint>[];

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

@@ -18,7 +18,7 @@ export declare const getSelectedElements: (elements: ElementsMapOrArray, appStat
     includeBoundTextElement?: boolean;
     includeElementsInFrames?: boolean;
 }) => NonDeletedExcalidrawElement[];
-export declare const getTargetElements: (elements: ElementsMapOrArray, appState: Pick<AppState, "selectedElementIds" | "editingTextElement" | "newElement">) => NonDeletedExcalidrawElement[] | import("./types").ExcalidrawTextElement[];
+export declare const getTargetElements: (elements: ElementsMapOrArray, appState: Pick<AppState, "selectedElementIds" | "editingTextElement" | "newElement" | "activeTool">) => NonDeletedExcalidrawElement[] | import("./types").ExcalidrawTextElement[];
 /**
  * returns prevState's selectedElementids if no change from previous, so as to
  * retain reference identity for memoization

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

@@ -1,6 +1,6 @@
 import { type GeometricShape } from "@excalidraw/utils/shape";
 import { type LocalPoint } from "@excalidraw/math";
-import type { GlobalPoint } from "@excalidraw/math";
+import type { GlobalPoint, Polygon } from "@excalidraw/math";
 import type { AppState, EmbedsValidationStatus } from "@excalidraw/excalidraw/types";
 import type { ElementShape, ElementShapes } from "@excalidraw/excalidraw/scene/types";
 import type { ExcalidrawElement, ExcalidrawSelectionElement, ExcalidrawLinearElement, ExcalidrawFreeDrawElement, ElementsMap, ExcalidrawLineElement } from "./types";
@@ -27,6 +27,11 @@ 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;
+/**
+ * Returns the flattened fill contour of a freedraw loop in local, unrotated
+ * coordinates, following the rendered fill rather than the stroke outline.
+ */
+export declare const getFreedrawFillPolygon: (element: ExcalidrawFreeDrawElement) => Polygon<LocalPoint>;
 export declare const generateLinearCollisionShape: (element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement, elementsMap: ElementsMap) => {
     op: string;
     data: number[];
@@ -41,3 +46,24 @@ export declare const toggleLinePolygonState: (element: ExcalidrawLineElement, ne
     points: ExcalidrawLineElement["points"];
 } | null;
 export declare const getFreedrawOutlinePoints: (element: ExcalidrawFreeDrawElement) => [number, number][];
+/**
+ * Upper bound on how far a freedraw stroke's ink reaches past its centerline
+ * points. Both stroke generators scale the stroke size by at most 1 (easing
+ * or pressure), so the size itself bounds the radius, except for
+ * perfect-freehand's short strokes: under 3px long, the start cap is drawn
+ * around the first point from an outline point of the last one (reaching
+ * sqrt(size² + 3²)), and a single point gets a synthetic neighbor 1px away.
+ */
+export declare const getFreedrawMaxStrokeRadius: (element: ExcalidrawFreeDrawElement) => number;
+/**
+ * The streamline-smoothed centerline the freedraw stroke is rendered
+ * around, in element-local coordinates. Boundary-sensitive consumers (e.g.
+ * bucket fill) should use this instead of `element.points`: raw input
+ * points can sit 20px+ apart and the rendered stroke is smoothed between
+ * them, so raw chords visibly deviate from what's on screen.
+ *
+ * Constant-width ("laser geometry") strokes technically smooth via
+ * `LaserPointer` instead; the perfect-freehand centerline with the same
+ * `streamline` is a close approximation the stroke width hides.
+ */
+export declare const getFreedrawStrokeCenterPoints: (element: ExcalidrawFreeDrawElement) => [number, number][];

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

@@ -1,5 +1,11 @@
 import type { AppState, Offsets, Zoom } from "@excalidraw/excalidraw/types";
 import type { ElementsMap, ExcalidrawElement } from "./types";
+export type VerticalResizeAnchor = "top" | "bottom" | "center";
+/** Keeps the chosen edge or center fixed when an element's height changes. */
+export declare const getPositionAfterHeightChange: (element: Pick<ExcalidrawElement, "x" | "y" | "height" | "angle">, nextHeight: number, anchor?: VerticalResizeAnchor) => {
+    x: number;
+    y: number;
+};
 export declare const INVISIBLY_SMALL_ELEMENT_SIZE = 0.1;
 export declare const isInvisiblySmallElement: (element: ExcalidrawElement) => boolean;
 export declare const isElementInViewport: (element: ExcalidrawElement, width: number, height: number, viewTransformations: {

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

@@ -1,2 +1,12 @@
 import type { ExcalidrawElement } from "./types";
+/**
+ * In theory, when we have text elements bound to a container, they
+ * should be right after the container element in the elements array.
+ * However, this is not guaranteed due to old and potential future bugs.
+ *
+ * This function sorts containers and their bound texts together. It prefers
+ * original z-index of container (i.e. it moves bound text elements after
+ * containers).
+ */
+export declare const normalizeBoundElementsOrder: <T extends ExcalidrawElement>(elements: readonly T[]) => readonly T[];
 export declare const normalizeElementOrder: (elements: readonly ExcalidrawElement[]) => readonly ExcalidrawElement[];

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

@@ -0,0 +1,183 @@
+import type { Scene } from "./Scene";
+import type { VerticalResizeAnchor } from "./sizeHelpers";
+import type { TransformHandleDirection } from "./transformHandles";
+import type { ElementsMap, ExcalidrawElement, ExcalidrawStickyNoteElement, ExcalidrawTextElement, NonDeletedExcalidrawElement } from "./types";
+export type StickyNoteRenderPoint = {
+    x: number;
+    y: number;
+};
+export type StickyNotePathCommand = {
+    type: "move";
+    point: StickyNoteRenderPoint;
+} | {
+    type: "line";
+    point: StickyNoteRenderPoint;
+} | {
+    type: "quadratic";
+    control: StickyNoteRenderPoint;
+    point: StickyNoteRenderPoint;
+};
+export declare const normalizeStickyNoteStrokeColor: (strokeColor: string | null | undefined) => string;
+export declare const normalizeStickyNoteBackgroundColor: (backgroundColor: string | null | undefined) => string;
+/**
+ * The update that applies a picked color to an element under the sticky
+ * note policy: a note is always filled and its label — the visible text,
+ * which the note's own `strokeColor` seeds — never goes transparent. Every
+ * color surface (actions, both eyedroppers, paste styles, bind) routes
+ * through this instead of re-deriving the rule.
+ */
+/**
+ * The element a color pick on `element` lands on. A note's label has no fill
+ * of its own, so a background pick on the label — the styles panel while
+ * editing it — goes to the note; everything else colors itself.
+ */
+export declare const getColorTargetElement: (element: ExcalidrawElement, property: "strokeColor" | "backgroundColor", elementsMap: ElementsMap) => ExcalidrawElement;
+export declare const getColorUpdate: (element: ExcalidrawElement, property: "strokeColor" | "backgroundColor", color: string, elementsMap: ElementsMap) => {
+    strokeColor: string;
+} | {
+    backgroundColor: string;
+};
+/**
+ * A note's ink is one color: the container's `strokeColor` — the seed for a
+ * new label and what the creation-date footer paints with — and its label's.
+ * Run after a property write to copy the side that changed onto the other;
+ * when both changed, or neither (data that drifted), the label wins: it is
+ * the text the user styled. A transparent label always takes the note's
+ * color. Returns the same array when nothing needs to change.
+ */
+export declare const syncStickyNoteInk: <T extends ExcalidrawElement>(elements: readonly T[], prevElementsMap: ElementsMap) => readonly T[];
+export declare const getStickyNoteCornerRadius: (element: ExcalidrawStickyNoteElement) => number;
+export declare const getStickyNoteRenderPoints: (element: ExcalidrawStickyNoteElement, { offsetX, offsetY, seedOffset, }?: {
+    offsetX?: number;
+    offsetY?: number;
+    seedOffset?: number;
+}) => StickyNoteRenderPoint[];
+export declare const getStickyNotePathCommands: (element: ExcalidrawStickyNoteElement, { shadow }?: {
+    shadow?: boolean;
+}) => StickyNotePathCommand[];
+export declare const normalizeStickyNoteFontSize: (fontSize: number) => number;
+/** whether the text element is the label of a sticky note */
+export declare const isStickyNoteBoundText: (textElement: ExcalidrawTextElement, elementsMap: ElementsMap) => boolean;
+/**
+ * The font size the user picked: the ceiling the auto-fit shrinks from for a
+ * sticky note label, plain `fontSize` for any other text.
+ *
+ * Container-aware on purpose — generic binding repair (duplication, history)
+ * rewrites `containerId` without touching the ceiling, so a numeric
+ * `baseFontSize` alone does not prove the text is still sticky-bound.
+ */
+export declare const getBaseFontSize: (textElement: ExcalidrawTextElement, elementsMap: ElementsMap) => number;
+/** the update that applies a user-picked font size (see `getBaseFontSize`) */
+export declare const getBaseFontSizeUpdate: (textElement: ExcalidrawTextElement, fontSize: number, elementsMap: ElementsMap) => {
+    fontSize: number;
+} | {
+    baseFontSize: number;
+};
+/**
+ * The creation-date label: absolute, so painting needs no clock and exports
+ * don't go stale, and short ("7 Sep") while the year is the current one.
+ * `null` when the note has no usable timestamp (files restored without one).
+ * Fixed English in the viewer's local time zone — the element package has no
+ * locale, and the footer is chosen by width bucket rather than measured.
+ */
+export declare const getStickyNoteDateLabel: (created: ExcalidrawStickyNoteElement["created"], { short, now }?: {
+    short?: boolean;
+    now?: number;
+}) => string | null;
+/**
+ * What the footer paints and where, in note-local coordinates — shared by the
+ * canvas and SVG renderers, which take the font and opacity from
+ * `STICKY_NOTE_FOOTER`. `null` for the 0×0 creation draft and anything under
+ * the data floor, where the band would overlap the top padding.
+ */
+export declare const getStickyNoteFooter: (element: Pick<ExcalidrawStickyNoteElement, "created" | "width" | "height">, now?: number) => {
+    text: string;
+    x: number;
+    y: number;
+} | null;
+/**
+ * The smallest note the UI lets a user create or resize to: one line at the
+ * label's font ceiling plus padding (and, vertically, the footer), never below
+ * `STICKY_NOTE_MIN_SIZE`. Without the font term a fresh note would grow on
+ * the very first keystroke. Data-level passes (restore, action post-passes)
+ * only enforce the constant floor — the layout grows a note as needed.
+ */
+export declare const getStickyNoteMinSize: ({ fontSize, fontFamily, }: Pick<ExcalidrawTextElement, "fontSize" | "fontFamily">) => {
+    width: number;
+    height: number;
+};
+export type StickyNoteLayoutAnchor = VerticalResizeAnchor;
+export type StickyNoteLayoutOpts = {
+    /** unwrapped text to lay out; defaults to the label's `originalText` */
+    originalText?: string;
+    /**
+     * absolute base-height intent — the gesture-start value to preserve, or the
+     * height a resize asked for. Omitted = keep the note's live `baseHeight`
+     * (typing, style changes, restore).
+     */
+    baseHeight?: number;
+    /**
+     * absolute font-ceiling intent (a proportional resize passes
+     * `gesture-start ceiling × scale`). Omitted = keep the label's live ceiling.
+     * Never a multiplier on the live value — that compounds across pointer-moves.
+     */
+    baseFontSize?: number;
+    /** the edge that stays put when the content correction changes the height */
+    anchor?: StickyNoteLayoutAnchor;
+};
+export type StickyNoteLayout = {
+    container: Pick<ExcalidrawStickyNoteElement, "x" | "y" | "width" | "height" | "baseHeight">;
+    text: Pick<ExcalidrawTextElement, "text" | "fontSize" | "baseFontSize" | "width" | "height" | "x" | "y" | "angle"> | null;
+};
+/**
+ * The single source of truth for a sticky note's geometry: wraps the label at
+ * the note's width, fits the font under the ceiling, grows the note past
+ * `baseHeight` only when the text still overflows at the minimum size, and
+ * positions the label inside. Pure — returns the updates for both elements.
+ */
+export declare const getStickyNoteLayout: (container: ExcalidrawStickyNoteElement, textElement: ExcalidrawTextElement | null, opts?: StickyNoteLayoutOpts) => StickyNoteLayout;
+/**
+ * Resize intents for a sticky note — the §3.3 matrix of the plan. Every value
+ * is absolute and derived from the gesture-start snapshot on each pointer-move,
+ * so releasing Shift (or Alt) mid-gesture restores the original base height
+ * and ceiling instead of keeping values a previous move scaled.
+ *
+ * - width-only gestures (free E/W, Stats W) preserve the base height
+ * - height-changing gestures use the requested height as the new base
+ * - proportional gestures (Shift on any handle, aspect-locked multi-select,
+ *   Stats group) additionally scale the font ceiling with the note
+ * - flips preserve everything
+ * - the content correction anchors at the edge the gesture holds still
+ */
+export declare const getStickyNoteResizeIntent: (
+/** the note with the requested geometry already applied */
+container: ExcalidrawStickyNoteElement, originalElementsMap: ElementsMap, handleDirection: TransformHandleDirection, { proportional, fromCenter, flip, }: {
+    proportional: boolean;
+    fromCenter: boolean;
+    flip?: boolean;
+}) => Pick<StickyNoteLayoutOpts, "baseHeight" | "baseFontSize" | "anchor">;
+/**
+ * Applies `getStickyNoteLayout` to a live scene, then runs the bound-arrow
+ * pass unless the caller already owns one (`bindings: false`) or needs to
+ * forward its context (`bindings: { simultaneouslyUpdated }` — arrows resized
+ * in the same gesture must not be moved by the pass, `updateBoundElements`
+ * skips them only when told).
+ */
+export declare const updateStickyNoteLayout: (container: ExcalidrawStickyNoteElement, scene: Scene, { text, bindings, ...layoutOpts }?: StickyNoteLayoutOpts & {
+    /** the label to lay out when it is an uncommitted clone (font actions clone before install) */
+    text?: ExcalidrawTextElement | null;
+    bindings?: {
+        simultaneouslyUpdated?: readonly NonDeletedExcalidrawElement[];
+    } | false;
+}) => StickyNoteLayout;
+/**
+ * Applies `getStickyNoteLayout` inside an immutable elements array (property
+ * actions, paste styles, restore): the notes among `affectedIds` — or the
+ * notes whose labels are — get both halves merged into their clones. Elements
+ * that need no change keep their identity and version; when `prevElementsMap`
+ * is given, notes whose layout inputs did not change skip the fit entirely.
+ * Bound arrows are the caller's job once the result is installed.
+ */
+export declare const relayoutStickyNotes: <T extends ExcalidrawElement>(elements: readonly T[], affectedIds: ReadonlySet<ExcalidrawElement["id"]>, opts?: {
+    prevElementsMap?: ElementsMap;
+}) => readonly T[];

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

@@ -1,11 +1,10 @@
 import { type Radians } from "@excalidraw/math";
-import type { AppState } from "@excalidraw/excalidraw/types";
 import type { ExtractSetType } from "@excalidraw/common/utility-types";
 import type { Scene } from "./Scene";
 import type { MaybeTransformHandleType } from "./transformHandles";
 import type { ElementsMap, ExcalidrawElement, ExcalidrawElementType, ExcalidrawTextContainer, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, NonDeleted } from "./types";
 export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null, scene: Scene) => void;
-export declare const handleBindTextResize: (container: ExcalidrawElement, scene: Scene, transformHandleType: MaybeTransformHandleType, shouldMaintainAspectRatio?: boolean) => void;
+export declare const handleBindTextResize: (container: ExcalidrawElement, scene: Scene, transformHandleType: MaybeTransformHandleType, shouldMaintainAspectRatio?: boolean, shouldResizeFromCenter?: boolean, flipByY?: boolean) => void;
 export declare const computeBoundTextPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
     x: number;
     y: number;
@@ -13,7 +12,11 @@ export declare const computeBoundTextPosition: (container: ExcalidrawElement, bo
 export declare const getBoundTextElementId: (container: ExcalidrawElement | null) => string | null;
 export declare const getBoundTextElement: (element: ExcalidrawElement | null, elementsMap: ElementsMap) => NonDeleted<ExcalidrawTextElementWithContainer> | null;
 export declare const getContainerElement: <T extends ExcalidrawTextElement, R extends ExcalidrawTextContainer>(element: T | null, elementsMap: ElementsMap) => R | null;
-export declare const getContainerCenter: (container: ExcalidrawElement, appState: AppState, elementsMap: ElementsMap) => {
+/**
+ * The point a text bound to this container centers on — and, for arrows, the
+ * point the text tool snaps a new label to.
+ */
+export declare const getContainerCenter: (container: ExcalidrawElement, elementsMap: ElementsMap) => {
     x: number;
     y: number;
 };
@@ -37,4 +40,5 @@ export declare const getBoundTextMaxWidth: (container: ExcalidrawElement, boundT
 export declare const getBoundTextMaxHeight: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => number;
 /** retrieves text from text elements and concatenates to a single string */
 export declare const getTextFromElements: (elements: readonly ExcalidrawElement[], separator?: string) => string;
+export declare const DEFAULT_BOUND_TEXT_LABEL_POSITION = 0.5;
 export {};