textmode.js 0.1.9 → 0.2.0-beta.2

package/dist/types/textmode/Textmodifier.d.ts

@@ -2,34 +2,26 @@ import { GLRenderer } from '../rendering/webgl/Renderer';
 import { TextmodeFont } from './font';
 import { TextmodeGrid } from './Grid';
 import { TextmodeCanvas } from './Canvas';
-import { TextmodeConversionPipeline } from './ConversionPipeline';
+import { AnimationController } from './AnimationController';
 import { type TextmodifierContext } from './mixins';
 import type { RenderingCapabilities } from './mixins/RenderingMixin';
 import type { ExportCapabilities } from './mixins/ExportMixin';
 import type { FontCapabilities } from './mixins/FontMixin';
-import type { ConversionCapabilities } from './mixins/ConversionMixin';
-/**
- * Supported capture sources for textmode rendering.
- * @ignore
- */
-export type TextmodeCaptureSource = HTMLCanvasElement | HTMLVideoElement;
+import type { AnimationCapabilities } from './mixins/AnimationMixin';
+import type { GLFramebuffer, Shader } from '../rendering';
 /**
  * Options for creating a {@link Textmodifier} instance.
  */
 export type TextmodeOptions = {
+    /** An existing HTMLCanvasElement to use instead of creating a new one. */
+    canvas?: HTMLCanvasElement;
     /** The font size to use for text rendering. Defaults to 16. */
     fontSize?: number;
-    /**
-     * Automatic rendering mode. Defaults to 'auto'.
-     * - `'manual'`: Requires manual `render()` calls
-     * - `'auto'`: Automatically renders using [requestAnimationFrame](https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame)
-     */
-    renderMode?: 'manual' | 'auto';
     /** Maximum frames per second for auto rendering. Defaults to 60. */
     frameRate?: number;
-    /** The width of the canvas in `standalone` mode. Defaults to 800. */
+    /** The width of the canvas when creating a new canvas. Defaults to 800. */
     width?: number;
-    /** The height of the canvas in `standalone` mode. Defaults to 600. */
+    /** The height of the canvas when creating a new canvas. Defaults to 600. */
     height?: number;
     /**
      * URL or path to a custom font file *(.otf/.ttf)*.
@@ -39,279 +31,61 @@ export type TextmodeOptions = {
     fontSource?: string;
 };
 /**
- * Base class for mixin application
+ * Base class for mixin application.
  */
 declare class TextmodifierCore implements TextmodifierContext {
     _renderer: GLRenderer;
     _font: TextmodeFont;
-    _pipeline: TextmodeConversionPipeline;
     _canvas: TextmodeCanvas;
     _grid: TextmodeGrid;
+    _animationController: AnimationController;
+    _textmodeDrawShader: Shader;
+    _textmodeDrawFramebuffer: GLFramebuffer;
+    _textmodeConversionShader: Shader;
+    $render(): void;
 }
 declare const Textmodifier_base: typeof TextmodifierCore;
 /**
- * Manages textmode rendering on a canvas or video element.
- *
- * Each `Textmodifier` instance applies a `HTMLCanvasElement` with custom WebGL rendering on top of the original content.
+ * Manages textmode rendering on a `HTMLCanvasElement` and provides methods for drawing,
+ * exporting, font management, and animation control.
  *
- * If the `Textmodifier` instance is created in `standalone` mode without a capture source,
- * it simply creates a new `HTMLCanvasElement` to draw on using the `textmode.js` drawing API.
+ * If the `Textmodifier` instance is created without a canvas parameter,
+ * it creates a new `HTMLCanvasElement` to draw on using the `textmode.js` drawing API.
+ * If a canvas is provided, it will use that canvas instead.
  */
 export declare class Textmodifier extends Textmodifier_base {
-    /** The element to capture content from (optional for standalone mode) */
-    private _captureSource;
-    /** Canvas framebuffer for capturing source content */
-    private _canvasFramebuffer;
-    private _resizeObserver;
-    private _mode;
-    private _frameRateLimit;
-    private _animationFrameId;
-    private _lastFrameTime;
-    private _frameInterval;
-    private _isLooping;
-    private _frameRate;
-    private _lastRenderTime;
-    private _frameCount;
-    private _frameTimeHistory;
-    private _frameTimeHistorySize;
     private _isDisposed;
-    private _standalone;
     private _drawCallback;
     private _resizedCallback;
     private _windowResizeListener;
     /**
      * Creates an instance of Textmodifier.
-     * @param source The HTML canvas or video element to capture content from. Pass `null` for standalone mode.
      * @param opts Optional configuration options for the Textmodifier instance.
      * @ignore
      */
-    constructor(source?: TextmodeCaptureSource | null, opts?: TextmodeOptions);
+    constructor(opts?: TextmodeOptions);
     /**
      * Static factory method for creating and initializing a Textmodifier instance.
-     * @param source The HTML canvas or video element to capture content from. Pass `null` for standalone mode.
      * @param opts Optional configuration options for the `Textmodifier` instance.
      * @ignore
      */
-    static create(source?: TextmodeCaptureSource | null, opts?: TextmodeOptions): Promise<Textmodifier>;
+    static create(opts?: TextmodeOptions): Promise<Textmodifier>;
     /**
      * Setup event listeners for resize handling.
      * @ignore
      */
     $setupEventListeners(): void;
     /**
-     * Apply textmode rendering to the canvas.
-     *
-     * **Note:** In `'auto'` mode, this is called automatically.
-     * In `'manual'` mode, you need to call this method when you want to update the textmode rendering.
-     *
-     * @example
-     * ```javascript
-     * // p5.js example
-     *
-     * let textmodifier;
-     *
-     * // p5.js setup function
-     * async function setup() {
-     *
-     *   // Create a p5.js canvas
-     *   const canvas = createCanvas(800, 600);
-     *
-     *   // Create a Textmodifier instance
-     *   textmodifier = await textmode.create(canvas.elt);
-     *
-     *   // Update the rendering mode to 'manual'
-     *   textmodifier.renderMode('manual');
-     * }
-     *
-     * // p5.js draw function
-     * function draw() {
-     *
-     *   // Draw something on the p5.js canvas
-     *   background(220);
-     *   fill(255, 0, 0);
-     *   rect(50, 50, 100, 100);
-     *
-     *   // Apply textmode rendering
-     *   textmodifier.render();
-     * }
-     * ```
-     */
-    render(): void;
-    private _resize;
-    /**
-     * Start automatic rendering
-     */
-    private _startAutoRendering;
-    /**
-     * Update FPS measurement - works for both auto and manual modes
-     * Uses a rolling average for smoother frame rate reporting
-     */
-    private _measureFrameRate;
-    /**
-     * Stop automatic rendering
-     */
-    private _stopAutoRendering;
-    /**
-     * Update the rendering mode.
-     *
-     * - `'manual'`: Requires manual [render](#render) calls
-     * - `'auto'`: Automatically renders using [requestAnimationFrame](https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame)
-     *
-     * @param mode The new rendering mode to set.
-     *
-     * @example
-     * ```javascript
-     * // Fetch a canvas element to apply textmode rendering to
-     * const canvas = document.querySelector('canvas#myCanvas');
-     *
-     * // Create a Textmodifier instance
-     * const textmodifier = await textmode.create(canvas);
-     *
-     * // Update the rendering mode to 'manual'
-     * textmodifier.renderMode('manual');
-     *
-     * // Now you need to call textmodifier.render() manually in your animation loop
-     * ```
-     */
-    renderMode(mode: 'manual' | 'auto'): void;
-    /**
-     * Set the maximum frame rate for auto rendering. If called without arguments, returns the current measured frame rate.
-     * @param fps The maximum frames per second for auto rendering.
-     *
-     * @example
-     * ```javascript
-     * // Fetch a canvas element to apply textmode rendering to
-     * const canvas = document.querySelector('canvas#myCanvas');
-     *
-     * // Create a Textmodifier instance
-     * const textmodifier = await textmode.create(canvas);
-     *
-     * // Set the maximum frame rate to 30 FPS
-     * textmodifier.frameRate(30);
-     * ```
-     */
-    frameRate(fps?: number): number | void;
-    /**
-     * Stop the automatic rendering loop while keeping the render mode as 'auto'.
-     *
-     * This method pauses the render loop without changing the render mode, allowing
-     * it to be resumed later with {@link loop}. This is useful for temporarily pausing
-     * animation while maintaining the ability to restart it.
-     *
-     * **Note:** This only affects rendering when in `'auto'` mode. In `'manual'` mode,
-     * this method has no effect since rendering is already controlled manually.
-     *
-     * @example
-     * ```javascript
-     * // Create a textmodifier instance in auto mode
-     * const textmodifier = await textmode.create(canvas);
-     *
-     * // The render loop is running automatically
-     * console.log(textmodifier.isLooping()); // true
-     *
-     * // Stop the automatic rendering loop
-     * textmodifier.noLoop();
-     * console.log(textmodifier.isLooping()); // false
-     *
-     * // Resume the automatic rendering loop
-     * textmodifier.loop();
-     * console.log(textmodifier.isLooping()); // true
-     * ```
-     */
-    noLoop(): void;
-    /**
-     * Resume the automatic rendering loop if it was stopped by {@link noLoop}.
-     *
-     * This method restarts the render loop when in `'auto'` mode. If the render mode
-     * is `'manual'`, the loop state will be set but automatic rendering will not start
-     * until the mode is changed back to `'auto'`.
-     *
-     * @example
-     * ```javascript
-     * // Create a textmodifier instance
-     * const textmodifier = await textmode.create(canvas);
-     *
-     * // Stop the loop
-     * textmodifier.noLoop();
-     *
-     * // Resume the loop
-     * textmodifier.loop();
-     *
-     * // You can also use this pattern for conditional animation
-     * if (someCondition) {
-     *   textmodifier.loop();
-     * } else {
-     *   textmodifier.noLoop();
-     * }
-     * ```
-     */
-    loop(): void;
-    /**
-     * Execute the render function a specified number of times.
-     *
-     * This method is useful when the render loop has been stopped with {@link noLoop}
-     * or when in `'manual'` mode, allowing you to trigger rendering on demand.
-     * Similar to p5.js's `redraw()` function.
-     *
-     * @param n The number of times to execute the render function. Defaults to 1.
-     *
-     * @example
-     * ```javascript
-     * // Create a textmodifier instance
-     * const textmodifier = await textmode.create(canvas, { renderMode: 'manual' });
-     *
-     * // Set up drawing
-     * textmodifier.draw(() => {
-     *   textmodifier.background(0);
-     *   textmodifier.fill(255, 0, 0);
-     *   textmodifier.rect(100, 100, 200, 150);
-     * });
-     *
-     * // Render once manually
-     * textmodifier.redraw();
-     *
-     * // Render 5 times
-     * textmodifier.redraw(5);
-     *
-     * // Also useful when loop is stopped
-     * textmodifier.noLoop();
-     * textmodifier.redraw(3); // Render 3 times despite loop being stopped
-     * ```
+     * Renders the current frame.
+     * @returns void
+     * @ignore
      */
-    redraw(n?: number): void;
+    $render(): void;
     /**
-     * Check whether the textmodifier is currently running the automatic render loop.
-     *
-     * Returns `true` when both the render mode is `'auto'` AND the loop is active.
-     * Returns `false` when in `'manual'` mode or when {@link noLoop} has been called.
-     *
-     * @returns True if the automatic render loop is currently active, false otherwise.
-     *
-     * @example
-     * ```javascript
-     * const textmodifier = await textmode.create(canvas);
-     *
-     * // Check loop status in different states
-     * console.log(textmodifier.isLooping()); // true (auto mode, looping)
-     *
-     * textmodifier.noLoop();
-     * console.log(textmodifier.isLooping()); // false (auto mode, not looping)
-     *
-     * textmodifier.renderMode('manual');
-     * console.log(textmodifier.isLooping()); // false (manual mode)
+     * Set a draw callback function that will be executed before each render.
      *
-     * textmodifier.renderMode('auto');
-     * console.log(textmodifier.isLooping()); // false (auto mode, but loop was stopped)
+     * This callback function is where all drawing commands should be placed for textmode rendering.
      *
-     * textmodifier.loop();
-     * console.log(textmodifier.isLooping()); // true (auto mode, looping)
-     * ```
-     */
-    isLooping(): boolean;
-    /**
-     * Set a draw callback function that will be executed before each render.
-     * This method is primarily useful for standalone textmodifier instances,
-     * but can also be used to draw on top of the captured video or canvas.
      * @param callback The function to call before each render
      *
      * @example
@@ -327,9 +101,8 @@ export declare class Textmodifier extends Textmodifier_base {
      *   // Set background color
      *   t.background(128);
      *
-     *   // Draw some content
-     *   t.fill(255, 0, 0); // Set fill color to red
-     *   t.rect(50, 50, 100, 100);
+     *   // Draw a textmode rectangle with default settings
+     *   t.rect(0, 0, 16, 16);
      * });
      * ```
      */
@@ -351,9 +124,7 @@ export declare class Textmodifier extends Textmodifier_base {
      *   // Set background color
      *   t.background(128);
      *
-     *   // Draw some content
-     *   t.fill(255, 0, 0); // Set fill color to red
-     *   t.rect(50, 50, 100, 100);
+     *   // todo...
      * });
      *
      * // Set up window resize callback
@@ -365,9 +136,8 @@ export declare class Textmodifier extends Textmodifier_base {
      */
     windowResized(callback: () => void): void;
     /**
-     * Resize the `textmode.js` canvas.
+     * Resize the canvas and adjust all related components accordingly.
      *
-     * Can only be used in `standalone` mode since the textmode canvas otherwise automatically adjusts to the video/canvas size.
      * @param width The new width of the canvas.
      * @param height The new height of the canvas.
      */
@@ -377,15 +147,12 @@ export declare class Textmodifier extends Textmodifier_base {
      *
      * After calling this method, the instance should not be used and will be eligible for garbage collection.
      *
-     * This method is idempotent and safe to call multiple times.
-     *
      * @example
      * ```javascript
      * // Create a textmodifier instance
-     * const textmodifier = await textmode.create(canvas);
+     * const textmodifier = await textmode.create();
      *
-     * // Use it for rendering
-     * textmodifier.render();
+     * // ...
      *
      * // When done, completely clean up
      * textmodifier.destroy();
@@ -398,25 +165,17 @@ export declare class Textmodifier extends Textmodifier_base {
     get grid(): TextmodeGrid;
     /** Get the current font object used for rendering. */
     get font(): TextmodeFont;
-    /** Get the current rendering mode.*/
-    get mode(): 'manual' | 'auto';
-    /** Get the current textmode conversion pipeline. */
-    get pipeline(): TextmodeConversionPipeline;
-    /** Get the current frame count. */
-    get frameCount(): number;
-    /** Get the WebGL renderer. */
-    get renderer(): GLRenderer;
-    /** Set the current frame count. */
-    set frameCount(value: number);
     /** Get the width of the canvas. */
     get width(): number;
     /** Get the height of the canvas. */
     get height(): number;
     /** Get the textmodifier canvas containing the rendered output. */
-    get canvas(): TextmodeCanvas;
+    get canvas(): HTMLCanvasElement;
     /** Check if the instance has been disposed/destroyed. */
     get isDisposed(): boolean;
+    /** Get the draw framebuffer used for offscreen rendering. @ignore */
+    get drawFramebuffer(): any;
 }
-export interface Textmodifier extends RenderingCapabilities, ExportCapabilities, FontCapabilities, ConversionCapabilities {
+export interface Textmodifier extends RenderingCapabilities, ExportCapabilities, FontCapabilities, AnimationCapabilities {
 }
 export {};

package/dist/types/textmode/font/CharacterColorMapper.d.ts

@@ -17,7 +17,7 @@ export declare class CharacterColorMapper {
     /**
      * Generates a unique RGB color for a character based on its index.
      * @param index The index of the character
-     * @returns RGB color as a tuple [r, g, b]
+     * @returns RGB color as a tuple [r, g, b] with values from 0-1 for shader use
      */
     private _generateCharacterColor;
     /**
@@ -26,12 +26,12 @@ export declare class CharacterColorMapper {
      * @param characters Array of TextmodeCharacter objects
      * @returns RGB color as a tuple [r, g, b], or [0, 0, 0] if not found
      */
-    getCharacterColor(character: string, characters: TextmodeCharacter[]): [number, number, number];
+    $getCharacterColor(character: string, characters: TextmodeCharacter[]): [number, number, number];
     /**
      * Gets colors for multiple characters.
      * @param characterString String of characters to get colors for
      * @param characters Array of TextmodeCharacter objects
      * @returns Array of RGB colors for each character
      */
-    getCharacterColors(characterString: string, characters: TextmodeCharacter[]): [number, number, number][];
+    $getCharacterColors(characterString: string, characters: TextmodeCharacter[]): [number, number, number][];
 }

package/dist/types/textmode/font/TextmodeFont.d.ts

@@ -3,10 +3,10 @@ import type { GLFramebuffer } from '../../rendering/webgl/Framebuffer.ts';
 import type { TextmodeCharacter } from './types.ts';
 import type { TyprFont } from './typr/types.ts';
 /**
- * Manages the textmode font used for rendering characters.
+ * Manages the font used for rendering characters.
  *
  * This class coordinates font loading, character extraction, texture atlas creation,
- * and provides character color information. It acts as a facade for the font system.
+ * and provides character information.
  */
 export declare class TextmodeFont {
     private _font;
@@ -17,7 +17,6 @@ export declare class TextmodeFont {
     private _textureRows;
     private _maxGlyphDimensions;
     private _fontFace;
-    private _fontFamilyName;
     private _characterExtractor;
     private _textureAtlas;
     private _metricsCalculator;
@@ -62,21 +61,17 @@ export declare class TextmodeFont {
      * Get the color associated with a character.
      * @param character The character to get the color for.
      * @returns The RGB color as an array `[r, g, b]`.
+     * @ignore
      */
-    getCharacterColor(character: string): [number, number, number];
+    $getCharacterColor(character: string): [number, number, number];
     /**
      * Get the colors associated with a string of characters.
      * @param characters The string of characters to get colors for.
      * @returns An array of RGB colors for each character in the string.
      * Each color is represented as an array `[r, g, b]`.
+     * @ignore
      */
-    getCharacterColors(characters: string): [number, number, number][];
-    /**
-     * Checks if all characters in the given string exist in the font.
-     * @param str The string to check.
-     * @returns `true` if all characters exist in the font, `false` otherwise.
-     */
-    hasAllCharacters(str: string): boolean;
+    $getCharacterColors(characters: string): [number, number, number][];
     /**
      * Dispose of all resources used by this font manager.
      * @ignore

package/dist/types/textmode/font/types.d.ts

@@ -6,7 +6,7 @@ export type TextmodeCharacter = {
     character: string;
     /** The Unicode code point of the character. */
     unicode: number;
-    /** The RGB color associated with the character for identification. */
+    /** The shader color associated with the character. */
     color: [number, number, number];
     /** The advance width of the character. @ignore */
     advanceWidth: number;

package/dist/types/textmode/font/typr/types.d.ts

@@ -171,7 +171,7 @@ export interface GlyphData {
  * Each table parser implements this interface
  */
 export interface TableParser<T = any> {
-    parseTab: (data: Uint8Array, offset: number, length: number, font?: TyprFont) => T;
+    parseTab: (data: Uint8Array, offset: number, length: number, font: TyprFont) => T;
 }
 /**
  * Extended cmap parser with format-specific methods

package/dist/types/textmode/font/utils/index.d.ts

@@ -6,4 +6,3 @@
  */
 export { FontTableReader } from './FontTableReader.ts';
 export { CmapParser } from './CmapParser.ts';
-export * from './FontConstants.ts';

package/dist/types/textmode/mixins/AnimationMixin.d.ts

@@ -0,0 +1,120 @@
+import type { Mixin } from './TextmodifierMixin';
+/**
+ * Interface for animation capabilities that will be mixed into Textmodifier
+ */
+export interface AnimationCapabilities {
+    /**
+     * Get or set the current frame count.
+     */
+    frameCount: number;
+    /**
+     * Set the maximum frame rate. If called without arguments, returns the current measured frame rate.
+     * @param fps The maximum frames per second for rendering.
+     *
+     * @example
+     * ```javascript
+     * // Create a Textmodifier instance
+     * const textmodifier = await textmode.create();
+     *
+     * // Set the maximum frame rate to 30 FPS
+     * textmodifier.frameRate(30);
+     * ```
+     */
+    frameRate(fps?: number): number | void;
+    /**
+     * Stop the automatic rendering loop.
+     *
+     * This method pauses the render loop without, allowing
+     * it to be resumed later with {@link loop}. This is useful for temporarily pausing
+     * animation while maintaining the ability to continue it.
+     *
+     * @example
+     * ```javascript
+     * // Create a textmodifier instance in auto mode
+     * const textmodifier = await textmode.create();
+     *
+     * // The render loop is running by default
+     * console.log(textmodifier.isLooping()); // true
+     *
+     * // Stop the automatic rendering loop
+     * textmodifier.noLoop();
+     * console.log(textmodifier.isLooping()); // false
+     *
+     * // Resume the rendering loop
+     * textmodifier.loop();
+     * console.log(textmodifier.isLooping()); // true
+     * ```
+     */
+    noLoop(): void;
+    /**
+     * Resume the rendering loop if it was stopped by {@link noLoop}.
+     *
+     * @example
+     * ```javascript
+     * // Create a textmodifier instance
+     * const textmodifier = await textmode.create();
+     *
+     * // Stop the loop
+     * textmodifier.noLoop();
+     *
+     * // Resume the loop
+     * textmodifier.loop();
+     *
+     * // You can also use this pattern for conditional animation
+     * if (someCondition) {
+     *   textmodifier.loop();
+     * } else {
+     *   textmodifier.noLoop();
+     * }
+     * ```
+     */
+    loop(): void;
+    /**
+     * Execute the render function a specified number of times.
+     *
+     * This method is useful when the render loop has been stopped with {@link noLoop},
+     * allowing you to trigger rendering on demand.
+     *
+     * @param n The number of times to execute the render function. Defaults to 1.
+     *
+     * @example
+     * ```javascript
+     * // Create a textmodifier instance
+     * const textmodifier = await textmode.create();
+     *
+     * // Set up drawing
+     * textmodifier.draw(() => {
+     *   // todo...
+     * });
+     *
+     * textmodifier.noLoop();
+     * textmodifier.redraw(3); // Render 3 times despite loop being stopped
+     * ```
+     */
+    redraw(n?: number): void;
+    /**
+     * Check whether the textmodifier is currently running the automatic render loop.
+     * @returns True if the render loop is currently active, false otherwise.
+     *
+     * @example
+     * ```javascript
+     * const textmodifier = await textmode.create(canvas);
+     *
+     * // Check loop status in different states
+     * console.log(textmodifier.isLooping()); // true (looping)
+     *
+     * textmodifier.noLoop();
+     * console.log(textmodifier.isLooping()); // false (not looping)
+     *
+     * textmodifier.loop();
+     * console.log(textmodifier.isLooping()); // true (alooping)
+     * ```
+     */
+    isLooping(): boolean;
+}
+/**
+ * Mixin that adds animation capabilities to a class
+ * @param Base The base class to extend
+ * @returns Extended class with animation capabilities
+ */
+export declare const AnimationMixin: Mixin<AnimationCapabilities>;

package/dist/types/textmode/mixins/ExportMixin.d.ts

@@ -32,7 +32,7 @@ export interface ExportCapabilities {
      * console.log(textString);
      * ```
      */
-    toString(options?: Omit<TXTExportOptions, 'filename'>): string;
+    toString(options?: TXTExportOptions): string;
     /**
      * Export the current textmode rendering to a TXT file.
      * @param options Options for TXT export
@@ -82,7 +82,7 @@ export interface ExportCapabilities {
      * console.log(svgString);
      * ```
      */
-    toSVG(options?: Omit<SVGExportOptions, 'filename'>): string;
+    toSVG(options?: SVGExportOptions): string;
     /**
      * Export the current textmode rendering to an SVG file.
      * @param options Options for SVG export
@@ -107,9 +107,7 @@ export interface ExportCapabilities {
     saveSVG(options?: SVGExportOptions): void;
     /**
      * Export the current textmode rendering to an image file.
-     * @param filename The filename (without extension) to save the image as
-     * @param format The image format ('png', 'jpg', or 'webp')
-     * @param options Additional options for image export
+     * @param options Options for image export
      *
      * @example
      * ```javascript
@@ -133,7 +131,7 @@ export interface ExportCapabilities {
      * });
      * ```
      */
-    saveCanvas(filename: string, format?: 'png' | 'jpg' | 'webp', options?: Omit<ImageExportOptions, 'filename' | 'format'>): Promise<void>;
+    saveCanvas(options?: ImageExportOptions): Promise<void>;
 }
 /**
  * Mixin that adds export capabilities to a class