@excalidraw/element 0.18.0-2a82821 → 0.18.0-2b1c2a9

package/dist/types/excalidraw/viewport.d.ts

@@ -0,0 +1,275 @@
+import type { SceneBounds } from "@excalidraw/element";
+import type { Bounds } from "@excalidraw/common";
+import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { AppState, NormalizedZoomValue, Offsets, PointerCoords, ScrollConstraints, ViewportOffsets, Zoom } from "./types";
+/** default rubberband overscroll give for scroll locks, in viewport px */
+export declare const DEFAULT_OVERSCROLL = 150;
+type ZoomOptions = {
+    viewportX: number;
+    viewportY: number;
+    nextZoom: NormalizedZoomValue;
+};
+export type AnimationOptions = {
+    duration?: number;
+};
+export type SetViewportRect = {
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+};
+export type SetViewportOptions = {
+    /**
+     * what to show in the viewport: an explicit scene-coordinate box/rect,
+     * element(s), or an element id / element-link URL.
+     *
+     * IMPORTANT: if supplying ExcalidrawElement(s), only non-deleted elements
+     * that actually exist on the canvas are considered. If you want to navigate
+     * to elements that's not on canvas yet, supply their bounds by using
+     * `getCommonBounds` (see {@link getCommonBounds}).
+     */
+    target: Bounds | SetViewportRect | ExcalidrawElement | readonly ExcalidrawElement[] | string;
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/object-fit
+     *
+     * - `scale-down` - zoom out so the target fits the viewport, never zooming past 100%
+     * - `contain` - zoom the target so it fills the viewport (may exceed 100%)
+     * - `none` - keep the current zoom, only center the target in the viewport
+     */
+    fit?: "scale-down" | "contain" | "none";
+    lock?: {
+        /** constraints panning to the target box */
+        scroll?: ScrollConstraints["lockScroll"];
+        /** makes the resolved zoom the minimum zoom */
+        zoom?: ScrollConstraints["lockZoom"];
+        /**
+         * Rubberband give past the lock, in viewport px (zoom-independent): how
+         * far the user can pan beyond the constraint before snapping back.
+         * `true` (default) uses {@link DEFAULT_OVERSCROLL}, `false` disables
+         * (rigid lock), a number sets the give explicitly.
+         */
+        overscroll?: boolean | number;
+    };
+    animation?: AnimationOptions | boolean;
+    /**
+     * CSS-style per-side viewport insets, in viewport pixels
+     * (zoom-independent) — static values, editor-UI-derived (`ui`), or a
+     * combination. See {@link ViewportOffsets}.
+     */
+    offsets?: ViewportOffsets;
+};
+type Viewport = Pick<AppState, "scrollX" | "scrollY" | "zoom">;
+/**
+ * Clamps a proposed scroll/zoom against the active lock (`scrollConstraints`).
+ * Returns the input scroll/zoom unchanged when there is no lock.
+ * `overscroll` (screen px, zoom-independent) is rubberband give past the
+ * resting clamp — pass 0 for a hard clamp.
+ */
+export declare const constrainScrollState: (state: Pick<AppState, "scrollX" | "scrollY" | "zoom" | "width" | "height" | "scrollConstraints">, overscroll?: number) => Viewport;
+/**
+ * Resolves a focal-point zoom against the active scroll constraints while
+ * preserving the current rubberband displacement in screen pixels. This lets
+ * zoom and scroll-constraint snap-back compose without either visually
+ * cancelling the other.
+ */
+export declare const getViewportForZoomWithScrollConstraints: (opts: ZoomOptions, state: AppState) => Viewport;
+export declare const zoomToFitBounds: ({ bounds, appState, canvasOffsets, fit, minZoom, maxZoom, steppedZoom, }: {
+    bounds: SceneBounds;
+    canvasOffsets?: Offsets;
+    appState: Readonly<AppState>;
+    fit?: SetViewportOptions["fit"];
+    minZoom?: number;
+    maxZoom?: number;
+    steppedZoom?: boolean;
+}) => {
+    appState: {
+        scrollX: number;
+        scrollY: number;
+        zoom: {
+            value: NormalizedZoomValue;
+        };
+        contextMenu: {
+            items: import("./components/ContextMenu").ContextMenuItems;
+            top: number;
+            left: number;
+        } | null;
+        showWelcomeScreen: boolean;
+        isLoading: boolean;
+        errorMessage: React.ReactNode;
+        activeEmbeddable: {
+            element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
+            state: "hover" | "active";
+        } | null;
+        newElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawNonSelectionElement> | null;
+        resizingElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
+        multiElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawLinearElement> | null;
+        selectionElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
+        isBindingEnabled: boolean;
+        boxSelectionMode: import("./types").BoxSelectionMode;
+        bindingPreference: "enabled" | "disabled";
+        isMidpointSnappingEnabled: boolean;
+        suggestedBinding: {
+            element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
+            midPoint?: import("@excalidraw/math").GlobalPoint;
+        } | null;
+        hoveredArrowTextAnchor: {
+            elementId: import("@excalidraw/element/types").ExcalidrawArrowElement["id"];
+            anchor: "start" | "end" | "label";
+        } | null;
+        frameToHighlight: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawFrameLikeElement> | null;
+        frameRendering: {
+            enabled: boolean;
+            name: boolean;
+            outline: boolean;
+            clip: boolean;
+        };
+        editingFrame: import("@excalidraw/element/types").ExcalidrawFrameLikeElement["id"] | null;
+        elementsToHighlight: readonly import("@excalidraw/element/types").NonDeletedExcalidrawElement[] | null;
+        editingTextElement: import("@excalidraw/element/types").ExcalidrawTextElement | null;
+        activeTool: {
+            lastActiveTool: import("./types").ActiveTool | null;
+            locked: boolean;
+            fromSelection: boolean;
+        } & import("./types").ActiveTool;
+        preferredSelectionTool: {
+            type: "selection" | "lasso";
+            initialized: boolean;
+        };
+        penMode: boolean;
+        penDetected: boolean;
+        exportBackground: boolean;
+        exportEmbedScene: boolean;
+        exportWithDarkMode: boolean;
+        exportScale: number;
+        currentItemStrokeColor: string;
+        currentItemBackgroundColor: string;
+        currentItemFillStyle: ExcalidrawElement["fillStyle"];
+        currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
+        currentItemStrokeStyle: ExcalidrawElement["strokeStyle"];
+        currentItemRoughness: number;
+        currentItemStrokeVariability: import("@excalidraw/element/types").StrokeVariability;
+        currentItemOpacity: number;
+        currentItemFontFamily: import("@excalidraw/element/types").FontFamilyValues;
+        currentItemFontSize: number;
+        currentItemTextAlign: import("@excalidraw/element/types").TextAlign;
+        currentItemStartArrowhead: import("@excalidraw/element/types").Arrowhead | null;
+        currentItemEndArrowhead: import("@excalidraw/element/types").Arrowhead | null;
+        currentHoveredFontFamily: import("@excalidraw/element/types").FontFamilyValues | null;
+        currentItemRoundness: import("@excalidraw/element/types").StrokeRoundness;
+        currentItemArrowType: "sharp" | "round" | "elbow";
+        viewBackgroundColor: string;
+        scrollConstraints: ScrollConstraints | null;
+        cursorButton: "up" | "down";
+        scrolledOutside: boolean;
+        name: string | null;
+        isResizing: boolean;
+        isRotating: boolean;
+        openMenu: "canvas" | null;
+        openPopup: "canvasBackground" | "elementBackground" | "elementStroke" | "fontFamily" | "compactTextProperties" | "compactStrokeStyles" | "compactOtherProperties" | "compactArrowProperties" | null;
+        openSidebar: {
+            name: import("./types").SidebarName;
+            tab?: import("./types").SidebarTabName;
+        } | null;
+        openDialog: null | {
+            name: "imageExport" | "help" | "jsonExport";
+        } | {
+            name: "ttd";
+            tab: "text-to-diagram" | "mermaid";
+        } | {
+            name: "commandPalette";
+        } | {
+            name: "settings";
+        } | {
+            name: "elementLinkSelector";
+            sourceElementId: ExcalidrawElement["id"];
+        } | {
+            name: "charts";
+            data: import("./charts").Spreadsheet;
+            rawText: string;
+        };
+        defaultSidebarDockedPreference: boolean;
+        lastPointerDownWith: import("@excalidraw/element/types").PointerType;
+        selectedElementIds: Readonly<{
+            [id: string]: true;
+        }>;
+        hoveredElementIds: Readonly<{
+            [id: string]: true;
+        }>;
+        previousSelectedElementIds: {
+            [id: string]: true;
+        };
+        selectedElementsAreBeingDragged: boolean;
+        shouldCacheIgnoreZoom: boolean;
+        toast: {
+            message: React.ReactNode;
+            closable?: boolean;
+            duration?: number;
+        } | null;
+        zenModeEnabled: boolean;
+        theme: import("@excalidraw/element/types").Theme;
+        gridSize: number;
+        gridStep: number;
+        gridModeEnabled: boolean;
+        viewModeEnabled: boolean;
+        selectedGroupIds: {
+            [groupId: string]: boolean;
+        };
+        editingGroupId: import("@excalidraw/element/types").GroupId | null;
+        width: number;
+        height: number;
+        offsetTop: number;
+        offsetLeft: number;
+        fileHandle: FileSystemFileHandle | null;
+        collaborators: Map<import("./types").SocketId, import("./types").Collaborator>;
+        stats: {
+            open: boolean;
+            panels: number;
+        };
+        showHyperlinkPopup: false | "info" | "editor";
+        selectedLinearElement: import("@excalidraw/element").LinearElementEditor | null;
+        snapLines: readonly import("./snapping").SnapLine[];
+        originSnapOffset: {
+            x: number;
+            y: number;
+        } | null;
+        objectsSnapModeEnabled: boolean;
+        isCropping: boolean;
+        croppingElementId: ExcalidrawElement["id"] | null;
+        searchMatches: Readonly<{
+            focusedId: ExcalidrawElement["id"] | null;
+            matches: readonly import("./types").SearchMatch[];
+        }> | null;
+        activeLockedId: string | null;
+        lockedMultiSelections: {
+            [groupId: string]: true;
+        };
+        bindMode: import("@excalidraw/element/types").BindMode;
+        colorTopPicks: {
+            elementStroke: readonly string[] | null;
+            elementBackground: readonly string[] | null;
+            bucketFill: readonly string[] | null;
+        };
+    };
+    captureUpdate: "EVENTUALLY";
+};
+export declare const getClosestElementBounds: (elements: readonly ExcalidrawElement[], from: {
+    x: number;
+    y: number;
+}) => Bounds;
+export declare const centerScrollOn: ({ scenePoint, viewportDimensions, zoom, offsets, }: {
+    scenePoint: PointerCoords;
+    viewportDimensions: {
+        height: number;
+        width: number;
+    };
+    zoom: Zoom;
+    offsets?: Offsets;
+}) => {
+    scrollX: number;
+    scrollY: number;
+};
+export declare const getScrollToContentState: (elements: readonly ExcalidrawElement[], appState: AppState) => {
+    scrollX: number;
+    scrollY: number;
+};
+export {};

