js-draw 0.17.4 → 0.18.0

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

@@ -0,0 +1,97 @@
+import AbstractRenderer from './rendering/renderers/AbstractRenderer';
+import Viewport from './Viewport';
+import AbstractComponent from './components/AbstractComponent';
+import Rect2 from './math/Rect2';
+import RenderingCache from './rendering/caching/RenderingCache';
+import SerializableCommand from './commands/SerializableCommand';
+import EventDispatcher from './EventDispatcher';
+export declare const sortLeavesByZIndex: (leaves: Array<ImageNode>) => void;
+export declare enum EditorImageEventType {
+    ExportViewportChanged = 0
+}
+export type EditorImageNotifier = EventDispatcher<EditorImageEventType, {
+    image: EditorImage;
+}>;
+export default class EditorImage {
+    private root;
+    private background;
+    private componentsById;
+    /** Viewport for the exported/imported image. */
+    private importExportViewport;
+    readonly notifier: EditorImageNotifier;
+    constructor();
+    getBackgroundComponents(): AbstractComponent[];
+    findParent(elem: AbstractComponent): ImageNode | null;
+    queueRerenderOf(elem: AbstractComponent): void;
+    /** @internal */
+    renderWithCache(screenRenderer: AbstractRenderer, cache: RenderingCache, viewport: Viewport): void;
+    /**
+     * Renders all nodes visible from `viewport` (or all nodes if `viewport = null`).
+     *
+     * `viewport` is used to improve rendering performance. If given, it must match
+     * the viewport used by the `renderer` (if any).
+     */
+    render(renderer: AbstractRenderer, viewport: Viewport | null): void;
+    /** Renders all nodes, even ones not within the viewport. @internal */
+    renderAll(renderer: AbstractRenderer): void;
+    /** @returns all elements in the image, sorted by z-index. This can be slow for large images. */
+    getAllElements(): AbstractComponent[];
+    /** @returns a list of `AbstractComponent`s intersecting `region`, sorted by z-index. */
+    getElementsIntersectingRegion(region: Rect2): AbstractComponent[];
+    /** @internal */
+    onDestroyElement(elem: AbstractComponent): void;
+    /**
+     * @returns the AbstractComponent with `id`, if it exists.
+     *
+     * @see {@link AbstractComponent.getId}
+     */
+    lookupElement(id: string): AbstractComponent | null;
+    private addElementDirectly;
+    private removeElementDirectly;
+    /**
+     * Returns a command that adds the given element to the `EditorImage`.
+     * If `applyByFlattening` is true, the content of the wet ink renderer is
+     * rendered onto the main rendering canvas instead of doing a full re-render.
+     *
+     * @see {@link Display.flatten}
+     */
+    static addElement(elem: AbstractComponent, applyByFlattening?: boolean): SerializableCommand;
+    /** @see EditorImage.addElement */
+    addElement(elem: AbstractComponent, applyByFlattening?: boolean): SerializableCommand;
+    private static AddElementCommand;
+    /**
+     * @returns a `Viewport` for rendering the image when importing/exporting.
+     */
+    getImportExportViewport(): Viewport;
+    setImportExportRect(imageRect: Rect2): SerializableCommand;
+    private static SetImportExportRectCommand;
+}
+type TooSmallToRenderCheck = (rect: Rect2) => boolean;
+/** Part of the Editor's image. @internal */
+export declare class ImageNode {
+    private parent;
+    private content;
+    private bbox;
+    private children;
+    private targetChildCount;
+    private id;
+    private static idCounter;
+    constructor(parent?: ImageNode | null);
+    getId(): number;
+    onContentChange(): void;
+    getContent(): AbstractComponent | null;
+    getParent(): ImageNode | null;
+    private getChildrenIntersectingRegion;
+    getChildrenOrSelfIntersectingRegion(region: Rect2): ImageNode[];
+    getLeavesIntersectingRegion(region: Rect2, isTooSmall?: TooSmallToRenderCheck): ImageNode[];
+    getChildWithContent(target: AbstractComponent): ImageNode | null;
+    getLeaves(): ImageNode[];
+    addLeaf(leaf: AbstractComponent): ImageNode;
+    getBBox(): Rect2;
+    recomputeBBox(bubbleUp: boolean): void;
+    private updateParents;
+    private rebalance;
+    remove(): void;
+    render(renderer: AbstractRenderer, visibleRect?: Rect2): void;
+}
+export {};

package/dist/{src/EditorImage.js → mjs/src/EditorImage.mjs}

