@excalidraw/excalidraw 0.17.1-d9bbf1e → 0.17.1-e63dd02

package/dist/excalidraw/history.d.ts

@@ -1,8 +1,9 @@
-import { AppStateChange, ElementsChange } from "./change";
-import { SceneElementsMap } from "./element/types";
+import type { AppStateChange, ElementsChange } from "./change";
+import type { SceneElementsMap } from "./element/types";
 import { Emitter } from "./emitter";
-import { Snapshot } from "./store";
-import { AppState } from "./types";
+import type Scene from "./scene/Scene";
+import type { Snapshot } from "./store";
+import type { AppState } from "./types";
 export declare class HistoryChangedEvent {
     readonly isUndoStackEmpty: boolean;
     readonly isRedoStackEmpty: boolean;
@@ -19,8 +20,8 @@ export declare class History {
      * Record a local change which will go into the history
      */
     record(elementsChange: ElementsChange, appStateChange: AppStateChange): void;
-    undo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): void | [SceneElementsMap, AppState];
-    redo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): void | [SceneElementsMap, AppState];
+    undo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>, scene: Scene): void | [SceneElementsMap, AppState];
+    redo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>, scene: Scene): void | [SceneElementsMap, AppState];
     private perform;
     private static pop;
     private static push;
@@ -31,7 +32,7 @@ export declare class HistoryEntry {
     private constructor();
     static create(appStateChange: AppStateChange, elementsChange: ElementsChange): HistoryEntry;
     inverse(): HistoryEntry;
-    applyTo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): [SceneElementsMap, AppState, boolean];
+    applyTo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>, scene: Scene): [SceneElementsMap, AppState, boolean];
     /**
      * Apply latest (remote) changes to the history entry, creates new instance of `HistoryEntry`.
      */

package/dist/excalidraw/history.js

@@ -38,13 +38,13 @@ export class History {
             this.onHistoryChangedEmitter.trigger(new HistoryChangedEvent(this.isUndoStackEmpty, this.isRedoStackEmpty));
         }
     }
