js-draw 0.17.3 → 0.18.0

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

package/dist/mjs/src/components/AbstractComponent.d.ts

@@ -0,0 +1,73 @@
+import SerializableCommand from '../commands/SerializableCommand';
+import EditorImage from '../EditorImage';
+import LineSegment2 from '../math/LineSegment2';
+import Mat33 from '../math/Mat33';
+import Rect2 from '../math/Rect2';
+import AbstractRenderer from '../rendering/renderers/AbstractRenderer';
+import { ImageComponentLocalization } from './localization';
+export type LoadSaveData = (string[] | Record<symbol, string | number>);
+export type LoadSaveDataTable = Record<string, Array<LoadSaveData>>;
+export type DeserializeCallback = (data: string) => AbstractComponent;
+/**
+ * A base class for everything that can be added to an {@link EditorImage}.
+ */
+export default abstract class AbstractComponent {
+    private readonly componentKind;
+    protected lastChangedTime: number;
+    protected abstract contentBBox: Rect2;
+    private zIndex;
+    private id;
+    private static zIndexCounter;
+    protected constructor(componentKind: string, initialZIndex?: number);
+    getId(): string;
+    private static deserializationCallbacks;
+    static registerComponent(componentKind: string, deserialize: DeserializeCallback | null): void;
+    private loadSaveData;
+    /**
+     * Attach data that can be used while exporting the component (e.g. to SVG).
+     *
+     * This is intended for use by a {@link ImageLoader}.
+     */
+    attachLoadSaveData(key: string, data: LoadSaveData): void;
+    /** See {@link attachLoadSaveData} */
+    getLoadSaveData(): LoadSaveDataTable;
+    getZIndex(): number;
+    /** @returns the bounding box of  */
+    getBBox(): Rect2;
+    /** Called when this component is added to the given image. */
+    onAddToImage(_image: EditorImage): void;
+    onRemoveFromImage(): void;
+    abstract render(canvas: AbstractRenderer, visibleRect?: Rect2): void;
+    /** @return true if `lineSegment` intersects this component. */
+    abstract intersects(lineSegment: LineSegment2): boolean;
+    /**
+     * @returns true if this component intersects `rect` -- it is entirely contained
+     *  within the rectangle or one of the rectangle's edges intersects this component.
+     */
+    intersectsRect(rect: Rect2): boolean;
+    protected abstract serializeToJSON(): any[] | Record<string, any> | number | string | null;
+    protected abstract applyTransformation(affineTransfm: Mat33): void;
+    transformBy(affineTransfm: Mat33): SerializableCommand;
+    setZIndex(newZIndex: number): SerializableCommand;
+    isSelectable(): boolean;
+    isBackground(): boolean;
+    getProportionalRenderingTime(): number;
+    private static transformElementCommandId;
+    private static TransformElementCommand;
+    /**
+     * @return a description that could be read by a screen reader
+     *     (e.g. when adding/erasing the component)
+     */
+    abstract description(localizationTable: ImageComponentLocalization): string;
+    protected abstract createClone(): AbstractComponent;
+    clone(): AbstractComponent;
+    serialize(): {
+        name: string;
+        zIndex: number;
+        id: string;
+        loadSaveData: LoadSaveDataTable;
+        data: string | number | any[] | Record<string, any>;
+    };
+    private static isNotDeserializable;
+    static deserialize(json: string | any): AbstractComponent;
+}

package/dist/{src/components/AbstractComponent.js → mjs/src/components/AbstractComponent.mjs}

@@ -1,8 +1,8 @@
 var _a;
-import SerializableCommand from '../commands/SerializableCommand';
-import EditorImage from '../EditorImage';
-import Mat33 from '../math/Mat33';
-import UnresolvedSerializableCommand from '../commands/UnresolvedCommand';
+import  SerializableCommand  from '../commands/SerializableCommand.mjs';
+import  EditorImage  from '../EditorImage.mjs';
+import  Mat33  from '../math/Mat33.mjs';
+import  UnresolvedSerializableCommand  from '../commands/UnresolvedCommand.mjs';
 /**
  * A base class for everything that can be added to an {@link EditorImage}.
  */

package/dist/mjs/src/components/ImageBackground.d.ts

