@excalidraw/excalidraw 0.18.0-817d8c5 → 0.18.0-a5d6939

package/dist/prod/locales/{en-B4ZKOASM.js → en-SBO6ZHT2.js}

@@ -1 +1 @@
-import{A,B,C,D,E,F,G,H,I,J,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z}from"../chunk-6U3AYISY.js";import"../chunk-SRAX5OIU.js";export{f as alerts,e as buttons,l as canvasError,s as clearCanvasDialog,C as colorPicker,A as colors,I as commandPalette,v as confirmDialog,J as default,i as element,b as elementLink,x as encrypted,p as errorDialog,m as errorSplash,g as errors,q as exportDialog,G as fontList,j as headings,r as helpDialog,k as hints,w as imageExportDialog,a as labels,c as library,E as mermaid,D as overwriteConfirm,t as publishDialog,u as publishSuccessDialog,F as quickSearch,o as roomDialog,d as search,n as shareDialog,y as stats,z as toast,h as toolBar,H as userList,B as welcomeScreen};
+import{A,B,C,D,E,F,G,H,I,J,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z}from"../chunk-IUH5AXLB.js";import"../chunk-SRAX5OIU.js";export{f as alerts,e as buttons,l as canvasError,s as clearCanvasDialog,C as colorPicker,A as colors,I as commandPalette,v as confirmDialog,J as default,i as element,b as elementLink,x as encrypted,p as errorDialog,m as errorSplash,g as errors,q as exportDialog,G as fontList,j as headings,r as helpDialog,k as hints,w as imageExportDialog,a as labels,c as library,E as mermaid,D as overwriteConfirm,t as publishDialog,u as publishSuccessDialog,F as quickSearch,o as roomDialog,d as search,n as shareDialog,y as stats,z as toast,h as toolBar,H as userList,B as welcomeScreen};

package/dist/prod/subset-shared.chunk.js

@@ -1 +1 @@
-import{a,b,c,d}from"./chunk-EIO257PC.js";import"./chunk-G5N3DNGT.js";import"./chunk-SRAX5OIU.js";export{a as Commands,b as subsetToBase64,c as subsetToBinary,d as toBase64};
+import{a,b,c,d}from"./chunk-LS7FJGPW.js";import"./chunk-GKI4RZ6C.js";import"./chunk-SRAX5OIU.js";export{a as Commands,b as subsetToBase64,c as subsetToBinary,d as toBase64};

package/dist/prod/subset-worker.chunk.js

@@ -1 +1 @@
-import{a as r,c as t}from"./chunk-EIO257PC.js";import"./chunk-G5N3DNGT.js";import"./chunk-SRAX5OIU.js";var s=import.meta.url?new URL(import.meta.url):void 0;typeof window>"u"&&typeof self<"u"&&(self.onmessage=async e=>{switch(e.data.command){case r.Subset:let a=await t(e.data.arrayBuffer,e.data.codePoints);self.postMessage(a,{transfer:[a]});break}});export{s as WorkerUrl};
+import{a as r,c as t}from"./chunk-LS7FJGPW.js";import"./chunk-GKI4RZ6C.js";import"./chunk-SRAX5OIU.js";var s=import.meta.url?new URL(import.meta.url):void 0;typeof window>"u"&&typeof self<"u"&&(self.onmessage=async e=>{switch(e.data.command){case r.Subset:let a=await t(e.data.arrayBuffer,e.data.codePoints);self.postMessage(a,{transfer:[a]});break}});export{s as WorkerUrl};

package/dist/types/{excalidraw/binaryheap.d.ts → common/src/binary-heap.d.ts}

