@zsviczian/excalidraw 0.18.0-60 → 0.18.0-62

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

@@ -1,5 +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;
+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/types/math/src/segment.d.ts

@@ -1,40 +1,40 @@
-import type { GlobalPoint, LineSegment, LocalPoint, Radians } from "./types";
-/**
- * Create a line segment from two points.
- *
- * @param points The two points delimiting the line segment on each end
- * @returns The line segment delineated by the points
- */
-export declare function lineSegment<P extends GlobalPoint | LocalPoint>(a: P, b: P): LineSegment<P>;
-/**
- *
- * @param segment
- * @returns
- */
-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.
- *
- * @param l
- * @param angle
- * @param origin
- * @returns
- */
-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 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
- *
- * @param l
- * @param s
- * @returns
- */
-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;
+import type { GlobalPoint, LineSegment, LocalPoint, Radians } from "./types";
+/**
+ * Create a line segment from two points.
+ *
+ * @param points The two points delimiting the line segment on each end
+ * @returns The line segment delineated by the points
+ */
+export declare function lineSegment<P extends GlobalPoint | LocalPoint>(a: P, b: P): LineSegment<P>;
+/**
+ *
+ * @param segment
+ * @returns
+ */
+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.
+ *
+ * @param l
+ * @param angle
+ * @param origin
+ * @returns
+ */
+export declare const lineSegmentRotate: <Point extends LocalPoint | GlobalPoint>(l: LineSegment<Point>, angle: Radians, origin?: Point) => LineSegment<Point>;
+/**
+ * Calculates the point two line segments with a definite start and end point
+ * intersect at.
+ */
+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 intersection point of a segment and a line
+ *
+ * @param l
+ * @param s
+ * @returns
+ */
+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;

package/types/math/src/triangle.d.ts

@@ -1,11 +1,11 @@
-import type { GlobalPoint, LocalPoint, Triangle } from "./types";
-/**
- * Tests if a point lies inside a triangle. This function
- * will return FALSE if the point lies exactly on the sides
- * of the triangle.
- *
- * @param triangle The triangle to test the point for
- * @param p The point to test whether is in the triangle
- * @returns TRUE if the point is inside of the triangle
- */
-export declare function triangleIncludesPoint<P extends GlobalPoint | LocalPoint>([a, b, c]: Triangle<P>, p: P): boolean;
+import type { GlobalPoint, LocalPoint, Triangle } from "./types";
+/**
+ * Tests if a point lies inside a triangle. This function
+ * will return FALSE if the point lies exactly on the sides
+ * of the triangle.
+ *
+ * @param triangle The triangle to test the point for
+ * @param p The point to test whether is in the triangle
+ * @returns TRUE if the point is inside of the triangle
+ */
+export declare function triangleIncludesPoint<P extends GlobalPoint | LocalPoint>([a, b, c]: Triangle<P>, p: P): boolean;

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