-    undo(elements, appState, snapshot) {
-        return this.perform(elements, appState, snapshot, () => History.pop(this.undoStack), (entry) => History.push(this.redoStack, entry, elements));
+    undo(elements, appState, snapshot, scene) {
+        return this.perform(elements, appState, snapshot, () => History.pop(this.undoStack), (entry) => History.push(this.redoStack, entry, elements), scene);
     }
-    redo(elements, appState, snapshot) {
-        return this.perform(elements, appState, snapshot, () => History.pop(this.redoStack), (entry) => History.push(this.undoStack, entry, elements));
+    redo(elements, appState, snapshot, scene) {
+        return this.perform(elements, appState, snapshot, () => History.pop(this.redoStack), (entry) => History.push(this.undoStack, entry, elements), scene);
     }
-    perform(elements, appState, snapshot, pop, push) {
+    perform(elements, appState, snapshot, pop, push, scene) {
         try {
             let historyEntry = pop();
             if (historyEntry === null) {
@@ -57,7 +57,7 @@ export class History {
             while (historyEntry) {
                 try {
                     [nextElements, nextAppState, containsVisibleChange] =
-                        historyEntry.applyTo(nextElements, nextAppState, snapshot);
+                        historyEntry.applyTo(nextElements, nextAppState, snapshot, scene);
                 }
                 finally {
                     // make sure to always push / pop, even if the increment is corrupted
@@ -104,8 +104,8 @@ export class HistoryEntry {
     inverse() {
         return new HistoryEntry(this.appStateChange.inverse(), this.elementsChange.inverse());
     }
-    applyTo(elements, appState, snapshot) {
-        const [nextElements, elementsContainVisibleChange] = this.elementsChange.applyTo(elements, snapshot.elements);
+    applyTo(elements, appState, snapshot, scene) {
+        const [nextElements, elementsContainVisibleChange] = this.elementsChange.applyTo(elements, snapshot.elements, scene);
         const [nextAppState, appStateContainsVisibleChange] = this.appStateChange.applyTo(appState, nextElements);
         const appliedVisibleChanges = elementsContainVisibleChange || appStateContainsVisibleChange;
         return [nextElements, nextAppState, appliedVisibleChanges];

package/dist/excalidraw/hooks/useEmitter.d.ts

@@ -1,2 +1,2 @@
-import { Emitter } from "../emitter";
+import type { Emitter } from "../emitter";
 export declare const useEmitter: <TEvent extends unknown>(emitter: Emitter<[TEvent]>, initialState: TEvent) => TEvent;

package/dist/excalidraw/hooks/useLibraryItemSvg.d.ts

@@ -1,4 +1,4 @@
-import { LibraryItem } from "../types";
+import type { LibraryItem } from "../types";
 export type SvgCache = Map<LibraryItem["id"], SVGSVGElement>;
 export declare const libraryItemSvgsCache: import("jotai").PrimitiveAtom<SvgCache> & {
     init: SvgCache;

package/dist/excalidraw/i18n.d.ts

@@ -1,5 +1,5 @@
 import fallbackLangData from "./locales/en.json";
-import { NestedKeyOf } from "./utility-types";
+import type { NestedKeyOf } from "./utility-types";
 export interface Language {
     code: string;
     label: string;

package/dist/excalidraw/index.d.ts

@@ -1,8 +1,8 @@
 import React from "react";
 import "./css/app.scss";
 import "./css/styles.scss";
-import "../../public/fonts/fonts.css";
-import { ExcalidrawProps } from "./types";
+import "./fonts/assets/fonts.css";
+import type { ExcalidrawProps } from "./types";
 import Footer from "./components/footer/FooterCenter";
 import MainMenu from "./components/main-menu/MainMenu";
 import WelcomeScreen from "./components/welcome-screen/WelcomeScreen";

package/dist/excalidraw/index.js

@@ -5,7 +5,7 @@ import App from "./components/App";
 import { isShallowEqual } from "./utils";
 import "./css/app.scss";
 import "./css/styles.scss";
-import "../../public/fonts/fonts.css";
+import "./fonts/assets/fonts.css";
 import polyfill from "./polyfill";
 import { defaultLang } from "./i18n";
 import { DEFAULT_UI_OPTIONS } from "./constants";
@@ -17,7 +17,7 @@ import WelcomeScreen from "./components/welcome-screen/WelcomeScreen";
 import LiveCollaborationTrigger from "./components/live-collaboration/LiveCollaborationTrigger";
 polyfill();
 const ExcalidrawBase = (props) => {
-    const { onChange, initialData, excalidrawAPI, isCollaborating = false, onPointerUpdate, renderTopRightUI, langCode = defaultLang.code, viewModeEnabled, zenModeEnabled, gridModeEnabled, libraryReturnUrl, theme, name, renderCustomStats, onPaste, detectScroll = true, handleKeyboardGlobally = false, onLibraryChange, autoFocus = false, generateIdForFile, onLinkOpen, onPointerDown, onPointerUp, onScrollChange, children, validateEmbeddable, renderEmbeddable, aiEnabled, } = props;
+    const { onChange, initialData, excalidrawAPI, isCollaborating = false, onPointerUpdate, renderTopRightUI, langCode = defaultLang.code, viewModeEnabled, zenModeEnabled, gridModeEnabled, libraryReturnUrl, theme, name, renderCustomStats, onPaste, detectScroll = true, handleKeyboardGlobally = false, onLibraryChange, autoFocus = false, generateIdForFile, onLinkOpen, onPointerDown, onPointerUp, onScrollChange, children, validateEmbeddable, renderEmbeddable, aiEnabled, showDeprecatedFonts, } = props;
     const canvasActions = props.UIOptions?.canvasActions;
     // FIXME normalize/set defaults in parent component so that the memo resolver
     // compares the same values
@@ -60,7 +60,7 @@ const ExcalidrawBase = (props) => {
             document.removeEventListener("touchmove", handleTouchMove);
         };
     }, []);
-    return (_jsx(Provider, { unstable_createStore: () => jotaiStore, scope: jotaiScope, children: _jsx(InitializeApp, { langCode: langCode, theme: theme, children: _jsx(App, { onChange: onChange, initialData: initialData, excalidrawAPI: excalidrawAPI, isCollaborating: isCollaborating, onPointerUpdate: onPointerUpdate, renderTopRightUI: renderTopRightUI, langCode: langCode, viewModeEnabled: viewModeEnabled, zenModeEnabled: zenModeEnabled, gridModeEnabled: gridModeEnabled, libraryReturnUrl: libraryReturnUrl, theme: theme, name: name, renderCustomStats: renderCustomStats, UIOptions: UIOptions, onPaste: onPaste, detectScroll: detectScroll, handleKeyboardGlobally: handleKeyboardGlobally, onLibraryChange: onLibraryChange, autoFocus: autoFocus, generateIdForFile: generateIdForFile, onLinkOpen: onLinkOpen, onPointerDown: onPointerDown, onPointerUp: onPointerUp, onScrollChange: onScrollChange, validateEmbeddable: validateEmbeddable, renderEmbeddable: renderEmbeddable, aiEnabled: aiEnabled !== false, children: children }) }) }));
+    return (_jsx(Provider, { unstable_createStore: () => jotaiStore, scope: jotaiScope, children: _jsx(InitializeApp, { langCode: langCode, theme: theme, children: _jsx(App, { onChange: onChange, initialData: initialData, excalidrawAPI: excalidrawAPI, isCollaborating: isCollaborating, onPointerUpdate: onPointerUpdate, renderTopRightUI: renderTopRightUI, langCode: langCode, viewModeEnabled: viewModeEnabled, zenModeEnabled: zenModeEnabled, gridModeEnabled: gridModeEnabled, libraryReturnUrl: libraryReturnUrl, theme: theme, name: name, renderCustomStats: renderCustomStats, UIOptions: UIOptions, onPaste: onPaste, detectScroll: detectScroll, handleKeyboardGlobally: handleKeyboardGlobally, onLibraryChange: onLibraryChange, autoFocus: autoFocus, generateIdForFile: generateIdForFile, onLinkOpen: onLinkOpen, onPointerDown: onPointerDown, onPointerUp: onPointerUp, onScrollChange: onScrollChange, validateEmbeddable: validateEmbeddable, renderEmbeddable: renderEmbeddable, aiEnabled: aiEnabled !== false, showDeprecatedFonts: showDeprecatedFonts, children: children }) }) }));
 };
 const areEqual = (prevProps, nextProps) => {
     // short-circuit early

package/dist/excalidraw/jotai.d.ts

@@ -1,4 +1,4 @@
-import { PrimitiveAtom } from "jotai";
+import type { PrimitiveAtom } from "jotai";
 export declare const jotaiScope: unique symbol;
 export declare const jotaiStore: {
     get: <Value>(atom: import("jotai").Atom<Value>) => Awaited<Value> | undefined;

package/dist/excalidraw/laser-trails.d.ts

@@ -1,5 +1,6 @@
-import { AnimatedTrail, Trail } from "./animated-trail";
-import { AnimationFrameHandler } from "./animation-frame-handler";
+import type { Trail } from "./animated-trail";
+import { AnimatedTrail } from "./animated-trail";
+import type { AnimationFrameHandler } from "./animation-frame-handler";
 import type App from "./components/App";
 export declare class LaserTrails implements Trail {
     private animationFrameHandler;

package/dist/excalidraw/locales/en.json

@@ -46,6 +46,10 @@
         "arrowhead_triangle_outline": "Triangle (outline)",
         "arrowhead_diamond": "Diamond",
         "arrowhead_diamond_outline": "Diamond (outline)",
+        "arrowtypes": "Arrow type",
+        "arrowtype_sharp": "Sharp arrow",
+        "arrowtype_round": "Curved arrow",
+        "arrowtype_elbowed": "Elbow arrow",
         "fontSize": "Font size",
         "fontFamily": "Font family",
         "addWatermark": "Add \"Made with Excalidraw\"",
@@ -109,6 +113,7 @@
         "share": "Share",
         "showStroke": "Show stroke color picker",
         "showBackground": "Show background color picker",
+        "showFonts": "Show font picker",
         "toggleTheme": "Toggle light/dark theme",
         "theme": "Theme",
         "personalLib": "Personal Library",
@@ -129,7 +134,7 @@
         },
         "lineEditor": {
             "edit": "Edit line",
-            "exit": "Exit line editor"
+            "editArrow": "Edit arrow"
         },
         "elementLock": {
             "lock": "Lock",
@@ -148,7 +153,9 @@
         "discordChat": "Discord chat",
         "zoomToFitViewport": "Zoom to fit in viewport",
         "zoomToFitSelection": "Zoom to fit selection",
-        "zoomToFit": "Zoom to fit all elements"
+        "zoomToFit": "Zoom to fit all elements",
+        "installPWA": "Install Excalidraw locally (PWA)",
+        "autoResize": "Enable text auto-resizing"
     },
     "library": {
         "noItems": "No items added yet...",
@@ -268,6 +275,22 @@
         "mermaidToExcalidraw": "Mermaid to Excalidraw",
         "magicSettings": "AI settings"
     },
+    "element": {
+        "rectangle": "Rectangle",
+        "diamond": "Diamond",
+        "ellipse": "Ellipse",
+        "arrow": "Arrow",
+        "line": "Line",
+        "freedraw": "Freedraw",
+        "text": "Text",
+        "image": "Image",
+        "group": "Group",
+        "frame": "Frame",
+        "magicframe": "Wireframe to code",
+        "embeddable": "Web Embed",
+        "selection": "Selection",
+        "iframe": "IFrame"
+    },
     "headings": {
         "canvasActions": "Canvas actions",
         "selectedShapeActions": "Selected shape actions",
@@ -276,6 +299,7 @@
     "hints": {
         "canvasPanning": "To move canvas, hold mouse wheel or spacebar while dragging, or use the hand tool",
         "linearElement": "Click to start multiple points, drag for single line",
+        "arrowTool": "Click to start multiple points, drag for single line. Press {{arrowShortcut}} again to change arrow type.",
         "freeDraw": "Click and drag, release when you're finished",
         "text": "Tip: you can also add text by double-clicking anywhere with the selection tool",
         "embeddable": "Click-drag to create a website embed",
@@ -441,7 +465,10 @@
         "scene": "Scene",
         "selected": "Selected",
         "storage": "Storage",
-        "title": "Stats for nerds",
+        "fullTitle": "Stats & Element properties",
+        "title": "Stats",
+        "generalStats": "General stats",
+        "elementProperties": "Element properties",
         "total": "Total",
         "version": "Version",
         "versionCopy": "Click to copy",
@@ -536,11 +563,19 @@
         "syntax": "Mermaid Syntax",
         "preview": "Preview"
     },
-    "userList": {
-        "search": {
-            "placeholder": "Quick search",
-            "empty": "No users found"
+    "quickSearch": {
+        "placeholder": "Quick search"
+    },
+    "fontList": {
+        "badge": {
+            "old": "old"
         },
+        "sceneFonts": "In this scene",
+        "availableFonts": "Available fonts",
+        "empty": "No fonts found"
+    },
+    "userList": {
+        "empty": "No users found",
         "hint": {
             "text": "Click on user to follow",
             "followStatus": "You're currently following this user",

package/dist/excalidraw/math.d.ts

@@ -1,5 +1,6 @@
-import { Point, Zoom } from "./types";
-import { ExcalidrawElement, ExcalidrawLinearElement, NonDeleted } from "./element/types";
+import type { Point, Zoom } from "./types";
+import type { ExcalidrawElement, ExcalidrawLinearElement, NonDeleted } from "./element/types";
+import type { Bounds } from "./element/bounds";
 export declare const rotate: (x: number, y: number, cx: number, cy: number, angle: number) => [number, number];
 export declare const rotatePoint: (point: readonly [number, number], center: readonly [number, number], angle: number) => [number, number];
 export declare const adjustXYWithRotation: (sides: {
@@ -14,6 +15,7 @@ export declare const getPointOnAPath: (point: readonly [number, number], path: P
     segment: number;
 } | null;
 export declare const distance2d: (x1: number, y1: number, x2: number, y2: number) => number;
+export declare const distanceSq2d: (p1: readonly [number, number], p2: readonly [number, number]) => number;
 export declare const centerPoint: (a: readonly [number, number], b: readonly [number, number]) => readonly [number, number];
 export declare const isPathALoop: (points: ExcalidrawLinearElement["points"], zoomValue?: Zoom["value"]) => boolean;
 export declare const isPointInPolygon: (points: Point[], x: number, y: number) => boolean;
@@ -28,6 +30,49 @@ export declare const getBezierCurveLength: (element: NonDeleted<ExcalidrawLinear
 export declare const mapIntervalToBezierT: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number], interval: number) => number;
 export declare const arePointsEqual: (p1: readonly [number, number], p2: readonly [number, number]) => boolean;
 export declare const isRightAngle: (angle: number) => boolean;
+export declare const radianToDegree: (r: number) => number;
+export declare const degreeToRadian: (d: number) => number;
 export declare const rangesOverlap: ([a0, a1]: [number, number], [b0, b1]: [number, number]) => boolean;
 export declare const rangeIntersection: (rangeA: [number, number], rangeB: [number, number]) => [number, number] | null;
 export declare const isValueInRange: (value: number, min: number, max: number) => boolean;
+export declare const translatePoint: (p: readonly [number, number], v: import("../utils/geometry/shape").Point) => readonly [number, number];
+export declare const scaleVector: (v: import("../utils/geometry/shape").Point, scalar: number) => import("../utils/geometry/shape").Point;
+export declare const pointToVector: (p: readonly [number, number], origin?: readonly [number, number]) => import("../utils/geometry/shape").Point;
+export declare const scalePointFromOrigin: (p: readonly [number, number], mid: readonly [number, number], multiplier: number) => readonly [number, number];
+export declare const PointInTriangle: (pt: readonly [number, number], v1: readonly [number, number], v2: readonly [number, number], v3: readonly [number, number]) => boolean;
+export declare const magnitudeSq: (vector: import("../utils/geometry/shape").Point) => number;
+export declare const magnitude: (vector: import("../utils/geometry/shape").Point) => number;
+export declare const normalize: (vector: import("../utils/geometry/shape").Point) => import("../utils/geometry/shape").Point;
+export declare const addVectors: (vec1: readonly [number, number], vec2: readonly [number, number]) => import("../utils/geometry/shape").Point;
+export declare const subtractVectors: (vec1: readonly [number, number], vec2: readonly [number, number]) => import("../utils/geometry/shape").Point;
+export declare const pointInsideBounds: (p: readonly [number, number], bounds: Bounds) => boolean;
+/**
+ * Get the axis-aligned bounding box for a given element
+ */
+export declare const aabbForElement: (element: Readonly<ExcalidrawElement>, offset?: [number, number, number, number]) => Bounds;
+type PolarCoords = [number, number];
+/**
+ * Return the polar coordinates for the given carthesian point represented by
+ * (x, y) for the center point 0,0 where the first number returned is the radius,
+ * the second is the angle in radians.
+ */
+export declare const carthesian2Polar: ([x, y]: readonly [number, number]) => PolarCoords;
+/**
+ * Angles are in radians and centered on 0, 0. Zero radians on a 1 radius circle
+ * corresponds to (1, 0) carthesian coordinates (point), i.e. to the "right".
+ */
+type SymmetricArc = {
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+};
+/**
+ * Determines if a carthesian point lies on a symmetric arc, i.e. an arc which
+ * is part of a circle contour centered on 0, 0.
+ */
+export declare const isPointOnSymmetricArc: ({ radius: arcRadius, startAngle, endAngle }: SymmetricArc, point: readonly [number, number]) => boolean;
+export declare const getCenterForBounds: (bounds: Bounds) => readonly [number, number];
+export declare const getCenterForElement: (element: ExcalidrawElement) => readonly [number, number];
+export declare const aabbsOverlapping: (a: Bounds, b: Bounds) => boolean;
+export declare const clamp: (value: number, min: number, max: number) => number;
+export {};

package/dist/excalidraw/math.js

@@ -102,6 +102,11 @@ export const distance2d = (x1, y1, x2, y2) => {
     const yd = y2 - y1;
     return Math.hypot(xd, yd);
 };
+export const distanceSq2d = (p1, p2) => {
+    const xd = p2[0] - p1[0];
+    const yd = p2[1] - p1[1];
+    return xd * xd + yd * yd;
+};
 export const centerPoint = (a, b) => {
     return [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
 };
@@ -338,6 +343,12 @@ export const isRightAngle = (angle) => {
     // angle, which we can check with modulo after rounding.
     return Math.round((angle / Math.PI) * 10000) % 5000 === 0;
 };
+export const radianToDegree = (r) => {
+    return (r * 180) / Math.PI;
+};
+export const degreeToRadian = (d) => {
+    return (d / 180) * Math.PI;
+};
 // Given two ranges, return if the two ranges overlap with each other
 // e.g. [1, 3] overlaps with [2, 4] while [1, 3] does not overlap with [4, 5]
 export const rangesOverlap = ([a0, a1], [b0, b1]) => {
@@ -362,3 +373,108 @@ export const rangeIntersection = (rangeA, rangeB) => {
 export const isValueInRange = (value, min, max) => {
     return value >= min && value <= max;
 };
+export const translatePoint = (p, v) => [
+    p[0] + v[0],
+    p[1] + v[1],
+];
+export const scaleVector = (v, scalar) => [
+    v[0] * scalar,
+    v[1] * scalar,
+];
+export const pointToVector = (p, origin = [0, 0]) => [
+    p[0] - origin[0],
+    p[1] - origin[1],
+];
+export const scalePointFromOrigin = (p, mid, multiplier) => translatePoint(mid, scaleVector(pointToVector(p, mid), multiplier));
+const triangleSign = (p1, p2, p3) => (p1[0] - p3[0]) * (p2[1] - p3[1]) - (p2[0] - p3[0]) * (p1[1] - p3[1]);
+export const PointInTriangle = (pt, v1, v2, v3) => {
+    const d1 = triangleSign(pt, v1, v2);
+    const d2 = triangleSign(pt, v2, v3);
+    const d3 = triangleSign(pt, v3, v1);
+    const has_neg = d1 < 0 || d2 < 0 || d3 < 0;
+    const has_pos = d1 > 0 || d2 > 0 || d3 > 0;
+    return !(has_neg && has_pos);
+};
+export const magnitudeSq = (vector) => vector[0] * vector[0] + vector[1] * vector[1];
+export const magnitude = (vector) => Math.sqrt(magnitudeSq(vector));
+export const normalize = (vector) => {
+    const m = magnitude(vector);
+    return [vector[0] / m, vector[1] / m];
+};
+export const addVectors = (vec1, vec2) => [vec1[0] + vec2[0], vec1[1] + vec2[1]];
+export const subtractVectors = (vec1, vec2) => [vec1[0] - vec2[0], vec1[1] - vec2[1]];
+export const pointInsideBounds = (p, bounds) => p[0] > bounds[0] && p[0] < bounds[2] && p[1] > bounds[1] && p[1] < bounds[3];
+/**
+ * Get the axis-aligned bounding box for a given element
+ */
+export const aabbForElement = (element, offset) => {
+    const bbox = {
+        minX: element.x,
+        minY: element.y,
+        maxX: element.x + element.width,
+        maxY: element.y + element.height,
+        midX: element.x + element.width / 2,
+        midY: element.y + element.height / 2,
+    };
+    const center = [bbox.midX, bbox.midY];
+    const [topLeftX, topLeftY] = rotatePoint([bbox.minX, bbox.minY], center, element.angle);
+    const [topRightX, topRightY] = rotatePoint([bbox.maxX, bbox.minY], center, element.angle);
+    const [bottomRightX, bottomRightY] = rotatePoint([bbox.maxX, bbox.maxY], center, element.angle);
+    const [bottomLeftX, bottomLeftY] = rotatePoint([bbox.minX, bbox.maxY], center, element.angle);
+    const bounds = [
+        Math.min(topLeftX, topRightX, bottomRightX, bottomLeftX),
+        Math.min(topLeftY, topRightY, bottomRightY, bottomLeftY),
+        Math.max(topLeftX, topRightX, bottomRightX, bottomLeftX),
+        Math.max(topLeftY, topRightY, bottomRightY, bottomLeftY),
+    ];
+    if (offset) {
+        const [topOffset, rightOffset, downOffset, leftOffset] = offset;
+        return [
+            bounds[0] - leftOffset,
+            bounds[1] - topOffset,
+            bounds[2] + rightOffset,
+            bounds[3] + downOffset,
+        ];
+    }
+    return bounds;
+};
+/**
+ * Return the polar coordinates for the given carthesian point represented by
+ * (x, y) for the center point 0,0 where the first number returned is the radius,
+ * the second is the angle in radians.
+ */
+export const carthesian2Polar = ([x, y]) => [
+    Math.hypot(x, y),
+    Math.atan2(y, x),
+];
+/**
+ * Determines if a carthesian point lies on a symmetric arc, i.e. an arc which
+ * is part of a circle contour centered on 0, 0.
+ */
+export const isPointOnSymmetricArc = ({ radius: arcRadius, startAngle, endAngle }, point) => {
+    const [radius, angle] = carthesian2Polar(point);
+    return startAngle < endAngle
+        ? Math.abs(radius - arcRadius) < 0.0000001 &&
+            startAngle <= angle &&
+            endAngle >= angle
+        : startAngle <= angle || endAngle >= angle;
+};
+export const getCenterForBounds = (bounds) => [
+    bounds[0] + (bounds[2] - bounds[0]) / 2,
+    bounds[1] + (bounds[3] - bounds[1]) / 2,
+];
+export const getCenterForElement = (element) => [
+    element.x + element.width / 2,
+    element.y + element.height / 2,
+];
+export const aabbsOverlapping = (a, b) => pointInsideBounds([a[0], a[1]], b) ||
+    pointInsideBounds([a[2], a[1]], b) ||
+    pointInsideBounds([a[2], a[3]], b) ||
+    pointInsideBounds([a[0], a[3]], b) ||
+    pointInsideBounds([b[0], b[1]], a) ||
+    pointInsideBounds([b[2], b[1]], a) ||
+    pointInsideBounds([b[2], b[3]], a) ||
+    pointInsideBounds([b[0], b[3]], a);
+export const clamp = (value, min, max) => {
+    return Math.min(Math.max(value, min), max);
+};

package/dist/excalidraw/mermaid.d.ts

@@ -0,0 +1,2 @@
+/** heuristically checks whether the text may be a mermaid diagram definition */
+export declare const isMaybeMermaidDefinition: (text: string) => boolean;

package/dist/excalidraw/mermaid.js

@@ -0,0 +1,29 @@
+/** heuristically checks whether the text may be a mermaid diagram definition */
+export const isMaybeMermaidDefinition = (text) => {
+    const chartTypes = [
+        "flowchart",
+        "graph",
+        "sequenceDiagram",
+        "classDiagram",
+        "stateDiagram",
+        "stateDiagram-v2",
+        "erDiagram",
+        "journey",
+        "gantt",
+        "pie",
+        "quadrantChart",
+        "requirementDiagram",
+        "gitGraph",
+        "C4Context",
+        "mindmap",
+        "timeline",
+        "zenuml",
+        "sankey",
+        "xychart",
+        "block",
+    ];
+    const re = new RegExp(`^(?:%%{.*?}%%[\\s\\n]*)?\\b(?:${chartTypes
+        .map((x) => `\\s*${x}(-beta)?`)
+        .join("|")})\\b`);
+    return re.test(text.trim());
+};

package/dist/excalidraw/points.d.ts

@@ -1,4 +1,4 @@
-import { Point } from "./types";
+import type { Point } from "./types";
 export declare const getSizeFromPoints: (points: readonly Point[]) => {
     width: number;
     height: number;

package/dist/excalidraw/queue.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from "./utility-types";
+import type { MaybePromise } from "./utility-types";
 type Job<T, TArgs extends unknown[]> = (...args: TArgs) => MaybePromise<T>;
 export declare class Queue {
     private jobs;

package/dist/excalidraw/renderer/helpers.d.ts

@@ -1,5 +1,5 @@
-import { StaticCanvasAppState, AppState } from "../types";
-import { StaticCanvasRenderConfig } from "../scene/types";
+import type { StaticCanvasAppState, AppState } from "../types";
+import type { StaticCanvasRenderConfig } from "../scene/types";
 export declare const fillCircle: (context: CanvasRenderingContext2D, cx: number, cy: number, radius: number, stroke?: boolean) => void;
 export declare const getNormalizedCanvasDimensions: (canvas: HTMLCanvasElement, scale: number) => [number, number];
 export declare const bootstrapCanvas: ({ canvas, scale, normalizedWidth, normalizedHeight, theme, isExporting, viewBackgroundColor, }: {

package/dist/excalidraw/renderer/interactiveScene.d.ts

@@ -1,4 +1,4 @@
-import { InteractiveSceneRenderConfig, RenderableElementsMap } from "../scene/types";
+import type { InteractiveSceneRenderConfig, RenderableElementsMap } from "../scene/types";
 /** throttled to animation framerate */
 export declare const renderInteractiveSceneThrottled: {
     (config: InteractiveSceneRenderConfig): void;
@@ -9,7 +9,7 @@ export declare const renderInteractiveSceneThrottled: {
  * Interactive scene is the ui-canvas where we render bounding boxes, selections
  * and other ui stuff.
  */
-export declare const renderInteractiveScene: <U extends ({ canvas, elementsMap, visibleElements, selectedElements, scale, appState, renderConfig, device, }: InteractiveSceneRenderConfig) => {
+export declare const renderInteractiveScene: <U extends ({ canvas, elementsMap, visibleElements, selectedElements, allElementsMap, scale, appState, renderConfig, device, }: InteractiveSceneRenderConfig) => {
     atLeastOneVisibleElement: boolean;
     elementsMap: RenderableElementsMap;
     scrollBars?: undefined;