package/dist/types/excalidraw/wysiwyg/textWysiwyg.d.ts

@@ -1,8 +1,7 @@
-import type { ExcalidrawElement, ExcalidrawTextElement } from "@excalidraw/element/types";
+import type { ExcalidrawTextElement } from "@excalidraw/element/types";
 import type App from "../components/App";
 type SubmitHandler = () => void;
-export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, autoSelect, initialCaretSceneCoords, }: {
-    id: ExcalidrawElement["id"];
+export declare const textWysiwyg: ({ onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, autoSelect, initialCaretSceneCoords, }: {
     /**
      * textWysiwyg only deals with `originalText`
      *

package/dist/types/laser-pointer/src/state.d.ts

@@ -6,6 +6,7 @@ export type SizeMappingDetails = {
     totalLength: number;
 };
 export type LaserPointerOptions = {
+    /** @default 2 */
     size: number;
     streamline: number;
     simplify: number;

package/dist/types/math/src/curve.d.ts

@@ -16,20 +16,25 @@ export declare function curveIntersectLineSegment<Point extends GlobalPoint | Lo
     tolerance?: number;
     iterLimit?: number;
 }): Point[];
+/**
+ * Finds the parameter on the Bezier curve whose point is closest to another
+ * point
+ *
+ * @param c The curve to test
+ * @param p The point to measure from
+ * @param tolerance The width of the search window under which the bisection
+ *   stops refining the parameter
+ */
+export declare function curveClosestParameter<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point, tolerance?: number): number;
 /**
  * Finds the closest point on the Bezier curve from another point
  *
- * @param x
- * @param y
- * @param P0
- * @param P1
- * @param P2
- * @param P3
- * @param tolerance
- * @param maxLevel
- * @returns
+ * @param c The curve to test
+ * @param p The point to measure from
+ * @param tolerance The width of the search window under which the bisection
+ *   stops refining the parameter
  */
