js-draw 0.17.4 → 0.18.0

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

package/dist/{src/components/builders/ArrowBuilder.js → mjs/src/components/builders/ArrowBuilder.mjs}

@@ -1,5 +1,5 @@
-import Path, { PathCommandType } from '../../math/Path';
-import Stroke from '../Stroke';
+import  Path, { PathCommandType }  from '../../math/Path.mjs';
+import  Stroke  from '../Stroke.mjs';
 export const makeArrowBuilder = (initialPoint, viewport) => {
     return new ArrowBuilder(initialPoint, viewport);
 };

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

@@ -0,0 +1,33 @@
+import AbstractRenderer, { RenderablePathSpec } from '../../rendering/renderers/AbstractRenderer';
+import Rect2 from '../../math/Rect2';
+import Stroke from '../Stroke';
+import Viewport from '../../Viewport';
+import { StrokeDataPoint } from '../../types';
+import { ComponentBuilder, ComponentBuilderFactory } from './types';
+import RenderingStyle from '../../rendering/RenderingStyle';
+export declare const makeFreehandLineBuilder: ComponentBuilderFactory;
+export default class FreehandLineBuilder implements ComponentBuilder {
+    private startPoint;
+    private minFitAllowed;
+    private viewport;
+    private isFirstSegment;
+    private parts;
+    private curveFitter;
+    private bbox;
+    private averageWidth;
+    private widthAverageNumSamples;
+    constructor(startPoint: StrokeDataPoint, minFitAllowed: number, maxFitAllowed: number, viewport: Viewport);
+    getBBox(): Rect2;
+    protected getRenderingStyle(): RenderingStyle;
+    protected previewCurrentPath(): RenderablePathSpec | null;
+    protected previewFullPath(): RenderablePathSpec[] | null;
+    private previewStroke;
+    preview(renderer: AbstractRenderer): void;
+    build(): Stroke;
+    private getMinFit;
+    private roundPoint;
+    private roundDistance;
+    private curveToPathCommands;
+    private addCurve;
+    addPoint(newPoint: StrokeDataPoint): void;
+}

package/dist/{src/components/builders/FreehandLineBuilder.js → mjs/src/components/builders/FreehandLineBuilder.mjs}