@@ -1,106 +1,106 @@
-/**
- * By definition one radian is the angle subtended at the centre
- * of a circle by an arc that is equal in length to the radius.
- */
-export type Radians = number & {
-    _brand: "excalimath__radian";
-};
-/**
- * An angle measurement of a plane angle in which one full
- * rotation is 360 degrees.
- */
-export type Degrees = number & {
-    _brand: "excalimath_degree";
-};
-/**
- * A number range which includes the start and end numbers in the range.
- */
-export type InclusiveRange = [number, number] & {
-    _brand: "excalimath_degree";
-};
-/**
- * Represents a 2D position in world or canvas space. A
- * global coordinate.
- */
-export type GlobalPoint = [x: number, y: number] & {
-    _brand: "excalimath__globalpoint";
-};
-/**
- * Represents a 2D position in whatever local space it's
- * needed. A local coordinate.
- */
-export type LocalPoint = [x: number, y: number] & {
-    _brand: "excalimath__localpoint";
-};
-/**
- * A line is an infinitely long object with no width, depth, or curvature.
- */
-export type Line<P extends GlobalPoint | LocalPoint> = [p: P, q: P] & {
-    _brand: "excalimath_line";
-};
-/**
- * In geometry, a line segment is a part of a straight
- * line that is bounded by two distinct end points, and
- * contains every point on the line that is between its endpoints.
- */
-export type LineSegment<P extends GlobalPoint | LocalPoint> = [a: P, b: P] & {
-    _brand: "excalimath_linesegment";
-};
-/**
- * Represents a 2D vector
- */
-export type Vector = [u: number, v: number] & {
-    _brand: "excalimath__vector";
-};
-/**
- * A triangle represented by 3 points
- */
-export type Triangle<P extends GlobalPoint | LocalPoint> = [
-    a: P,
-    b: P,
-    c: P
-] & {
-    _brand: "excalimath__triangle";
-};
-/**
- * A rectangular shape represented by 4 points at its corners
- */
-export type Rectangle<P extends GlobalPoint | LocalPoint> = [a: P, b: P] & {
-    _brand: "excalimath__rectangle";
-};
-/**
- * A polygon is a closed shape by connecting the given points
- * rectangles and diamonds are modelled by polygons
- */
-export type Polygon<Point extends GlobalPoint | LocalPoint> = Point[] & {
-    _brand: "excalimath_polygon";
-};
-/**
- * Cubic bezier curve with four control points
- */
-export type Curve<Point extends GlobalPoint | LocalPoint> = [
-    Point,
-    Point,
-    Point,
-    Point
-] & {
-    _brand: "excalimath_curve";
-};
-export type PolarCoords = [
-    radius: number,
-    /** angle in radians */
-    angle: number
-];
-/**
-  An ellipse is specified by its center, angle, and its major and minor axes
-  but for the sake of simplicity, we've used halfWidth and halfHeight instead
-  in replace of semi major and semi minor axes
- */
-export type Ellipse<Point extends GlobalPoint | LocalPoint> = {
-    center: Point;
-    halfWidth: number;
-    halfHeight: number;
-} & {
-    _brand: "excalimath_ellipse";
-};
-export type ElementsSegmentsMap = Map<string, LineSegment<GlobalPoint>[]>;
+/**
+ * By definition one radian is the angle subtended at the centre
+ * of a circle by an arc that is equal in length to the radius.
+ */
+export type Radians = number & {
+    _brand: "excalimath__radian";
+};
+/**
+ * An angle measurement of a plane angle in which one full
+ * rotation is 360 degrees.
+ */
+export type Degrees = number & {
+    _brand: "excalimath_degree";
+};
+/**
+ * A number range which includes the start and end numbers in the range.
+ */
+export type InclusiveRange = [number, number] & {
+    _brand: "excalimath_degree";
+};
+/**
+ * Represents a 2D position in world or canvas space. A
+ * global coordinate.
+ */
+export type GlobalPoint = [x: number, y: number] & {
+    _brand: "excalimath__globalpoint";
+};
+/**
+ * Represents a 2D position in whatever local space it's
+ * needed. A local coordinate.
+ */
+export type LocalPoint = [x: number, y: number] & {
+    _brand: "excalimath__localpoint";
+};
+/**
+ * A line is an infinitely long object with no width, depth, or curvature.
+ */
+export type Line<P extends GlobalPoint | LocalPoint> = [p: P, q: P] & {
+    _brand: "excalimath_line";
+};
+/**
+ * In geometry, a line segment is a part of a straight
+ * line that is bounded by two distinct end points, and
+ * contains every point on the line that is between its endpoints.
+ */
+export type LineSegment<P extends GlobalPoint | LocalPoint> = [a: P, b: P] & {
+    _brand: "excalimath_linesegment";
+};
+/**
+ * Represents a 2D vector
+ */
+export type Vector = [u: number, v: number] & {
+    _brand: "excalimath__vector";
+};
+/**
+ * A triangle represented by 3 points
+ */
+export type Triangle<P extends GlobalPoint | LocalPoint> = [
+    a: P,
+    b: P,
+    c: P
+] & {
+    _brand: "excalimath__triangle";
+};
+/**
+ * A rectangular shape represented by 4 points at its corners
+ */
+export type Rectangle<P extends GlobalPoint | LocalPoint> = [a: P, b: P] & {
+    _brand: "excalimath__rectangle";
+};
+/**
+ * A polygon is a closed shape by connecting the given points
+ * rectangles and diamonds are modelled by polygons
+ */
+export type Polygon<Point extends GlobalPoint | LocalPoint> = Point[] & {
+    _brand: "excalimath_polygon";
+};
+/**
+ * Cubic bezier curve with four control points
+ */
+export type Curve<Point extends GlobalPoint | LocalPoint> = [
+    Point,
+    Point,
+    Point,
+    Point
+] & {
+    _brand: "excalimath_curve";
+};
+export type PolarCoords = [
+    radius: number,
+    /** angle in radians */
+    angle: number
+];
+/**
+  An ellipse is specified by its center, angle, and its major and minor axes
+  but for the sake of simplicity, we've used halfWidth and halfHeight instead
+  in replace of semi major and semi minor axes
+ */
+export type Ellipse<Point extends GlobalPoint | LocalPoint> = {
+    center: Point;
+    halfWidth: number;
+    halfHeight: number;
+} & {
+    _brand: "excalimath_ellipse";
+};
+export type ElementsSegmentsMap = Map<string, LineSegment<GlobalPoint>[]>;

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