-export declare function curveClosestPoint<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point, tolerance?: number): Point | null;
+export declare function curveClosestPoint<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point, tolerance?: number): Point;
 /**
  * Determines the distance between a point and the closest point on the
  * Bezier curve.
@@ -37,7 +42,7 @@ export declare function curveClosestPoint<Point extends GlobalPoint | LocalPoint
  * @param c The curve to test
  * @param p The point to measure from
  */
-export declare function curvePointDistance<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point): number;
+export declare function curvePointDistance<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point, tolerance?: number): number;
 /**
  * Determines if the parameter is a Curve
  */
@@ -74,4 +79,6 @@ export declare function curveLengthAtParameter<P extends GlobalPoint | LocalPoin
  * @param percent A value between 0 and 1 representing the percentage of the curve's length
  * @returns The point at the specified percentage of curve length
  */
-export declare function curvePointAtLength<P extends GlobalPoint | LocalPoint>(c: Curve<P>, percent: number): P;
+export declare function curvePointAtLength<P extends GlobalPoint | LocalPoint>(c: Curve<P>, percent: number, 
+/** pass the curve's total length when already known to skip recomputing it */
+totalLength?: number): P;

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

@@ -2,6 +2,7 @@ export * from "./angle";
 export * from "./curve";
 export * from "./ellipse";
 export * from "./line";
