@excalidraw/element 0.18.0-4872083 → 0.18.0-4ce38fb

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

@@ -1,4 +1,5 @@
 export declare const applyDarkModeFilter: (color: string, enable?: boolean) => string;
+export declare const removeDarkModeFilter: (color: string) => string;
 export type ColorTuple = readonly [string, string, string, string, string];
 export type ColorPaletteCustom = {
     [key: string]: ColorTuple | string;
@@ -28,9 +29,16 @@ export declare const COLOR_PALETTE: {
 };
 export type ColorPalette = typeof COLOR_PALETTE;
 export type ColorPickerColor = keyof typeof COLOR_PALETTE;
+/** number of slots in the color-picker top-picks strip — the strip layout is
+ * sized for exactly this many swatches, and pick customization (replace /
+ * reorder) preserves it */
+export declare const COLOR_TOP_PICKS_SLOTS = 5;
 export declare const DEFAULT_ELEMENT_STROKE_PICKS: ColorTuple;
 export declare const DEFAULT_ELEMENT_BACKGROUND_PICKS: ColorTuple;
 export declare const BUCKET_FILL_BACKGROUND_PICKS: ColorTuple;
+export declare const DEFAULT_STICKY_NOTE_BG = "#ffdf6b";
+export declare const STICKY_NOTE_STROKE_PICKS: ColorTuple;
+export declare const STICKY_NOTE_BACKGROUND_PICKS: ColorTuple;
 export declare const DEFAULT_CANVAS_BACKGROUND_PICKS: ColorTuple;
 export declare const DEFAULT_ELEMENT_STROKE_COLOR_PALETTE: {
     readonly cyan: readonly ["#e3fafc", "#99e9f2", "#3bc9db", "#15aabf", "#0c8599"];
@@ -66,15 +74,13 @@ export declare const DEFAULT_ELEMENT_BACKGROUND_COLOR_PALETTE: {
     readonly black: "#1e1e1e";
     readonly bronze: readonly ["#f8f1ee", "#eaddd7", "#d2bab0", "#a18072", "#846358"];
 };
-/**
- * The color the bucket fill tool actually fills with: the shared
- * `currentItemBackgroundColor`, falling back to green when that is
- * transparent (the tool's picker doesn't offer transparent, but the shared
- * state can hold it from the generic shape picker).
- */
-export declare const getBucketFillBackgroundColor: (backgroundColor: string) => string;
 export declare const getAllColorsSpecificShade: (index: 0 | 1 | 2 | 3 | 4) => ("#fff5f5" | "#ffc9c9" | "#ff8787" | "#fa5252" | "#e03131" | "#fff0f6" | "#fcc2d7" | "#f783ac" | "#e64980" | "#c2255c" | "#f8f0fc" | "#eebefa" | "#da77f2" | "#be4bdb" | "#9c36b5" | "#f3f0ff" | "#d0bfff" | "#9775fa" | "#7950f2" | "#6741d9" | "#e7f5ff" | "#a5d8ff" | "#4dabf7" | "#228be6" | "#1971c2" | "#e3fafc" | "#99e9f2" | "#3bc9db" | "#15aabf" | "#0c8599" | "#e6fcf5" | "#96f2d7" | "#38d9a9" | "#12b886" | "#099268" | "#ebfbee" | "#b2f2bb" | "#69db7c" | "#40c057" | "#2f9e44" | "#fff9db" | "#ffec99" | "#ffd43b" | "#fab005" | "#f08c00" | "#fff4e6" | "#ffd8a8" | "#ffa94d" | "#fd7e14" | "#e8590c")[];
 export declare const rgbToHex: (r: number, g: number, b: number, a?: number) => string;
+/**
+ * @returns the color with its alpha replaced by `alpha` (as #RRGGBBAA), or the
+ *  input unchanged if it's not a valid color
+ */
+export declare const setColorAlpha: (color: string, alpha: number) => string;
 /**
  * @returns #RRGGBB or #RRGGBBAA based on color containing non-opaque alpha,
  *  null if not valid color

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

@@ -1,8 +1,11 @@
 import type { ExcalidrawElement, FontFamilyValues } from "@excalidraw/element/types";
 import type { AppProps, AppState } from "@excalidraw/excalidraw/types";
+export { DEFAULT_STICKY_NOTE_BG } from "./colors";
 export declare const supportsResizeObserver: boolean;
 export declare const APP_NAME = "Excalidraw";
 export declare const TEXT_AUTOWRAP_THRESHOLD = 36;
+export declare const TEXT_VIEWPORT_PADDING = 20;
+export declare const TEXT_MAX_WRAP_WIDTH = 800;
 export declare const DRAGGING_THRESHOLD = 10;
 export declare const MINIMUM_ARROW_SIZE = 20;
 export declare const LINE_CONFIRM_THRESHOLD = 8;
@@ -52,6 +55,7 @@ export declare enum EVENT {
     POINTER_MOVE = "pointermove",
     POINTER_DOWN = "pointerdown",
     POINTER_UP = "pointerup",
+    POINTER_CANCEL = "pointercancel",
     STATE_CHANGE = "statechange",
     WHEEL = "wheel",
     TOUCH_START = "touchstart",
@@ -150,7 +154,53 @@ export declare const FRAME_STYLE: {
 };
 export declare const MIN_FONT_SIZE = 1;
 export declare const DEFAULT_FONT_SIZE = 20;
+export declare const STICKY_NOTE_MIN_FONT_SIZE = 16;
+export declare const STICKY_NOTE_MAX_FONT_SIZE = 512;
+export declare const STICKY_NOTE_FALLBACK_FONT_SIZE = 28;
+export declare const STICKY_NOTE_FONT_STEP = 2;
+export declare const STICKY_NOTE_PADDING = 16;
+/**
+ * The creation-date footer: a 20px text row under the label body plus a 12px
+ * gap above it, inside the note's bottom padding. Reserved for every note —
+ * also when `created` is unknown — so geometry never depends on data
+ * availability. The label is chosen by width bucket, never measured, so
+ * painting stays measurement-free (the server has no text measurer):
+ * `minBodyWidthForYear` is the worst case ("30 May 2026") in the system sans
+ * stack at 12px, with margin for wider fallbacks such as DejaVu Sans.
+ */
+/**
+ * The creation-date footer of a sticky note. The label body ends `height`
+ * above the note's bottom padding, and the date's baseline sits
+ * `baselineFromBottom` above the note's bottom edge — so the 12px glyphs
+ * (~9px above the baseline, ~3px below) end up roughly 11px from the edge
+ * with a ~13px gap to the label body above them.
+ */
+export declare const STICKY_NOTE_FOOTER: {
+    readonly height: 20;
+    readonly fontSize: 12;
+    readonly fontFamily: "Helvetica, Arial, sans-serif";
+    readonly baselineFromBottom: 14;
+    readonly opacity: 1;
+    readonly minBodyWidthForYear: 80;
+};
+/**
+ * outer height → label body height: top + bottom padding + footer. The body
+ * is what the label is fitted into; a middle-aligned label is still centered
+ * in the whole padded note when it fits (see `computeBoundTextPosition`).
+ */
+export declare const STICKY_NOTE_BODY_INSET_Y: number;
+export declare const DEFAULT_STICKY_NOTE_SIZE = 250;
+export declare const STICKY_NOTE_MIN_SIZE = 75;
+export declare const STICKY_NOTE_SHADOW_OFFSET = 3;
+export declare const STICKY_NOTE_SHADOW_OPACITY = 0.16;
+export declare const STICKY_NOTE_EDGE_SHADOW_WIDTH = 0.5;
+export declare const STICKY_NOTE_EDGE_SHADOW_OPACITY = 0.08;
 export declare const DEFAULT_FONT_FAMILY: FontFamilyValues;
+/** number of slots in the font-picker top-picks strip — pick customization
+ * (replace / reorder) preserves it. Must equal `DEFAULT_FONTS.length` in
+ * `packages/excalidraw/components/FontPicker/FontPicker.tsx` (enforced by
+ * `fontTopPicks.test.ts`) */
+export declare const FONT_TOP_PICKS_SLOTS = 3;
 export declare const DEFAULT_TEXT_ALIGN = "left";
 export declare const DEFAULT_VERTICAL_ALIGN = "top";
 export declare const DEFAULT_VERSION = "{version}";
@@ -224,9 +274,12 @@ export declare const TOUCH_CTX_MENU_TIMEOUT = 500;
 export declare const TITLE_TIMEOUT = 10000;
 export declare const VERSION_TIMEOUT = 30000;
 export declare const SCROLL_TIMEOUT = 100;
+export declare const ZEN_MODE_TRANSITION_DURATION = 250;
 export declare const ZOOM_STEP = 0.1;
 export declare const MIN_ZOOM = 0.1;
 export declare const MAX_ZOOM = 30;
+/** 100% zoom, for computations that have no editor zoom to go by */
+export declare const DEFAULT_ZOOM: AppState["zoom"];
 export declare const HYPERLINK_TOOLTIP_DELAY = 300;
 export declare const IDLE_THRESHOLD = 60000;
 export declare const ACTIVE_THRESHOLD = 3000;
@@ -313,6 +366,7 @@ export declare const TOOL_TYPE: {
     readonly hand: "hand";
     readonly frame: "frame";
     readonly magicframe: "magicframe";
+    readonly stickynote: "stickynote";
     readonly embeddable: "embeddable";
     readonly laser: "laser";
     readonly autoshape: "autoshape";

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

@@ -55,6 +55,7 @@ export declare const KEYS: {
     readonly H: "h";
     readonly I: "i";
     readonly L: "l";
+    readonly N: "n";
     readonly O: "o";
     readonly P: "p";
     readonly Q: "q";
@@ -111,6 +112,7 @@ export declare const KeyCodeMap: Map<ValueOf<{
     readonly H: "h";
     readonly I: "i";
     readonly L: "l";
+    readonly N: "n";
     readonly O: "o";
     readonly P: "p";
     readonly Q: "q";

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

@@ -1,3 +1,10 @@
 export declare const randomInteger: () => number;
 export declare const reseed: (seed: number) => void;
 export declare const randomId: () => string;
+/**
+ * Deterministic PRNG (mulberry32) for a given seed: same seed, same
+ * sequence — used where a render must be stable across frames and clients
+ * (e.g. the sticky note's corner jitter) and roughjs's `Random` is
+ * unsuitable (it degenerates for seed 0). Returns numbers in [0, 1).
+ */
+export declare const seededRandom: (seed: number) => () => number;

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

@@ -87,6 +87,11 @@ export declare const getGlobalCSSVariable: (name: string) => string;
  * See https://github.com/excalidraw/excalidraw/pull/1722#discussion_r436340171
  */
 export declare const isRTL: (text: string) => boolean;
+/**
+ * Checks whether the text has any RTL character, i.e. whether it may be laid
+ * out bidirectionally.
+ */
+export declare const hasRTLChars: (text: string) => boolean;
 export declare const tupleToCoors: (xyTuple: readonly [number, number]) => {
     x: number;
     y: number;

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

@@ -72,7 +72,7 @@ export declare class Scene {
     getElementIndex(elementId: string): number;
     getContainerElement: (element: (ExcalidrawElement & {
         containerId: ExcalidrawElement["id"] | null;
-    }) | null) => import("@excalidraw/element/types").ExcalidrawLinearElement | import("@excalidraw/element/types").ExcalidrawSelectionElement | import("@excalidraw/element/types").ExcalidrawRectangleElement | import("@excalidraw/element/types").ExcalidrawDiamondElement | import("@excalidraw/element/types").ExcalidrawEllipseElement | import("@excalidraw/element/types").ExcalidrawEmbeddableElement | import("@excalidraw/element/types").ExcalidrawIframeElement | import("@excalidraw/element/types").ExcalidrawImageElement | import("@excalidraw/element/types").ExcalidrawFrameElement | import("@excalidraw/element/types").ExcalidrawMagicFrameElement | import("@excalidraw/element/types").ExcalidrawTextElement | import("@excalidraw/element/types").ExcalidrawFreeDrawElement | null;
+    }) | null) => import("@excalidraw/element/types").ExcalidrawLinearElement | import("@excalidraw/element/types").ExcalidrawSelectionElement | import("@excalidraw/element/types").ExcalidrawRectangleElement | import("@excalidraw/element/types").ExcalidrawStickyNoteElement | import("@excalidraw/element/types").ExcalidrawDiamondElement | import("@excalidraw/element/types").ExcalidrawEllipseElement | import("@excalidraw/element/types").ExcalidrawEmbeddableElement | import("@excalidraw/element/types").ExcalidrawIframeElement | import("@excalidraw/element/types").ExcalidrawImageElement | import("@excalidraw/element/types").ExcalidrawFrameElement | import("@excalidraw/element/types").ExcalidrawMagicFrameElement | import("@excalidraw/element/types").ExcalidrawTextElement | import("@excalidraw/element/types").ExcalidrawFreeDrawElement | null;
     getElementsFromId: (id: string) => ExcalidrawElement[];
     mutateElement<TElement extends Mutable<ExcalidrawElement>>(element: TElement, updates: ElementUpdate<TElement>, options?: {
         informMutation: boolean;

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

@@ -25,10 +25,9 @@ export type BindingStrategy = {
  * IMPORTANT: currently must be > 0 (this also applies to the computed gap)
  */
 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: Pick<ExcalidrawBindableElement, "strokeWidth">, opts: Pick<ExcalidrawArrowElement, "elbowed">) => number;
+export declare const getBindingGap: (bindTarget: Pick<ExcalidrawBindableElement, "strokeWidth">) => number;
 export declare const maxBindingDistance_simple: (zoom?: AppState["zoom"]) => number;
 export declare const isBindingEnabled: (appState: {
     isBindingEnabled: AppState["isBindingEnabled"];
@@ -49,16 +48,17 @@ export declare const getBindingStrategyForDraggingBindingElementEndpoints: (arro
     altKey?: boolean;
     finalize?: boolean;
     initialBinding?: boolean;
-    zoom?: AppState["zoom"];
     gridSize?: NullableGridSize;
 }) => {
     start: BindingStrategy;
     end: BindingStrategy;
 };
 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, focusPoint?: GlobalPoint, shouldSnapToOutline?: boolean, isMidpointSnappingEnabled?: boolean) => 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;
 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;
 export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, scene: Scene, options?: {
+    /** see `getSimultaneouslyUpdatedElementIds` for how to pass it */
     simultaneouslyUpdated?: readonly NonDeletedExcalidrawElement[];
     changedElements?: Map<string, ExcalidrawElement>;
 }) => void;
@@ -69,12 +69,18 @@ export declare const updateBindings: (latestElement: NonDeletedExcalidrawElement
         height: number;
     };
 }) => void;
+/**
+ * The id set of `simultaneouslyUpdated`, shared by every `updateBoundElements()`
+ * call given the same array. Pass one array instance for all elements of an
+ * operation, and don't change its membership after the first lookup, or the
+ * cached ids go stale.
+ */
+export declare const getSimultaneouslyUpdatedElementIds: (simultaneouslyUpdated: readonly ExcalidrawElement[] | undefined) => ReadonlySet<ExcalidrawElement["id"]>;
 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>, isMidpointSnappingEnabled?: boolean) => GlobalPoint;
+export declare const bindPointToSnapToElementOutline: (arrowElement: ExcalidrawArrowElement, bindableElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, zoom: AppState["zoom"], customIntersector?: LineSegment<GlobalPoint>, isMidpointSnappingEnabled?: boolean) => GlobalPoint;
 export declare const avoidRectangularCorner: (arrowElement: ExcalidrawArrowElement, bindTarget: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint) => GlobalPoint;
-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) => {
+export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, zoom: AppState["zoom"], shouldSnapToOutline?: boolean, isMidpointSnappingEnabled?: boolean) => {
     fixedPoint: FixedPoint;
 };
 export declare const calculateFixedPointForNonElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawArrowElement>, hoveredElement: NonDeleted<ExcalidrawBindableElement>, startOrEnd: "start" | "end", elementsMap: ElementsMap, focusPoint?: 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, ExcalidrawArrowElement, ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap, Ordered } from "./types";