@@ -1,7 +1,7 @@
-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;
-export declare const roundToStep: (value: number, step: number, func?: "round" | "floor" | "ceil") => number;
-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 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;
+export declare const roundToStep: (value: number, step: number, func?: "round" | "floor" | "ceil") => number;
+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;

package/types/math/src/vector.d.ts

@@ -1,94 +1,94 @@
-import type { GlobalPoint, LocalPoint, Vector } from "./types";
-/**
- * Create a vector from the x and y coordiante elements.
- *
- * @param x The X aspect of the vector
- * @param y T Y aspect of the vector
- * @returns The constructed vector with X and Y as the coordinates
- */
-export declare function vector(x: number, y: number, originX?: number, originY?: number): Vector;
-/**
- * Turn a point into a vector with the origin point.
- *
- * @param p The point to turn into a vector
- * @param origin The origin point in a given coordiante system
- * @param threshold The threshold to consider the vector as 'undefined'
- * @param defaultValue The default value to return if the vector is 'undefined'
- * @returns The created vector from the point and the origin or default
- */
-export declare function vectorFromPoint<Point extends GlobalPoint | LocalPoint>(p: Point, origin?: Point, threshold?: number, defaultValue?: Vector): Vector;
-/**
- * Cross product is a binary operation on two vectors in 2D space.
- * It results in a vector that is perpendicular to both vectors.
- *
- * @param a One of the vectors to use for the directed area calculation
- * @param b The other vector to use for the directed area calculation
- * @returns The directed area value for the two vectos
- */
-export declare function vectorCross(a: Vector, b: Vector): number;
-/**
- * Dot product is defined as the sum of the products of the
- * two vectors.
- *
- * @param a One of the vectors for which the sum of products is calculated
- * @param b The other vector for which the sum of products is calculated
- * @returns The sum of products of the two vectors
- */
-export declare function vectorDot(a: Vector, b: Vector): number;
-/**
- * Determines if the value has the shape of a Vector.
- *
- * @param v The value to test
- * @returns TRUE if the value has the shape and components of a Vectors
- */
-export declare function isVector(v: unknown): v is Vector;
-/**
- * Add two vectors by adding their coordinates.
- *
- * @param a One of the vectors to add
- * @param b The other vector to add
- * @returns The sum vector of the two provided vectors
- */
-export declare function vectorAdd(a: Readonly<Vector>, b: Readonly<Vector>): Vector;
-/**
- * Add two vectors by adding their coordinates.
- *
- * @param start One of the vectors to add
- * @param end The other vector to add
- * @returns The sum vector of the two provided vectors
- */
-export declare function vectorSubtract(start: Readonly<Vector>, end: Readonly<Vector>): Vector;
-/**
- * Scale vector by a scalar.
- *
- * @param v The vector to scale
- * @param scalar The scalar to multiply the vector components with
- * @returns The new scaled vector
- */
-export declare function vectorScale(v: Vector, scalar: number): Vector;
-/**
- * Calculates the sqare magnitude of a vector. Use this if you compare
- * magnitudes as it saves you an SQRT.
- *
- * @param v The vector to measure
- * @returns The scalar squared magnitude of the vector
- */
-export declare function vectorMagnitudeSq(v: Vector): number;
-/**
- * Calculates the magnitude of a vector.
- *
- * @param v The vector to measure
- * @returns The scalar magnitude of the vector
- */
-export declare function vectorMagnitude(v: Vector): number;
-/**
- * Normalize the vector (i.e. make the vector magnitue equal 1).
- *
- * @param v The vector to normalize
- * @returns The new normalized vector
- */
-export declare const vectorNormalize: (v: Vector) => Vector;
-/**
- * Calculate the right-hand normal of the vector.
- */
-export declare const vectorNormal: (v: Vector) => Vector;
+import type { GlobalPoint, LocalPoint, Vector } from "./types";
+/**
+ * Create a vector from the x and y coordiante elements.
+ *
+ * @param x The X aspect of the vector
+ * @param y T Y aspect of the vector
+ * @returns The constructed vector with X and Y as the coordinates
+ */
+export declare function vector(x: number, y: number, originX?: number, originY?: number): Vector;
+/**
+ * Turn a point into a vector with the origin point.
+ *
+ * @param p The point to turn into a vector
+ * @param origin The origin point in a given coordiante system
+ * @param threshold The threshold to consider the vector as 'undefined'
+ * @param defaultValue The default value to return if the vector is 'undefined'
+ * @returns The created vector from the point and the origin or default
+ */
+export declare function vectorFromPoint<Point extends GlobalPoint | LocalPoint>(p: Point, origin?: Point, threshold?: number, defaultValue?: Vector): Vector;
+/**
+ * Cross product is a binary operation on two vectors in 2D space.
+ * It results in a vector that is perpendicular to both vectors.
+ *
+ * @param a One of the vectors to use for the directed area calculation
+ * @param b The other vector to use for the directed area calculation
+ * @returns The directed area value for the two vectos
+ */
+export declare function vectorCross(a: Vector, b: Vector): number;
+/**
+ * Dot product is defined as the sum of the products of the
+ * two vectors.
+ *
+ * @param a One of the vectors for which the sum of products is calculated
+ * @param b The other vector for which the sum of products is calculated
+ * @returns The sum of products of the two vectors
+ */
+export declare function vectorDot(a: Vector, b: Vector): number;
+/**
+ * Determines if the value has the shape of a Vector.
+ *
+ * @param v The value to test
+ * @returns TRUE if the value has the shape and components of a Vectors
+ */
+export declare function isVector(v: unknown): v is Vector;
+/**
+ * Add two vectors by adding their coordinates.
+ *
+ * @param a One of the vectors to add
+ * @param b The other vector to add
+ * @returns The sum vector of the two provided vectors
+ */
+export declare function vectorAdd(a: Readonly<Vector>, b: Readonly<Vector>): Vector;
+/**
+ * Add two vectors by adding their coordinates.
+ *
+ * @param start One of the vectors to add
+ * @param end The other vector to add
+ * @returns The sum vector of the two provided vectors
+ */
+export declare function vectorSubtract(start: Readonly<Vector>, end: Readonly<Vector>): Vector;
+/**
+ * Scale vector by a scalar.
+ *
+ * @param v The vector to scale
+ * @param scalar The scalar to multiply the vector components with
+ * @returns The new scaled vector
+ */
+export declare function vectorScale(v: Vector, scalar: number): Vector;
+/**
+ * Calculates the sqare magnitude of a vector. Use this if you compare
+ * magnitudes as it saves you an SQRT.
+ *
+ * @param v The vector to measure
+ * @returns The scalar squared magnitude of the vector
+ */
+export declare function vectorMagnitudeSq(v: Vector): number;
+/**
+ * Calculates the magnitude of a vector.
+ *
+ * @param v The vector to measure
+ * @returns The scalar magnitude of the vector
+ */
+export declare function vectorMagnitude(v: Vector): number;
+/**
+ * Normalize the vector (i.e. make the vector magnitue equal 1).
+ *
+ * @param v The vector to normalize
+ * @returns The new normalized vector
+ */
+export declare const vectorNormalize: (v: Vector) => Vector;
+/**
+ * Calculate the right-hand normal of the vector.
+ */
+export declare const vectorNormal: (v: Vector) => Vector;