+export * from "./pca";
 export * from "./point";
 export * from "./polygon";
 export * from "./range";

package/dist/types/math/src/pca.d.ts

@@ -0,0 +1,79 @@
+import type { GlobalPoint, LocalPoint, Vector } from "./types";
+/**
+ * The principal axes of a point set, i.e. the eigen decomposition of its
+ * 2x2 covariance matrix.
+ *
+ * The axes are orthonormal and ordered by variance, so `major` is the
+ * direction along which the points spread the most. Together with `centroid`
+ * they define a canonical frame: expressing the points in it removes
+ * translation and rotation, and dividing by `sqrt(majorVariance)` removes
+ * scale.
+ */
+export type PrincipalAxes<Point extends GlobalPoint | LocalPoint> = {
+    centroid: Point;
+    /** Unit vector along the direction of largest variance. */
+    major: Vector;
+    /** Unit vector along the direction of smallest variance, normal to major. */
+    minor: Vector;
+    /** Variance along `major` (the larger eigenvalue, λ₁). */
+    majorVariance: number;
+    /** Variance along `minor` (the smaller eigenvalue, λ₂). */
+    minorVariance: number;
+};
+/**
+ * A point expressed in a principal axes frame: `u` along the major axis,
+ * `v` along the minor axis, both relative to the centroid.
+ */
+export type PrincipalCoords = [u: number, v: number];
+/**
+ * Compute the centroid of a point set.
+ */
+export declare function centroid<Point extends GlobalPoint | LocalPoint>(points: readonly Point[]): Point;
+/**
+ * Principal component analysis of a 2D point set.
+ *
+ * Computes the centroid and the eigen decomposition of the covariance matrix
+ * [[μ20, μ11], [μ11, μ02]].
+ *
+ * @param points At least two points; fewer leaves the axes degenerate.
+ * @returns The centroid, the orthonormal axes and their variances.
+ */
+export declare function principalAxes<Point extends GlobalPoint | LocalPoint>(points: readonly Point[]): PrincipalAxes<Point>;
+/**
+ * Express points in the frame of the given principal axes, making the point
+ * cloud rotation, scale and translation invariant.
+ */
+export declare function principalCoords<Point extends GlobalPoint | LocalPoint>(points: readonly Point[], axes: PrincipalAxes<Point>, scale?: number): PrincipalCoords[];
+/**
+ * Flip the major axis so that it points toward the denser end of the point
+ * cloud, resolving the 180° sign ambiguity of the eigenvector.
+ *
+ * @returns The axes with `major`/`minor` flipped if needed. Variances are
+ * unchanged, as they are invariant to axis sign.
+ */
+export declare function orientPrincipalAxes<Point extends GlobalPoint | LocalPoint>(points: readonly Point[], axes: PrincipalAxes<Point>): PrincipalAxes<Point>;
+/**
+ * Ratio of the minor to the major variance in [0, 1]
+ *
+ * @returns 0 is a perfectly straight stroke, 1 is a stroke with no preferred
+ * direction.
+ */
+export declare function elongation<Point extends GlobalPoint | LocalPoint>(axes: PrincipalAxes<Point>): number;
+/**
+ * The `order`-th standardized moment of a sample in a rotation and scale
+ * invariant way (sandardizing by sigma).
+ *
+ * @returns 0 for a degenerate (zero variance) sample.
+ */
+export declare function standardizedMoment(values: readonly number[], order: number): number;
+/**
+ * Third standardized moment: how lopsided a sample is.
+ *
+ */
+export declare function skewness(values: readonly number[]): number;
+/**
+ * Fourth standardized moment: how the mass is split between the tails and the
+ * middle of a sample. Not excess kurtosis, a normal sample gives 3.
+ *
+ */
+export declare function kurtosis(values: readonly number[]): number;