@@ -1,4 +1,4 @@
-export default class BinaryHeap<T> {
+export declare class BinaryHeap<T> {
     private scoreFunction;
     private content;
     constructor(scoreFunction: (node: T) => number);

package/dist/types/{excalidraw → common/src}/colors.d.ts

@@ -1,5 +1,6 @@
 import oc from "open-color";
 import type { Merge } from "./utility-types";
+export declare const COLOR_OUTLINE_CONTRAST_THRESHOLD = 240;
 export type ColorPickerColor = Exclude<keyof oc, "indigo" | "lime"> | "transparent" | "bronze";
 export type ColorTuple = readonly [string, string, string, string, string];
 export type ColorPalette = Merge<Record<ColorPickerColor, ColorTuple>, {

package/dist/types/{excalidraw → common/src}/constants.d.ts

@@ -1,5 +1,5 @@
-import type { AppProps, AppState } from "./types";
-import type { ExcalidrawElement, FontFamilyValues } from "./element/types";
+import type { ExcalidrawElement, FontFamilyValues } from "@excalidraw/element/types";
+import type { AppProps, AppState } from "@excalidraw/excalidraw/types";
 export declare const isDarwin: boolean;
 export declare const isWindows: boolean;
 export declare const isAndroid: boolean;
@@ -82,6 +82,7 @@ export declare const YOUTUBE_STATES: {
 export declare const ENV: {
     TEST: string;
     DEVELOPMENT: string;
+    PRODUCTION: string;
 };
 export declare const CLASSES: {
     SHAPE_ACTIONS_MENU: string;
@@ -120,11 +121,11 @@ export declare const THEME: {
 export declare const FRAME_STYLE: {
     strokeColor: string;
     strokeWidth: number;
-    strokeStyle: import("./element/types").StrokeStyle;
-    fillStyle: import("./element/types").FillStyle;
+    strokeStyle: import("@excalidraw/element/types").StrokeStyle;
+    fillStyle: import("@excalidraw/element/types").FillStyle;
     roughness: number;
     roundness: {
-        type: import("./element/types").RoundnessType;
+        type: import("@excalidraw/element/types").RoundnessType;
         value?: number | undefined;
     } | null;
     backgroundColor: string;
@@ -224,6 +225,7 @@ export declare const DEFAULT_EXPORT_PADDING = 10;
 export declare const DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT = 1440;
 export declare const MAX_ALLOWED_FILE_BYTES: number;
 export declare const SVG_NS = "http://www.w3.org/2000/svg";
+export declare const SVG_DOCUMENT_PREAMBLE = "<?xml version=\"1.0\" standalone=\"no\"?>\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n";
 export declare const ENCRYPTION_KEY_BITS = 128;
 export declare const VERSIONS: {
     readonly excalidraw: 2;
@@ -276,9 +278,10 @@ export declare const DEFAULT_SIDEBAR: {
     readonly name: "default";
     readonly defaultTab: "library";
 };
-export declare const LIBRARY_DISABLED_TYPES: Set<"image" | "iframe" | "embeddable">;
+export declare const LIBRARY_DISABLED_TYPES: Set<"embeddable" | "image" | "iframe">;
 export declare const TOOL_TYPE: {
     readonly selection: "selection";
+    readonly lasso: "lasso";
     readonly rectangle: "rectangle";
     readonly diamond: "diamond";
     readonly ellipse: "ellipse";

package/dist/types/{excalidraw/fonts/FontMetadata.d.ts → common/src/font-metadata.d.ts}

@@ -1,4 +1,4 @@
-import type { JSX } from "react";
+import type { ExcalidrawTextElement, FontFamilyValues } from "@excalidraw/element/types";
 /**
  * Encapsulates font metrics with additional font metadata.
  * */
@@ -14,8 +14,6 @@ export interface FontMetadata {
         /** harcoded unitless line-height, https://github.com/excalidraw/excalidraw/pull/6360#issuecomment-1477635971 */
         lineHeight: number;
     };
-    /** element to be displayed as an icon  */
-    icon?: JSX.Element;
     /** flag to indicate a deprecated font */
     deprecated?: true;
     /** flag to indicate a server-side only font */
@@ -36,3 +34,13 @@ export declare const GOOGLE_FONTS_RANGES: {
 };
 /** local protocol to skip the local font from registering or inlining */
 export declare const LOCAL_FONT_PROTOCOL = "local:";
+/**
+ * Calculates vertical offset for a text with alphabetic baseline.
+ */
+export declare const getVerticalOffset: (fontFamily: ExcalidrawTextElement["fontFamily"], fontSize: ExcalidrawTextElement["fontSize"], lineHeightPx: number) => number;
+/**
+ * Gets line height for a selected family.
+ */
+export declare const getLineHeight: (fontFamily: FontFamilyValues) => number & {
+    _brand: "unitlessLineHeight";
+};

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

@@ -0,0 +1,11 @@
+export * from "./binary-heap";
+export * from "./colors";
+export * from "./constants";
+export * from "./font-metadata";
+export * from "./queue";
+export * from "./keys";
+export * from "./points";
+export * from "./promise-pool";
+export * from "./random";
+export * from "./url";
+export * from "./utils";

package/dist/types/{excalidraw → common/src}/points.d.ts

@@ -1,7 +1,9 @@
 import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
+import type { NullableGridSize } from "@excalidraw/excalidraw/types";
 export declare const getSizeFromPoints: (points: readonly (GlobalPoint | LocalPoint)[]) => {
     width: number;
     height: number;
 };
 /** @arg dimension, 0 for rescaling only x, 1 for y */
 export declare const rescalePoints: <Point extends GlobalPoint | LocalPoint>(dimension: 0 | 1, newSize: number, points: readonly Point[], normalize: boolean) => Point[];
+export declare const getGridPoint: (x: number, y: number, gridSize: NullableGridSize) => [number, number];

package/dist/types/common/src/promise-pool.d.ts

@@ -0,0 +1,6 @@
+export declare class PromisePool<T> {
+    private readonly pool;
+    private readonly entries;
+    constructor(source: IterableIterator<Promise<void | readonly [number, T]>>, concurrency: number);
+    all(): PromiseLike<T[]>;
+}

package/dist/types/{excalidraw → common/src}/utils.d.ts

@@ -1,14 +1,15 @@
-import type { EVENT } from "./constants";
-import type { ExcalidrawBindableElement, FontFamilyValues, FontString } from "./element/types";
-import type { ActiveTool, AppState, ToolType, UnsubscribeCallback, Zoom } from "./types";
+import { type GlobalPoint } from "@excalidraw/math";
+import type { ExcalidrawBindableElement, FontFamilyValues, FontString, ExcalidrawElement } from "@excalidraw/element/types";
+import type { ActiveTool, AppState, ToolType, UnsubscribeCallback, Zoom } from "@excalidraw/excalidraw/types";
 import type { MaybePromise } from "./utility-types";
+import type { EVENT } from "./constants";
 export declare const setDateTimeForTests: (dateTime: string) => void;
 export declare const getDateTime: () => string;
 export declare const capitalizeString: (str: string) => string;
 export declare const isToolIcon: (target: Element | EventTarget | null) => target is HTMLElement;
-export declare const isInputLike: (target: Element | EventTarget | null) => target is HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | HTMLBRElement | HTMLDivElement;
+export declare const isInputLike: (target: Element | EventTarget | null) => target is HTMLBRElement | HTMLDivElement | HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
 export declare const isInteractive: (target: Element | EventTarget | null) => boolean;
-export declare const isWritableElement: (target: Element | EventTarget | null) => target is HTMLInputElement | HTMLTextAreaElement | HTMLBRElement | HTMLDivElement;
+export declare const isWritableElement: (target: Element | EventTarget | null) => target is HTMLBRElement | HTMLDivElement | HTMLInputElement | HTMLTextAreaElement;
 export declare const getFontFamilyString: ({ fontFamily, }: {
     fontFamily: FontFamilyValues;
 }) => string;
@@ -87,6 +88,7 @@ export declare const updateActiveTool: (appState: Pick<AppState, "activeTool">,
     customType: string;
 }) & {
     locked?: boolean;
+    fromSelection?: boolean;
 }) & {
     lastActiveToolBeforeEraser?: ActiveTool | null;
 }) => AppState["activeTool"];
@@ -178,13 +180,14 @@ export type Node<T> = T & {
 export declare const arrayToList: <T>(array: readonly T[]) => Node<T>[];
 export declare const isTestEnv: () => boolean;
 export declare const isDevEnv: () => boolean;
+export declare const isProdEnv: () => boolean;
 export declare const isServerEnv: () => boolean;
 export declare const wrapEvent: <T extends Event>(name: EVENT, nativeEvent: T) => CustomEvent<{
     nativeEvent: T;
 }>;
 export declare const updateObject: <T extends Record<string, any>>(obj: T, updates: Partial<T>) => T;
 export declare const isPrimitive: (val: any) => boolean;
-export declare const getFrame: () => "top" | "iframe";
+export declare const getFrame: () => "iframe" | "top";
 export declare const isRunningInIframe: () => boolean;
 export declare const isPromiseLike: (value: any) => value is Promise<any>;
 export declare const queryFocusableElements: (container: HTMLElement | null) => HTMLElement[];
@@ -241,16 +244,11 @@ export declare const toBrandedType: <BrandedType, CurrentType = BrandedType>(val
 export declare const promiseTry: <TValue, TArgs extends unknown[]>(fn: (...args: TArgs) => TValue | PromiseLike<TValue>, ...args: TArgs) => Promise<TValue>;
 export declare const isAnyTrue: (...args: boolean[]) => boolean;
 export declare const safelyParseJSON: (json: string) => Record<string, any> | null;
-export declare class PromisePool<T> {
-    private readonly pool;
-    private readonly entries;
-    constructor(source: IterableIterator<Promise<void | readonly [number, T]>>, concurrency: number);
-    all(): PromiseLike<T[]>;
-}
 /**
  * use when you need to render unsafe string as HTML attribute, but MAKE SURE
  * the attribute is double-quoted when constructing the HTML string
  */
 export declare const escapeDoubleQuotes: (str: string) => string;
 export declare const castArray: <T>(value: T | T[]) => T[];
+export declare const elementCenterPoint: (element: ExcalidrawElement, xOffset?: number, yOffset?: number) => GlobalPoint;
 export {};

package/dist/types/{excalidraw/scene → element/src}/Shape.d.ts

@@ -1,7 +1,7 @@
+import type { EmbedsValidationStatus } from "@excalidraw/excalidraw/types";
+import type { ExcalidrawElement, NonDeletedExcalidrawElement, ExcalidrawSelectionElement } from "./types";
 import type { Drawable, Options } from "roughjs/bin/core";
 import type { RoughGenerator } from "roughjs/bin/generator";
-import type { ExcalidrawElement, NonDeletedExcalidrawElement, ExcalidrawSelectionElement } from "../element/types";
-import type { EmbedsValidationStatus } from "../types";
 export declare const generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean) => Options;
 /**
  * Generates the roughjs shape for given element.

package/dist/types/{excalidraw/scene → element/src}/ShapeCache.d.ts

@@ -1,7 +1,7 @@
+import type { AppState, EmbedsValidationStatus } from "@excalidraw/excalidraw/types";
+import type { ElementShape, ElementShapes } from "@excalidraw/excalidraw/scene/types";
+import type { ExcalidrawElement } from "./types";
 import type { Drawable } from "roughjs/bin/core";
-import type { ExcalidrawElement } from "../element/types";
-import type { ElementShape, ElementShapes } from "./types";
-import type { AppState, EmbedsValidationStatus } from "../types";
 export declare class ShapeCache {
     private static rg;
     private static cache;
@@ -17,7 +17,7 @@ export declare class ShapeCache {
      * Generates & caches shape for element if not already cached, otherwise
      * returns cached shape.
      */
-    static generateElementShape: <T extends import("../element/types").ExcalidrawRectangleElement | import("../element/types").ExcalidrawDiamondElement | import("../element/types").ExcalidrawEllipseElement | import("../element/types").ExcalidrawTextElement | import("../element/types").ExcalidrawLinearElement | import("../element/types").ExcalidrawArrowElement | import("../element/types").ExcalidrawFreeDrawElement | import("../element/types").ExcalidrawImageElement | import("../element/types").ExcalidrawFrameElement | import("../element/types").ExcalidrawMagicFrameElement | import("../element/types").ExcalidrawIframeElement | import("../element/types").ExcalidrawEmbeddableElement>(element: T, renderConfig: {
+    static generateElementShape: <T extends import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawEmbeddableElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawTextElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawLinearElement | import("./types").ExcalidrawArrowElement | import("./types").ExcalidrawFreeDrawElement>(element: T, renderConfig: {
         isExporting: boolean;
         canvasBackgroundColor: AppState["viewBackgroundColor"];
         embedsValidationStatus: EmbedsValidationStatus;

package/dist/types/{excalidraw → element/src}/align.d.ts

@@ -1,5 +1,5 @@
-import type { ElementsMap, ExcalidrawElement } from "./element/types";
-import type Scene from "./scene/Scene";
+import type Scene from "@excalidraw/excalidraw/scene/Scene";
+import type { ElementsMap, ExcalidrawElement } from "./types";
 export interface Alignment {
     position: "start" | "center" | "end";
     axis: "x" | "y";

package/dist/types/{excalidraw/element → element/src}/binding.d.ts

@@ -1,11 +1,11 @@
-import type { ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, ExcalidrawLinearElement, NonDeletedExcalidrawElement, ElementsMap, NonDeletedSceneElementsMap, OrderedExcalidrawElement, ExcalidrawElbowArrowElement, FixedPoint, SceneElementsMap } from "./types";
+import { type GlobalPoint } from "@excalidraw/math";
+import type { LocalPoint } from "@excalidraw/math";
+import type Scene from "@excalidraw/excalidraw/scene/Scene";
+import type { AppState } from "@excalidraw/excalidraw/types";
+import { type Heading } from "./heading";
 import type { Bounds } from "./bounds";
-import type { AppState } from "../types";
 import type { ElementUpdate } from "./mutateElement";
-import type Scene from "../scene/Scene";
-import { type Heading } from "./heading";
-import type { LocalPoint } from "@excalidraw/math";
-import { type GlobalPoint } from "@excalidraw/math";
+import type { ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, ExcalidrawLinearElement, NonDeletedExcalidrawElement, ElementsMap, NonDeletedSceneElementsMap, OrderedExcalidrawElement, ExcalidrawElbowArrowElement, FixedPoint, SceneElementsMap } from "./types";
 export type SuggestedBinding = NonDeleted<ExcalidrawBindableElement> | SuggestedPointBinding;
 export type SuggestedPointBinding = [
     NonDeleted<ExcalidrawLinearElement>,
@@ -39,13 +39,13 @@ export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawE
     changedElements?: Map<string, OrderedExcalidrawElement>;
 }) => void;
 export declare const getHeadingForElbowArrowSnap: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined | null, aabb: Bounds | undefined | null, elementsMap: ElementsMap, origPoint: GlobalPoint, zoom?: AppState["zoom"]) => Heading;
-export declare const bindPointToSnapToElementOutline: (arrow: ExcalidrawElbowArrowElement, bindableElement: ExcalidrawBindableElement | undefined, startOrEnd: "start" | "end") => GlobalPoint;
+export declare const bindPointToSnapToElementOutline: (arrow: ExcalidrawElbowArrowElement, bindableElement: ExcalidrawBindableElement, startOrEnd: "start" | "end") => GlobalPoint;
 export declare const avoidRectangularCorner: (element: ExcalidrawBindableElement, p: GlobalPoint) => GlobalPoint;
 export declare const snapToMid: (element: ExcalidrawBindableElement, p: GlobalPoint, tolerance?: number) => GlobalPoint;
 export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => {
     fixedPoint: FixedPoint;
 };
-export declare const fixBindingsAfterDuplication: (sceneElements: readonly ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicatesServeAsOld?: "duplicatesServeAsOld" | undefined) => void;
+export declare const fixDuplicatedBindingsAfterDuplication: (duplicatedElements: ExcalidrawElement[], origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicateElementsMap: NonDeletedSceneElementsMap) => void;
 export declare const fixBindingsAfterDeletion: (sceneElements: readonly ExcalidrawElement[], deletedElements: readonly ExcalidrawElement[]) => void;
 export declare const bindingBorderTest: (element: NonDeleted<ExcalidrawBindableElement>, { x, y }: {
     x: number;

package/dist/types/{excalidraw/element → element/src}/bounds.d.ts

@@ -1,7 +1,7 @@
+import type { Degrees, GlobalPoint, LineSegment } from "@excalidraw/math";
+import type { AppState } from "@excalidraw/excalidraw/types";
 import type { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, ExcalidrawFreeDrawElement, NonDeleted, ElementsMap } from "./types";
 import type { Drawable, Op } from "roughjs/bin/core";
-import type { AppState } from "../types";
-import type { Degrees, GlobalPoint, LineSegment } from "@excalidraw/math";
 export type RectangleBox = {
     x: number;
     y: number;
@@ -30,6 +30,11 @@ export declare class ElementBounds {
     private static calculateBounds;
 }
 export declare const getElementAbsoluteCoords: (element: ExcalidrawElement, elementsMap: ElementsMap, includeBoundText?: boolean) => [number, number, number, number, number, number];
+/**
+ * Given an element, return the line segments that make up the element.
+ *
+ * Uses helpers from /math
+ */
 export declare const getElementLineSegments: (element: ExcalidrawElement, elementsMap: ElementsMap) => LineSegment<GlobalPoint>[];
 /**
  * Scene -> Scene coords, but in x1,x2,y1,y2 format.

package/dist/types/{excalidraw/element → element/src}/collision.d.ts

@@ -1,7 +1,7 @@
-import type { ElementsMap, ExcalidrawElement } from "./types";
-import type { FrameNameBounds } from "../types";
-import type { GeometricShape } from "@excalidraw/utils/geometry/shape";
+import { type GeometricShape } from "@excalidraw/utils/shape";
 import type { GlobalPoint, LineSegment, LocalPoint } from "@excalidraw/math";
+import type { FrameNameBounds } from "@excalidraw/excalidraw/types";
+import type { ElementsMap, ExcalidrawElement } from "./types";
 export declare const shouldTestInside: (element: ExcalidrawElement) => boolean;
 export type HitTestArgs<Point extends GlobalPoint | LocalPoint> = {
     x: number;

package/dist/types/{excalidraw/scene → element/src}/comparisons.d.ts

@@ -1,4 +1,4 @@
-import type { ElementOrToolType } from "../types";
+import type { ElementOrToolType } from "@excalidraw/excalidraw/types";
 export declare const hasBackground: (type: ElementOrToolType) => boolean;
 export declare const hasStrokeColor: (type: ElementOrToolType) => boolean;
 export declare const hasStrokeWidth: (type: ElementOrToolType) => boolean;

package/dist/types/{excalidraw → element/src}/distribute.d.ts

@@ -1,4 +1,4 @@
-import type { ElementsMap, ExcalidrawElement } from "./element/types";
+import type { ElementsMap, ExcalidrawElement } from "./types";
 export interface Distribution {
     space: "between";
     axis: "x" | "y";

package/dist/types/{excalidraw/element → element/src}/dragElements.d.ts

@@ -1,6 +1,6 @@
-import type { NonDeletedExcalidrawElement } from "./types";
-import type { AppState, NormalizedZoomValue, NullableGridSize, PointerDownState } from "../types";
-import type Scene from "../scene/Scene";
+import type { AppState, NormalizedZoomValue, NullableGridSize, PointerDownState } from "@excalidraw/excalidraw/types";
+import type Scene from "@excalidraw/excalidraw/scene/Scene";
+import type { NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 export declare const dragSelectedElements: (pointerDownState: PointerDownState, _selectedElements: NonDeletedExcalidrawElement[], offset: {
     x: number;
     y: number;

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

@@ -0,0 +1,63 @@
+import type { Mutable } from "@excalidraw/common/utility-types";
+import type { AppState } from "@excalidraw/excalidraw/types";
+import type { ExcalidrawElement, GroupId } from "./types";
+/**
+ * Duplicate an element, often used in the alt-drag operation.
+ * Note that this method has gotten a bit complicated since the
+ * introduction of gruoping/ungrouping elements.
+ * @param editingGroupId The current group being edited. The new
+ *                       element will inherit this group and its
+ *                       parents.
+ * @param groupIdMapForOperation A Map that maps old group IDs to
+ *                               duplicated ones. If you are duplicating
+ *                               multiple elements at once, share this map
+ *                               amongst all of them
+ * @param element Element to duplicate
+ */
+export declare const duplicateElement: <TElement extends ExcalidrawElement>(editingGroupId: AppState["editingGroupId"], groupIdMapForOperation: Map<GroupId, GroupId>, element: TElement, randomizeSeed?: boolean) => Readonly<TElement>;
+export declare const duplicateElements: (opts: {
+    elements: readonly ExcalidrawElement[];
+    randomizeSeed?: boolean | undefined;
+    overrides?: ((data: {
+        duplicateElement: ExcalidrawElement;
+        origElement: ExcalidrawElement;
+        origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>;
+    }) => Partial<ExcalidrawElement>) | undefined;
+} & ({
+    /**
+     * Duplicates all elements in array.
+     *
+     * Use this when programmaticaly duplicating elements, without direct
+     * user interaction.
+     */
+    type: "everything";
+} | {
+    /**
+     * Duplicates specified elements and inserts them back into the array
+     * in specified order.
+     *
+     * Use this when duplicating Scene elements, during user interaction
+     * such as alt-drag or on duplicate action.
+     */
+    type: "in-place";
+    idsOfElementsToDuplicate: Map<ExcalidrawElement["id"], ExcalidrawElement>;
+    appState: {
+        editingGroupId: AppState["editingGroupId"];
+        selectedGroupIds: AppState["selectedGroupIds"];
+    };
+})) => {
+    duplicatedElements: ExcalidrawElement[];
+    duplicateElementsMap: Map<string, ExcalidrawElement>;
+    elementsWithDuplicates: ExcalidrawElement[];
+    origIdToDuplicateId: Map<string, string>;
+};
+/**
+ * Clones ExcalidrawElement data structure. Does not regenerate id, nonce, or
+ * any value. The purpose is to to break object references for immutability
+ * reasons, whenever we want to keep the original element, but ensure it's not
+ * mutated.
+ *
+ * Only clones plain objects and arrays. Doesn't clone Date, RegExp, Map, Set,
+ * Typed arrays and other non-null objects.
+ */
+export declare const deepCopyElement: <T extends ExcalidrawElement>(val: T) => Mutable<T>;

package/dist/types/{excalidraw/element → element/src}/elementLink.d.ts

@@ -1,7 +1,7 @@
 /**
  * Create and link between shapes.
  */
-import type { AppProps, AppState } from "../types";
+import type { AppProps, AppState } from "@excalidraw/excalidraw/types";
 import type { ExcalidrawElement } from "./types";
 export declare const defaultGetElementLinkFromSelection: Exclude<AppProps["generateLinkForSelection"], undefined>;
 export declare const getLinkIdAndTypeFromSelection: (selectedElements: ExcalidrawElement[], appState: AppState) => {

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

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

package/dist/types/{excalidraw/element → element/src}/flowchart.d.ts

@@ -1,5 +1,5 @@
+import type { AppState, PendingExcalidrawElements } from "@excalidraw/excalidraw/types";
 import { type ElementsMap, type ExcalidrawBindableElement, type ExcalidrawElement, type ExcalidrawFlowchartNodeElement } from "./types";
-import type { AppState, PendingExcalidrawElements } from "../types";
 type LinkDirection = "up" | "right" | "down" | "left";
 export declare const getLinkDirectionFromKey: (key: string) => LinkDirection;
 export declare const getPredecessors: (node: ExcalidrawBindableElement, elementsMap: ElementsMap, direction: LinkDirection) => ExcalidrawBindableElement[];

package/dist/types/{excalidraw → element/src}/fractionalIndex.d.ts

@@ -1,4 +1,7 @@
-import type { ExcalidrawElement, OrderedExcalidrawElement } from "./element/types";
+import type { ExcalidrawElement, OrderedExcalidrawElement } from "./types";
+export declare class InvalidFractionalIndexError extends Error {
+    code: "ELEMENT_HAS_INVALID_INDEX";
+}
 /**
  * Envisioned relation between array order and fractional indices:
  *

package/dist/types/{excalidraw → element/src}/frame.d.ts

@@ -1,8 +1,8 @@
-import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "./element/types";
-import type { AppClassProperties, AppState, StaticCanvasAppState } from "./types";
-import type { ExcalidrawElementsIncludingDeleted } from "./scene/Scene";
-import type { ReadonlySetLike } from "./utility-types";
-export declare const bindElementsToFramesAfterDuplication: (nextElements: readonly ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
+import type { ExcalidrawElementsIncludingDeleted } from "@excalidraw/excalidraw/scene/Scene";
+import type { AppClassProperties, AppState, StaticCanvasAppState } from "@excalidraw/excalidraw/types";
+import type { ReadonlySetLike } from "@excalidraw/common/utility-types";
+import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "./types";
+export declare const bindElementsToFramesAfterDuplication: (nextElements: readonly ExcalidrawElement[], origElements: readonly ExcalidrawElement[], origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
 export declare function isElementIntersectingFrame(element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap): boolean;
 export declare const getElementsCompletelyInFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => ExcalidrawElement[];
 export declare const isElementContainingFrame: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
@@ -31,8 +31,8 @@ export declare const getFrameLikeElements: (allElements: ExcalidrawElementsInclu
  */
 export declare const getRootElements: (allElements: ExcalidrawElementsIncludingDeleted) => ExcalidrawElement[];
 export declare const getElementsInResizingFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, appState: AppState, elementsMap: ElementsMap) => ExcalidrawElement[];
-export declare const getElementsInNewFrame: (elements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => (import("./element/types").ExcalidrawSelectionElement | import("./element/types").ExcalidrawRectangleElement | import("./element/types").ExcalidrawDiamondElement | import("./element/types").ExcalidrawEllipseElement | import("./element/types").ExcalidrawTextElement | import("./element/types").ExcalidrawLinearElement | import("./element/types").ExcalidrawFreeDrawElement | import("./element/types").ExcalidrawImageElement | import("./element/types").ExcalidrawFrameElement | import("./element/types").ExcalidrawMagicFrameElement | import("./element/types").ExcalidrawIframeElement | import("./element/types").ExcalidrawEmbeddableElement)[];
-export declare const omitPartialGroups: (elements: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, allElementsMap: ElementsMap) => (import("./element/types").ExcalidrawSelectionElement | import("./element/types").ExcalidrawRectangleElement | import("./element/types").ExcalidrawDiamondElement | import("./element/types").ExcalidrawEllipseElement | import("./element/types").ExcalidrawTextElement | import("./element/types").ExcalidrawLinearElement | import("./element/types").ExcalidrawFreeDrawElement | import("./element/types").ExcalidrawImageElement | import("./element/types").ExcalidrawFrameElement | import("./element/types").ExcalidrawMagicFrameElement | import("./element/types").ExcalidrawIframeElement | import("./element/types").ExcalidrawEmbeddableElement)[];
+export declare const getElementsInNewFrame: (elements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => (import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawEmbeddableElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawTextElement | import("./types").ExcalidrawSelectionElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawLinearElement | import("./types").ExcalidrawFreeDrawElement)[];
+export declare const omitPartialGroups: (elements: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, allElementsMap: ElementsMap) => (import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawEmbeddableElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawTextElement | import("./types").ExcalidrawSelectionElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawLinearElement | 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/{excalidraw → element/src}/groups.d.ts

@@ -1,6 +1,6 @@
-import type { GroupId, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, ElementsMapOrArray, ElementsMap } from "./element/types";
-import type { AppClassProperties, AppState, InteractiveCanvasAppState } from "./types";
-import type { Mutable } from "./utility-types";
+import type { AppClassProperties, AppState, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
+import type { Mutable } from "@excalidraw/common/utility-types";
+import type { GroupId, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, ElementsMapOrArray, ElementsMap } from "./types";
 export declare const selectGroup: (groupId: GroupId, appState: InteractiveCanvasAppState, elements: readonly NonDeleted<ExcalidrawElement>[]) => Pick<InteractiveCanvasAppState, "selectedGroupIds" | "selectedElementIds" | "editingGroupId">;
 export declare const selectGroupsForSelectedElements: {
     (appState: Pick<AppState, "selectedElementIds" | "editingGroupId">, elements: readonly NonDeletedExcalidrawElement[], prevAppState: InteractiveCanvasAppState, app: AppClassProperties | null): Mutable<Pick<InteractiveCanvasAppState, "selectedGroupIds" | "editingGroupId" | "selectedElementIds">>;
@@ -11,7 +11,7 @@ export declare const selectGroupsForSelectedElements: {
  * selection border around it.
  */
 export declare const isSelectedViaGroup: (appState: InteractiveCanvasAppState, element: ExcalidrawElement) => boolean;
-export declare const getSelectedGroupForElement: (appState: InteractiveCanvasAppState, element: ExcalidrawElement) => string | undefined;
+export declare const getSelectedGroupForElement: (appState: Pick<InteractiveCanvasAppState, "editingGroupId" | "selectedGroupIds">, element: ExcalidrawElement) => string | undefined;
 export declare const getSelectedGroupIds: (appState: InteractiveCanvasAppState) => GroupId[];
 export declare const selectGroupsFromGivenElements: (elements: readonly NonDeleted<ExcalidrawElement>[], appState: InteractiveCanvasAppState) => {
     [groupId: string]: boolean;
@@ -22,7 +22,6 @@ export declare const getElementsInGroup: (elements: ElementsMapOrArray, groupId:
 export declare const getSelectedGroupIdForElement: (element: ExcalidrawElement, selectedGroupIds: {
     [groupId: string]: boolean;
 }) => string | undefined;
-export declare const getNewGroupIdsForDuplication: (groupIds: ExcalidrawElement["groupIds"], editingGroupId: AppState["editingGroupId"], mapper: (groupId: GroupId) => GroupId) => string[];
 export declare const addToGroup: (prevGroupIds: ExcalidrawElement["groupIds"], newGroupId: GroupId, editingGroupId: AppState["editingGroupId"]) => string[];
 export declare const removeFromSelectedGroups: (groupIds: ExcalidrawElement["groupIds"], selectedGroupIds: {
     [groupId: string]: boolean;
@@ -31,3 +30,4 @@ export declare const getMaximumGroups: (elements: ExcalidrawElement[], elementsM
 export declare const getNonDeletedGroupIds: (elements: ElementsMap) => Set<string>;
 export declare const elementsAreInSameGroup: (elements: readonly ExcalidrawElement[]) => boolean;
 export declare const isInGroup: (element: NonDeletedExcalidrawElement) => boolean;
+export declare const getNewGroupIdsForDuplication: (groupIds: ExcalidrawElement["groupIds"], editingGroupId: AppState["editingGroupId"], mapper: (groupId: GroupId) => GroupId) => string[];

package/dist/types/{excalidraw/element → element/src}/heading.d.ts

@@ -5,12 +5,11 @@ export declare const HEADING_DOWN: Heading;
 export declare const HEADING_LEFT: Heading;
 export declare const HEADING_UP: Heading;
 export type Heading = [1, 0] | [0, 1] | [-1, 0] | [0, -1];
-export declare const headingForDiamond: <Point extends GlobalPoint | LocalPoint>(a: Point, b: Point) => Heading;
 export declare const vectorToHeading: (vec: Vector) => Heading;
 export declare const headingForPoint: <P extends GlobalPoint | LocalPoint>(p: P, o: P) => Heading;
 export declare const headingForPointIsHorizontal: <P extends GlobalPoint | LocalPoint>(p: P, o: P) => boolean;
 export declare const compareHeading: (a: Heading, b: Heading) => boolean;
 export declare const headingIsHorizontal: (a: Heading) => boolean;
 export declare const headingIsVertical: (a: Heading) => boolean;
-export declare const headingForPointFromElement: <Point extends GlobalPoint | LocalPoint>(element: Readonly<ExcalidrawBindableElement>, aabb: readonly [minX: number, minY: number, maxX: number, maxY: number], p: Readonly<Point>) => Heading;
+export declare const headingForPointFromElement: <Point extends GlobalPoint>(element: Readonly<ExcalidrawBindableElement>, aabb: readonly [minX: number, minY: number, maxX: number, maxY: number], p: Readonly<Point>) => Heading;
 export declare const flipHeading: (h: Heading) => Heading;

package/dist/types/{excalidraw/element → element/src}/image.d.ts

@@ -1,4 +1,4 @@
-import type { AppClassProperties, DataURL, BinaryFiles } from "../types";
+import type { AppClassProperties, DataURL, BinaryFiles } from "@excalidraw/excalidraw/types";
 import type { ExcalidrawElement, FileId, InitializedExcalidrawImageElement } from "./types";
 export declare const loadHTMLImageElement: (dataURL: DataURL) => Promise<HTMLImageElement>;
 /** NOTE: updates cache even if already populated with given image. Thus,
@@ -10,7 +10,7 @@ export declare const updateImageCache: ({ fileIds, files, imageCache, }: {
 }) => Promise<{
     imageCache: Map<FileId, {
         image: HTMLImageElement | Promise<HTMLImageElement>;
-        mimeType: import("../utility-types").ValueOf<{
+        mimeType: import("../../common/src/utility-types").ValueOf<{
             readonly svg: "image/svg+xml";
             readonly png: "image/png";
             readonly jpg: "image/jpeg";

package/dist/types/{excalidraw/element → element/src}/index.d.ts

@@ -1,14 +1,4 @@
 import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted } from "./types";
-export { newElement, newTextElement, refreshTextDimensions, newLinearElement, newArrowElement, newImageElement, duplicateElement, } from "./newElement";
-export { getElementAbsoluteCoords, getElementBounds, getCommonBounds, getDiamondPoints, getArrowheadPoints, getClosestElementBounds, } from "./bounds";
-export { OMIT_SIDES_FOR_MULTIPLE_ELEMENTS, getTransformHandlesFromCoords, getTransformHandles, } from "./transformHandles";
-export { resizeTest, getCursorForResizingElement, getElementWithTransformHandleType, getTransformHandleTypeFromCoords, } from "./resizeTest";
-export { transformElements, getResizeOffsetXY, getResizeArrowDirection, } from "./resizeElements";
-export { dragSelectedElements, getDragOffsetXY, dragNewElement, } from "./dragElements";
-export { isTextElement, isExcalidrawElement } from "./typeChecks";
-export { redrawTextBoundingBox, getTextFromElements } from "./textElement";
-export { getPerfectElementSize, getLockedLinearCursorAlignSize, isInvisiblySmallElement, resizePerfectLineForNWHandler, getNormalizedDimensions, } from "./sizeHelpers";
-export { showSelectedShapeActions } from "./showSelectedShapeActions";
 /**
  * @deprecated unsafe, use hashElementsVersion instead
  */

package/dist/types/{excalidraw/element → element/src}/linearElementEditor.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="react" />
-import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, SceneElementsMap, ExcalidrawElbowArrowElement } from "./types";
-import type { Bounds } from "./bounds";
-import type { AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize, Zoom } from "../types";
-import type { Store } from "../store";
-import type Scene from "../scene/Scene";
 import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
+import Scene from "@excalidraw/excalidraw/scene/Scene";
+import type { Store } from "@excalidraw/excalidraw/store";
+import type { AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize, Zoom } from "@excalidraw/excalidraw/types";
+import type { Bounds } from "./bounds";
+import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, SceneElementsMap, ExcalidrawElbowArrowElement } from "./types";
 declare const editorMidPointsCache: {
     version: number | null;
     points: (GlobalPoint | null)[];
@@ -57,7 +57,7 @@ export declare class LinearElementEditor {
     static handlePointDragging(event: PointerEvent, app: AppClassProperties, scenePointerX: number, scenePointerY: number, maybeSuggestBinding: (element: NonDeleted<ExcalidrawLinearElement>, pointSceneCoords: {
         x: number;
         y: number;
-    }[]) => void, linearElementEditor: LinearElementEditor, scene: Scene): boolean;
+    }[]) => void, linearElementEditor: LinearElementEditor, scene: Scene): LinearElementEditor | null;
     static handlePointerUp(event: PointerEvent, editingLinearElement: LinearElementEditor, appState: AppState, scene: Scene): LinearElementEditor;
     static getEditorMidPoints: (element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, appState: InteractiveCanvasAppState) => (typeof editorMidPointsCache)["points"];
     static updateEditorMidPointsCache: (element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, appState: InteractiveCanvasAppState) => void;
@@ -110,7 +110,7 @@ export declare class LinearElementEditor {
     }[], otherUpdates?: {
         startBinding?: PointBinding | null;
         endBinding?: PointBinding | null;
-    }): void;
+    }, sceneElementsMap?: NonDeletedSceneElementsMap): void;
     static shouldAddMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState, elementsMap: ElementsMap): boolean;
     static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, app: AppClassProperties, snapToGrid: boolean, elementsMap: ElementsMap): {
         pointerDownState: LinearElementEditor["pointerDownState"];