package/types/utils/src/bbox.d.ts

@@ -1,9 +1,9 @@
-import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
-import type { Bounds } from "@excalidraw/element";
-export type LineSegment<P extends LocalPoint | GlobalPoint> = [P, P];
-export declare function getBBox<P extends LocalPoint | GlobalPoint>(line: LineSegment<P>): Bounds;
-export declare function doBBoxesIntersect(a: Bounds, b: Bounds): boolean;
-export declare function isPointOnLine<P extends GlobalPoint | LocalPoint>(l: LineSegment<P>, p: P): boolean;
-export declare function isPointRightOfLine<P extends GlobalPoint | LocalPoint>(l: LineSegment<P>, p: P): boolean;
-export declare function isLineSegmentTouchingOrCrossingLine<P extends GlobalPoint | LocalPoint>(a: LineSegment<P>, b: LineSegment<P>): boolean;
-export declare function doLineSegmentsIntersect<P extends GlobalPoint | LocalPoint>(a: LineSegment<P>, b: LineSegment<P>): boolean;
+import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
+import type { Bounds } from "@excalidraw/element";
+export type LineSegment<P extends LocalPoint | GlobalPoint> = [P, P];
+export declare function getBBox<P extends LocalPoint | GlobalPoint>(line: LineSegment<P>): Bounds;
+export declare function doBBoxesIntersect(a: Bounds, b: Bounds): boolean;
+export declare function isPointOnLine<P extends GlobalPoint | LocalPoint>(l: LineSegment<P>, p: P): boolean;
+export declare function isPointRightOfLine<P extends GlobalPoint | LocalPoint>(l: LineSegment<P>, p: P): boolean;
+export declare function isLineSegmentTouchingOrCrossingLine<P extends GlobalPoint | LocalPoint>(a: LineSegment<P>, b: LineSegment<P>): boolean;
+export declare function doLineSegmentsIntersect<P extends GlobalPoint | LocalPoint>(a: LineSegment<P>, b: LineSegment<P>): boolean;

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