+import type { AppState, FrameNameBounds } from "@excalidraw/excalidraw/types";
+import type { ElementsMap, ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap, Ordered } from "./types";
 export declare const shouldTestInside: (element: ExcalidrawElement) => boolean;
 export type HitTestArgs = {
     point: GlobalPoint;
@@ -14,9 +14,18 @@ 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, 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) => NonDeleted<ExcalidrawBindableElement> | null;
+/**
+ * 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
+ * background.
+ */
+export declare const isOpaqueForBinding: (element: ExcalidrawElement) => boolean;
+/**
+ * All elements an arrow endpoint at the point could bind to. Always includes
+ * the result of `getHoveredElementForBinding` for the same arguments.
+ */
+export declare const getAllHoveredElementAtPoint: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, zoom: AppState["zoom"]) => NonDeleted<ExcalidrawBindableElement>[];
+export declare const getHoveredElementForBinding: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, zoom: AppState["zoom"]) => NonDeleted<ExcalidrawBindableElement> | null;
 /**
  * Intersect a line with an element for binding test
  *

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

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

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

@@ -192,7 +192,29 @@ export declare class ElementsDelta implements DeltaContainer<SceneElementsMap> {
     private static createGetter;
     private static applyDelta;
     /**
-     * Check for visible changes regardless of whether they were removed, added or updated.
+     * Whether an element looks different after the delta — and the layout that
+     * followed it — was applied. The input to history's "skip entries with no
+     * visible change" loop.
+     *
+     * Both sides are first reduced to what actually paints:
+     * - a missing or deleted element paints nothing;
+     * - an empty text element paints nothing either — unless it carries arrow
+     *   bindings (an arrow may end at it) or sits on an arrow (an empty label
+     *   still cuts the arrow's gap);
+     * so an empty label's deletion or restoration compares as nothing against
+     * nothing. Two painting elements are then compared property by property:
+     * - `version`, `versionNonce`, `updated`, `created` are metadata, and
+     *   `index` is covered by the separate z-order check (`reorderElements`);
+     * - `boundElements` is compared as `type:id` references with references to
+     *   empty labels dropped, so adding or removing an empty label's reference
+     *   is not visible on its own, and binding repair that rebuilt equal
+     *   objects is not either;
+     * - everything else counts. Nested arrays (`points`, binding fixed points)
+     *   compare by reference, which can only over-report a change — the safe
+     *   direction, where undo stops one entry early.
+     *
+     * `previousElements` holds only `idsToCheck` (see `applyTo`); the label
+     * lookups it serves are for elements whose labels are in that set.
      */
     private static checkForVisibleDifference;
     /**

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,7 +1,11 @@
 import type { AppState, PendingExcalidrawElements } from "@excalidraw/excalidraw/types";
-import { type NonDeleted, type ElementsMap, type ExcalidrawElement, type ExcalidrawFlowchartNodeElement } from "./types";
+import { type NonDeleted, type ElementsMap, type ExcalidrawElement, type ExcalidrawFlowchartNodeElement, type NonDeletedExcalidrawElement } from "./types";
 import type { Scene } from "./Scene";
 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;

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

@@ -36,6 +36,7 @@ export * from "./groups";
 export * from "./heading";
 export * from "./image";
 export * from "./linearElementEditor";
+export * from "./listMarker";
 export * from "./mutateElement";
 export * from "./newElement";
 export * from "./positionElementsOnGrid";
@@ -49,6 +50,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";

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

@@ -65,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;
@@ -76,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;
     /**
@@ -114,10 +121,13 @@ export declare class LinearElementEditor {
      * 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/listMarker.d.ts

@@ -0,0 +1,34 @@
+import type { Scene } from "./Scene";
+import type { ExcalidrawElement, ExcalidrawTextElement } from "./types";
+/** a list marker advanced by duplication, to go back and forth */
+export type ListMarkerAdvance = {
+    elementId: ExcalidrawTextElement["id"];
+    prevOriginalText: string;
+    nextOriginalText: string;
+    /**
+     * where the item's text (after the marker and whitespace) starts in
+     * `nextOriginalText` (its length if there's none)
+     */
+    contentStart: number;
+    /** the label's container before the label (may have) grown it */
+    prevContainerSize: {
+        width: number;
+        height: number;
+    } | null;
+};
+/**
+ * Advances the list markers of the duplicated texts and labels, so that
+ * duplicating `1. foo` gives `2. foo` (and `1` gives `2`).
+ *
+ * Duplicating several list items at once continues the list from the
+ * highest of them: duplicating `1.`, `3.`, `5.` gives `6.`, `7.`, `8.` (only
+ * if they're just markers, i.e. without text).
+ *
+ * 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[];
+/**
+ * Sets the advanced list markers back (`"prev"`), or forth again (`"next"`).
+ */
+export declare const applyListMarkerAdvances: (advances: readonly ListMarkerAdvance[], direction: "prev" | "next", scene: Scene) => void;

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>;
@@ -39,8 +59,24 @@ 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) => {
+export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null, elementsMap: ElementsMap, text?: string, 
+/**
+ * For a free text that grows with its content (`autoResize`): the widest
+ * it may grow to. Crossing it, the text stops growing and wraps at this
+ * width from then on (`autoResize: false`), anchored as its growth was. A
+ * text that is already wider keeps growing.
+ */
+maxWidth?: number) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text: string;
+    autoResize: boolean;
+} | {
     x: number;
     y: number;
     width: number;