@@ -0,0 +1,42 @@
+import Color4 from '../Color4';
+import Editor from '../Editor';
+import EditorImage from '../EditorImage';
+import SerializableCommand from '../commands/SerializableCommand';
+import LineSegment2 from '../math/LineSegment2';
+import Mat33 from '../math/Mat33';
+import Rect2 from '../math/Rect2';
+import AbstractRenderer from '../rendering/renderers/AbstractRenderer';
+import AbstractComponent from './AbstractComponent';
+import { ImageComponentLocalization } from './localization';
+import RestyleableComponent, { ComponentStyle } from './RestylableComponent';
+export declare enum BackgroundType {
+    SolidColor = 0,
+    None = 1
+}
+export declare const imageBackgroundCSSClassName = "js-draw-image-background";
+export default class ImageBackground extends AbstractComponent implements RestyleableComponent {
+    private backgroundType;
+    private mainColor;
+    protected contentBBox: Rect2;
+    private viewportSizeChangeListener;
+    readonly isRestylableComponent: true;
+    constructor(backgroundType: BackgroundType, mainColor: Color4);
+    getStyle(): ComponentStyle;
+    updateStyle(style: ComponentStyle): SerializableCommand;
+    forceStyle(style: ComponentStyle, editor: Editor | null): void;
+    onAddToImage(image: EditorImage): void;
+    onRemoveFromImage(): void;
+    private recomputeBBox;
+    render(canvas: AbstractRenderer, visibleRect?: Rect2): void;
+    intersects(lineSegment: LineSegment2): boolean;
+    isSelectable(): boolean;
+    isBackground(): boolean;
+    protected serializeToJSON(): {
+        mainColor: string;
+        backgroundType: BackgroundType;
+    };
+    protected applyTransformation(_affineTransfm: Mat33): void;
+    description(localizationTable: ImageComponentLocalization): string;
+    protected createClone(): AbstractComponent;
+    static deserializeFromJSON(json: any): ImageBackground;
+}

package/dist/{src/components/ImageBackground.js → mjs/src/components/ImageBackground.mjs}