@@ -1,35 +1,35 @@
-import { MIME_TYPES } from "@excalidraw/common";
-import type { ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted } from "@excalidraw/element/types";
-import type { AppState, BinaryFiles } from "@excalidraw/excalidraw/types";
-export { MIME_TYPES };
-type ExportOpts = {
-    elements: readonly NonDeleted<ExcalidrawElement>[];
-    appState?: Partial<Omit<AppState, "offsetTop" | "offsetLeft">>;
-    files: BinaryFiles | null;
-    maxWidthOrHeight?: number;
-    exportingFrame?: ExcalidrawFrameLikeElement | null;
-    getDimensions?: (width: number, height: number) => {
-        width: number;
-        height: number;
-        scale?: number;
-    };
-};
-export declare const exportToCanvas: ({ elements, appState, files, maxWidthOrHeight, getDimensions, exportPadding, exportingFrame, }: ExportOpts & {
-    exportPadding?: number | undefined;
-}) => Promise<HTMLCanvasElement>;
-export declare const exportToBlob: (opts: ExportOpts & {
-    mimeType?: string;
-    quality?: number;
-    exportPadding?: number;
-}) => Promise<Blob>;
-export declare const exportToSvg: ({ elements, appState, files, exportPadding, renderEmbeddables, exportingFrame, skipInliningFonts, reuseImages, }: Omit<ExportOpts, "getDimensions"> & {
-    exportPadding?: number | undefined;
-    renderEmbeddables?: boolean | undefined;
-    skipInliningFonts?: true | undefined;
-    reuseImages?: boolean | undefined;
-}) => Promise<SVGSVGElement>;
-export declare const exportToClipboard: (opts: ExportOpts & {
-    mimeType?: string;
-    quality?: number;
-    type: "png" | "svg" | "json";
-}) => Promise<void>;
+import { MIME_TYPES } from "@excalidraw/common";
+import type { ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted } from "@excalidraw/element/types";
+import type { AppState, BinaryFiles } from "@excalidraw/excalidraw/types";
+export { MIME_TYPES };
+type ExportOpts = {
+    elements: readonly NonDeleted<ExcalidrawElement>[];
+    appState?: Partial<Omit<AppState, "offsetTop" | "offsetLeft">>;
+    files: BinaryFiles | null;
+    maxWidthOrHeight?: number;
+    exportingFrame?: ExcalidrawFrameLikeElement | null;
+    getDimensions?: (width: number, height: number) => {
+        width: number;
+        height: number;
+        scale?: number;
+    };
+};
+export declare const exportToCanvas: ({ elements, appState, files, maxWidthOrHeight, getDimensions, exportPadding, exportingFrame, }: ExportOpts & {
+    exportPadding?: number;
+}) => Promise<HTMLCanvasElement>;
+export declare const exportToBlob: (opts: ExportOpts & {
+    mimeType?: string;
+    quality?: number;
+    exportPadding?: number;
+}) => Promise<Blob>;
+export declare const exportToSvg: ({ elements, appState, files, exportPadding, renderEmbeddables, exportingFrame, skipInliningFonts, reuseImages, }: Omit<ExportOpts, "getDimensions"> & {
+    exportPadding?: number;
+    renderEmbeddables?: boolean;
+    skipInliningFonts?: true;
+    reuseImages?: boolean;
+}) => Promise<SVGSVGElement>;
+export declare const exportToClipboard: (opts: ExportOpts & {
+    mimeType?: string;
+    quality?: number;
+    type: "png" | "svg" | "json";
+}) => Promise<void>;

package/types/utils/src/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./export";
-export * from "./withinBounds";
-export * from "./bbox";
-export { getCommonBounds } from "@excalidraw/element";
+export * from "./export";
+export * from "./withinBounds";
+export * from "./bbox";
+export { getCommonBounds } from "@excalidraw/element";