js-draw 0.17.3 → 0.18.0

package/dist/{src/tools/SelectionTool/SelectionHandle.js → mjs/src/tools/SelectionTool/SelectionHandle.mjs}

@@ -1,6 +1,6 @@
-import { assertUnreachable } from '../../util/assertions';
-import { Vec2 } from '../../math/Vec2';
-import { cssPrefix } from './SelectionTool';
+import  { assertUnreachable }  from '../../util/assertions.mjs';
+import  { Vec2 }  from '../../math/Vec2.mjs';
+import  { cssPrefix }  from './SelectionTool.mjs';
 export var HandleShape;
 (function (HandleShape) {
     HandleShape[HandleShape["Circle"] = 0] = "Circle";

package/dist/mjs/src/tools/SelectionTool/SelectionTool.d.ts

@@ -0,0 +1,36 @@
+import AbstractComponent from '../../components/AbstractComponent';
+import Editor from '../../Editor';
+import { CopyEvent, KeyPressEvent, KeyUpEvent, PointerEvt } from '../../types';
+import BaseTool from '../BaseTool';
+import Selection from './Selection';
+export declare const cssPrefix = "selection-tool-";
+export default class SelectionTool extends BaseTool {
+    private editor;
+    private handleOverlay;
+    private prevSelectionBox;
+    private selectionBox;
+    private lastEvtTarget;
+    private expandingSelectionBox;
+    private shiftKeyPressed;
+    private ctrlKeyPressed;
+    constructor(editor: Editor, description: string);
+    private makeSelectionBox;
+    private snapSelectionToGrid;
+    private selectionBoxHandlingEvt;
+    onPointerDown({ allPointers, current }: PointerEvt): boolean;
+    onPointerMove(event: PointerEvt): void;
+    private onSelectionUpdated;
+    private onGestureEnd;
+    private zoomToSelection;
+    onPointerUp(event: PointerEvt): void;
+    onGestureCancel(): void;
+    private static handleableKeys;
+    onKeyPress(event: KeyPressEvent): boolean;
+    onKeyUp(evt: KeyUpEvent): boolean;
+    onCopy(event: CopyEvent): boolean;
+    setEnabled(enabled: boolean): void;
+    getSelection(): Selection | null;
+    getSelectedObjects(): AbstractComponent[];
+    setSelection(objects: AbstractComponent[]): void;
+    clearSelection(): void;
+}

package/dist/{src/tools/SelectionTool/SelectionTool.js → mjs/src/tools/SelectionTool/SelectionTool.mjs}

@@ -1,11 +1,11 @@
-import Mat33 from '../../math/Mat33';
-import { Vec2 } from '../../math/Vec2';
-import { EditorEventType } from '../../types';
-import Viewport from '../../Viewport';
-import BaseTool from '../BaseTool';
-import SVGRenderer from '../../rendering/renderers/SVGRenderer';
-import Selection from './Selection';
-import TextComponent from '../../components/TextComponent';
+import  Mat33  from '../../math/Mat33.mjs';
+import  { Vec2 }  from '../../math/Vec2.mjs';
+import  { EditorEventType }  from '../../types.mjs';
+import  Viewport  from '../../Viewport.mjs';
+import  BaseTool  from '../BaseTool.mjs';
+import  SVGRenderer  from '../../rendering/renderers/SVGRenderer.mjs';
+import  Selection  from './Selection.mjs';
+import  TextComponent  from '../../components/TextComponent.mjs';
 export const cssPrefix = 'selection-tool-';
 // Allows users to select/transform portions of the `EditorImage`.
 // With respect to `extend`ing, `SelectionTool` is not stable.
@@ -306,19 +306,18 @@ export default class SelectionTool extends BaseTool {
         }
         const exportViewport = new Viewport(() => { });
         exportViewport.updateScreenSize(Vec2.of(bbox.w, bbox.h));
-        exportViewport.resetTransform(Mat33.translation(bbox.topLeft));
-        const svgNameSpace = 'http://www.w3.org/2000/svg';
-        const exportElem = document.createElementNS(svgNameSpace, 'svg');
+        exportViewport.resetTransform(Mat33.translation(bbox.topLeft.times(-1)));
         const sanitize = true;
-        const renderer = new SVGRenderer(exportElem, exportViewport, sanitize);
+        const { element: svgExportElem, renderer: svgRenderer } = SVGRenderer.fromViewport(exportViewport, sanitize);
         const text = [];
         for (const elem of selectedElems) {
-            elem.render(renderer);
+            elem.render(svgRenderer);
             if (elem instanceof TextComponent) {
                 text.push(elem.getText());
             }
         }
-        event.setData('image/svg+xml', exportElem.outerHTML);
+        event.setData('image/svg+xml', svgExportElem.outerHTML);
+        event.setData('text/html', svgExportElem.outerHTML);
         if (text.length > 0) {
             event.setData('text/plain', text.join('\n'));
         }

package/dist/mjs/src/tools/SelectionTool/TransformMode.d.ts

@@ -0,0 +1,34 @@
+import Editor from '../../Editor';
+import Vec3 from '../../math/Vec3';
+import Selection from './Selection';
+import { ResizeMode } from './types';
+export declare class DragTransformer {
+    private readonly editor;
+    private selection;
+    private dragStartPoint;
+    constructor(editor: Editor, selection: Selection);
+    onDragStart(startPoint: Vec3): void;
+    onDragUpdate(canvasPos: Vec3): void;
+    onDragEnd(): void;
+}
+export declare class ResizeTransformer {
+    private readonly editor;
+    private selection;
+    private mode;
+    private dragStartPoint;
+    constructor(editor: Editor, selection: Selection);
+    onDragStart(startPoint: Vec3, mode: ResizeMode): void;
+    onDragUpdate(canvasPos: Vec3): void;
+    onDragEnd(): void;
+}
+export declare class RotateTransformer {
+    private readonly editor;
+    private selection;
+    private startAngle;
+    constructor(editor: Editor, selection: Selection);
+    private getAngle;
+    private roundAngle;
+    onDragStart(startPoint: Vec3): void;
+    onDragUpdate(canvasPos: Vec3): void;
+    onDragEnd(): void;
+}

package/dist/{src/tools/SelectionTool/TransformMode.js → mjs/src/tools/SelectionTool/TransformMode.mjs}

@@ -1,7 +1,7 @@
-import Mat33 from '../../math/Mat33';
-import { Vec2 } from '../../math/Vec2';
-import Viewport from '../../Viewport';
-import { ResizeMode } from './types';
+import  Mat33  from '../../math/Mat33.mjs';
+import  { Vec2 }  from '../../math/Vec2.mjs';
+import  Viewport  from '../../Viewport.mjs';
+import  { ResizeMode }  from './types.mjs';
 export class DragTransformer {
     constructor(editor, selection) {
         this.editor = editor;

package/dist/mjs/src/tools/SelectionTool/types.d.ts

@@ -0,0 +1,9 @@
+export declare enum ResizeMode {
+    Both = 0,
+    HorizontalOnly = 1,
+    VerticalOnly = 2
+}
+export declare enum TransformMode {
+    Snap = 0,
+    NoSnap = 1
+}

package/dist/mjs/src/tools/TextTool.d.ts

@@ -0,0 +1,33 @@
+import Color4 from '../Color4';
+import Editor from '../Editor';
+import { PointerEvt } from '../types';
+import BaseTool from './BaseTool';
+import { ToolLocalization } from './localization';
+import TextStyle from '../rendering/TextRenderingStyle';
+export default class TextTool extends BaseTool {
+    private editor;
+    private localizationTable;
+    private textStyle;
+    private textEditOverlay;
+    private textInputElem;
+    private textTargetPosition;
+    private textMeasuringCtx;
+    private textRotation;
+    private textScale;
+    private removeExistingCommand;
+    constructor(editor: Editor, description: string, localizationTable: ToolLocalization);
+    private getTextAscent;
+    private flushInput;
+    private getTextScaleMatrix;
+    private updateTextInput;
+    private startTextInput;
+    setEnabled(enabled: boolean): void;
+    onPointerDown({ current, allPointers }: PointerEvt): boolean;
+    onGestureCancel(): void;
+    private dispatchUpdateEvent;
+    setFontFamily(fontFamily: string): void;
+    setColor(color: Color4): void;
+    setFontSize(size: number): void;
+    getTextStyle(): TextStyle;
+    private setTextStyle;
+}

package/dist/{src/tools/TextTool.js → mjs/src/tools/TextTool.mjs}

@@ -1,14 +1,14 @@
-import Color4 from '../Color4';
-import TextComponent from '../components/TextComponent';
-import EditorImage from '../EditorImage';
-import Rect2 from '../math/Rect2';
-import Mat33 from '../math/Mat33';
-import { Vec2 } from '../math/Vec2';
-import { PointerDevice } from '../Pointer';
-import { EditorEventType } from '../types';
-import BaseTool from './BaseTool';
-import Erase from '../commands/Erase';
-import uniteCommands from '../commands/uniteCommands';
+import  Color4  from '../Color4.mjs';
+import  TextComponent  from '../components/TextComponent.mjs';
+import  EditorImage  from '../EditorImage.mjs';
+import  Rect2  from '../math/Rect2.mjs';
+import  Mat33  from '../math/Mat33.mjs';
+import  { Vec2 }  from '../math/Vec2.mjs';
+import  { PointerDevice }  from '../Pointer.mjs';
+import  { EditorEventType }  from '../types.mjs';
+import  BaseTool  from './BaseTool.mjs';
+import  Erase  from '../commands/Erase.mjs';
+import  uniteCommands  from '../commands/uniteCommands.mjs';
 const overlayCssClass = 'textEditorOverlay';
 export default class TextTool extends BaseTool {
     constructor(editor, description, localizationTable) {

package/dist/mjs/src/tools/ToolController.d.ts

@@ -0,0 +1,18 @@
+import { InputEvt } from '../types';
+import Editor from '../Editor';
+import BaseTool from './BaseTool';
+import ToolEnabledGroup from './ToolEnabledGroup';
+import { ToolLocalization } from './localization';
+export default class ToolController {
+    private tools;
+    private activeTool;
+    private primaryToolGroup;
+    /** @internal */
+    constructor(editor: Editor, localization: ToolLocalization);
+    setTools(tools: BaseTool[], primaryToolGroup?: ToolEnabledGroup): void;
+    addPrimaryTool(tool: BaseTool): void;
+    getPrimaryTools(): BaseTool[];
+    addTool(tool: BaseTool): void;
+    dispatchInputEvent(event: InputEvt): boolean;
+    getMatchingTools<Type extends BaseTool>(type: new (...args: any[]) => Type): Type[];
+}

package/dist/{src/tools/ToolController.js → mjs/src/tools/ToolController.mjs}

@@ -1,19 +1,19 @@
-import { InputEvtType, EditorEventType } from '../types';
-import PanZoom, { PanZoomMode } from './PanZoom';
-import Pen from './Pen';
-import ToolEnabledGroup from './ToolEnabledGroup';
-import Eraser from './Eraser';
-import SelectionTool from './SelectionTool/SelectionTool';
-import Color4 from '../Color4';
-import UndoRedoShortcut from './UndoRedoShortcut';
-import TextTool from './TextTool';
-import PipetteTool from './PipetteTool';
-import ToolSwitcherShortcut from './ToolSwitcherShortcut';
-import PasteHandler from './PasteHandler';
-import ToolbarShortcutHandler from './ToolbarShortcutHandler';
-import { makePressureSensitiveFreehandLineBuilder } from '../components/builders/PressureSensitiveFreehandLineBuilder';
-import FindTool from './FindTool';
-import SelectAllShortcutHandler from './SelectionTool/SelectAllShortcutHandler';
+import  { InputEvtType, EditorEventType }  from '../types.mjs';
+import  PanZoom, { PanZoomMode }  from './PanZoom.mjs';
+import  Pen  from './Pen.mjs';
+import  ToolEnabledGroup  from './ToolEnabledGroup.mjs';
+import  Eraser  from './Eraser.mjs';
+import  SelectionTool  from './SelectionTool/SelectionTool.mjs';
+import  Color4  from '../Color4.mjs';
+import  UndoRedoShortcut  from './UndoRedoShortcut.mjs';
+import  TextTool  from './TextTool.mjs';
+import  PipetteTool  from './PipetteTool.mjs';
+import  ToolSwitcherShortcut  from './ToolSwitcherShortcut.mjs';
+import  PasteHandler  from './PasteHandler.mjs';
+import  ToolbarShortcutHandler  from './ToolbarShortcutHandler.mjs';
+import  { makePressureSensitiveFreehandLineBuilder }  from '../components/builders/PressureSensitiveFreehandLineBuilder.mjs';
+import  FindTool  from './FindTool.mjs';
+import  SelectAllShortcutHandler  from './SelectionTool/SelectAllShortcutHandler.mjs';
 export default class ToolController {
     /** @internal */
     constructor(editor, localization) {

package/dist/mjs/src/tools/ToolEnabledGroup.d.ts

@@ -0,0 +1,6 @@
+import BaseTool from './BaseTool';
+export default class ToolEnabledGroup {
+    private activeTool;
+    constructor();
+    notifyEnabled(tool: BaseTool): void;
+}

package/dist/mjs/src/tools/ToolSwitcherShortcut.d.ts

@@ -0,0 +1,16 @@
+import Editor from '../Editor';
+import { KeyPressEvent } from '../types';
+import BaseTool from './BaseTool';
+/**
+ * Handles keyboard events used, by default, to select tools. By default,
+ * 1 maps to the first primary tool, 2 to the second primary tool, ... .
+ *
+ * This is in the default set of {@link ToolController} tools.
+ *
+ * @deprecated This may be replaced in the future.
+ */
+export default class ToolSwitcherShortcut extends BaseTool {
+    private editor;
+    constructor(editor: Editor);
+    onKeyPress({ key }: KeyPressEvent): boolean;
+}

package/dist/{src/tools/ToolSwitcherShortcut.js → mjs/src/tools/ToolSwitcherShortcut.mjs}

@@ -1,4 +1,4 @@
-import BaseTool from './BaseTool';
+import  BaseTool  from './BaseTool.mjs';
 /**
  * Handles keyboard events used, by default, to select tools. By default,
  * 1 maps to the first primary tool, 2 to the second primary tool, ... .

package/dist/mjs/src/tools/ToolbarShortcutHandler.d.ts

@@ -0,0 +1,12 @@
+import Editor from '../Editor';
+import { KeyPressEvent } from '../types';
+import BaseTool from './BaseTool';
+type KeyPressListener = (event: KeyPressEvent) => boolean;
+export default class ToolbarShortcutHandler extends BaseTool {
+    private listeners;
+    constructor(editor: Editor);
+    registerListener(listener: KeyPressListener): void;
+    removeListener(listener: KeyPressListener): void;
+    onKeyPress(event: KeyPressEvent): boolean;
+}
+export {};

package/dist/{src/tools/ToolbarShortcutHandler.js → mjs/src/tools/ToolbarShortcutHandler.mjs}

@@ -1,6 +1,6 @@
 // Allows the toolbar to register keyboard events.
 // @packageDocumentation
-import BaseTool from './BaseTool';
+import  BaseTool  from './BaseTool.mjs';
 export default class ToolbarShortcutHandler extends BaseTool {
     constructor(editor) {
         super(editor.notifier, editor.localization.changeTool);

package/dist/mjs/src/tools/UndoRedoShortcut.d.ts

@@ -0,0 +1,8 @@
+import Editor from '../Editor';
+import { KeyPressEvent } from '../types';
+import BaseTool from './BaseTool';
+export default class UndoRedoShortcut extends BaseTool {
+    private editor;
+    constructor(editor: Editor);
+    onKeyPress({ key, ctrlKey }: KeyPressEvent): boolean;
+}

package/dist/{src/tools/UndoRedoShortcut.js → mjs/src/tools/UndoRedoShortcut.mjs}

@@ -1,4 +1,4 @@
-import BaseTool from './BaseTool';
+import  BaseTool  from './BaseTool.mjs';
 // Handles ctrl+Z, ctrl+Shift+Z keyboard shortcuts.
 export default class UndoRedoShortcut extends BaseTool {
     constructor(editor) {

package/dist/{src/tools/lib.js → mjs/src/tools/lib.d.ts}

@@ -7,7 +7,7 @@ export { default as ToolEnabledGroup } from './ToolEnabledGroup';
 export { default as UndoRedoShortcut } from './UndoRedoShortcut';
 export { default as ToolSwitcherShortcut } from './ToolSwitcherShortcut';
 export { default as PanZoomTool, PanZoomMode } from './PanZoom';
-export { default as PenTool } from './Pen';
+export { default as PenTool, PenStyle } from './Pen';
 export { default as TextTool } from './TextTool';
 export { default as SelectionTool } from './SelectionTool/SelectionTool';
 export { default as SelectAllShortcutHandler } from './SelectionTool/SelectAllShortcutHandler';

package/dist/mjs/src/tools/lib.mjs

@@ -0,0 +1,16 @@
+/**
+ * @packageDocumentation
+ */
+export  { default as BaseTool }  from './BaseTool.mjs';
+export  { default as ToolController }  from './ToolController.mjs';
+export  { default as ToolEnabledGroup }  from './ToolEnabledGroup.mjs';
+export  { default as UndoRedoShortcut }  from './UndoRedoShortcut.mjs';
+export  { default as ToolSwitcherShortcut }  from './ToolSwitcherShortcut.mjs';
+export  { default as PanZoomTool, PanZoomMode }  from './PanZoom.mjs';
+export  { default as PenTool }  from './Pen.mjs';
+export  { default as TextTool }  from './TextTool.mjs';
+export  { default as SelectionTool }  from './SelectionTool/SelectionTool.mjs';
+export  { default as SelectAllShortcutHandler }  from './SelectionTool/SelectAllShortcutHandler.mjs';
+export  { default as EraserTool }  from './Eraser.mjs';
+export  { default as PasteHandler }  from './PasteHandler.mjs';
+export  { default as ToolbarShortcutHandler }  from './ToolbarShortcutHandler.mjs';

package/dist/mjs/src/tools/localization.d.ts

@@ -0,0 +1,28 @@
+export interface ToolLocalization {
+    keyboardPanZoom: string;
+    penTool: (penId: number) => string;
+    selectionTool: string;
+    selectAllTool: string;
+    eraserTool: string;
+    touchPanTool: string;
+    twoFingerPanZoomTool: string;
+    undoRedoTool: string;
+    pipetteTool: string;
+    rightClickDragPanTool: string;
+    textTool: string;
+    enterTextToInsert: string;
+    changeTool: string;
+    pasteHandler: string;
+    findLabel: string;
+    toNextMatch: string;
+    closeFindDialog: string;
+    findDialogShown: string;
+    findDialogHidden: string;
+    focusedFoundText: (currentMatchNumber: number, totalMatches: number) => string;
+    anyDevicePanning: string;
+    copied: (count: number, description: string) => string;
+    pasted: (count: number, description: string) => string;
+    toolEnabledAnnouncement: (toolName: string) => string;
+    toolDisabledAnnouncement: (toolName: string) => string;
+}
+export declare const defaultToolLocalization: ToolLocalization;

package/dist/mjs/src/types.d.ts

@@ -0,0 +1,151 @@
+import EventDispatcher from './EventDispatcher';
+import Mat33 from './math/Mat33';
+import { Point2, Vec2 } from './math/Vec2';
+import Vec3 from './math/Vec3';
+import BaseTool from './tools/BaseTool';
+import AbstractComponent from './components/AbstractComponent';
+import Rect2 from './math/Rect2';
+import Pointer from './Pointer';
+import Color4 from './Color4';
+import Command from './commands/Command';
+import BaseWidget from './toolbar/widgets/BaseWidget';
+export interface PointerEvtListener {
+    onPointerDown(event: PointerEvt): boolean;
+    onPointerMove(event: PointerEvt): void;
+    onPointerUp(event: PointerEvt): void;
+    onGestureCancel(): void;
+}
+export declare enum InputEvtType {
+    PointerDownEvt = 0,
+    PointerMoveEvt = 1,
+    PointerUpEvt = 2,
+    GestureCancelEvt = 3,
+    WheelEvt = 4,
+    KeyPressEvent = 5,
+    KeyUpEvent = 6,
+    CopyEvent = 7,
+    PasteEvent = 8
+}
+export interface WheelEvt {
+    readonly kind: InputEvtType.WheelEvt;
+    readonly delta: Vec3;
+    readonly screenPos: Point2;
+}
+export interface KeyPressEvent {
+    readonly kind: InputEvtType.KeyPressEvent;
+    readonly key: string;
+    readonly ctrlKey: boolean | undefined;
+    readonly altKey: boolean | undefined;
+}
+export interface KeyUpEvent {
+    readonly kind: InputEvtType.KeyUpEvent;
+    readonly key: string;
+    readonly ctrlKey: boolean | undefined;
+    readonly altKey: boolean | undefined;
+}
+export interface CopyEvent {
+    readonly kind: InputEvtType.CopyEvent;
+    setData(mime: string, data: string): void;
+}
+export interface PasteEvent {
+    readonly kind: InputEvtType.PasteEvent;
+    readonly data: string;
+    readonly mime: string;
+}
+export interface GestureCancelEvt {
+    readonly kind: InputEvtType.GestureCancelEvt;
+}
+interface PointerEvtBase {
+    readonly current: Pointer;
+    readonly allPointers: Pointer[];
+}
+export interface PointerDownEvt extends PointerEvtBase {
+    readonly kind: InputEvtType.PointerDownEvt;
+}
+export interface PointerMoveEvt extends PointerEvtBase {
+    readonly kind: InputEvtType.PointerMoveEvt;
+}
+export interface PointerUpEvt extends PointerEvtBase {
+    readonly kind: InputEvtType.PointerUpEvt;
+}
+export type PointerEvt = PointerDownEvt | PointerMoveEvt | PointerUpEvt;
+export type InputEvt = KeyPressEvent | KeyUpEvent | WheelEvt | GestureCancelEvt | PointerEvt | CopyEvent | PasteEvent;
+export type EditorNotifier = EventDispatcher<EditorEventType, EditorEventDataType>;
+export declare enum EditorEventType {
+    ToolEnabled = 0,
+    ToolDisabled = 1,
+    ToolUpdated = 2,
+    UndoRedoStackUpdated = 3,
+    CommandDone = 4,
+    CommandUndone = 5,
+    ObjectAdded = 6,
+    ViewportChanged = 7,
+    DisplayResized = 8,
+    ColorPickerToggled = 9,
+    ColorPickerColorSelected = 10,
+    ToolbarDropdownShown = 11
+}
+export declare enum UndoEventType {
+    CommandDone = 0,
+    CommandUndone = 1,
+    CommandRedone = 2
+}
+type EditorToolEventType = EditorEventType.ToolEnabled | EditorEventType.ToolDisabled | EditorEventType.ToolUpdated;
+export interface EditorToolEvent {
+    readonly kind: EditorToolEventType;
+    readonly tool: BaseTool;
+}
+export interface EditorObjectEvent {
+    readonly kind: EditorEventType.ObjectAdded;
+    readonly object: AbstractComponent;
+}
+export interface EditorViewportChangedEvent {
+    readonly kind: EditorEventType.ViewportChanged;
+    readonly newTransform: Mat33;
+    readonly oldTransform: Mat33;
+}
+export interface DisplayResizedEvent {
+    readonly kind: EditorEventType.DisplayResized;
+    readonly newSize: Vec2;
+}
+export interface EditorUndoStackUpdated {
+    readonly kind: EditorEventType.UndoRedoStackUpdated;
+    readonly undoStackSize: number;
+    readonly redoStackSize: number;
+    readonly command?: Command;
+    readonly stackUpdateType: UndoEventType;
+}
+export interface CommandDoneEvent {
+    readonly kind: EditorEventType.CommandDone;
+    readonly command: Command;
+}
+export interface CommandUndoneEvent {
+    readonly kind: EditorEventType.CommandUndone;
+    readonly command: Command;
+}
+export interface ColorPickerToggled {
+    readonly kind: EditorEventType.ColorPickerToggled;
+    readonly open: boolean;
+}
+export interface ColorPickerColorSelected {
+    readonly kind: EditorEventType.ColorPickerColorSelected;
+    readonly color: Color4;
+}
+export interface ToolbarDropdownShownEvent {
+    readonly kind: EditorEventType.ToolbarDropdownShown;
+    readonly parentWidget: BaseWidget;
+}
+export type EditorEventDataType = EditorToolEvent | EditorObjectEvent | EditorViewportChangedEvent | DisplayResizedEvent | EditorUndoStackUpdated | CommandDoneEvent | CommandUndoneEvent | ColorPickerToggled | ColorPickerColorSelected | ToolbarDropdownShownEvent;
+export type OnProgressListener = (amountProcessed: number, totalToProcess: number) => Promise<void> | null | void;
+export type ComponentAddedListener = (component: AbstractComponent) => Promise<void> | void;
+export type OnDetermineExportRectListener = (exportRect: Rect2) => void;
+export interface ImageLoader {
+    start(onAddComponent: ComponentAddedListener, onProgressListener: OnProgressListener, onDetermineExportRect?: OnDetermineExportRectListener): Promise<void>;
+}
+export interface StrokeDataPoint {
+    pos: Point2;
+    width: number;
+    time: number;
+    color: Color4;
+}
+export {};

package/dist/mjs/src/util/assertions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Compile-time assertion that a branch of code is unreachable.
+ * @internal
+ */
+export declare const assertUnreachable: (key: never) => never;
+/**
+ * Throws an exception if the typeof given value is not a number or `value` is NaN.
+ *
+ * @example
+ * ```ts
+ * const foo: unknown = 3;
+ * assertIsNumber(foo);
+ *
+ * assertIsNumber('hello, world'); // throws an Error.
+ * ```
+ *
+ *
+ */
+export declare const assertIsNumber: (value: any, allowNaN?: boolean) => value is number;
+/**
+ * Throws if any of `values` is not of type number.
+ */
+export declare const assertIsNumberArray: (values: any[], allowNaN?: boolean) => values is number[];

package/dist/mjs/src/util/fileToBase64.d.ts

@@ -0,0 +1,3 @@
+type ProgressListener = (evt: ProgressEvent<FileReader>) => void;
+declare const fileToBase64: (file: File, onprogress?: ProgressListener) => Promise<string | null>;
+export default fileToBase64;

package/dist/mjs/src/util/untilNextAnimationFrame.d.ts

@@ -0,0 +1,3 @@
+/** @internal */
+declare const untilNextAnimationFrame: () => Promise<void>;
+export default untilNextAnimationFrame;

package/dist/mjs/src/util/waitForTimeout.d.ts

@@ -0,0 +1,2 @@
+declare const waitForTimeout: (timeout: number) => Promise<void>;
+export default waitForTimeout;