@excalidraw/math 0.18.0-4e758db → 0.18.0-4f68076

package/dist/types/excalidraw/components/App.d.ts

@@ -1,9 +1,8 @@
 import React from "react";
 import { AppEventBus, type EXPORT_IMAGE_TYPES, Emitter, type EditorInterface, type StylesPanelMode } from "@excalidraw/common";
 import { LinearElementEditor, Scene, Store, type ElementUpdate, StoreDelta, type ApplyToOptions } from "@excalidraw/element";
-import type { LocalPoint, Radians } from "@excalidraw/math";
-import type { ExcalidrawElement, ExcalidrawTextElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawTextContainer, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered, SceneElementsMap } from "@excalidraw/element/types";
-import type { ArrowEndpoint, TransformHandleDirection } from "@excalidraw/element";
+import type { ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered, SceneElementsMap } from "@excalidraw/element/types";
+import type { TransformHandleDirection } from "@excalidraw/element";
 import type { Mutable } from "@excalidraw/common/utility-types";
 import { ActionManager } from "../actions/manager";
 import { History } from "../history";
@@ -16,17 +15,24 @@ import { isOverScrollBars } from "../scene/scrollbars";
 import { LassoTrail } from "../lasso";
 import { EraserTrail } from "../eraser";
 import { AppArrowText } from "./App.arrowText";
+import { AppClipboard } from "./App.clipboard";
+import { AppText } from "./App.text";
+import { AppTextTool } from "./App.textTool";
 import { AppBucketFill } from "./App.bucketFill";
 import { AppToolDrag } from "./App.toolDrag";
 import { AppCursor } from "./App.cursor";
 import { AppDrawShape } from "./App.drawshape";
+import { AppDuplicate } from "./App.duplicate";
 import { AppFlowchart } from "./App.flowchart";
+import { AppModifiers } from "./App.modifiers";
+import { AppPan } from "./App.pan";
 import { AppViewport } from "./App.viewport";
 import { AppWheel } from "./App.wheel";
+import { AppSelectionTool } from "./App.selectionTool";
 import { CursorHints } from "./CursorHint";
 import { type OnStateChange } from "./AppStateObserver";
 import type { ExportedElements } from "../data";
