@myoc/excalidraw 0.18.19 → 0.18.20

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

@@ -1,7 +1,7 @@
 import React from "react";
 import { type EXPORT_IMAGE_TYPES, Emitter } from "@excalidraw/common";
 import { LinearElementEditor, FlowChartCreator, Scene, Store, type ElementUpdate } from "@excalidraw/element";
-import type { ExcalidrawElement, NonDeleted, InitializedExcalidrawImageElement, ExcalidrawImageElement, NonDeletedExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered } from "@excalidraw/element/types";
+import type { ExcalidrawElement, NonDeleted, InitializedExcalidrawImageElement, NonDeletedExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered } from "@excalidraw/element/types";
 import type { Mutable } from "@excalidraw/common/utility-types";
 import { ActionManager } from "../actions/manager";
 import { AnimationFrameHandler } from "../animation-frame-handler";
@@ -78,6 +78,7 @@ declare class App extends React.Component<AppProps, AppState> {
     /** embeds that have been inserted to DOM (as a perf optim, we don't want to
      * insert to DOM before user initially scrolls to them) */
     private initializedEmbeds;
+    private handleToastClose;
     private elementsPendingErasure;
     flowChartCreator: FlowChartCreator;
     private flowChartNavigator;
@@ -315,12 +316,13 @@ declare class App extends React.Component<AppProps, AppState> {
     private static resetTapTwice;
     private onTouchStart;
     private onTouchEnd;
-    addImageElementsToScene: ({ sceneX, sceneY, files, selectAfterInsert, }: {
+    addImageElementsToScene: ({ sceneX, sceneY, files, selectAfterInsert, addToFrameUnderCursor, }: {
         sceneX: number;
         sceneY: number;
         files: File[];
         selectAfterInsert?: boolean | undefined;
-    }) => Promise<void>;
+        addToFrameUnderCursor?: boolean | undefined;
+    }) => Promise<NonDeleted<InitializedExcalidrawImageElement>[]>;
     pasteFromClipboard: (event: ClipboardEvent) => Promise<void>;
     addElementsFromPasteOrLibrary: (opts: {
         elements: readonly ExcalidrawElement[];
@@ -508,12 +510,17 @@ declare class App extends React.Component<AppProps, AppState> {
     private restoreReadyToEraseElements;
     private eraseElements;
     private initializeImage;
+    /**
+     * use during async image initialization,
+     * when the placeholder image could have been modified in the meantime,
+     * and when you don't want to loose those modifications
+     */
+    private getLatestInitializedImageElement;
     /**
      * inserts image into elements array and rerenders
      */
-    insertImageElement: (imageElement: ExcalidrawImageElement, imageFile: File) => Promise<NonDeleted<InitializedExcalidrawImageElement> | null | undefined>;
+    private insertImageElement;
     private onImageAction;
-    initializeImageDimensions: (imageElement: ExcalidrawImageElement) => void;
     private getImageNaturalDimensions;
     /** updates image cache, refreshing updated elements and/or setting status
         to error for images that fail during <img> element creation */
@@ -525,7 +532,6 @@ declare class App extends React.Component<AppProps, AppState> {
     private scheduleImageRefresh;
     private updateBindingEnabledOnPointerMove;
     private maybeSuggestBindingAtCursor;
-    private maybeSuggestBindingsForLinearElementAtCoords;
     private clearSelection;
     private handleInteractiveCanvasRef;
     private handleAppOnDrop;

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

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export declare const Ellipsify: ({ children, ...rest }: {
+    children: React.ReactNode;
+} & import("react").HTMLAttributes<HTMLSpanElement>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/Stats/DragInput.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="react" />
 import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
 import type { Scene } from "@excalidraw/element";
+import { useApp, useExcalidrawSetAppState } from "../App";
 import "./DragInput.scss";
 import type { StatsInputProperty } from "./utils";
 import type { AppState } from "../../types";
@@ -16,6 +17,14 @@ export type DragInputCallbackType<P extends StatsInputProperty, E = ExcalidrawEl
     property: P;
     originalAppState: AppState;
     setInputValue: (value: number) => void;
+    app: ReturnType<typeof useApp>;
+    setAppState: ReturnType<typeof useExcalidrawSetAppState>;
+}) => void;
+export type DragFinishedCallbackType<E = ExcalidrawElement> = (props: {
+    app: ReturnType<typeof useApp>;
+    setAppState: ReturnType<typeof useExcalidrawSetAppState>;
+    originalElements: readonly E[] | null;
+    originalAppState: AppState;
 }) => void;
 interface StatsDragInputProps<T extends StatsInputProperty, E = ExcalidrawElement> {
     label: string | React.ReactNode;
@@ -30,6 +39,7 @@ interface StatsDragInputProps<T extends StatsInputProperty, E = ExcalidrawElemen
     appState: AppState;
     /** how many px you need to drag to get 1 unit change */
     sensitivity?: number;
+    dragFinishedCallback?: DragFinishedCallbackType;
 }
-declare const StatsDragInput: <T extends StatsInputProperty, E extends ExcalidrawElement = ExcalidrawElement>({ label, icon, dragInputCallback, value, elements, editable, shouldKeepAspectRatio, property, scene, appState, sensitivity, }: StatsDragInputProps<T, E>) => import("react/jsx-runtime").JSX.Element | null;
+declare const StatsDragInput: <T extends StatsInputProperty, E extends ExcalidrawElement = ExcalidrawElement>({ label, icon, dragInputCallback, value, elements, editable, shouldKeepAspectRatio, property, scene, appState, sensitivity, dragFinishedCallback, }: StatsDragInputProps<T, E>) => import("react/jsx-runtime").JSX.Element | null;
 export default StatsDragInput;

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

@@ -59,4 +59,4 @@ export declare const SHAPES: readonly [{
     readonly fillable: false;
     readonly myocSimplifiedMode: true;
 }];
-export declare const findShapeByKey: (key: string) => "text" | "line" | "arrow" | "selection" | "rectangle" | "diamond" | "ellipse" | "freedraw" | "image" | "eraser" | null;
+export declare const findShapeByKey: (key: string) => "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | "eraser" | null;

package/dist/types/excalidraw/data/blob.d.ts

@@ -6,7 +6,7 @@ import type { FileSystemHandle } from "./filesystem";
 import type { ImportedLibraryData } from "./types";
 export declare const getMimeType: (blob: Blob | string) => string;
 export declare const getFileHandleType: (handle: FileSystemHandle | null) => string | null;
-export declare const isImageFileHandleType: (type: string | null) => type is "svg" | "png";
+export declare const isImageFileHandleType: (type: string | null) => type is "png" | "svg";
 export declare const isImageFileHandle: (handle: FileSystemHandle | null) => boolean;
 export declare const isSupportedImageFileType: (type: string | null | undefined) => boolean;
 export declare const isSupportedImageFile: (blob: Blob | null | undefined) => blob is Blob & {

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

@@ -29,6 +29,7 @@ export { Sidebar } from "./components/Sidebar/Sidebar";
 export { Button } from "./components/Button";
 export { Footer };
 export { MainMenu };
+export { Ellipsify } from "./components/Ellipsify";
 export { useDevice } from "./components/App";
 export { WelcomeScreen };
 export { LiveCollaborationTrigger };

package/dist/types/excalidraw/renderer/staticScene.d.ts

@@ -1,4 +1,7 @@
-import type { StaticSceneRenderConfig } from "../scene/types";
+import type { ExcalidrawFrameLikeElement } from "@excalidraw/element/types";
+import type { StaticCanvasRenderConfig, StaticSceneRenderConfig } from "../scene/types";
+import type { StaticCanvasAppState } from "../types";
+export declare const frameClip: (frame: ExcalidrawFrameLikeElement, context: CanvasRenderingContext2D, renderConfig: StaticCanvasRenderConfig, appState: StaticCanvasAppState) => void;
 /** throttled to animation framerate */
 export declare const renderStaticSceneThrottled: {
     (config: StaticSceneRenderConfig): void;

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

@@ -129,7 +129,6 @@ export type StaticCanvasAppState = Readonly<_CommonCanvasAppState & {
 }>;
 export type InteractiveCanvasAppState = Readonly<_CommonCanvasAppState & {
     activeEmbeddable: AppState["activeEmbeddable"];
-    editingLinearElement: AppState["editingLinearElement"];
     selectionElement: AppState["selectionElement"];
     selectedGroupIds: AppState["selectedGroupIds"];
     selectedLinearElement: AppState["selectedLinearElement"];
@@ -156,8 +155,8 @@ export type ObservedElementsAppState = {
     editingGroupId: AppState["editingGroupId"];
     selectedElementIds: AppState["selectedElementIds"];
     selectedGroupIds: AppState["selectedGroupIds"];
-    editingLinearElementId: LinearElementEditor["elementId"] | null;
     selectedLinearElementId: LinearElementEditor["elementId"] | null;
+    selectedLinearElementIsEditing: boolean | null;
     croppingElementId: AppState["croppingElementId"];
     lockedMultiSelections: AppState["lockedMultiSelections"];
     activeLockedId: AppState["activeLockedId"];
@@ -219,7 +218,6 @@ export interface AppState {
      * set when a new text is created or when an existing text is being edited
      */
     editingTextElement: NonDeletedExcalidrawElement | null;
-    editingLinearElement: LinearElementEditor | null;
     activeTool: {
         /**
          * indicates a previous tool we should revert back to if we deselect the
@@ -651,7 +649,7 @@ export interface ExcalidrawImperativeAPI {
         sceneY: number;
         files: File[];
         selectAfterInsert?: boolean;
-    }) => Promise<void>;
+    }) => Promise<ExcalidrawElement[]>;
     id: string;
     setActiveTool: InstanceType<typeof App>["setActiveTool"];
     setCursor: InstanceType<typeof App>["setCursor"];

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

@@ -5,7 +5,7 @@ export declare const normalizeRadians: (angle: Radians) => Radians;
  * (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 cartesian2Polar: <P extends LocalPoint | GlobalPoint>([x, y,]: P) => PolarCoords;
+export declare const cartesian2Polar: <P extends GlobalPoint | LocalPoint>([x, y,]: P) => PolarCoords;
 export declare function degreesToRadians(degrees: Degrees): Radians;
 export declare function radiansToDegrees(degrees: Radians): Degrees;
 /**

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

@@ -8,7 +8,7 @@ import type { Curve, GlobalPoint, LineSegment, LocalPoint } from "./types";
  * @returns
  */
 export declare function curve<Point extends GlobalPoint | LocalPoint>(a: Point, b: Point, c: Point, d: Point): Curve<Point>;
-export declare const bezierEquation: <Point extends LocalPoint | GlobalPoint>(c: Curve<Point>, t: number) => Point;
+export declare const bezierEquation: <Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, t: number) => Point;
 /**
  * Computes the intersection between a cubic spline and a line segment.
  */

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

@@ -16,7 +16,7 @@ export declare function ellipse<Point extends GlobalPoint | LocalPoint>(center:
  * @param ellipse The ellipse to compare against
  * @returns TRUE if the point is inside or on the outline of the ellipse
  */
-export declare const ellipseIncludesPoint: <Point extends LocalPoint | GlobalPoint>(p: Point, ellipse: Ellipse<Point>) => boolean;
+export declare const ellipseIncludesPoint: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => boolean;
 /**
  * Tests whether a point lies on the outline of the ellipse within a given
  * tolerance
@@ -26,7 +26,7 @@ export declare const ellipseIncludesPoint: <Point extends LocalPoint | GlobalPoi
  * @param threshold The distance to consider a point close enough to be "on" the outline
  * @returns TRUE if the point is on the ellise outline
  */
-export declare const ellipseTouchesPoint: <Point extends LocalPoint | GlobalPoint>(point: Point, ellipse: Ellipse<Point>, threshold?: number) => boolean;
+export declare const ellipseTouchesPoint: <Point extends GlobalPoint | LocalPoint>(point: Point, ellipse: Ellipse<Point>, threshold?: number) => boolean;
 /**
  * Determine the shortest euclidean distance from a point to the
  * outline of the ellipse
@@ -35,7 +35,7 @@ export declare const ellipseTouchesPoint: <Point extends LocalPoint | GlobalPoin
  * @param ellipse The ellipse to calculate the distance to
  * @returns The eucledian distance
  */
-export declare const ellipseDistanceFromPoint: <Point extends LocalPoint | GlobalPoint>(p: Point, ellipse: Ellipse<Point>) => number;
+export declare const ellipseDistanceFromPoint: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => number;
 /**
  * Calculate a maximum of two intercept points for a line going throug an
  * ellipse.

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

@@ -109,7 +109,7 @@ export declare function pointDistanceSq<P extends LocalPoint | GlobalPoint>(a: P
  * @param multiplier The scaling factor
  * @returns
  */
-export declare const pointScaleFromOrigin: <P extends LocalPoint | GlobalPoint>(p: P, mid: P, multiplier: number) => LocalPoint | GlobalPoint;
+export declare const pointScaleFromOrigin: <P extends GlobalPoint | LocalPoint>(p: P, mid: P, multiplier: number) => GlobalPoint | LocalPoint;
 /**
  * Returns whether `q` lies inside the segment/rectangle defined by `p` and `r`.
  * This is an approximation to "does `q` lie on a segment `pr`" check.
@@ -119,4 +119,4 @@ export declare const pointScaleFromOrigin: <P extends LocalPoint | GlobalPoint>(
  * @param r The other point to compare against
  * @returns TRUE if q is indeed between p and r
  */
-export declare const isPointWithinBounds: <P extends LocalPoint | GlobalPoint>(p: P, q: P, r: P) => boolean;
+export declare const isPointWithinBounds: <P extends GlobalPoint | LocalPoint>(p: P, q: P, r: P) => boolean;

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

@@ -1,6 +1,6 @@
 import type { GlobalPoint, LocalPoint, Polygon } from "./types";
 export declare function polygon<Point extends GlobalPoint | LocalPoint>(...points: Point[]): Polygon<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 polygonIncludesPoint: <Point extends GlobalPoint | LocalPoint>(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 const pointOnPolygon: <Point extends GlobalPoint | LocalPoint>(p: Point, poly: Polygon<Point>, threshold?: number) => boolean;

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

@@ -1,3 +1,5 @@
 import type { GlobalPoint, LineSegment, LocalPoint, Rectangle } from "./types";
 export declare function rectangle<P extends GlobalPoint | LocalPoint>(topLeft: P, bottomRight: P): Rectangle<P>;
+export declare function rectangleFromNumberSequence<Point extends LocalPoint | GlobalPoint>(minX: number, minY: number, maxX: number, maxY: number): Rectangle<Point>;
 export declare function rectangleIntersectLineSegment<Point extends LocalPoint | GlobalPoint>(r: Rectangle<Point>, l: LineSegment<Point>): Point[];
+export declare function rectangleIntersectRectangle<Point extends LocalPoint | GlobalPoint>(rectangle1: Rectangle<Point>, rectangle2: Rectangle<Point>): boolean;

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

@@ -11,7 +11,7 @@ export declare function lineSegment<P extends GlobalPoint | LocalPoint>(a: P, b:
  * @param segment
  * @returns
  */
-export declare const isLineSegment: <Point extends LocalPoint | GlobalPoint>(segment: unknown) => segment is LineSegment<Point>;
+export declare const isLineSegment: <Point extends GlobalPoint | LocalPoint>(segment: unknown) => segment is LineSegment<Point>;
 /**
  * Return the coordinates resulting from rotating the given line about an origin by an angle in radians
  * note that when the origin is not given, the midpoint of the given line is used as the origin.
@@ -21,14 +21,14 @@ export declare const isLineSegment: <Point extends LocalPoint | GlobalPoint>(seg
  * @param origin
  * @returns
  */
-export declare const lineSegmentRotate: <Point extends LocalPoint | GlobalPoint>(l: LineSegment<Point>, angle: Radians, origin?: Point | undefined) => LineSegment<Point>;
+export declare const lineSegmentRotate: <Point extends GlobalPoint | LocalPoint>(l: LineSegment<Point>, angle: Radians, origin?: Point | undefined) => LineSegment<Point>;
 /**
  * Calculates the point two line segments with a definite start and end point
  * intersect at.
  */
-export declare const segmentsIntersectAt: <Point extends LocalPoint | GlobalPoint>(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;
+export declare const segmentsIntersectAt: <Point extends GlobalPoint | LocalPoint>(a: Readonly<LineSegment<Point>>, b: Readonly<LineSegment<Point>>) => Point | null;
+export declare const pointOnLineSegment: <Point extends GlobalPoint | LocalPoint>(point: Point, line: LineSegment<Point>, threshold?: number) => boolean;
+export declare const distanceToLineSegment: <Point extends GlobalPoint | LocalPoint>(point: Point, line: LineSegment<Point>) => number;
 /**
  * Returns the intersection point of a segment and a line
  *

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

@@ -1,4 +1,3 @@
-import { type Bounds } from "@excalidraw/element";
 export declare const PRECISION = 0.0001;
 export declare const clamp: (value: number, min: number, max: number) => number;
 export declare const round: (value: number, precision: number, func?: "round" | "floor" | "ceil") => number;
@@ -6,4 +5,3 @@ export declare const roundToStep: (value: number, step: number, func?: "round" |
 export declare const average: (a: number, b: number) => number;
 export declare const isFiniteNumber: (value: any) => value is number;
 export declare const isCloseTo: (a: number, b: number, precision?: number) => boolean;
-export declare const doBoundsIntersect: (bounds1: Bounds | null, bounds2: Bounds | null) => boolean;

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

@@ -30,13 +30,13 @@ export type GeometricShape<Point extends GlobalPoint | LocalPoint> = {
     data: Polycurve<Point>;
 };
 type RectangularElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawFrameLikeElement | ExcalidrawEmbeddableElement | ExcalidrawImageElement | ExcalidrawIframeElement | ExcalidrawTextElement | ExcalidrawSelectionElement;
-export declare const getPolygonShape: <Point extends LocalPoint | GlobalPoint>(element: RectangularElement) => GeometricShape<Point>;
-export declare const getSelectionBoxShape: <Point extends LocalPoint | GlobalPoint>(element: ExcalidrawElement, elementsMap: ElementsMap, padding?: number) => GeometricShape<Point>;
-export declare const getEllipseShape: <Point extends LocalPoint | GlobalPoint>(element: ExcalidrawEllipseElement) => GeometricShape<Point>;
+export declare const getPolygonShape: <Point extends GlobalPoint | LocalPoint>(element: RectangularElement) => GeometricShape<Point>;
+export declare const getSelectionBoxShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawElement, elementsMap: ElementsMap, padding?: number) => GeometricShape<Point>;
+export declare const getEllipseShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawEllipseElement) => GeometricShape<Point>;
 export declare const getCurvePathOps: (shape: Drawable) => Op[];
-export declare const getCurveShape: <Point extends LocalPoint | GlobalPoint>(roughShape: Drawable, startingPoint: Point | undefined, angleInRadian: Radians, center: Point) => GeometricShape<Point>;
-export declare const getFreedrawShape: <Point extends LocalPoint | GlobalPoint>(element: ExcalidrawFreeDrawElement, center: Point, isClosed?: boolean) => GeometricShape<Point>;
-export declare const getClosedCurveShape: <Point extends LocalPoint | GlobalPoint>(element: ExcalidrawLinearElement, roughShape: Drawable, startingPoint: Point | undefined, angleInRadian: Radians, center: Point) => GeometricShape<Point>;
+export declare const getCurveShape: <Point extends GlobalPoint | LocalPoint>(roughShape: Drawable, startingPoint: Point | undefined, angleInRadian: Radians, center: Point) => GeometricShape<Point>;
+export declare const getFreedrawShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawFreeDrawElement, center: Point, isClosed?: boolean) => GeometricShape<Point>;
+export declare const getClosedCurveShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawLinearElement, roughShape: Drawable, startingPoint: Point | undefined, angleInRadian: Radians, center: Point) => GeometricShape<Point>;
 /**
  * Determine intersection of a rectangular shaped element and a
  * line segment.
@@ -46,13 +46,13 @@ export declare const getClosedCurveShape: <Point extends LocalPoint | GlobalPoin
  * @param gap Optional value to inflate the shape before testing
  * @returns An array of intersections
  */
-export declare const segmentIntersectRectangleElement: <Point extends LocalPoint | GlobalPoint>(element: ExcalidrawBindableElement, segment: LineSegment<Point>, gap?: number) => Point[];
-export declare const pointOnEllipse: <Point extends LocalPoint | GlobalPoint>(point: Point, ellipse: Ellipse<Point>, threshold?: number) => boolean;
-export declare const pointInEllipse: <Point extends LocalPoint | GlobalPoint>(p: Point, ellipse: Ellipse<Point>) => boolean;
-export declare const ellipseAxes: <Point extends LocalPoint | GlobalPoint>(ellipse: Ellipse<Point>) => {
+export declare const segmentIntersectRectangleElement: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawBindableElement, segment: LineSegment<Point>, gap?: number) => Point[];
+export declare const pointOnEllipse: <Point extends GlobalPoint | LocalPoint>(point: Point, ellipse: Ellipse<Point>, threshold?: number) => boolean;
+export declare const pointInEllipse: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => boolean;
+export declare const ellipseAxes: <Point extends GlobalPoint | LocalPoint>(ellipse: Ellipse<Point>) => {
     majorAxis: number;
     minorAxis: number;
 };
-export declare const ellipseFocusToCenter: <Point extends LocalPoint | GlobalPoint>(ellipse: Ellipse<Point>) => number;
-export declare const ellipseExtremes: <Point extends LocalPoint | GlobalPoint>(ellipse: Ellipse<Point>) => import("@excalidraw/math").Vector[];
+export declare const ellipseFocusToCenter: <Point extends GlobalPoint | LocalPoint>(ellipse: Ellipse<Point>) => number;
+export declare const ellipseExtremes: <Point extends GlobalPoint | LocalPoint>(ellipse: Ellipse<Point>) => import("@excalidraw/math").Vector[];
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myoc/excalidraw",
-  "version": "0.18.19",
+  "version": "0.18.20",
   "type": "module",
   "types": "./dist/types/excalidraw/index.d.ts",
   "main": "./dist/prod/index.js",
@@ -72,7 +72,10 @@
   },
   "dependencies": {
     "@braintree/sanitize-url": "6.0.2",
+    "@excalidraw/common": "0.18.0",
+    "@excalidraw/element": "0.18.0",
     "@excalidraw/laser-pointer": "1.3.1",
+    "@excalidraw/math": "0.18.0",
     "@excalidraw/mermaid-to-excalidraw": "1.1.2",
     "@excalidraw/random-username": "1.1.0",
     "@radix-ui/react-popover": "1.1.6",