@excalidraw/math 0.18.0-4ce38fb → 0.18.0-4ce8305

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

@@ -1,31 +1,299 @@
-import type { ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import { MIME_TYPES } from "@excalidraw/common";
+import type { RenderEnvironment } from "@excalidraw/element";
+import type { ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement, Theme } from "@excalidraw/element/types";
+import { cleanAppStateForExport } from "../appState";
 import type { AppState, BinaryFiles } from "../types";
-export declare const exportToCanvas: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, exportingFrame, }: {
-    exportBackground: boolean;
-    exportPadding?: number;
-    viewBackgroundColor: string;
+export type ExportSceneData = {
+    elements: readonly NonDeletedExcalidrawElement[];
+    /**
+     * The scene settings a `.excalidraw` file stores (`viewBackgroundColor`,
+     * grid settings) — not editor state. Used as the default background
+     * (`canvasBackgroundColor`) and embedded with the scene (`embedScene`).
+     * Anything else passed in is ignored; rendering options go to `config`.
+     */
+    appState?: ReturnType<typeof cleanAppStateForExport>;
+    files?: BinaryFiles | null;
+};
+/**
+ * The host capabilities an export uses, shared by every format: e.g. for test
+ * environments, Node.js or another window.
+ *
+ * Unlike the editor's `renderEnvironment` prop, this needn't be the same
+ * object across exports (e.g. on a server): exports draw without the element
+ * caches keyed by an environment, and measure little text. Passing a complete
+ * one (`createCanvas` and `createImage`) as-is, as the editor does, only keeps
+ * its measuring caches warm.
+ */
+type ExportEnvironment = {
+    /**
+     * Creates the canvas a canvas/PNG/JPEG export renders into, and any canvas
+     * the export measures text with (e.g. frame labels, embed placeholders).
+     *
+     * Do not set `canvas.width/height` or modify the canvas context as that's
+     * handled by Excalidraw.
+     *
+     * Defaults to `document.createElement("canvas")`.
+     */
+    createCanvas?: RenderEnvironment["createCanvas"];
+    /**
+     * Creates the images that image elements are decoded into.
+     *
+     * Defaults to `new Image()`.
+     */
+    createImage?: RenderEnvironment["createImage"];
+    /**
+     * Creates the paths that freedraw elements are filled through.
+     *
+     * Defaults to the global `Path2D`.
+     */
+    createPath?: RenderEnvironment["createPath"];
+    /**
+     * The document an SVG export is built in, e.g. a popout window's or,
+     * outside the browser, a DOM implementation's (such as `linkedom`).
+     *
+     * Defaults to the global `document`.
+     */
+    document?: RenderEnvironment["document"];
+    /**
+     * Measures text (frame labels, embed placeholders), e.g. where there is no
+     * canvas to measure on.
+     *
+     * Defaults to the global provider set with `setCustomTextMetricsProvider`,
+     * else to measuring on a canvas from `createCanvas`.
+     */
+    textMetrics?: RenderEnvironment["textMetrics"];
+    /**
+     * Loads the fonts the exported elements use, before rendering.
+     *
+     * Defaults to loading them through the browser's
+     * [FontFace API](https://developer.mozilla.org/en-US/docs/Web/API/FontFace).
+     */
+    loadFonts?: () => Promise<void>;
+};
+type ExportSceneBaseConfig = {
+    /**
+     * @default "light"
+     */
+    theme?: Theme;
+    /**
+     * Canvas background. Valid values are:
+     *
+     * - `undefined` - the background of "appState.viewBackgroundColor" is used.
+     * - `false` - no background is used (transparent). Not supported for JPEG,
+     *   which falls back to the default.
+     * - `string` - should be a valid CSS color.
+     *
+     * Specified in light-theme terms: `theme: "dark"` transforms it like any
+     * other scene color. Only affects the rendered image, not the embedded
+     * scene (`embedScene`).
+     *
+     * @default undefined
+     */
+    canvasBackgroundColor?: string | false;
+    /**
+     * Canvas padding in pixels. Affected by `scale`.
+     *
+     * When `fit` is `none`, padding is added around the content bounding box,
+     * or around the `width`/`height` frame if set — in which case the content
+     * may overflow the frame, thus right or bottom padding may be ignored.
+     *
+     * When `fit` is `contain`, or `maxWidthOrHeight`/`widthOrHeight` is set,
+     * padding is subtracted from the target size (so the export doesn't exceed
+     * it, `scale` aside), and serves as a minimum distance between the content
+     * and the canvas edges — it may be exceeded on one axis to maintain the
+     * aspect ratio. It is recommended to set `position` to `center` when using
+     * `fit: "contain"`.
+     *
+     * @default 10
+     */
+    padding?: number;
+    /**
+     * A multiplier to increase/decrease the frame dimensions
+     * (content resolution).
+     *
+     * For example, if your canvas is 300x150 and you set scale to 2, the
+     * resulting size will be 600x300.
+     *
+     * Can be a function, which receives the export dimensions at scale 1
+     * (padding included) and returns the multiplier — e.g. to cap the output
+     * by a pixel budget.
+     *
+     * @default 1
+     */
+    scale?: number | ((width: number, height: number) => number);
+    /**
+     * Host environment overrides, e.g. for test environments or Node.js.
+     */
+    environment?: ExportEnvironment;
     exportingFrame?: NonDeleted<ExcalidrawFrameLikeElement> | null;
-}, createCanvas?: (width: number, height: number) => {
-    canvas: HTMLCanvasElement;
+    /**
+     * Which frame decorations to render. Ignored when exporting a single frame
+     * (`exportingFrame`), which renders neither its name nor outline, and clips
+     * to it.
+     *
+     * @default { name: true, outline: true, clip: true }
+     */
+    frames?: {
+        name?: boolean;
+        outline?: boolean;
+        clip?: boolean;
+    };
+};
+/**
+ * The ways to size the export — only one can be used. The positioning options
+ * (`fit`, `position`, `x`, `y`, `origin`) belong to `width`/`height` (or no
+ * size option).
+ */
+type ExportSizeOptions = {
+    /**
+     * Makes sure the canvas content fits into a frame of width/height no larger
+     * than this value, while maintaining the aspect ratio.
+     *
+     * Final dimensions can get smaller/larger if used in conjunction with
+     * `scale`.
+     *
+     * Can't be combined with `width`/`height`, `widthOrHeight`, or the
+     * positioning options (`fit`, `position`, `x`, `y`, `origin`).
+     */
+    maxWidthOrHeight?: number;
+    /**
+     * Scale the canvas content to be exactly this many pixels wide/tall,
+     * maintaining the aspect ratio.
+     *
+     * Final dimensions can get smaller/larger if used in conjunction with
+     * `scale`.
+     *
+     * Can't be combined with `width`/`height`, `maxWidthOrHeight`, or the
+     * positioning options (`fit`, `position`, `x`, `y`, `origin`).
+     */
+    widthOrHeight?: number;
+    /**
+     * Width of the frame. Supply `x` or `y` if you want to offset the canvas
+     * content.
+     *
+     * If `width` omitted but `height` supplied, `width` is calculated from the
+     * content's aspect ratio when `fit` is `contain` (the default), or is the
+     * content bounding box width when `fit` is `none`.
+     *
+     * Defaults to the content bounding box width when both `width` and `height`
+     * are omitted.
+     *
+     * Can't be combined with `maxWidthOrHeight` or `widthOrHeight`.
+     */
+    width?: number;
+    /**
+     * Height of the frame.
+     *
+     * If `height` omitted but `width` supplied, `height` is calculated from the
+     * content's aspect ratio when `fit` is `contain` (the default), or is the
+     * content bounding box height when `fit` is `none`.
+     *
+     * Defaults to the content bounding box height when both `width` and `height`
+     * are omitted.
+     *
+     * Can't be combined with `maxWidthOrHeight` or `widthOrHeight`.
+     */
+    height?: number;
+    /**
+     * Left edge of the exported region (`padding` is added around it). By
+     * default the coordinate is relative to the canvas. You can switch to
+     * content coordinates by setting `origin` to `content`.
+     *
+     * Defaults to the `x` position of the content bounding box.
+     *
+     * Can't be combined with `maxWidthOrHeight` or `widthOrHeight`, and is
+     * ignored with `fit: "contain"`, so setting `x` or `y` makes `fit` default
+     * to `none` (cropping the region).
+     */
+    x?: number;
+    /**
+     * Top edge of the exported region (`padding` is added around it). By
+     * default the coordinate is relative to the canvas. You can switch to
+     * content coordinates by setting `origin` to `content`.
+     *
+     * Defaults to the `y` position of the content bounding box.
+     *
+     * Can't be combined with `maxWidthOrHeight` or `widthOrHeight`, and is
+     * ignored with `fit: "contain"`, so setting `x` or `y` makes `fit` default
+     * to `none` (cropping the region).
+     */
+    y?: number;
+    /**
+     * Indicates the coordinate system of the `x` and `y` values.
+     *
+     * - `canvas` - `x` and `y` are relative to the canvas [0, 0] position.
+     * - `content` - `x` and `y` are relative to the content bounding box.
+     *
+     * Can't be combined with `maxWidthOrHeight` or `widthOrHeight`.
+     *
+     * @default "canvas"
+     */
+    origin?: "canvas" | "content";
+    /**
+     * How the content should be scaled into the `width`/`height` frame.
+     *
+     * Behavior aligns with the `object-fit` CSS property.
+     *
+     * - `none`    - no scaling.
+     * - `contain` - scale to fit the frame. Includes `padding`.
+     *
+     * Can't be combined with `maxWidthOrHeight` or `widthOrHeight`.
+     *
+     * @default "contain" if `width` or `height` is set (and `x`/`y` aren't),
+     * otherwise "none"
+     */
+    fit?: "none" | "contain";
+    /**
+     * When either `x` or `y` are not specified, indicates how the canvas should
+     * be aligned on the respective axis.
+     *
+     * - `topLeft` - canvas aligned to top left.
+     * - `center`  - canvas is centered on the axis which is not specified
+     *               (or both).
+     *
+     * Can't be combined with `maxWidthOrHeight` or `widthOrHeight`.
+     *
+     * @default "center"
+     */
+    position?: "center" | "topLeft";
+};
+type ExportSizeOption<K extends keyof ExportSizeOptions> = Pick<ExportSizeOptions, K> & {
+    [P in keyof ExportSizeOptions as P extends K ? never : P]?: never;
+};
+type ExportSizeConfig = ExportSizeOption<"width" | "height" | "fit" | "position" | "x" | "y" | "origin"> | ExportSizeOption<"maxWidthOrHeight"> | ExportSizeOption<"widthOrHeight">;
+export type ExportSceneConfig = ExportSceneBaseConfig & ExportSizeConfig;
+/**
+ * The export config the editor's export settings translate to. Internal: hosts
+ * pass their own config.
+ */
+export declare const getExportConfigFromAppState: (appState: Pick<AppState, "exportWithDarkMode" | "exportBackground" | "viewBackgroundColor" | "exportScale" | "frameRendering">) => {
+    theme: "light" | "dark";
+    canvasBackgroundColor: string | false;
     scale: number;
-}, loadFonts?: () => Promise<void>) => Promise<HTMLCanvasElement>;
-export declare const exportToSvg: (elements: readonly NonDeletedExcalidrawElement[], appState: {
-    exportBackground: boolean;
-    exportPadding?: number;
-    exportScale?: number;
-    viewBackgroundColor: string;
-    exportWithDarkMode?: boolean;
-    exportEmbedScene?: boolean;
-    frameRendering?: AppState["frameRendering"];
-}, files: BinaryFiles | null, opts?: {
+    frames: {
+        enabled: boolean;
+        name: boolean;
+        outline: boolean;
+        clip: boolean;
+    } | {
+        name: boolean;
+        outline: boolean;
+        clip: boolean;
+    };
+};
+type ExportToSvgConfig = Pick<ExportSceneBaseConfig, "canvasBackgroundColor" | "padding" | "theme" | "exportingFrame" | "scale" | "frames" | "environment"> & ExportSizeConfig & {
     /**
      * if true, all embeddables passed in will be rendered when possible.
      */
     renderEmbeddables?: boolean;
-    exportingFrame?: NonDeleted<ExcalidrawFrameLikeElement> | null;
     skipInliningFonts?: true;
     reuseImages?: boolean;
-}) => Promise<SVGSVGElement>;
+    /**
+     * Embeds the scene into the SVG, so that it can be imported back into
+     * Excalidraw.
+     */
+    embedScene?: boolean;
+};
 export declare const encodeSvgBase64Payload: ({ payload, metadataElement, }: {
     payload: string;
     metadataElement: SVGMetadataElement;
@@ -33,4 +301,59 @@ export declare const encodeSvgBase64Payload: ({ payload, metadataElement, }: {
 export declare const decodeSvgBase64Payload: ({ svg }: {
     svg: string;
 }) => string;
-export declare const getExportSize: (elements: readonly NonDeletedExcalidrawElement[], exportPadding: number, scale: number) => [number, number];
+export { MIME_TYPES };
+type ExportToPngConfig = ExportSceneConfig & {
+    /**
+     * Embeds the scene into the PNG metadata, so that it can be imported back
+     * into Excalidraw.
+     */
+    embedScene?: boolean;
+};
+type ExportToJpegConfig = ExportSceneConfig & {
+    /**
+     * Encoding quality between 0 and 1.
+     *
+     * @default 0.92
+     */
+    quality?: number;
+};
+export type ExportSceneOptions = {
+    data: ExportSceneData;
+} & ({
+    type: "canvas";
+    config?: ExportSceneConfig;
+} | {
+    type: "png";
+    config?: ExportToPngConfig;
+} | {
+    type: "jpeg";
+    config?: ExportToJpegConfig;
+} | {
+    type: "svg";
+    config?: ExportToSvgConfig;
+});
+/**
+ * Exports the scene to a canvas, a PNG or JPEG blob, or an SVG element.
+ */
+export declare function exportScene(opts: Extract<ExportSceneOptions, {
+    type: "canvas";
+}>): Promise<HTMLCanvasElement>;
+export declare function exportScene(opts: Extract<ExportSceneOptions, {
+    type: "png" | "jpeg";
+}>): Promise<Blob>;
+export declare function exportScene(opts: Extract<ExportSceneOptions, {
+    type: "svg";
+}>): Promise<SVGSVGElement>;
+export declare function exportScene(opts: ExportSceneOptions): Promise<HTMLCanvasElement | Blob | SVGSVGElement>;
+export declare const exportToClipboard: (opts: {
+    data: ExportSceneData;
+} & ({
+    type: "png";
+    config?: ExportToPngConfig;
+} | {
+    type: "svg";
+    config?: ExportToSvgConfig;
+} | {
+    type: "json";
+    config?: never;
+})) => Promise<void>;

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

@@ -1,12 +1,28 @@
 import type { UserIdleState, EditorInterface } from "@excalidraw/common";
-import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
+import type { ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
 import type { MakeBrand } from "@excalidraw/common/utility-types";
+import type { RenderEnvironment } from "@excalidraw/element/renderEnvironment";
 import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementRenderOverrides, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, PendingExcalidrawElements } from "../types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
 import type { Drawable } from "roughjs/bin/core";
 export type RenderableElementsMap = NonDeletedElementsMap & MakeBrand<"RenderableElementsMap">;
 export type StaticCanvasRenderConfig = {
     canvasBackgroundColor: AppState["viewBackgroundColor"];
+    /**
+     * Backing-store scale the target canvas was bootstrapped with -- the owner
+     * window's devicePixelRatio when rendering into the editor, exportScale when
+     * exporting. Element caches are built and blitted at this ratio, so it must
+     * be the same value passed as `StaticSceneRenderConfig["scale"]`.
+     */
+    scale: number;
+    /**
+     * Host environment that creates the canvases and images this render
+     * rasterizes (per-editor owner window in the app; the export's
+     * `config.environment` when exporting). Defaults to the browser's.
+     */
+    renderEnvironment?: RenderEnvironment;
+    /** export only: clips everything drawn to this frame (square corners) */
+    clipToFrame?: ExcalidrawFrameLikeElement | null;
     imageCache: AppClassProperties["imageCache"];
     renderGrid: boolean;
     /** whether to render link icons on elements with links (never rendered
@@ -22,6 +38,12 @@ export type StaticCanvasRenderConfig = {
     elementRenderOverrides?: ElementRenderOverrides;
 };
 export type SVGRenderConfig = {
+    /**
+     * Host environment used for the text measurements this render needs (the
+     * SVG itself is built through `exportToSvg`'s owner document). Defaults to
+     * the browser's.
+     */
+    renderEnvironment?: RenderEnvironment;
     offsetX: number;
     offsetY: number;
     isExporting: boolean;

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

@@ -3,7 +3,7 @@ import type { LinearElementEditor } from "@excalidraw/element";
 import type { ListMarkerAdvance, MaybeTransformHandleType } from "@excalidraw/element";
 import type { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, ExcalidrawArrowElement, Arrowhead, FontFamilyValues, FileId, Theme, StrokeRoundness, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeLikeElement, OrderedExcalidrawElement, ExcalidrawNonSelectionElement, BindMode, ExcalidrawTextElement, StrokeVariability } from "@excalidraw/element/types";
 import type { Merge, MaybePromise, ValueOf, MakeBrand } from "@excalidraw/common/utility-types";
-import type { CaptureUpdateActionType, DurableIncrement, EphemeralIncrement, OnDuplicateData } from "@excalidraw/element";
+import type { CaptureUpdateActionType, DurableIncrement, EphemeralIncrement, RenderEnvironment, OnDuplicateData } from "@excalidraw/element";
 import type { GlobalPoint } from "@excalidraw/math";
 import type { Action } from "./actions/types";
 import type { Spreadsheet } from "./charts";
@@ -692,6 +692,30 @@ export interface ExcalidrawProps {
      * @default document
      */
     ownerDocument?: Document;
+    /**
+     * Host environment used by the renderer and export pipeline to create
+     * canvases and images. Supply a custom implementation to redirect canvas
+     * creation and image decoding to e.g. a host canvas pool, an
+     * `OffscreenCanvas`, or a non-DOM image decoder. When omitted, canvas and
+     * image creation fall back to `ownerDocument` / `ownerWindow`.
+     *
+     * The value must be referentially stable -- every render cache (element
+     * canvases, text metrics, char widths, link icons) is keyed by this
+     * object's identity, so a new identity is a full cache miss. Passing an
+     * inline object literal mints a fresh identity on every React render,
+     * which silently re-rasterizes every element on every frame; hoist it to a
+     * module constant or memoize it (e.g. `useMemo`) instead.
+     *
+     * Only `createCanvas` and `createImage` are required. `createPath` (used to
+     * fill freedraw strokes) falls back to the global `Path2D`, which every
+     * browser has -- a non-browser host without one must supply it. Pass
+     * `document` (the owner document) for SVG exports to be built in it rather
+     * than in the global `document`, and `textMetrics` to measure the editor's
+     * text with your own provider.
+     *
+     * @default { createCanvas: () => ownerDocument.createElement("canvas"), createImage: () => new ownerWindow.Image(), createPath: (d) => new ownerWindow.Path2D(d), document: ownerDocument }
+     */
+    renderEnvironment?: RenderEnvironment;
     onChange?: (elements: readonly OrderedExcalidrawElement[], appState: AppState, files: BinaryFiles) => void;
     onThemeChange?: (theme: Theme | "system") => void;
     /**
@@ -960,6 +984,7 @@ export type AppClassProperties = {
     state: AppState;
     readonly ownerDocument: Document;
     readonly ownerWindow: Window & typeof globalThis;
+    renderEnvironment: RenderEnvironment;
     api: App["api"];
     sessionExportThemeOverride: App["sessionExportThemeOverride"];
     interactiveCanvas: HTMLCanvasElement | null;
@@ -1000,6 +1025,9 @@ export type AppClassProperties = {
     duplicate: App["duplicate"];
     toolDrag: App["toolDrag"];
     activeResizeHandle: App["activeResizeHandle"];
+    selectionTool: App["selectionTool"];
+    wrap: App["wrap"];
+    modifiers: App["modifiers"];
     isToolLocked: App["isToolLocked"];
     getEffectiveGridSize: App["getEffectiveGridSize"];
     setPlugins: App["setPlugins"];
@@ -1052,6 +1080,7 @@ export type PointerDownState = Readonly<{
         element: NonDeleted<ExcalidrawElement> | null;
         allHitElements: NonDeleted<ExcalidrawElement>[];
         wasAddedToSelection: boolean;
+        cycleTarget: NonDeleted<ExcalidrawElement> | null;
         hasBeenDuplicated: boolean;
         advancedListMarkers: readonly ListMarkerAdvance[];
         editedTextId: ExcalidrawTextElement["id"] | null;
@@ -1069,6 +1098,10 @@ export type PointerDownState = Readonly<{
             x: number;
             y: number;
         };
+        lastOffset: {
+            x: number;
+            y: number;
+        };
         blockDragging: boolean;
     };
     eventListeners: {
@@ -1104,6 +1137,21 @@ export interface ExcalidrawImperativeAPI {
     history: {
         clear: InstanceType<typeof App>["resetHistory"];
     };
+    /**
+     * Selects elements (or their ids — one or many), adds them to or removes
+     * them from the selection, or clears it — as the editor does: an element is
+     * selected with its group (unless `deep`), a frame and its children aren't
+     * selected at the same time, and locked elements are skipped (unless
+     * `includeLocked`). Text editing and cropping end, and the link popup of a
+     * lone selected element shows. Missing and deleted elements are skipped.
+     *
+     * By default the change is recorded for undo along with the next undoable
+     * change — pass `captureUpdate` as for `updateScene()` otherwise. Like
+     * `updateScene()`, it applies on the next render: read it back through
+     * `onChange()` or `getAppState()` after that. Works in view mode too, where
+     * the selection shows without transform handles.
+     */
+    selection: Pick<InstanceType<typeof App>["selection"], "select" | "add" | "remove" | "clear">;
     getSceneElements: InstanceType<typeof App>["getSceneElements"];
     getAppState: () => InstanceType<typeof App>["state"];
     getFiles: () => InstanceType<typeof App>["files"];

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

@@ -1,3 +1,5 @@
-export * from "./export";
+export { exportScene, exportToClipboard, MIME_TYPES, } from "@excalidraw/excalidraw/scene/export";
+export type { ExportSceneData, ExportSceneConfig, ExportSceneOptions, } from "@excalidraw/excalidraw/scene/export";
 export { elementsOverlappingBBox } from "@excalidraw/element";
 export { getCommonBounds } from "@excalidraw/element";
+export type { RenderEnvironment } from "@excalidraw/element";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@excalidraw/math",
-  "version": "0.18.0-4ce38fb",
+  "version": "0.18.0-4ce8305",
   "type": "module",
   "types": "./dist/types/math/src/index.d.ts",
   "main": "./dist/prod/index.js",
@@ -61,6 +61,6 @@
     "build:esm": "rimraf dist && node ../../scripts/buildBase.js && yarn gen:types"
   },
   "dependencies": {
-    "@excalidraw/common": "0.18.0-4ce38fb"
+    "@excalidraw/common": "0.18.0-4ce8305"
   }
 }

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

@@ -1,36 +0,0 @@
-import { MIME_TYPES } from "@excalidraw/common";
-import type { ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
-import type { AppState, BinaryFiles } from "@excalidraw/excalidraw/types";
-export { MIME_TYPES };
-type ExportOpts = {
-    /** restored before exporting */
-    elements: readonly NonDeletedExcalidrawElement[];
-    appState?: Partial<Omit<AppState, "offsetTop" | "offsetLeft">>;
-    files: BinaryFiles | null;
-    maxWidthOrHeight?: number;
-    exportingFrame?: NonDeleted<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>;