@@ -1,10 +1,10 @@
-import { Vec2 } from '../../math/Vec2';
-import Rect2 from '../../math/Rect2';
-import { PathCommandType } from '../../math/Path';
-import Stroke from '../Stroke';
-import Viewport from '../../Viewport';
-import { StrokeSmoother } from '../util/StrokeSmoother';
-import Color4 from '../../Color4';
+import  { Vec2 }  from '../../math/Vec2.mjs';
+import  Rect2  from '../../math/Rect2.mjs';
+import  { PathCommandType }  from '../../math/Path.mjs';
+import  Stroke  from '../Stroke.mjs';
+import  Viewport  from '../../Viewport.mjs';
+import  { StrokeSmoother }  from '../util/StrokeSmoother.mjs';
+import  Color4  from '../../Color4.mjs';
 export const makeFreehandLineBuilder = (initialPoint, viewport) => {
     // Don't smooth if input is more than ± 3 pixels from the true curve, do smooth if
     // less than ±1 px from the curve.

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

@@ -0,0 +1,18 @@
+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 makeLineBuilder: ComponentBuilderFactory;
+export default class LineBuilder implements ComponentBuilder {
+    private readonly startPoint;
+    private readonly viewport;
+    private endPoint;
+    constructor(startPoint: StrokeDataPoint, viewport: Viewport);
+    getBBox(): Rect2;
+    private buildPreview;
+    build(): AbstractComponent;
+    preview(renderer: AbstractRenderer): void;
+    addPoint(point: StrokeDataPoint): void;
+}

package/dist/{src/components/builders/LineBuilder.js → mjs/src/components/builders/LineBuilder.mjs}

@@ -1,5 +1,5 @@
-import Path, { PathCommandType } from '../../math/Path';
-import Stroke from '../Stroke';
+import  Path, { PathCommandType }  from '../../math/Path.mjs';
+import  Stroke  from '../Stroke.mjs';
 export const makeLineBuilder = (initialPoint, viewport) => {
     return new LineBuilder(initialPoint, viewport);
 };

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

@@ -0,0 +1,36 @@
+import AbstractRenderer from '../../rendering/renderers/AbstractRenderer';
+import Rect2 from '../../math/Rect2';
+import Stroke from '../Stroke';
+import Viewport from '../../Viewport';
+import { StrokeDataPoint } from '../../types';
+import { ComponentBuilder, ComponentBuilderFactory } from './types';
+export declare const makePressureSensitiveFreehandLineBuilder: ComponentBuilderFactory;
+export default class PressureSensitiveFreehandLineBuilder implements ComponentBuilder {
+    private startPoint;
+    private minFitAllowed;
+    private viewport;
+    private isFirstSegment;
+    private pathStartConnector;
+    private mostRecentConnector;
+    private upperSegments;
+    private lowerSegments;
+    private lastUpperBezier;
+    private lastLowerBezier;
+    private parts;
+    private curveFitter;
+    private curveStartWidth;
+    private bbox;
+    constructor(startPoint: StrokeDataPoint, minFitAllowed: number, maxFitAllowed: number, viewport: Viewport);
+    getBBox(): Rect2;
+    private getRenderingStyle;
+    private previewCurrentPath;
+    private previewFullPath;
+    private previewStroke;
+    preview(renderer: AbstractRenderer): void;
+    build(): Stroke;
+    private roundPoint;
+    private shouldStartNewSegment;
+    private addCurve;
+    private segmentToPath;
+    addPoint(newPoint: StrokeDataPoint): void;
+}

package/dist/{src/components/builders/PressureSensitiveFreehandLineBuilder.js → mjs/src/components/builders/PressureSensitiveFreehandLineBuilder.mjs}

@@ -1,10 +1,10 @@
 import { Bezier } from 'bezier-js';
-import { Vec2 } from '../../math/Vec2';
-import Rect2 from '../../math/Rect2';
-import { PathCommandType } from '../../math/Path';
-import Stroke from '../Stroke';
-import Viewport from '../../Viewport';
-import { StrokeSmoother } from '../util/StrokeSmoother';
+import  { Vec2 }  from '../../math/Vec2.mjs';
+import  Rect2  from '../../math/Rect2.mjs';
+import  { PathCommandType }  from '../../math/Path.mjs';
+import  Stroke  from '../Stroke.mjs';
+import  Viewport  from '../../Viewport.mjs';
+import  { StrokeSmoother }  from '../util/StrokeSmoother.mjs';
 export const makePressureSensitiveFreehandLineBuilder = (initialPoint, viewport) => {
     // Don't smooth if input is more than ± 3 pixels from the true curve, do smooth if
     // less than ±1 px from the curve.

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

@@ -0,0 +1,20 @@
+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 makeFilledRectangleBuilder: ComponentBuilderFactory;
+export declare const makeOutlinedRectangleBuilder: ComponentBuilderFactory;
+export default class RectangleBuilder implements ComponentBuilder {
+    private readonly startPoint;
+    private filled;
+    private viewport;
+    private endPoint;
+    constructor(startPoint: StrokeDataPoint, filled: boolean, viewport: Viewport);
+    getBBox(): Rect2;
+    private buildPreview;
+    build(): AbstractComponent;
+    preview(renderer: AbstractRenderer): void;
+    addPoint(point: StrokeDataPoint): void;
+}

package/dist/{src/components/builders/RectangleBuilder.js → mjs/src/components/builders/RectangleBuilder.mjs}

@@ -1,7 +1,7 @@
-import Mat33 from '../../math/Mat33';
-import Path from '../../math/Path';
-import Rect2 from '../../math/Rect2';
-import Stroke from '../Stroke';
+import  Mat33  from '../../math/Mat33.mjs';
+import  Path  from '../../math/Path.mjs';
+import  Rect2  from '../../math/Rect2.mjs';
+import  Stroke  from '../Stroke.mjs';
 export const makeFilledRectangleBuilder = (initialPoint, viewport) => {
     return new RectangleBuilder(initialPoint, true, viewport);
 };