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

package/dist/types/excalidraw/components/TopPicksDnD/topPicksDnD.d.ts

@@ -17,7 +17,7 @@ export type TopPicksDragState<T> = {
     slotSpan: number;
 } | null;
 export type TopPicksGhost = {
-    /** the ghost's visual. Rendered into `document.body` — outside the
+    /** the ghost's visual. Rendered into the source's `document.body` — outside the
      * editor's CSS scope, so theme-dependent styling must be resolved from the
      * rendered DOM (computed styles) rather than CSS variables */
     content: HTMLElement;

package/dist/types/excalidraw/components/canvases/InteractiveCanvas.d.ts

@@ -31,6 +31,5 @@ type InteractiveCanvasProps = {
     onPointerDown: Exclude<DOMAttributes<HTMLCanvasElement>["onPointerDown"], undefined>;
     onDoubleClick: Exclude<DOMAttributes<HTMLCanvasElement>["onDoubleClick"], undefined>;
 };
-export declare const INTERACTIVE_SCENE_ANIMATION_KEY = "animateInteractiveScene";
 declare const _default: React.MemoExoticComponent<(props: InteractiveCanvasProps) => import("react/jsx-runtime").JSX.Element>;
 export default _default;

package/dist/types/excalidraw/components/hyperlink/Hyperlink.d.ts

@@ -2,6 +2,7 @@ import type { Scene } from "@excalidraw/element";
 import type { ElementsMap, ExcalidrawEmbeddableElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import "./Hyperlink.scss";
 import type { AppState, ExcalidrawProps, UIAppState } from "../../types";
+export type HyperlinkTooltipOwner = Record<string, unknown>;
 export declare const Hyperlink: ({ element, scene, setAppState, onLinkOpen, setToast, updateEmbedValidationStatus, }: {
     element: NonDeletedExcalidrawElement;
     scene: Scene;
@@ -15,5 +16,5 @@ export declare const Hyperlink: ({ element, scene, setAppState, onLinkOpen, setT
     updateEmbedValidationStatus: (element: ExcalidrawEmbeddableElement, status: boolean) => void;
 }) => import("react/jsx-runtime").JSX.Element | null;
 export declare const getContextMenuLabel: (elements: readonly NonDeletedExcalidrawElement[], appState: UIAppState) => "labels.link.editEmbed" | "labels.link.edit" | "labels.link.create";
-export declare const showHyperlinkTooltip: (element: NonDeletedExcalidrawElement, appState: AppState, elementsMap: ElementsMap) => void;
-export declare const hideHyperlinkToolip: () => void;
+export declare const showHyperlinkTooltip: (element: NonDeletedExcalidrawElement, appState: AppState, elementsMap: ElementsMap, ownerDocument: Document, owner: HyperlinkTooltipOwner) => void;
+export declare const hideHyperlinkToolip: (owner?: HyperlinkTooltipOwner) => void;

package/dist/types/excalidraw/components/hyperlink/helpers.d.ts

@@ -1,10 +1,21 @@
+import type { RenderEnvironment } from "@excalidraw/element/renderEnvironment";
 import type { GlobalPoint, Radians } from "@excalidraw/math";
 import type { Bounds } from "@excalidraw/common";
 import type { ElementsMap, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { AppState } from "../../types";
 export declare const DEFAULT_LINK_SIZE = 12;
-export declare const EXTERNAL_LINK_IMG: HTMLImageElement;
-export declare const ELEMENT_LINK_IMG: HTMLImageElement;
+type SettledLinkImgStatus = Exclude<LinkImgStatus, "decoding">;
+export type LinkImgStatus = "decoding" | "decoded" | "failed";
+export type LinkImg = {
+    /** Only safe as a `drawImage` source while `status` is `decoded`. */
+    img: HTMLImageElement;
+    status: LinkImgStatus;
+    settled: Promise<SettledLinkImgStatus>;
+};
+export declare const getExternalLinkImg: (renderEnvironment: RenderEnvironment) => LinkImg;
+export declare const getElementLinkImg: (renderEnvironment: RenderEnvironment) => LinkImg;
+export declare const startLinkImgDecoding: (renderEnvironment: RenderEnvironment) => Promise<boolean>;
 export declare const getLinkHandleFromCoords: ([x1, y1, x2, y2]: Bounds, angle: Radians, appState: Pick<AppState, "zoom">) => Bounds;
 export declare const isPointHittingLinkIcon: (element: NonDeletedExcalidrawElement, elementsMap: ElementsMap, appState: AppState, [x, y]: GlobalPoint) => boolean;
 export declare const isPointHittingLink: (element: NonDeletedExcalidrawElement, elementsMap: ElementsMap, appState: AppState, [x, y]: GlobalPoint, isMobile: boolean) => boolean;
+export {};

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

@@ -34,6 +34,8 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
             name: string | null;
             currentItemArrowType: "sharp" | "round" | "elbow";
             gridSize: number;
+            scrollX: number;
+            scrollY: number;
             contextMenu: {
                 items: import("../components/ContextMenu").ContextMenuItems;
                 top: number;
@@ -109,8 +111,6 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
             currentHoveredFontFamily: import("@excalidraw/element/types").FontFamilyValues | null;
             currentItemRoundness: import("@excalidraw/element/types").StrokeRoundness;
             viewBackgroundColor: string;
-            scrollX: number;
-            scrollY: number;
             scrollConstraints: import("../types").ScrollConstraints | null;
             cursorButton: "up" | "down";
             scrolledOutside: boolean;
@@ -222,6 +222,8 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
         name: string | null;
         currentItemArrowType: "sharp" | "round" | "elbow";
         gridSize: number;
+        scrollX: number;
+        scrollY: number;
         contextMenu: {
             items: import("../components/ContextMenu").ContextMenuItems;
             top: number;
@@ -297,8 +299,6 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
         currentHoveredFontFamily: import("@excalidraw/element/types").FontFamilyValues | null;
         currentItemRoundness: import("@excalidraw/element/types").StrokeRoundness;
         viewBackgroundColor: string;
-        scrollX: number;
-        scrollY: number;
         scrollConstraints: import("../types").ScrollConstraints | null;
         cursorButton: "up" | "down";
         scrolledOutside: boolean;

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

@@ -1,4 +1,5 @@
 import type { ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { RenderEnvironment } from "@excalidraw/element";
 import type { ExportType } from "../scene/types";
 import type { AppState, BinaryFiles } from "../types";
 export { loadFromBlob } from "./blob";
@@ -10,12 +11,11 @@ export declare const prepareElementsForExport: (allElements: readonly Excalidraw
     exportingFrame: NonDeleted<ExcalidrawFrameLikeElement> | null;
     exportedElements: ExportedElements;
 };
-export declare const exportCanvas: (type: Omit<ExportType, "backend">, elements: ExportedElements, appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, name, fileHandle, exportingFrame, }: {
-    exportBackground: boolean;
+export declare const exportCanvas: (type: Omit<ExportType, "backend">, elements: ExportedElements, appState: AppState, files: BinaryFiles, { exportPadding, name, fileHandle, exportingFrame, renderEnvironment, }: {
     exportPadding?: number;
-    viewBackgroundColor: string;
     /** filename, if applicable */
     name?: string;
     fileHandle?: FileSystemFileHandle | null;
     exportingFrame: NonDeleted<ExcalidrawFrameLikeElement> | null;
+    renderEnvironment?: RenderEnvironment;
 }) => Promise<FileSystemFileHandle | null | undefined>;

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

@@ -32,6 +32,8 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
         name: string | null;
         currentItemArrowType: "sharp" | "round" | "elbow";
         gridSize: number;
+        scrollX: number;
+        scrollY: number;
         contextMenu: {
             items: import("../components/ContextMenu").ContextMenuItems;
             top: number;
@@ -107,8 +109,6 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
         currentHoveredFontFamily: import("@excalidraw/element/types").FontFamilyValues | null;
         currentItemRoundness: import("@excalidraw/element/types").StrokeRoundness;
         viewBackgroundColor: string;
-        scrollX: number;
-        scrollY: number;
         scrollConstraints: import("../types").ScrollConstraints | null;
         cursorButton: "up" | "down";
         scrolledOutside: boolean;

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

@@ -1,5 +1,5 @@
 import { type FontMetadata } from "@excalidraw/common";
-import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { ExcalidrawElement, ExcalidrawTextElement } from "@excalidraw/element/types";
 import type { Scene } from "@excalidraw/element";
 import { ExcalidrawFontFace } from "./ExcalidrawFontFace";
 export declare class Fonts {
@@ -16,6 +16,7 @@ export declare class Fonts {
     }>;
     private readonly scene;
     private readonly ownerDocument;
+    private readonly loadedFonts;
     constructor(scene: Scene, ownerDocument?: Document);
     /**
      * Get all the font families for the given scene.
@@ -33,9 +34,15 @@ export declare class Fonts {
     /**
      * Load font faces for a given scene and trigger scene update.
      */
-    loadSceneFonts: () => Promise<FontFace[]>;
+    loadSceneFonts: (defaultFontFamily?: ExcalidrawTextElement["fontFamily"]) => Promise<FontFace[]>;
     /**
      * Load font faces for passed elements - use when the scene is unavailable (i.e. export).
+     *
+     * Loads into the document's font set, or in a worker into the worker's own
+     * (`self.fonts`, what an `OffscreenCanvas` there measures with). Where there
+     * is neither -- e.g. a DOM shim without `FontFaceSet` (`linkedom`), or Node
+     * -- nothing is loaded: the host makes the fonts available itself, and is
+     * warned once if the elements use fonts that would need loading.
      */
     static loadElementsFonts: (elements: readonly ExcalidrawElement[], ownerDocument?: Document) => Promise<FontFace[]>;
     /**
@@ -69,10 +76,6 @@ export declare class Fonts {
      * Get characters for a given family.
      */
     private static getCharacters;
-    /**
-     * Get all registered font families.
-     */
-    private static getAllFamilies;
 }
 export interface ExcalidrawFontFaceDescriptor {
     uri: string;

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

@@ -1,13 +1,15 @@
 import { Emitter } from "@excalidraw/common";
 import { StoreDelta } from "@excalidraw/element";
-import type { StoreSnapshot, Store } from "@excalidraw/element";
+import type { RenderEnvironment, StoreSnapshot, Store } from "@excalidraw/element";
 import type { SceneElementsMap } from "@excalidraw/element/types";
 import type { AppState } from "./types";
 export declare class HistoryDelta extends StoreDelta {
     /**
      * Apply the delta to the passed elements and appState, does not modify the snapshot.
      */
-    applyTo(elements: SceneElementsMap, appState: AppState, snapshot: StoreSnapshot): [SceneElementsMap, AppState, boolean];
+    applyTo(elements: SceneElementsMap, appState: AppState, snapshot: StoreSnapshot, 
+    /** measures the labels re-laid out after applying */
+    renderEnvironment?: RenderEnvironment): [SceneElementsMap, AppState, boolean];
     /**
      * Overriding once to avoid type casting everywhere.
      */
@@ -40,8 +42,12 @@ export declare class History {
      * Do not re-record history entries, which were already pushed to undo / redo stack, as part of history action.
      */
     record(delta: StoreDelta): void;
-    undo(elements: SceneElementsMap, appState: AppState): void | [SceneElementsMap, AppState];
-    redo(elements: SceneElementsMap, appState: AppState): void | [SceneElementsMap, AppState];
+    undo(elements: SceneElementsMap, appState: AppState, 
+    /** measures the labels re-laid out after undoing (the host's, in the editor) */
+    renderEnvironment?: RenderEnvironment): void | [SceneElementsMap, AppState];
+    redo(elements: SceneElementsMap, appState: AppState, 
+    /** measures the labels re-laid out after redoing (the host's, in the editor) */
+    renderEnvironment?: RenderEnvironment): void | [SceneElementsMap, AppState];
     private perform;
     private static pop;
     private static push;

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

@@ -6,7 +6,7 @@ export declare const withBatchedUpdates: <TFunction extends ((event: any) => voi
  * barches React state updates and throttles the calls to a single call per
  * animation frame
  */
-export declare const withBatchedUpdatesThrottled: <TFunction extends ((event: any) => void) | (() => void)>(func: Parameters<TFunction>["length"] extends 0 | 1 ? TFunction : never) => {
+export declare const withBatchedUpdatesThrottled: <TFunction extends ((event: any) => void) | (() => void)>(func: Parameters<TFunction>["length"] extends 0 | 1 ? TFunction : never, ownerWindow?: Window) => {
     (...args: Parameters<TFunction>): void;
     flush(): void;
     cancel(): void;

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

@@ -1,16 +1,23 @@
+/** String keys are shared process-wide; symbols are created per owning
+ * instance, which lets concurrent instances run the same named animation
+ * independently. */
+export type AnimationKey = string | symbol;
 export type Animation<R extends object> = (params: {
     deltaTime: number;
     state?: R;
 }) => R | null | undefined;
+export type AnimationScheduler = Pick<Window, "requestAnimationFrame" | "cancelAnimationFrame" | "setTimeout" | "clearTimeout">;
 export declare class AnimationController {
-    private static scheduledFrame;
+    private static scheduledFrames;
     private static animations;
-    static start<R extends object>(key: string, animation: Animation<R>): void;
+    private static readonly schedulerCleanups;
+    static start<R extends object>(key: AnimationKey, animation: Animation<R>, scheduler?: AnimationScheduler): void;
     private static scheduleNextFrame;
     private static cancelScheduledFrame;
     private static cancelScheduledFrameIfIdle;
+    private static registerSchedulerCleanup;
     private static tick;
-    static running(key: string): boolean;
-    static cancel(key: string): void;
+    static running(key: AnimationKey): boolean;
+    static cancel(key: AnimationKey): void;
     static reset(): void;
 }

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

@@ -2,12 +2,17 @@ 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;
-    flush(): void;
-    cancel(): void;
-};
+/**
+ * Throttled to animation framerate, one throttle per canvas. A shared
+ * throttle drops all but the last caller's pending frame when multiple
+ * editors render in the same frame, and a module-realm scheduler would run
+ * popout renders on the main window's rAF, which freezes while that window
+ * is hidden.
+ */
+export declare const renderStaticSceneThrottled: (config: StaticSceneRenderConfig) => void;
+/** Drops the canvas' pending frame; the throttle itself is dropped with the
+ * canvas. */
+export declare const cancelStaticSceneThrottle: (canvas: HTMLCanvasElement) => void;
 /**
  * Static scene is the non-ui canvas where we render elements.
  */

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

@@ -494,6 +494,6 @@ export declare class Renderer {
         }) | null;
         canvasNonce: string;
     };
-    destroy(): void;
+    destroy(staticCanvas: HTMLCanvasElement): void;
 }
 export {};

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>;