@@ -1,8 +1,8 @@
-import Color4 from '../Color4';
-import { EditorImageEventType } from '../EditorImage';
-import Rect2 from '../math/Rect2';
-import AbstractComponent from './AbstractComponent';
-import { createRestyleComponentCommand } from './RestylableComponent';
+import  Color4  from '../Color4.mjs';
+import  { EditorImageEventType }  from '../EditorImage.mjs';
+import  Rect2  from '../math/Rect2.mjs';
+import  AbstractComponent  from './AbstractComponent.mjs';
+import  { createRestyleComponentCommand }  from './RestylableComponent.mjs';
 export var BackgroundType;
 (function (BackgroundType) {
     BackgroundType[BackgroundType["SolidColor"] = 0] = "SolidColor";

package/dist/mjs/src/components/ImageComponent.d.ts

@@ -0,0 +1,31 @@
+import LineSegment2 from '../math/LineSegment2';
+import Mat33, { Mat33Array } from '../math/Mat33';
+import Rect2 from '../math/Rect2';
+import AbstractRenderer, { RenderableImage } from '../rendering/renderers/AbstractRenderer';
+import AbstractComponent from './AbstractComponent';
+import { ImageComponentLocalization } from './localization';
+export default class ImageComponent extends AbstractComponent {
+    protected contentBBox: Rect2;
+    private image;
+    constructor(image: RenderableImage);
+    private getImageRect;
+    private recomputeBBox;
+    static fromImage(elem: HTMLImageElement, transform: Mat33): Promise<ImageComponent>;
+    render(canvas: AbstractRenderer, _visibleRect?: Rect2): void;
+    getProportionalRenderingTime(): number;
+    intersects(lineSegment: LineSegment2): boolean;
+    protected serializeToJSON(): {
+        src: string;
+        label: string | undefined;
+        width: number;
+        height: number;
+        transform: Mat33Array;
+    };
+    protected applyTransformation(affineTransfm: Mat33): void;
+    description(localizationTable: ImageComponentLocalization): string;
+    getAltText(): string | undefined;
+    getURL(): string;
+    getTransformation(): Mat33;
+    protected createClone(): AbstractComponent;
+    static deserializeFromJSON(data: any): ImageComponent;
+}

package/dist/{src/components/ImageComponent.js → mjs/src/components/ImageComponent.mjs}

@@ -7,9 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import Mat33 from '../math/Mat33';
-import Rect2 from '../math/Rect2';
-import AbstractComponent from './AbstractComponent';
+import  Mat33  from '../math/Mat33.mjs';
+import  Rect2  from '../math/Rect2.mjs';
+import  AbstractComponent  from './AbstractComponent.mjs';
 // Represents a raster image.
 export default class ImageComponent extends AbstractComponent {
     constructor(image) {

package/dist/mjs/src/components/RestylableComponent.d.ts

@@ -0,0 +1,24 @@
+import Color4 from '../Color4';
+import SerializableCommand from '../commands/SerializableCommand';
+import Editor from '../Editor';
+import TextStyle from '../rendering/TextRenderingStyle';
+import AbstractComponent from './AbstractComponent';
+export interface ComponentStyle {
+    color?: Color4;
+    textStyle?: TextStyle;
+}
+export declare const createRestyleComponentCommand: (initialStyle: ComponentStyle, newStyle: ComponentStyle, component: RestyleableComponent) => SerializableCommand;
+export declare const isRestylableComponent: (component: AbstractComponent) => component is RestyleableComponent;
+export interface RestyleableComponent extends AbstractComponent {
+    getStyle(): ComponentStyle;
+    updateStyle(style: ComponentStyle): SerializableCommand;
+    /**
+     * Set the style of this component in a way that can't be undone/redone
+     * (does not create a command).
+     *
+     * Prefer `updateStyle(style).apply(editor)`.
+     */
+    forceStyle(style: ComponentStyle, editor: Editor | null): void;
+    isRestylableComponent: true;
+}
+export default RestyleableComponent;

package/dist/{src/components/RestylableComponent.js → mjs/src/components/RestylableComponent.mjs}

@@ -1,7 +1,7 @@
-import Color4 from '../Color4';
-import SerializableCommand from '../commands/SerializableCommand';
-import UnresolvedSerializableCommand from '../commands/UnresolvedCommand';
-import { textStyleFromJSON, textStyleToJSON } from '../rendering/TextRenderingStyle';
+import  Color4  from '../Color4.mjs';
+import  SerializableCommand  from '../commands/SerializableCommand.mjs';
+import  UnresolvedSerializableCommand  from '../commands/UnresolvedCommand.mjs';
+import  { textStyleFromJSON, textStyleToJSON }  from '../rendering/TextRenderingStyle.mjs';
 const serializeComponentStyle = (style) => {
     const result = {};
     if (style.color) {

package/dist/mjs/src/components/SVGGlobalAttributesObject.d.ts

@@ -0,0 +1,21 @@
+import LineSegment2 from '../math/LineSegment2';
+import Mat33 from '../math/Mat33';
+import Rect2 from '../math/Rect2';
+import AbstractRenderer from '../rendering/renderers/AbstractRenderer';
+import AbstractComponent from './AbstractComponent';
+import { ImageComponentLocalization } from './localization';
+type GlobalAttrsList = Array<[string, string | null]>;
+export default class SVGGlobalAttributesObject extends AbstractComponent {
+    private readonly attrs;
+    protected contentBBox: Rect2;
+    constructor(attrs: GlobalAttrsList);
+    render(canvas: AbstractRenderer, _visibleRect?: Rect2): void;
+    intersects(_lineSegment: LineSegment2): boolean;
+    protected applyTransformation(_affineTransfm: Mat33): void;
+    isSelectable(): boolean;
+    protected createClone(): SVGGlobalAttributesObject;
+    description(localization: ImageComponentLocalization): string;
+    protected serializeToJSON(): string | null;
+    static deserializeFromString(data: string): AbstractComponent;
+}
+export {};

package/dist/{src/components/SVGGlobalAttributesObject.js → mjs/src/components/SVGGlobalAttributesObject.mjs}

@@ -4,9 +4,9 @@
 // @internal
 // @packageDocumentation
 //
-import Rect2 from '../math/Rect2';
-import SVGRenderer from '../rendering/renderers/SVGRenderer';
-import AbstractComponent from './AbstractComponent';
+import  Rect2  from '../math/Rect2.mjs';
+import  SVGRenderer  from '../rendering/renderers/SVGRenderer.mjs';
+import  AbstractComponent  from './AbstractComponent.mjs';
 const componentKind = 'svg-global-attributes';
 // Stores global SVG attributes (e.g. namespace identifiers.)
 export default class SVGGlobalAttributesObject extends AbstractComponent {

package/dist/mjs/src/components/Stroke.d.ts

@@ -0,0 +1,40 @@
+import SerializableCommand from '../commands/SerializableCommand';
+import LineSegment2 from '../math/LineSegment2';
+import Mat33 from '../math/Mat33';
+import Path from '../math/Path';
+import Rect2 from '../math/Rect2';
+import Editor from '../Editor';
+import AbstractRenderer, { RenderablePathSpec } from '../rendering/renderers/AbstractRenderer';
+import AbstractComponent from './AbstractComponent';
+import { ImageComponentLocalization } from './localization';
+import RestyleableComponent, { ComponentStyle } from './RestylableComponent';
+export default class Stroke extends AbstractComponent implements RestyleableComponent {
+    private parts;
+    protected contentBBox: Rect2;
+    readonly isRestylableComponent: true;
+    private approximateRenderingTime;
+    constructor(parts: RenderablePathSpec[]);
+    getStyle(): ComponentStyle;
+    updateStyle(style: ComponentStyle): SerializableCommand;
+    forceStyle(style: ComponentStyle, editor: Editor | null): void;
+    intersects(line: LineSegment2): boolean;
+    render(canvas: AbstractRenderer, visibleRect?: Rect2): void;
+    getProportionalRenderingTime(): number;
+    private bboxForPart;
+    protected applyTransformation(affineTransfm: Mat33): void;
+    getPath(): Path;
+    description(localization: ImageComponentLocalization): string;
+    protected createClone(): AbstractComponent;
+    protected serializeToJSON(): {
+        style: {
+            fill: string;
+            stroke: {
+                color: string;
+                width: number;
+            } | undefined;
+        };
+        path: string;
+    }[];
+    /** @internal */
+    static deserializeFromJSON(json: any): Stroke;
+}

package/dist/{src/components/Stroke.js → mjs/src/components/Stroke.mjs}

@@ -1,8 +1,8 @@
-import Path from '../math/Path';
-import Rect2 from '../math/Rect2';
-import { styleFromJSON, styleToJSON } from '../rendering/RenderingStyle';
-import AbstractComponent from './AbstractComponent';
-import { createRestyleComponentCommand } from './RestylableComponent';
+import  Path  from '../math/Path.mjs';
+import  Rect2  from '../math/Rect2.mjs';
+import  { styleFromJSON, styleToJSON }  from '../rendering/RenderingStyle.mjs';
+import  AbstractComponent  from './AbstractComponent.mjs';
+import  { createRestyleComponentCommand }  from './RestylableComponent.mjs';
 export default class Stroke extends AbstractComponent {
     // Creates a `Stroke` from the given `parts`. All parts should have the
     // same color.

package/dist/mjs/src/components/TextComponent.d.ts

@@ -0,0 +1,53 @@
+import SerializableCommand from '../commands/SerializableCommand';
+import LineSegment2 from '../math/LineSegment2';
+import Mat33 from '../math/Mat33';
+import Rect2 from '../math/Rect2';
+import Editor from '../Editor';
+import AbstractRenderer from '../rendering/renderers/AbstractRenderer';
+import { TextStyle } from '../rendering/TextRenderingStyle';
+import AbstractComponent from './AbstractComponent';
+import { ImageComponentLocalization } from './localization';
+import RestyleableComponent, { ComponentStyle } from './RestylableComponent';
+export default class TextComponent extends AbstractComponent implements RestyleableComponent {
+    protected readonly textObjects: Array<string | TextComponent>;
+    private transform;
+    private style;
+    protected contentBBox: Rect2;
+    readonly isRestylableComponent: true;
+    constructor(textObjects: Array<string | TextComponent>, transform: Mat33, style: TextStyle);
+    static applyTextStyles(ctx: CanvasRenderingContext2D, style: TextStyle): void;
+    private static textMeasuringCtx;
+    private static estimateTextDimens;
+    private static getTextDimens;
+    private computeBBoxOfPart;
+    private recomputeBBox;
+    private renderInternal;
+    render(canvas: AbstractRenderer, _visibleRect?: Rect2): void;
+    getProportionalRenderingTime(): number;
+    intersects(lineSegment: LineSegment2): boolean;
+    getStyle(): ComponentStyle;
+    updateStyle(style: ComponentStyle): SerializableCommand;
+    forceStyle(style: ComponentStyle, editor: Editor | null): void;
+    getTextStyle(): {
+        renderingStyle: {
+            fill: import("../Color4").default;
+            stroke: {
+                color: import("../Color4").default;
+                width: number;
+            } | undefined;
+        };
+        size: number;
+        fontFamily: string;
+        fontWeight?: string | undefined;
+        fontVariant?: string | undefined;
+    };
+    getBaselinePos(): import("../lib").Vec3;
+    getTransform(): Mat33;
+    protected applyTransformation(affineTransfm: Mat33): void;
+    protected createClone(): AbstractComponent;
+    getText(): string;
+    description(localizationTable: ImageComponentLocalization): string;
+    protected serializeToJSON(): Record<string, any>;
+    static deserializeFromString(json: any): TextComponent;
+    static fromLines(lines: string[], transform: Mat33, style: TextStyle): AbstractComponent;
+}

package/dist/{src/components/TextComponent.js → mjs/src/components/TextComponent.mjs}

@@ -1,10 +1,10 @@
-import LineSegment2 from '../math/LineSegment2';
-import Mat33 from '../math/Mat33';
-import Rect2 from '../math/Rect2';
-import { Vec2 } from '../math/Vec2';
-import { cloneTextStyle, textStyleFromJSON, textStyleToJSON } from '../rendering/TextRenderingStyle';
-import AbstractComponent from './AbstractComponent';
-import { createRestyleComponentCommand } from './RestylableComponent';
+import  LineSegment2  from '../math/LineSegment2.mjs';
+import  Mat33  from '../math/Mat33.mjs';
+import  Rect2  from '../math/Rect2.mjs';
+import  { Vec2 }  from '../math/Vec2.mjs';
+import  { cloneTextStyle, textStyleFromJSON, textStyleToJSON }  from '../rendering/TextRenderingStyle.mjs';
+import  AbstractComponent  from './AbstractComponent.mjs';
+import  { createRestyleComponentCommand }  from './RestylableComponent.mjs';
 const componentTypeId = 'text';
 export default class TextComponent extends AbstractComponent {
     constructor(textObjects, transform, style) {

package/dist/mjs/src/components/UnknownSVGObject.d.ts

@@ -0,0 +1,18 @@
+import LineSegment2 from '../math/LineSegment2';
+import Mat33 from '../math/Mat33';
+import Rect2 from '../math/Rect2';
+import AbstractRenderer from '../rendering/renderers/AbstractRenderer';
+import AbstractComponent from './AbstractComponent';
+import { ImageComponentLocalization } from './localization';
+export default class UnknownSVGObject extends AbstractComponent {
+    private svgObject;
+    protected contentBBox: Rect2;
+    constructor(svgObject: SVGElement);
+    render(canvas: AbstractRenderer, _visibleRect?: Rect2): void;
+    intersects(lineSegment: LineSegment2): boolean;
+    protected applyTransformation(_affineTransfm: Mat33): void;
+    isSelectable(): boolean;
+    protected createClone(): AbstractComponent;
+    description(localization: ImageComponentLocalization): string;
+    protected serializeToJSON(): string | null;
+}

package/dist/{src/components/UnknownSVGObject.js → mjs/src/components/UnknownSVGObject.mjs}

@@ -3,9 +3,9 @@
 // @internal
 // @packageDocumentation
 //
-import Rect2 from '../math/Rect2';
-import SVGRenderer from '../rendering/renderers/SVGRenderer';
-import AbstractComponent from './AbstractComponent';
+import  Rect2  from '../math/Rect2.mjs';
+import  SVGRenderer  from '../rendering/renderers/SVGRenderer.mjs';
+import  AbstractComponent  from './AbstractComponent.mjs';
 const componentId = 'unknown-svg-object';
 export default class UnknownSVGObject extends AbstractComponent {
     constructor(svgObject) {

package/dist/mjs/src/components/builders/ArrowBuilder.d.ts

@@ -0,0 +1,19 @@
+import Rect2 from '../../math/Rect2';
+import AbstractRenderer from '../../rendering/renderers/AbstractRenderer';
+import { StrokeDataPoint } from '../../types';
+import Viewport from '../../Viewport';
+import AbstractComponent from '../AbstractComponent';
+import { ComponentBuilder, ComponentBuilderFactory } from './types';
+export declare const makeArrowBuilder: ComponentBuilderFactory;
+export default class ArrowBuilder implements ComponentBuilder {
+    private readonly startPoint;
+    private readonly viewport;
+    private endPoint;
+    constructor(startPoint: StrokeDataPoint, viewport: Viewport);
+    private getLineWidth;
+    getBBox(): Rect2;
+    private buildPreview;
+    build(): AbstractComponent;
+    preview(renderer: AbstractRenderer): void;
+    addPoint(point: StrokeDataPoint): void;
+}