@@ -1,12 +1,12 @@
 var _a, _b, _c;
-import Viewport from './Viewport';
-import AbstractComponent from './components/AbstractComponent';
-import Rect2 from './math/Rect2';
-import SerializableCommand from './commands/SerializableCommand';
-import EventDispatcher from './EventDispatcher';
-import { Vec2 } from './math/Vec2';
-import Mat33 from './math/Mat33';
-import { assertIsNumber, assertIsNumberArray } from './util/assertions';
+import  Viewport  from './Viewport.mjs';
+import  AbstractComponent  from './components/AbstractComponent.mjs';
+import  Rect2  from './math/Rect2.mjs';
+import  SerializableCommand  from './commands/SerializableCommand.mjs';
+import  EventDispatcher  from './EventDispatcher.mjs';
+import  { Vec2 }  from './math/Vec2.mjs';
+import  Mat33  from './math/Mat33.mjs';
+import  { assertIsNumber, assertIsNumberArray }  from './util/assertions.mjs';
 // @internal Sort by z-index, low to high
 export const sortLeavesByZIndex = (leaves) => {
     leaves.sort((a, b) => a.getContent().getZIndex() - b.getContent().getZIndex());

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

@@ -0,0 +1,30 @@
+/**
+ * Handles notifying listeners of events.
+ *
+ * `EventKeyType` is used to distinguish events (e.g. a `ClickEvent` vs a `TouchEvent`)
+ * while `EventMessageType` is the type of the data sent with an event (can be `void`).
+ *
+ * @example
+ * ```
+ * const dispatcher = new EventDispatcher<'event1'|'event2'|'event3', void>();
+ * dispatcher.on('event1', () => {
+ *   console.log('Event 1 triggered.');
+ * });
+ * dispatcher.dispatch('event1');
+ * ```
+ *
+ * @packageDocumentation
+ */
+type CallbackHandler<EventType> = (data: EventType) => void;
+export interface DispatcherEventListener {
+    remove: () => void;
+}
+export default class EventDispatcher<EventKeyType extends string | symbol | number, EventMessageType> {
+    private listeners;
+    constructor();
+    dispatch(eventName: EventKeyType, event: EventMessageType): void;
+    on(eventName: EventKeyType, callback: CallbackHandler<EventMessageType>): DispatcherEventListener;
+    /** Removes an event listener. This is equivalent to calling `.remove()` on the object returned by `.on`. */
+    off(eventName: EventKeyType, callback: CallbackHandler<EventMessageType>): void;
+}
+export {};

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

@@ -0,0 +1,24 @@
+import { Point2 } from './math/Vec2';
+import Viewport from './Viewport';
+export declare enum PointerDevice {
+    Pen = 0,
+    Eraser = 1,
+    Touch = 2,
+    PrimaryButtonMouse = 3,
+    RightButtonMouse = 4,
+    Other = 5
+}
+export default class Pointer {
+    readonly screenPos: Point2;
+    readonly canvasPos: Point2;
+    readonly pressure: number | null;
+    readonly isPrimary: boolean;
+    readonly down: boolean;
+    readonly device: PointerDevice;
+    readonly id: number;
+    readonly timeStamp: number;
+    private constructor();
+    snappedToGrid(viewport: Viewport): Pointer;
+    static ofEvent(evt: PointerEvent, isDown: boolean, viewport: Viewport, relativeTo?: HTMLElement): Pointer;
+    static ofCanvasPoint(canvasPos: Point2, isDown: boolean, viewport: Viewport, id?: number, device?: PointerDevice, isPrimary?: boolean, pressure?: number | null): Pointer;
+}

package/dist/{src/Pointer.js → mjs/src/Pointer.mjs}

@@ -1,4 +1,4 @@
-import { Vec2 } from './math/Vec2';
+import  { Vec2 }  from './math/Vec2.mjs';
 export var PointerDevice;
 (function (PointerDevice) {
     PointerDevice[PointerDevice["Pen"] = 0] = "Pen";

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

@@ -0,0 +1,48 @@
+import Rect2 from './math/Rect2';
+import { ComponentAddedListener, ImageLoader, OnDetermineExportRectListener, OnProgressListener } from './types';
+export declare const defaultSVGViewRect: Rect2;
+export declare const svgAttributesDataKey = "svgAttrs";
+export declare const svgStyleAttributesDataKey = "svgStyleAttrs";
+export type SVGLoaderUnknownAttribute = [string, string];
+export type SVGLoaderUnknownStyleAttribute = {
+    key: string;
+    value: string;
+    priority?: string;
+};
+export default class SVGLoader implements ImageLoader {
+    private source;
+    private onFinish?;
+    private readonly storeUnknown;
+    private onAddComponent;
+    private onProgress;
+    private onDetermineExportRect;
+    private processedCount;
+    private totalToProcess;
+    private rootViewBox;
+    private constructor();
+    private getStyle;
+    private strokeDataFromElem;
+    private attachUnrecognisedAttrs;
+    private addPath;
+    private addBackground;
+    private getTransform;
+    private makeText;
+    private addText;
+    private addImage;
+    private addUnknownNode;
+    private updateViewBox;
+    private updateSVGAttrs;
+    private visit;
+    private getSourceAttrs;
+    start(onAddComponent: ComponentAddedListener, onProgress: OnProgressListener, onDetermineExportRect?: OnDetermineExportRectListener | null): Promise<void>;
+    /**
+     * Create an `SVGLoader` from the content of an SVG image. SVGs are loaded within a sandboxed
+     * iframe with `sandbox="allow-same-origin"`
+     * [thereby disabling JavaScript](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#sandbox).
+     *
+     * @see {@link Editor.loadFrom}
+     * @param text - Textual representation of the SVG (e.g. `<svg viewbox='...'>...</svg>`).
+     * @param sanitize - if `true`, don't store unknown attributes.
+     */
+    static fromString(text: string, sanitize?: boolean): SVGLoader;
+}

package/dist/{src/SVGLoader.js → mjs/src/SVGLoader.mjs}

@@ -7,17 +7,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import Color4 from './Color4';
-import ImageBackground, { BackgroundType, imageBackgroundCSSClassName } from './components/ImageBackground';
-import ImageComponent from './components/ImageComponent';
-import Stroke from './components/Stroke';
-import SVGGlobalAttributesObject from './components/SVGGlobalAttributesObject';
-import TextComponent from './components/TextComponent';
-import UnknownSVGObject from './components/UnknownSVGObject';
-import Mat33 from './math/Mat33';
-import Path from './math/Path';
-import Rect2 from './math/Rect2';
-import { Vec2 } from './math/Vec2';
+import  Color4  from './Color4.mjs';
+import  ImageBackground, { BackgroundType, imageBackgroundCSSClassName }  from './components/ImageBackground.mjs';
+import  ImageComponent  from './components/ImageComponent.mjs';
+import  Stroke  from './components/Stroke.mjs';
+import  SVGGlobalAttributesObject  from './components/SVGGlobalAttributesObject.mjs';
+import  TextComponent  from './components/TextComponent.mjs';
+import  UnknownSVGObject  from './components/UnknownSVGObject.mjs';
+import  Mat33  from './math/Mat33.mjs';
+import  Path  from './math/Path.mjs';
+import  Rect2  from './math/Rect2.mjs';
+import  { Vec2 }  from './math/Vec2.mjs';
 // Size of a loaded image if no size is specified.
 export const defaultSVGViewRect = new Rect2(0, 0, 500, 500);
 // Key to retrieve unrecognised attributes from an AbstractComponent

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

@@ -0,0 +1,19 @@
+import Editor from './Editor';
+import Command from './commands/Command';
+type AnnounceRedoCallback = (command: Command) => void;
+type AnnounceUndoCallback = (command: Command) => void;
+declare class UndoRedoHistory {
+    #private;
+    private readonly editor;
+    private announceRedoCallback;
+    private announceUndoCallback;
+    private readonly maxUndoRedoStackSize;
+    constructor(editor: Editor, announceRedoCallback: AnnounceRedoCallback, announceUndoCallback: AnnounceUndoCallback);
+    private fireUpdateEvent;
+    push(command: Command, apply?: boolean): void;
+    undo(): void;
+    redo(): void;
+    get undoStackSize(): number;
+    get redoStackSize(): number;
+}
+export default UndoRedoHistory;

package/dist/{src/UndoRedoHistory.js → mjs/src/UndoRedoHistory.mjs}

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _UndoRedoHistory_undoStack, _UndoRedoHistory_redoStack;
-import { EditorEventType, UndoEventType } from './types';
+import  { EditorEventType, UndoEventType }  from './types.mjs';
 class UndoRedoHistory {
     // @internal
     constructor(editor, announceRedoCallback, announceUndoCallback) {

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

@@ -0,0 +1,71 @@
+import Command from './commands/Command';
+import Mat33 from './math/Mat33';
+import Rect2 from './math/Rect2';
+import { Point2, Vec2 } from './math/Vec2';
+import Vec3 from './math/Vec3';
+import { StrokeDataPoint } from './types';
+type PointDataType<T extends Point2 | StrokeDataPoint | number> = T extends Point2 ? Point2 : number;
+export declare abstract class ViewportTransform extends Command {
+    abstract readonly transform: Mat33;
+}
+type TransformChangeCallback = (oldTransform: Mat33, newTransform: Mat33) => void;
+export declare class Viewport {
+    private onTransformChangeCallback;
+    private static ViewportTransform;
+    private transform;
+    private inverseTransform;
+    private screenRect;
+    constructor(onTransformChangeCallback: TransformChangeCallback);
+    /**
+     * @returns a temporary copy of `this` that does not notify when modified. This is
+     * useful when rendering with a temporarily different viewport.
+     */
+    getTemporaryClone(): Viewport;
+    updateScreenSize(screenSize: Vec2): void;
+    /** Get the screen's visible region transformed into canvas space. */
+    get visibleRect(): Rect2;
+    /** @returns the given point, but in canvas coordinates */
+    screenToCanvas(screenPoint: Point2): Point2;
+    /** @returns the given point transformed into screen coordinates. */
+    canvasToScreen(canvasPoint: Point2): Point2;
+    /** @returns a command that transforms the canvas by `transform`. */
+    static transformBy(transform: Mat33): ViewportTransform;
+    /**
+     * Updates the transformation directly. Using `transformBy` is preferred.
+     * @param newTransform - should map from canvas coordinates to screen coordinates.
+     */
+    resetTransform(newTransform?: Mat33): void;
+    get screenToCanvasTransform(): Mat33;
+    get canvasToScreenTransform(): Mat33;
+    /** @returns the size of the visible region in pixels. */
+    getScreenRectSize(): Vec2;
+    /** Alias for `getScreenRectSize`. @deprecated */
+    getResolution(): Vec3;
+    /** @returns the amount a vector on the canvas is scaled to become a vector on the screen. */
+    getScaleFactor(): number;
+    /**
+     * @returns `getScaleFactor()` rounded to the nearest power of 10.
+     * For example, if `getScaleFactor()` returns 101, `getScaleFactorToNearestPowerOfTen()`
+     * should return `100` because `100` is the nearest power of 10 to 101.
+     */
+    getScaleFactorToNearestPowerOfTen(): number;
+    private getScaleFactorToNearestPowerOf;
+    snapToGrid(canvasPos: Point2): Vec3;
+    /** Returns the size of one screen pixel in canvas units. */
+    getSizeOfPixelOnCanvas(): number;
+    /**
+     * @returns the angle of the canvas in radians.
+     * This is the angle by which the canvas is rotated relative to the screen.
+     */
+    getRotationAngle(): number;
+    /**
+     * Rounds the given `point` to a multiple of 10 such that it is within `tolerance` of
+     * its original location. This is useful for preparing data for base-10 conversion.
+     */
+    static roundPoint<T extends Point2 | number>(point: T, tolerance: number): PointDataType<T>;
+    roundPoint(point: Point2): Point2;
+    static roundScaleRatio(scaleRatio: number, roundAmount?: number): number;
+    computeZoomToTransform(toMakeVisible: Rect2, allowZoomIn?: boolean, allowZoomOut?: boolean): Mat33;
+    zoomTo(toMakeVisible: Rect2, allowZoomIn?: boolean, allowZoomOut?: boolean): Command;
+}
+export default Viewport;

package/dist/{src/Viewport.js → mjs/src/Viewport.mjs}

@@ -10,11 +10,11 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _inverseTransform, _a;
-import Command from './commands/Command';
-import Mat33 from './math/Mat33';
-import Rect2 from './math/Rect2';
-import { Vec2 } from './math/Vec2';
-import Vec3 from './math/Vec3';
+import  Command  from './commands/Command.mjs';
+import  Mat33  from './math/Mat33.mjs';
+import  Rect2  from './math/Rect2.mjs';
+import  { Vec2 }  from './math/Vec2.mjs';
+import  Vec3  from './math/Vec3.mjs';
 export class ViewportTransform extends Command {
 }
 export class Viewport {

package/dist/mjs/src/bundle/bundled.d.ts

@@ -0,0 +1,4 @@
+import '../styles';
+import Editor from '../Editor';
+export * from '../lib';
+export default Editor;

package/dist/{src/bundle/bundled.js → mjs/src/bundle/bundled.mjs}

@@ -1,5 +1,5 @@
 // Main entrypoint for Webpack when building a bundle for release.
 import '../styles';
-import Editor from '../Editor';
-export * from '../lib';
+import  Editor  from '../Editor.mjs';
+export  *  from '../lib.mjs';
 export default Editor;

package/dist/mjs/src/commands/Command.d.ts

@@ -0,0 +1,16 @@
+import Editor from '../Editor';
+import { EditorLocalization } from '../localization';
+export declare abstract class Command {
+    abstract apply(editor: Editor): Promise<void> | void;
+    abstract unapply(editor: Editor): Promise<void> | void;
+    onDrop(_editor: Editor): void;
+    abstract description(editor: Editor, localizationTable: EditorLocalization): string;
+    static union(a: Command, b: Command): Command;
+    static readonly empty: {
+        description(_editor: Editor, _localizationTable: EditorLocalization): string;
+        apply(_editor: Editor): void;
+        unapply(_editor: Editor): void;
+        onDrop(_editor: Editor): void;
+    };
+}
+export default Command;

package/dist/mjs/src/commands/Duplicate.d.ts

@@ -0,0 +1,14 @@
+import AbstractComponent from '../components/AbstractComponent';
+import Editor from '../Editor';
+import { EditorLocalization } from '../localization';
+import SerializableCommand from './SerializableCommand';
+export default class Duplicate extends SerializableCommand {
+    private toDuplicate;
+    private duplicates;
+    private reverse;
+    constructor(toDuplicate: AbstractComponent[]);
+    apply(editor: Editor): void;
+    unapply(editor: Editor): void;
+    description(_editor: Editor, localizationTable: EditorLocalization): string;
+    protected serializeToJSON(): string[];
+}

package/dist/{src/commands/Duplicate.js → mjs/src/commands/Duplicate.mjs}

@@ -1,6 +1,6 @@
-import describeComponentList from '../components/util/describeComponentList';
-import Erase from './Erase';
-import SerializableCommand from './SerializableCommand';
+import  describeComponentList  from '../components/util/describeComponentList.mjs';
+import  Erase  from './Erase.mjs';
+import  SerializableCommand  from './SerializableCommand.mjs';
 export default class Duplicate extends SerializableCommand {
     constructor(toDuplicate) {
         super('duplicate');

package/dist/mjs/src/commands/Erase.d.ts

@@ -0,0 +1,14 @@
+import AbstractComponent from '../components/AbstractComponent';
+import Editor from '../Editor';
+import { EditorLocalization } from '../localization';
+import SerializableCommand from './SerializableCommand';
+export default class Erase extends SerializableCommand {
+    private toRemove;
+    private applied;
+    constructor(toRemove: AbstractComponent[]);
+    apply(editor: Editor): void;
+    unapply(editor: Editor): void;
+    onDrop(editor: Editor): void;
+    description(_editor: Editor, localizationTable: EditorLocalization): string;
+    protected serializeToJSON(): string[];
+}

package/dist/{src/commands/Erase.js → mjs/src/commands/Erase.mjs}

@@ -1,6 +1,6 @@
-import describeComponentList from '../components/util/describeComponentList';
-import EditorImage from '../EditorImage';
-import SerializableCommand from './SerializableCommand';
+import  describeComponentList  from '../components/util/describeComponentList.mjs';
+import  EditorImage  from '../EditorImage.mjs';
+import  SerializableCommand  from './SerializableCommand.mjs';
 export default class Erase extends SerializableCommand {
     constructor(toRemove) {
         super('erase');

package/dist/mjs/src/commands/SerializableCommand.d.ts

@@ -0,0 +1,12 @@
+import Editor from '../Editor';
+import Command from './Command';
+export type DeserializationCallback = (data: Record<string, any> | any[], editor: Editor) => SerializableCommand;
+export default abstract class SerializableCommand extends Command {
+    private commandTypeId;
+    constructor(commandTypeId: string);
+    protected abstract serializeToJSON(): string | Record<string, any> | any[];
+    private static deserializationCallbacks;
+    serialize(): Record<string | symbol, any>;
+    static deserialize(data: string | Record<string, any>, editor: Editor): SerializableCommand;
+    static register(commandTypeId: string, deserialize: DeserializationCallback): void;
+}

package/dist/{src/commands/SerializableCommand.js → mjs/src/commands/SerializableCommand.mjs}

@@ -1,4 +1,4 @@
-import Command from './Command';
+import  Command  from './Command.mjs';
 export default class SerializableCommand extends Command {
     constructor(commandTypeId) {
         super();

package/dist/mjs/src/commands/UnresolvedCommand.d.ts

@@ -0,0 +1,14 @@
+import EditorImage from '../EditorImage';
+import AbstractComponent from '../components/AbstractComponent';
+import SerializableCommand from './SerializableCommand';
+export type ResolveFromComponentCallback = () => SerializableCommand;
+/**
+ * A command that requires a component that may or may not be present in the editor when
+ * the command is created.
+ */
+export default abstract class UnresolvedSerializableCommand extends SerializableCommand {
+    protected component: AbstractComponent | null;
+    protected readonly componentID: string;
+    protected constructor(commandId: string, componentID: string, component?: AbstractComponent);
+    protected resolveComponent(image: EditorImage): void;
+}

package/dist/{src/commands/UnresolvedCommand.js → mjs/src/commands/UnresolvedCommand.mjs}

@@ -1,4 +1,4 @@
-import SerializableCommand from './SerializableCommand';
+import  SerializableCommand  from './SerializableCommand.mjs';
 /**
  * A command that requires a component that may or may not be present in the editor when
  * the command is created.

package/dist/mjs/src/commands/invertCommand.d.ts

@@ -0,0 +1,4 @@
+import Command from './Command';
+import SerializableCommand from './SerializableCommand';
+declare const invertCommand: <T extends Command>(command: T) => T extends SerializableCommand ? SerializableCommand : Command;
+export default invertCommand;

package/dist/{src/commands/invertCommand.js → mjs/src/commands/invertCommand.mjs}

@@ -1,5 +1,5 @@
-import Command from './Command';
-import SerializableCommand from './SerializableCommand';
+import  Command  from './Command.mjs';
+import  SerializableCommand  from './SerializableCommand.mjs';
 // Returns a command that does the opposite of the given command --- `result.apply()` calls
 // `command.unapply()` and `result.unapply()` calls `command.apply()`.
 const invertCommand = (command) => {

package/dist/mjs/src/commands/lib.mjs

@@ -0,0 +1,7 @@
+import  Command  from './Command.mjs';
+import  Duplicate  from './Duplicate.mjs';
+import  Erase  from './Erase.mjs';
+import  invertCommand  from './invertCommand.mjs';
+import  SerializableCommand  from './SerializableCommand.mjs';
+import  uniteCommands  from './uniteCommands.mjs';
+export { Command, Duplicate, Erase, SerializableCommand, invertCommand, uniteCommands, };

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

@@ -0,0 +1,23 @@
+import Rect2 from '../math/Rect2';
+export interface CommandLocalization {
+    movedLeft: string;
+    movedUp: string;
+    movedDown: string;
+    movedRight: string;
+    rotatedBy: (degrees: number) => string;
+    zoomedOut: string;
+    zoomedIn: string;
+    erasedNoElements: string;
+    duplicatedNoElements: string;
+    elements: string;
+    updatedViewport: string;
+    transformedElements: (elemCount: number) => string;
+    resizeOutputCommand: (newSize: Rect2) => string;
+    addElementAction: (elemDescription: string) => string;
+    eraseAction: (elemDescription: string, numElems: number) => string;
+    duplicateAction: (elemDescription: string, count: number) => string;
+    inverseOf: (actionDescription: string) => string;
+    unionOf: (actionDescription: string, actionCount: number) => string;
+    selectedElements: (count: number) => string;
+}
+export declare const defaultCommandLocalization: CommandLocalization;

package/dist/mjs/src/commands/uniteCommands.d.ts

@@ -0,0 +1,4 @@
+import Command from './Command';
+import SerializableCommand from './SerializableCommand';
+declare const uniteCommands: <T extends Command>(commands: T[], applyChunkSize?: number) => T extends SerializableCommand ? SerializableCommand : Command;
+export default uniteCommands;

package/dist/{src/commands/uniteCommands.js → mjs/src/commands/uniteCommands.mjs}

@@ -1,5 +1,5 @@
-import Command from './Command';
-import SerializableCommand from './SerializableCommand';
+import  Command  from './Command.mjs';
+import  SerializableCommand  from './SerializableCommand.mjs';
 class NonSerializableUnion extends Command {
     constructor(commands, applyChunkSize) {
         super();