@excalidraw/math 0.18.0-1118751 → 0.18.0-143b5b6

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,19 +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, ElementRenderOverrides, ExcalidrawImperativeAPI, BinaryFiles, LibraryItems, SceneData, FrameNameBoundsCache, SidebarName, SidebarTabName, KeyboardModifiersObject, 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: {
@@ -87,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;
@@ -132,10 +137,13 @@ declare class App extends React.Component<AppProps, AppState> {
     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;
     /**
@@ -201,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;
         };
@@ -264,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;
         };
@@ -297,6 +311,7 @@ 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 */
@@ -387,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
@@ -434,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
@@ -478,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;
@@ -499,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;
@@ -512,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.
@@ -590,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;
@@ -609,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
@@ -885,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;
@@ -902,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;
@@ -956,11 +761,14 @@ 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;
     /** opens the context menu for the element under the pointer, or the canvas */
     openContextMenu: (pointer: {
@@ -969,16 +777,8 @@ declare class App extends React.Component<AppProps, AppState> {
         button?: number;
         pointerType?: string;
     }) => void;
-    private maybeDragNewGenericElement;
-    private maybeHandleCrop;
-    private maybeHandleResize;
+    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;
     savePointer: (x: number, y: number, button: "up" | "down") => void;
     resetShouldCacheIgnoreZoomDebounced: {
         (): void;

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

@@ -1,5 +1,5 @@
 import { duplicateElements } from "@excalidraw/element";
-import type { ExcalidrawElement } from "@excalidraw/element/types";
+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">;
@@ -11,7 +11,11 @@ type Duplication = Pick<ReturnType<typeof duplicateElements>, "duplicatedElement
  */
 export declare class AppDuplicate {
     private app;
-    constructor(app: 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.
@@ -24,6 +28,52 @@ export declare class AppDuplicate {
         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.

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;
+}

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

@@ -33,10 +33,18 @@ export declare class AppPan {
     constructor(app: App, dependencies: {
         /** pointers currently down (a two-finger gesture is not a pan) */
         getPointerCount: () => number;
+        /** a scrollbar being dragged (App's own drag, not a pan session) */
+        isDraggingScrollBar: () => boolean;
     });
     isActive: () => boolean;
     isSpaceHeld: () => boolean;
     setSpaceHeld: (held: boolean) => void;
+    /**
+     * Whether the pointer is navigating the viewport rather than acting on the
+     * scene — space held to pan, a pan in progress, a scrollbar drag, or the
+     * hand tool. Hover and cursor then belong to the navigation.
+     */
+    isNavigating: () => boolean;
     /** applies the pointer move still waiting for its frame, if any */
     flushMove: () => void;
     /** ends the active session, if any — pointerup may never arrive (the user

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

@@ -0,0 +1,57 @@
+import type { ExcalidrawElement, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
+import type React from "react";
+import type { PointerDownState } from "../types";
+import type App from "./App";
+/**
+ * The selection tool's (and the lasso's) selection: what a pointer down
+ * selects, what a click (a pointer up without a drag) does to the selection —
+ * including alt-click cycling through the overlapping elements — and the
+ * selection's transform handles (resizing, rotating, cropping).
+ */
+export declare class AppSelectionTool {
+    private app;
+    constructor(app: App);
+    clearSelectionIfNotUsingSelection: () => void;
+    /**
+     * @returns whether the pointer event has been completely handled
+     */
+    handleSelectionOnPointerDown: (event: React.PointerEvent<HTMLElement>, pointerDownState: PointerDownState) => boolean;
+    maybeHandleCrop: (pointerDownState: PointerDownState, event: MouseEvent | KeyboardEvent) => boolean;
+    maybeHandleResize: (pointerDownState: PointerDownState, event: MouseEvent | KeyboardEvent) => boolean;
+    /**
+     * Updates the selection on a click (no drag): the element below the
+     * selected one on an alt-click, the clicked element added to or removed
+     * from the selection with shift, or selected, and the selection cleared
+     * by a click hitting only a bounding box.
+     *
+     * @returns whether the pointer event has been completely handled
+     */
+    handleSelectionOnPointerUp: (childEvent: PointerEvent, pointerDownState: PointerDownState, elementsMap: NonDeletedSceneElementsMap) => boolean;
+    clearSelection(hitElement: ExcalidrawElement | null): void;
+    isASelectedElement(hitElement: ExcalidrawElement | null): boolean;
+    isHittingCommonBoundingBoxOfSelectedElements(point: Readonly<{
+        x: number;
+        y: number;
+    }>, selectedElements: readonly ExcalidrawElement[]): boolean;
+    /** whether an alt-click on the selection (over other elements) cycles it */
+    canCycleSelection: () => boolean;
+    /**
+     * The selectable unit (an element, or the group a click would select) an
+     * element belongs to. Inside an edited group, its elements are units of
+     * their own.
+     */
+    private getSelectableUnit;
+    /**
+     * The selected unit, if an alt-click can cycle away from it: exactly one
+     * is selected, and neither the linear nor the crop editor is open.
+     */
+    private getCyclableSelectedUnit;
+    /**
+     * The element an alt-click selects: the selectable unit below the selected
+     * one among the hit elements, wrapping around to the topmost — or `null`
+     * unless it's an alt-click, the selection can cycle, and it's under the
+     * pointer. Inside an edited group, it cycles through the group's elements
+     * only, never leaving the group.
+     */
+    private getSelectionCycleTarget;
+}