package/dist/types/math/src/polygon.d.ts

@@ -3,4 +3,28 @@ export declare function polygon<Point extends GlobalPoint | LocalPoint>(...point
 export declare function polygonFromPoints<Point extends GlobalPoint | LocalPoint>(points: Point[]): Polygon<Point>;
 export declare const polygonIncludesPoint: <Point extends LocalPoint | GlobalPoint>(point: Point, polygon: Polygon<Point>) => boolean;
 export declare const polygonIncludesPointNonZero: <Point extends [number, number]>(point: Point, polygon: Point[]) => boolean;
-export declare const pointOnPolygon: <Point extends LocalPoint | GlobalPoint>(p: Point, poly: Polygon<Point>, threshold?: number) => boolean;
+export declare function polygonIsClosed<Point extends LocalPoint | GlobalPoint>(polygon: readonly Point[], tolerance?: number): boolean;
+/**
+ * The signed area of a polygon via the shoelace formula. Positive when the
+ * vertices wind counter-clockwise in a y-down coordinate system.
+ *
+ * The polygon may be given open or closed; a closing vertex
+ */
+export declare function polygonSignedArea<Point extends LocalPoint | GlobalPoint>(polygon: readonly Point[], tolerance?: number): number;
+export declare function polygonArea<Point extends LocalPoint | GlobalPoint>(polygon: readonly Point[], tolerance?: number): number;
+/**
+ * The convex hull of a point set via Andrew's monotone chain.
+ *
+ * @returns The hull vertices in counter-clockwise order (y-down), without a
+ * repeated closing vertex.
+ */
+export declare function convexHull<Point extends LocalPoint | GlobalPoint>(points: readonly Point[]): Point[];
+/**
+ * Drop the points of a convex polygon that only contribute a shallow turn,
+ * merging each run of near-collinear points into one.
+ *
+ * @param polygon A convex polygon, as returned by `convexHull`.
+ * @param angleThreshold Minimum accumulated turn (radians) for a vertex to be
+ * kept.
+ */
+export declare function simplifyConvexPolygon<Point extends LocalPoint | GlobalPoint>(polygon: readonly Point[], angleThreshold: number): Point[];

package/dist/types/math/src/segment.d.ts

@@ -29,6 +29,11 @@ export declare const lineSegmentRotate: <Point extends LocalPoint | GlobalPoint>
 export declare const segmentsIntersectAt: <Point extends GlobalPoint | LocalPoint>(a: Readonly<LineSegment<Point>>, b: Readonly<LineSegment<Point>>) => Point | null;
 export declare const pointOnLineSegment: <Point extends LocalPoint | GlobalPoint>(point: Point, line: LineSegment<Point>, threshold?: number) => boolean;
 export declare const distanceToLineSegment: <Point extends LocalPoint | GlobalPoint>(point: Point, line: LineSegment<Point>) => number;
+/**
+ * Returns the point at parameter `t` along the segment, where `t = 0` is the
+ * segment's start and `t = 1` its end. Not clamped.
+ */
+export declare function lineSegmentPointAt<Point extends GlobalPoint | LocalPoint>(line: LineSegment<Point>, t: number): Point;
 /**
  * Returns the intersection point of a segment and a line
  *
@@ -38,3 +43,4 @@ export declare const distanceToLineSegment: <Point extends LocalPoint | GlobalPo
  */
 export declare function lineSegmentIntersectionPoints<Point extends GlobalPoint | LocalPoint>(l: LineSegment<Point>, s: LineSegment<Point>, threshold?: number): Point | null;
 export declare function lineSegmentsDistance<Point extends GlobalPoint | LocalPoint>(s1: LineSegment<Point>, s2: LineSegment<Point>): number;
+export declare function lineSegmentClosestParameter<Point extends GlobalPoint | LocalPoint>(point: Point, line: LineSegment<Point>): number;

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

@@ -1,13 +1,13 @@
 import { MIME_TYPES } from "@excalidraw/common";
-import type { ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted } from "@excalidraw/element/types";
+import type { ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { AppState, BinaryFiles } from "@excalidraw/excalidraw/types";
 export { MIME_TYPES };
 type ExportOpts = {
-    elements: readonly NonDeleted<ExcalidrawElement>[];
+    elements: readonly NonDeletedExcalidrawElement[];
     appState?: Partial<Omit<AppState, "offsetTop" | "offsetLeft">>;
     files: BinaryFiles | null;
     maxWidthOrHeight?: number;
-    exportingFrame?: ExcalidrawFrameLikeElement | null;
+    exportingFrame?: NonDeleted<ExcalidrawFrameLikeElement> | null;
     getDimensions?: (width: number, height: number) => {
         width: number;
         height: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@excalidraw/element",
-  "version": "0.18.0-2a82821",
+  "version": "0.18.0-2b1c2a9",
   "type": "module",
   "types": "./dist/types/element/src/index.d.ts",
   "main": "./dist/prod/index.js",
@@ -63,8 +63,8 @@
     "build:esm": "rimraf dist && node ../../scripts/buildBase.js && yarn gen:types"
   },
   "dependencies": {
-    "@excalidraw/common": "0.18.0-2a82821",
-    "@excalidraw/math": "0.18.0-2a82821",
-    "@excalidraw/fractional-indexing": "0.18.0-2a82821"
+    "@excalidraw/common": "0.18.0-2b1c2a9",
+    "@excalidraw/math": "0.18.0-2b1c2a9",
+    "@excalidraw/fractional-indexing": "0.18.0-2b1c2a9"
   }
 }