-import type { AppClassProperties, AppProps, AppState, ExcalidrawImperativeAPI, BinaryFiles, LibraryItems, SceneData, FrameNameBoundsCache, SidebarName, SidebarTabName, ToolType, OnUserFollowedPayload, ExcalidrawImperativeAPIEventMap, GenerateDiagramToCode, NullableGridSize, UIConfig } from "../types";
+import type { AppClassProperties, AppProps, AppState, ElementRenderOverrides, ExcalidrawImperativeAPI, BinaryFiles, LibraryItems, PointerDownState, SceneData, FrameNameBoundsCache, SidebarName, SidebarTabName, KeyboardModifiersObject, ToolType, OnUserFollowedPayload, ExcalidrawImperativeAPIEventMap, GenerateDiagramToCode, NullableGridSize, UIConfig } from "../types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
 import type { ActionResult } from "../actions/types";
 declare const editorLifecycleEventBehavior: {
@@ -85,6 +91,7 @@ declare class App extends React.Component<AppProps, AppState> {
     editorInterface: EditorInterface;
     private stylesPanelMode;
     private excalidrawContainerRef;
+    private zenModeTransitionTimer;
     get ownerDocument(): Document;
     get ownerWindow(): Window & typeof globalThis;
     scene: Scene;
@@ -124,14 +131,19 @@ declare class App extends React.Component<AppProps, AppState> {
     private appStateObserver;
     onStateChange: OnStateChange;
     bucketFill: AppBucketFill;
+    duplicate: AppDuplicate;
     toolDrag: AppToolDrag;
     flowchart: AppFlowchart;
     cursor: AppCursor;
     arrowText: AppArrowText;
+    pan: AppPan;
+    textTool: AppTextTool;
+    clipboard: AppClipboard;
+    text: AppText;
     viewport: AppViewport;
     wheel: AppWheel;
+    selectionTool: AppSelectionTool;
     bindModeHandler: ReturnType<typeof setTimeout> | null;
-    private textWysiwygSubmitHandler;
     hitLinkElement?: NonDeletedExcalidrawElement;
     lastPointerDownEvent: React.PointerEvent<HTMLElement> | null;
     /**
@@ -197,7 +209,10 @@ declare class App extends React.Component<AppProps, AppState> {
             element: NonDeleted<ExcalidrawElement> | null;
             allHitElements: NonDeleted<ExcalidrawElement>[];
             wasAddedToSelection: boolean;
+            cycleTarget: NonDeleted<ExcalidrawElement> | null;
             hasBeenDuplicated: boolean;
+            advancedListMarkers: readonly import("@excalidraw/element").ListMarkerAdvance[];
+            editedTextId: import("@excalidraw/element/types").ExcalidrawTextElement["id"] | null;
             hasHitCommonBoundingBoxOfSelectedElements: boolean;
             arrowLabel: boolean;
         };
@@ -260,7 +275,10 @@ declare class App extends React.Component<AppProps, AppState> {
             element: NonDeleted<ExcalidrawElement> | null;
             allHitElements: NonDeleted<ExcalidrawElement>[];
             wasAddedToSelection: boolean;
+            cycleTarget: NonDeleted<ExcalidrawElement> | null;
             hasBeenDuplicated: boolean;
+            advancedListMarkers: readonly import("@excalidraw/element").ListMarkerAdvance[];
+            editedTextId: import("@excalidraw/element/types").ExcalidrawTextElement["id"] | null;
             hasHitCommonBoundingBoxOfSelectedElements: boolean;
             arrowLabel: boolean;
         };
@@ -293,7 +311,14 @@ declare class App extends React.Component<AppProps, AppState> {
     }>]>;
     missingPointerEventCleanupEmitter: Emitter<[event: PointerEvent | null]>;
     onRemoveEventListenersEmitter: Emitter<[]>;
+    modifiers: AppModifiers;
     api: ExcalidrawImperativeAPI;
+    private elementRenderOverrides;
+    /** offsets of `elementRenderOverrides`; keeps its identity while they don't change */
+    private elementRenderOffsets;
+    private renderOverridesUpdatePending;
+    private getRenderOverrideConfig;
+    private getElementRenderState;
     private createExcalidrawAPI;
     constructor(props: AppProps);
     /**
@@ -377,7 +402,6 @@ declare class App extends React.Component<AppProps, AppState> {
      * If disabled, returns null.
      */
     getEffectiveGridSize: () => NullableGridSize;
-    private getTextCreationGridPoint;
     private getHTMLIFrameElement;
     /**
      * AI-generated iframe elements aren't interactive while their generation
@@ -424,6 +448,8 @@ declare class App extends React.Component<AppProps, AppState> {
     private onBlur;
     private onUnload;
     private disableEvent;
+    private isFileDropEnabled;
+    private onDragOver;
     private handleNavigationModeKeyDown;
     /**
      * PageUp/PageDown scroll the canvas by a page — vertically, or
@@ -468,16 +494,20 @@ declare class App extends React.Component<AppProps, AppState> {
     private onFullscreenChange;
     private removeEventListeners;
     private addEventListeners;
+    getSnapshotBeforeUpdate(prevProps: AppProps, prevState: AppState): null;
+    /**
+     * Flags the container while toggling zen mode so that UI chrome
+     * (backgrounds etc.) animates only then, and hover transitions stay
+     * instant. A data attribute so that React doesn't reset it on re-render.
+     */
+    private markZenModeTransition;
+    private unmarkZenModeTransition;
     componentDidUpdate(prevProps: AppProps, prevState: AppState): void;
     private renderInteractiveSceneCallback;
     private onScroll;
-    private onCut;
-    private onCopy;
     private static resetTapTwice;
     private onTouchStart;
     private onTouchEnd;
-    private insertClipboardContent;
-    pasteFromClipboard: (event: ClipboardEvent) => Promise<void>;
     addElementsFromPasteOrLibrary: (opts: {
         elements: readonly ExcalidrawElement[];
         files: BinaryFiles | null;
@@ -489,8 +519,6 @@ declare class App extends React.Component<AppProps, AppState> {
         fit?: SetViewportOptions["fit"];
         preserveFrameChildrenOrder?: boolean;
     }) => void;
-    private addElementsFromMixedContentPaste;
-    private addTextFromPaste;
     setAppState: React.Component<any, AppState>["setState"];
     removePointer: (event: React.PointerEvent<HTMLElement> | PointerEvent) => void;
     toggleLock: (source?: "keyboard" | "ui") => void;
@@ -502,9 +530,11 @@ declare class App extends React.Component<AppProps, AppState> {
      *  imperative API emitter */
     emitUserFollowIntent: (payload: OnUserFollowedPayload) => void;
     /** emits an UNFOLLOW intent if currently following someone — use on
-     *  user-initiated viewport changes which should break follow mode */
+     *  viewport changes that take the view over from the followed user (user
+     *  pans and zooms, `setViewport` navigation) */
     requestUnfollow: () => void;
     setToast: (toast: AppState["toast"]) => void;
+    private showSceneReplacedToast;
     restoreFileFromShare: () => Promise<void>;
     /**
      * adds supplied files to existing files in the appState.
@@ -529,6 +559,10 @@ declare class App extends React.Component<AppProps, AppState> {
          */
         captureUpdate?: SceneData["captureUpdate"];
     }) => void;
+    /**
+     * see {@link ExcalidrawImperativeAPI.setElementRenderOverrides} for details
+     */
+    setElementRenderOverrides: (overrides: ElementRenderOverrides | null) => void;
     applyDeltas: (deltas: StoreDelta[], options?: ApplyToOptions) => [SceneElementsMap, AppState, boolean];
     mutateElement: <TElement extends Mutable<ExcalidrawElement>>(element: TElement, updates: ElementUpdate<TElement>, informMutation?: boolean) => TElement;
     triggerRender: (
@@ -576,13 +610,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private onGestureStart;
     private onGestureChange;
     private onGestureEnd;
-    private handleTextWysiwyg;
-    private deselectElements;
-    private getSelectedTextElement;
-    private getSelectedTextEditingContainerAtPosition;
-    getTextElementAtPosition(x: number, y: number): NonDeleted<ExcalidrawTextElement> | null;
-    private isHittingTextAutoResizeHandle;
-    private handleTextAutoResizeHandlePointerDown;
+    deselectElements(): void;
     getElementAtPosition(x: number, y: number, opts?: ({
         includeBoundTextElement?: boolean;
         includeLockedElements?: boolean;
@@ -595,230 +623,22 @@ declare class App extends React.Component<AppProps, AppState> {
         includeBoundTextElement?: boolean;
         includeLockedElements?: boolean;
     }): NonDeleted<ExcalidrawElement>[];
-    getElementHitThreshold(element: ExcalidrawElement): number;
-    hitElement(x: number, y: number, element: NonDeletedExcalidrawElement, considerBoundingBox?: boolean): boolean;
-    getTextBindableContainerAtPosition(x: number, y: number): (Readonly<{
-        id: string;
-        x: number;
-        y: number;
-        strokeColor: string;
-        backgroundColor: string;
-        fillStyle: import("@excalidraw/element/types").FillStyle;
-        strokeWidth: number;
-        strokeStyle: import("@excalidraw/element/types").StrokeStyle;
-        roundness: null | {
-            type: import("@excalidraw/element/types").RoundnessType;
-            value?: number;
-        };
-        roughness: number;
-        opacity: number;
-        width: number;
-        height: number;
-        angle: Radians;
-        seed: number;
-        version: number;
-        versionNonce: number;
-        index: import("@excalidraw/element/types").FractionalIndex | null;
-        isDeleted: boolean;
-        groupIds: readonly import("@excalidraw/element/types").GroupId[];
-        frameId: string | null;
-        boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
-        updated: number;
-        created: number | null;
-        link: string | null;
-        locked: boolean;
-        customData?: Record<string, any>;
-    }> & {
-        type: "rectangle";
-    } & {
-        isDeleted: false;
-    }) | (Readonly<{
-        id: string;
-        x: number;
-        y: number;
-        strokeColor: string;
-        backgroundColor: string;
-        fillStyle: import("@excalidraw/element/types").FillStyle;
-        strokeWidth: number;
-        strokeStyle: import("@excalidraw/element/types").StrokeStyle;
-        roundness: null | {
-            type: import("@excalidraw/element/types").RoundnessType;
-            value?: number;
-        };
-        roughness: number;
-        opacity: number;
-        width: number;
-        height: number;
-        angle: Radians;
-        seed: number;
-        version: number;
-        versionNonce: number;
-        index: import("@excalidraw/element/types").FractionalIndex | null;
-        isDeleted: boolean;
-        groupIds: readonly import("@excalidraw/element/types").GroupId[];
-        frameId: string | null;
-        boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
-        updated: number;
-        created: number | null;
-        link: string | null;
-        locked: boolean;
-        customData?: Record<string, any>;
-    }> & Readonly<{
-        type: "stickynote";
-        baseHeight: number;
-    }> & {
-        isDeleted: false;
-    }) | (Readonly<{
-        id: string;
-        x: number;
-        y: number;
-        strokeColor: string;
-        backgroundColor: string;
-        fillStyle: import("@excalidraw/element/types").FillStyle;
-        strokeWidth: number;
-        strokeStyle: import("@excalidraw/element/types").StrokeStyle;
-        roundness: null | {
-            type: import("@excalidraw/element/types").RoundnessType;
-            value?: number;
-        };
-        roughness: number;
-        opacity: number;
-        width: number;
-        height: number;
-        angle: Radians;
-        seed: number;
-        version: number;
-        versionNonce: number;
-        index: import("@excalidraw/element/types").FractionalIndex | null;
-        isDeleted: boolean;
-        groupIds: readonly import("@excalidraw/element/types").GroupId[];
-        frameId: string | null;
-        boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
-        updated: number;
-        created: number | null;
-        link: string | null;
-        locked: boolean;
-        customData?: Record<string, any>;
-    }> & {
-        type: "diamond";
-    } & {
-        isDeleted: false;
-    }) | (Readonly<{
-        id: string;
-        x: number;
-        y: number;
-        strokeColor: string;
-        backgroundColor: string;
-        fillStyle: import("@excalidraw/element/types").FillStyle;
-        strokeWidth: number;
-        strokeStyle: import("@excalidraw/element/types").StrokeStyle;
-        roundness: null | {
-            type: import("@excalidraw/element/types").RoundnessType;
-            value?: number;
-        };
-        roughness: number;
-        opacity: number;
-        width: number;
-        height: number;
-        angle: Radians;
-        seed: number;
-        version: number;
-        versionNonce: number;
-        index: import("@excalidraw/element/types").FractionalIndex | null;
-        isDeleted: boolean;
-        groupIds: readonly import("@excalidraw/element/types").GroupId[];
-        frameId: string | null;
-        boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
-        updated: number;
-        created: number | null;
-        link: string | null;
-        locked: boolean;
-        customData?: Record<string, any>;
-    }> & {
-        type: "ellipse";
-    } & {
-        isDeleted: false;
-    }) | (Readonly<{
-        id: string;
-        x: number;
-        y: number;
-        strokeColor: string;
-        backgroundColor: string;
-        fillStyle: import("@excalidraw/element/types").FillStyle;
-        strokeWidth: number;
-        strokeStyle: import("@excalidraw/element/types").StrokeStyle;
-        roundness: null | {
-            type: import("@excalidraw/element/types").RoundnessType;
-            value?: number;
-        };
-        roughness: number;
-        opacity: number;
-        width: number;
-        height: number;
-        angle: Radians;
-        seed: number;
-        version: number;
-        versionNonce: number;
-        index: import("@excalidraw/element/types").FractionalIndex | null;
-        isDeleted: boolean;
-        groupIds: readonly import("@excalidraw/element/types").GroupId[];
-        frameId: string | null;
-        boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
-        updated: number;
-        created: number | null;
-        link: string | null;
-        locked: boolean;
-        customData?: Record<string, any>;
-    }> & Readonly<{
-        type: "line" | "arrow";
-        points: readonly LocalPoint[];
-        startBinding: import("@excalidraw/element/types").FixedPointBinding | null;
-        endBinding: import("@excalidraw/element/types").FixedPointBinding | null;
-        startArrowhead: import("@excalidraw/element/types").Arrowhead | null;
-        endArrowhead: import("@excalidraw/element/types").Arrowhead | null;
-    }> & Readonly<{
-        type: "arrow";
-        elbowed: boolean;
-    }> & {
-        isDeleted: false;
-    }) | null;
     /**
-     * Whether a text element's content is still being authored.
-     *
-     * Creating a text reverts the tool to selection during pointerdown, so the
-     * pointerup that follows looks like an ordinary canvas click and would
-     * capture the still-empty element as a history entry of its own. Undo would
-     * then rewind only the typing, restoring an invisible, zero-content element
-     * (and, for an endpoint label, leaving the arrow bound to it) rather than
-     * removing it. The editor's own submit captures the finished text instead,
-     * so the whole create-and-type lands in a single entry.
+     * Whether the element's frame clips it away at the position — hitting a
+     * frame's element from outside the frame is not considered a hit.
      */
-    private isEditingTextContent;
-    startTextEditing: ({ sceneX, sceneY, insertAtParentCenter, container, autoEdit, initialCaretSceneCoords, arrowEndpoint, }: {
-        /** X position to insert text at */
-        sceneX: number;
-        /** Y position to insert text at */
-        sceneY: number;
-        /** whether to attempt to insert at element center if applicable */
-        insertAtParentCenter?: boolean;
-        container?: ExcalidrawTextContainer | null;
-        autoEdit?: boolean;
-        initialCaretSceneCoords?: {
-            x: number;
-            y: number;
-        };
-        /**
-         * creates the text as a label for this arrow endpoint: the binding then
-         * dictates the text's position and alignment, overriding (sceneX, sceneY)
-         */
-        arrowEndpoint?: ArrowEndpoint | null;
-    }) => void;
+    isClippedByFrameAt(x: number, y: number, element: ExcalidrawElement): boolean;
+    getElementHitThreshold(element: ExcalidrawElement): number;
+    hitElement(x: number, y: number, element: NonDeletedExcalidrawElement, considerBoundingBox?: boolean): boolean;
     private startImageCropping;
-    private finishImageCropping;
+    finishImageCropping: () => void;
     private shouldHandleBrowserCanvasDoubleClick;
     private handleCanvasDoubleClick;
     private handleCanvasClick;
-    private getElementLinkAtPosition;
+    getElementLinkAtPosition: (scenePointer: Readonly<{
+        x: number;
+        y: number;
+    }>, hitElementMightBeLocked: NonDeletedExcalidrawElement | null) => NonDeletedExcalidrawElement | undefined;
     private handleElementLinkClick;
     /**
      * Applies (or clears) the element-link hover affordances — pointer cursor
@@ -871,6 +691,13 @@ declare class App extends React.Component<AppProps, AppState> {
      */
     handleHoverSelectedLinearElement(linearElementEditor: LinearElementEditor, scenePointerX: number, scenePointerY: number): void;
     private handleCanvasPointerDown;
+    /**
+     * The browser took the pointer over (scroll, pinch, palm rejection): no
+     * pointerup will follow, so the gesture is torn down here and now — the
+     * same cleanup a lost pointerup gets at the next press, only not left
+     * lying in wait for it, where its replay would tangle with that press.
+     */
+    private handleCanvasPointerCancel;
     private handleCanvasPointerUp;
     private maybeOpenContextMenuAfterPointerDownOnTouchDevices;
     private resetContextMenuTimer;
@@ -880,7 +707,6 @@ declare class App extends React.Component<AppProps, AppState> {
      * pointerup handlers manually
      */
     private maybeCleanupAfterMissingPointerUp;
-    handleCanvasPanUsingWheelOrSpaceDrag: (event: React.PointerEvent<HTMLElement> | MouseEvent) => boolean;
     private updateGestureOnPointerDown;
     /**
      * Tracks the pointer within the ongoing multi-touch gesture and applies
@@ -889,14 +715,6 @@ declare class App extends React.Component<AppProps, AppState> {
     private updateMultiTouchGesture;
     private initialPointerDownState;
     private handleDraggingScrollBar;
-    private clearSelectionIfNotUsingSelection;
-    /**
-     * @returns whether the pointer event has been completely handled
-     */
-    private handleSelectionOnPointerDown;
-    private isASelectedElement;
-    private isHittingCommonBoundingBoxOfSelectedElements;
-    private handleTextOnPointerDown;
     private handleFreeDrawElementOnPointerDown;
     insertIframeElement: ({ sceneX, sceneY, width, height, }: {
         sceneX: number;
@@ -917,8 +735,8 @@ declare class App extends React.Component<AppProps, AppState> {
     getCurrentItemStrokeWidth(elementType: ExcalidrawElement["type"]): number;
     private createGenericElementOnPointerDown;
     private createFrameElementOnPointerDown;
-    private maybeCacheReferenceSnapPoints;
-    private maybeCacheVisibleGaps;
+    maybeCacheReferenceSnapPoints(event: KeyboardModifiersObject, selectedElements: readonly NonDeletedExcalidrawElement[], recomputeAnyways?: boolean): void;
+    maybeCacheVisibleGaps(event: KeyboardModifiersObject, selectedElements: readonly NonDeletedExcalidrawElement[], recomputeAnyways?: boolean): void;
     private onKeyDownFromPointerDownHandler;
     private onKeyUpFromPointerDownHandler;
     private onPointerMoveFromPointerDownHandler;
@@ -943,23 +761,25 @@ declare class App extends React.Component<AppProps, AppState> {
     /** generally you should use `addNewImagesToImageCache()` directly if you need
      *  to render new images. This is just a failsafe  */
     private scheduleImageRefresh;
-    private clearSelection;
     private handleInteractiveCanvasRef;
-    private insertImages;
+    insertImages: (imageFiles: File[], sceneX: number, sceneY: number) => Promise<void>;
     private handleAppOnDrop;
-    loadFileToCanvas: (file: File, fileHandle: FileSystemFileHandle | null) => Promise<void>;
+    /** @returns true if the file replaced the scene */
+    loadFileToCanvas: (file: File, fileHandle: FileSystemFileHandle | null, insertPosition?: {
+        clientX: number;
+        clientY: number;
+    }) => Promise<true | undefined>;
     private handleCanvasContextMenu;
-    private maybeDragNewGenericElement;
-    private maybeHandleCrop;
-    private maybeHandleResize;
+    /** opens the context menu for the element under the pointer, or the canvas */
+    openContextMenu: (pointer: {
+        clientX: number;
+        clientY: number;
+        button?: number;
+        pointerType?: string;
+    }) => void;
+    maybeDragNewGenericElement: (pointerDownState: PointerDownState, event: MouseEvent | KeyboardEvent, informMutation?: boolean) => void;
     private getContextMenuItems;
-    getTextWysiwygSnappedToCenterPosition(x: number, y: number, appState: AppState, container?: ExcalidrawTextContainer | null): {
-        viewportX: number;
-        viewportY: number;
-        elementCenterX: number;
-        elementCenterY: number;
-    } | undefined;
-    private savePointer;
+    savePointer: (x: number, y: number, button: "up" | "down") => void;
     resetShouldCacheIgnoreZoomDebounced: {
         (): void;
         flush(): void;

package/dist/types/excalidraw/components/App.duplicate.d.ts

@@ -0,0 +1,101 @@
+import { duplicateElements } from "@excalidraw/element";
+import type { ExcalidrawElement, ExcalidrawTextElement } from "@excalidraw/element/types";
+import type { PointerDownState } from "../types";
+import type App from "./App";
+type Duplication = Pick<ReturnType<typeof duplicateElements>, "duplicatedElements" | "duplicateElementsMap" | "origElementsMap" | "origIdToDuplicateId" | "duplicateIdToOrigId">;
+/**
+ * Owns the duplication paths which involve the host (`props.onDuplicate`):
+ * duplicating elements into the scene (paste, library insert etc.), and
+ * duplicating the dragged selection (alt-drag). The duplicate action shares
+ * `runOnDuplicate()`.
+ */
+export declare class AppDuplicate {
+    private app;
+    private dependencies;
+    constructor(app: App, dependencies: {
+        /** pointers currently down */
+        getPointerCount: () => number;
+    });
+    /**
+     * Hands the duplication over to the host's `props.onDuplicate` (if any),
+     * and reconciles what it returned with the duplicates.
+     *
+     * @returns next elements, and the duplicates that weren't vetoed
+     */
+    runOnDuplicate: (duplication: Duplication, nextElements: ExcalidrawElement[], 
+    /** excludes the duplicated elements */
+    prevElements: readonly ExcalidrawElement[]) => {
+        elements: ExcalidrawElement[];
+        duplicatedElements: import("@excalidraw/element/types").NonDeletedExcalidrawElement[];
+    };
+    /**
+     * Runs `update` once what's pending is committed, capturing what it changes
+     * (if it returns `true`) as a separate undo step.
+     */
+    private afterCommit;
+    /**
+     * Advances the list markers of the duplicated texts (`1.` -> `2.`) once
+     * the duplication is committed, as a separate undo step, so that undo
+     * reverts the markers first.
+     */
+    advanceListMarkers: (duplicatedElements: readonly ExcalidrawElement[]) => void;
+    /**
+     * The text whose editing an alt-press on it ended, while the press is
+     * handed over to the canvas (see `handOverTextEditorPress()`).
+     */
+    handedOverTextId: ExcalidrawTextElement["id"] | null;
+    /**
+     * An alt-press on the text being edited, once it ended the editing, is
+     * handed over to the canvas, for the text to be alt-dragged (duplicated) as
+     * on the canvas — its duplicate is then edited on drop.
+     */
+    handOverTextEditorPress: (event: PointerEvent, textElementId: ExcalidrawTextElement["id"]) => void;
+    /**
+     * The pointer down a handed-over press is replayed as (see
+     * `handOverTextEditorPress()`) moves what was edited — the text, or its
+     * container — and nothing beneath the editor, which reaches past the text:
+     * no resize handle, nor an arrow's point, midpoint or label.
+     *
+     * @returns `false` if the pointer down isn't a handed-over press
+     */
+    hitEditedElement: (pointerDownState: PointerDownState) => boolean;
+    /**
+     * On alt-drag drop: the list markers advanced along with the drag go back,
+     * for the drag to be committed as is, and forth again once it is, as
+     * a separate undo step (before the browser gets to paint either).
+     *
+     * A duplicate is then edited (once the drop is committed): a single list
+     * item with text after its marker, with that text selected (`1. |foo|`),
+     * as it's likely to differ from the original's — or else the duplicate of
+     * the text the drag ended the editing of, with all of it selected.
+     */
+    commitDraggedDuplicates: ({ hit }: PointerDownState, { editText, }: {
+        /** `false` if the drag didn't end with a genuine pointerup */
+        editText: boolean;
+    }) => void;
+    private editDuplicatedText;
+    /**
+     * Duplicates elements so that they end up centered at the scene coords
+     * (and in the frame at that point, if any). Doesn't update the scene.
+     *
+     * @returns `null` if the host vetoed the duplication
+     */
+    duplicateAtSceneCoords: (elements: readonly ExcalidrawElement[], { x, y }: {
+        x: number;
+        y: number;
+    }, opts?: {
+        retainSeed?: boolean;
+        preserveFrameChildrenOrder?: boolean;
+    }) => {
+        nextElements: ExcalidrawElement[];
+        duplicatedElements: import("@excalidraw/element/types").NonDeletedExcalidrawElement[];
+    } | null;
+    /**
+     * Duplicates the selection being dragged: the originals go back to where
+     * the drag started, and the drag continues with the duplicates.
+     *
+     * If the host vetoes the duplication, the originals keep being dragged.
+     */
+    duplicateDraggedSelection: (pointerDownState: PointerDownState, event: PointerEvent) => void;
+}
+export {};

package/dist/types/excalidraw/components/App.modifiers.d.ts

@@ -0,0 +1,38 @@
+import { Emitter } from "@excalidraw/common";
+export type HeldModifiers = Readonly<{
+    alt: boolean;
+    shift: boolean;
+    /** Ctrl, or Cmd on macOS */
+    ctrlOrCmd: boolean;
+}>;
+/**
+ * The modifier keys held over the editor, synced from the flags of its
+ * keyboard and pointer events. Kept out of appState so that pressing one
+ * re-renders only its subscribers (e.g. the hint).
+ */
+export declare class AppModifiers {
+    private held;
+    /** fires with a new snapshot whenever a modifier is pressed or released */
+    readonly onChange: Emitter<[held: Readonly<{
+        alt: boolean;
+        shift: boolean;
+        /** Ctrl, or Cmd on macOS */
+        ctrlOrCmd: boolean;
+    }>]>;
+    get: () => HeldModifiers;
+    /**
+     * A hook re-rendering on the held modifiers: all of them, or with
+     * `modifier`, only on that one being pressed or released.
+     */
+    useHeld(): HeldModifiers;
+    useHeld(modifier: keyof HeldModifiers): boolean;
+    sync: (event: {
+        altKey: boolean;
+        shiftKey: boolean;
+        ctrlKey: boolean;
+        metaKey: boolean;
+    }) => void;
+    /** releases them all — e.g. on blur, as Alt+Tab never delivers the keyup */
+    reset: () => void;
+    private set;
+}