js-draw 0.17.4 → 0.18.0

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

@@ -0,0 +1,12 @@
+import Rect2 from '../../math/Rect2';
+import AbstractRenderer from '../../rendering/renderers/AbstractRenderer';
+import { StrokeDataPoint } from '../../types';
+import Viewport from '../../Viewport';
+import AbstractComponent from '../AbstractComponent';
+export interface ComponentBuilder {
+    getBBox(): Rect2;
+    build(): AbstractComponent;
+    preview(renderer: AbstractRenderer): void;
+    addPoint(point: StrokeDataPoint): void;
+}
+export type ComponentBuilderFactory = (startPoint: StrokeDataPoint, viewport: Viewport) => ComponentBuilder;

package/dist/mjs/src/components/builders/types.mjs

@@ -0,0 +1 @@
+export {};

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

@@ -1,12 +1,12 @@
 export * from './builders/types';
 export { makeFreehandLineBuilder } from './builders/FreehandLineBuilder';
 export { makePressureSensitiveFreehandLineBuilder } from './builders/PressureSensitiveFreehandLineBuilder';
-export { default as StrokeSmoother } from './util/StrokeSmoother';
+export { default as StrokeSmoother, Curve as StrokeSmootherCurve } from './util/StrokeSmoother';
 export * from './AbstractComponent';
 export { default as AbstractComponent } from './AbstractComponent';
 import Stroke from './Stroke';
 import TextComponent from './TextComponent';
 import ImageComponent from './ImageComponent';
-import { createRestyleComponentCommand, isRestylableComponent } from './RestylableComponent';
+import RestyleableComponent, { createRestyleComponentCommand, isRestylableComponent } from './RestylableComponent';
 import ImageBackground from './ImageBackground';
-export { Stroke, TextComponent as Text, createRestyleComponentCommand, isRestylableComponent, TextComponent, Stroke as StrokeComponent, ImageBackground as BackgroundComponent, ImageComponent, };
+export { Stroke, TextComponent as Text, RestyleableComponent, createRestyleComponentCommand, isRestylableComponent, TextComponent, Stroke as StrokeComponent, ImageBackground as BackgroundComponent, ImageComponent, };

package/dist/mjs/src/components/lib.mjs

@@ -0,0 +1,12 @@
+export  *  from './builders/types.mjs';
+export  { makeFreehandLineBuilder }  from './builders/FreehandLineBuilder.mjs';
+export  { makePressureSensitiveFreehandLineBuilder }  from './builders/PressureSensitiveFreehandLineBuilder.mjs';
+export  { default as StrokeSmoother }  from './util/StrokeSmoother.mjs';
+export  *  from './AbstractComponent.mjs';
+export  { default as AbstractComponent }  from './AbstractComponent.mjs';
+import  Stroke  from './Stroke.mjs';
+import  TextComponent  from './TextComponent.mjs';
+import  ImageComponent  from './ImageComponent.mjs';
+import  { createRestyleComponentCommand, isRestylableComponent }  from './RestylableComponent.mjs';
+import  ImageBackground  from './ImageBackground.mjs';
+export { Stroke, TextComponent as Text, createRestyleComponentCommand, isRestylableComponent, TextComponent, Stroke as StrokeComponent, ImageBackground as BackgroundComponent, ImageComponent, };

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

@@ -0,0 +1,11 @@
+export interface ImageComponentLocalization {
+    unlabeledImageNode: string;
+    text: (text: string) => string;
+    imageNode: (description: string) => string;
+    stroke: string;
+    svgObject: string;
+    emptyBackground: string;
+    filledBackgroundWithColor: (color: string) => string;
+    restyledElement: (elementDescription: string) => string;
+}
+export declare const defaultComponentLocalization: ImageComponentLocalization;

package/dist/mjs/src/components/util/StrokeSmoother.d.ts

@@ -0,0 +1,35 @@
+import { Vec2 } from '../../math/Vec2';
+import Rect2 from '../../math/Rect2';
+import { StrokeDataPoint } from '../../types';
+export interface Curve {
+    startPoint: Vec2;
+    startWidth: number;
+    controlPoint: Vec2;
+    endWidth: number;
+    endPoint: Vec2;
+}
+type OnCurveAddedCallback = (curve: Curve | null) => void;
+export declare class StrokeSmoother {
+    private startPoint;
+    private minFitAllowed;
+    private maxFitAllowed;
+    private onCurveAdded;
+    private isFirstSegment;
+    private buffer;
+    private lastPoint;
+    private lastExitingVec;
+    private currentCurve;
+    private curveStartWidth;
+    private curveEndWidth;
+    private momentum;
+    private bbox;
+    constructor(startPoint: StrokeDataPoint, minFitAllowed: number, maxFitAllowed: number, onCurveAdded: OnCurveAddedCallback);
+    getBBox(): Rect2;
+    preview(): Curve | null;
+    private approxCurrentCurveLength;
+    finalizeCurrentCurve(): void;
+    private currentSegmentToPath;
+    private computeExitingVec;
+    addPoint(newPoint: StrokeDataPoint): void;
+}
+export default StrokeSmoother;

package/dist/{src/components/util/StrokeSmoother.js → mjs/src/components/util/StrokeSmoother.mjs}

@@ -1,7 +1,7 @@
 import { Bezier } from 'bezier-js';
-import { Vec2 } from '../../math/Vec2';
-import Rect2 from '../../math/Rect2';
-import LineSegment2 from '../../math/LineSegment2';
+import  { Vec2 }  from '../../math/Vec2.mjs';
+import  Rect2  from '../../math/Rect2.mjs';
+import  LineSegment2  from '../../math/LineSegment2.mjs';
 // Handles stroke smoothing
 export class StrokeSmoother {
     constructor(startPoint, 

package/dist/mjs/src/components/util/describeComponentList.d.ts

@@ -0,0 +1,4 @@
+import AbstractComponent from '../AbstractComponent';
+import { ImageComponentLocalization } from '../localization';
+declare const _default: (localizationTable: ImageComponentLocalization, elems: AbstractComponent[]) => string | null;
+export default _default;

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

@@ -12,7 +12,7 @@
  *
  * @packageDocumentation
  */
-import Editor from './Editor';
+import Editor, { EditorSettings } from './Editor';
 export { default as EditorImage } from './EditorImage';
 export * from './types';
 export { default as getLocalizationTable } from './localizations/getLocalizationTable';
@@ -30,5 +30,5 @@ export * from './testing/lib';
 export { default as Pointer, PointerDevice } from './Pointer';
 export { default as HTMLToolbar } from './toolbar/HTMLToolbar';
 export { default as UndoRedoHistory } from './UndoRedoHistory';
-export { Editor };
+export { Editor, EditorSettings };
 export default Editor;

package/dist/mjs/src/lib.mjs

@@ -0,0 +1,34 @@
+/**
+ * The main entrypoint for the NPM package. Everything exported by this file
+ * is available through the [`js-draw` package](https://www.npmjs.com/package/js-draw).
+ *
+ * @example
+ * ```
+ * import { Editor, Vec3, Mat33 } from 'js-draw';
+ * ```
+ *
+ * @see
+ * {@link Editor}
+ *
+ * @packageDocumentation
+ */
+import  Editor  from './Editor.mjs';
+export  { default as EditorImage }  from './EditorImage.mjs';
+export  *  from './types.mjs';
+export  { default as getLocalizationTable }  from './localizations/getLocalizationTable.mjs';
+export  *  from './localization.mjs';
+export  { default as Color4 }  from './Color4.mjs';
+export  { default as SVGLoader }  from './SVGLoader.mjs';
+export  { default as Viewport }  from './Viewport.mjs';
+export  *  from './math/lib.mjs';
+export  *  from './components/lib.mjs';
+export  *  from './commands/lib.mjs';
+export  *  from './tools/lib.mjs';
+export  *  from './toolbar/lib.mjs';
+export  *  from './rendering/lib.mjs';
+export  *  from './testing/lib.mjs';
+export  { default as Pointer, PointerDevice }  from './Pointer.mjs';
+export  { default as HTMLToolbar }  from './toolbar/HTMLToolbar.mjs';
+export  { default as UndoRedoHistory }  from './UndoRedoHistory.mjs';
+export { Editor };
+export default Editor;

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

@@ -0,0 +1,14 @@
+import { CommandLocalization } from './commands/localization';
+import { ImageComponentLocalization } from './components/localization';
+import { TextRendererLocalization } from './rendering/localization';
+import { ToolbarLocalization } from './toolbar/localization';
+import { ToolLocalization } from './tools/localization';
+export interface EditorLocalization extends ToolbarLocalization, ToolLocalization, CommandLocalization, ImageComponentLocalization, TextRendererLocalization {
+    accessibilityInputInstructions: string;
+    undoAnnouncement: (actionDescription: string) => string;
+    redoAnnouncement: (actionDescription: string) => string;
+    doneLoading: string;
+    loading: (percentage: number) => string;
+    imageEditor: string;
+}
+export declare const defaultEditorLocalization: EditorLocalization;

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

@@ -1,8 +1,8 @@
-import { defaultCommandLocalization } from './commands/localization';
-import { defaultComponentLocalization } from './components/localization';
-import { defaultTextRendererLocalization } from './rendering/localization';
-import { defaultToolbarLocalization } from './toolbar/localization';
-import { defaultToolLocalization } from './tools/localization';
+import  { defaultCommandLocalization }  from './commands/localization.mjs';
+import  { defaultComponentLocalization }  from './components/localization.mjs';
+import  { defaultTextRendererLocalization }  from './rendering/localization.mjs';
+import  { defaultToolbarLocalization }  from './toolbar/localization.mjs';
+import  { defaultToolLocalization }  from './tools/localization.mjs';
 export const defaultEditorLocalization = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, defaultToolbarLocalization), defaultToolLocalization), defaultCommandLocalization), defaultComponentLocalization), defaultTextRendererLocalization), { accessibilityInputInstructions: [
         'Press "t" to read the contents of the viewport as text.',
         'Use the arrow keys to move the viewport, click and drag to draw strokes.',

package/dist/mjs/src/localizations/de.d.ts

@@ -0,0 +1,3 @@
+import { EditorLocalization } from '../localization';
+declare const localization: EditorLocalization;
+export default localization;

package/dist/{src/localizations/de.js → mjs/src/localizations/de.mjs}

@@ -1,4 +1,4 @@
-import { defaultEditorLocalization } from '../localization';
+import  { defaultEditorLocalization }  from '../localization.mjs';
 // German localization
 const localization = Object.assign(Object.assign({}, defaultEditorLocalization), { pen: 'Stift', eraser: 'Radierer', select: 'Auswahl', handTool: 'Verschieben', zoom: 'Vergrößerung', resetView: 'Ansicht zurücksetzen', thicknessLabel: 'Dicke: ', colorLabel: 'Farbe: ', fontLabel: 'Schriftart: ', resizeImageToSelection: 'Bildgröße an Auswahl anpassen', deleteSelection: 'Auswahl löschen', duplicateSelection: 'Auswahl duplizieren', undo: 'Rückgängig', redo: 'Wiederholen', pickColorFromScreen: 'Farbe von Bildschirm auswählen', clickToPickColorAnnouncement: 'Klicke auf den Bildschirm, um eine Farbe auszuwählen', selectionToolKeyboardShortcuts: 'Auswahl-Werkzeug: Verwende die Pfeiltasten, um ausgewählte Elemente zu verschieben und ‚i‘ und ‚o‘, um ihre Größe zu ändern.', touchPanning: 'Ansicht mit Touchscreen verschieben', anyDevicePanning: 'Ansicht mit jedem Eingabegerät verschieben', selectObjectType: 'Objekt-Typ: ', freehandPen: 'Freihand', arrowPen: 'Pfeil', linePen: 'Linie', outlinedRectanglePen: 'Umrissenes Rechteck', filledRectanglePen: 'Ausgefülltes Rechteck', dropdownShown: t => `Dropdown-Menü für ${t} angezeigt`, dropdownHidden: t => `Dropdown-Menü für ${t} versteckt`, zoomLevel: t => `Vergößerung: ${t}%`, colorChangedAnnouncement: t => `Farbe zu ${t} geändert`, penTool: t => `Stift ${t}`, selectionTool: 'Auswahl', eraserTool: 'Radiergummi', touchPanTool: 'Ansicht mit Touchscreen verschieben', twoFingerPanZoomTool: 'Ansicht verschieben und vergrößern', undoRedoTool: 'Rückgängig/Wiederholen', rightClickDragPanTool: 'Rechtsklick-Ziehen', pipetteTool: 'Farbe von Bildschirm auswählen', keyboardPanZoom: 'Tastaturkürzel zum Verschieben/Vergrößern der Ansicht', textTool: 'Text', enterTextToInsert: 'Einzufügender Text', toolEnabledAnnouncement: t => `${t} aktiviert`, toolDisabledAnnouncement: t => `${t} deaktiviert`, updatedViewport: 'Transformierte Ansicht', transformedElements: t => `${t} Element${1 === t ? '' : 'e'} transformiert`, resizeOutputCommand: t => `Bildgröße auf ${t.w}x${t.h} geändert`, addElementAction: t => `${t} hinzugefügt`, eraseAction: (t, e) => `${e} ${t} gelöscht`, duplicateAction: (t, e) => `${e} ${t} dupliziert`, inverseOf: t => `Umkehrung von ${t}`, elements: 'Elemente', erasedNoElements: 'Nichts entfernt', duplicatedNoElements: 'Nichts dupliziert', rotatedBy: t => `${Math.abs(t)} Grad ${t < 0 ? 'im Uhrzeigersinn' : 'gegen den Uhrzeigersinn'} gedreht`, movedLeft: 'Nacht links bewegt', movedUp: 'Nacht oben bewegt', movedDown: 'Nacht unten bewegt', movedRight: 'Nacht rechts bewegt', zoomedOut: 'Ansicht verkleinert', zoomedIn: 'Ansicht vergrößert', selectedElements: t => `${t} Element${1 === t ? '' : 'e'} ausgewählt`, stroke: 'Strich', svgObject: 'SVG-Objekt', text: t => `Text-Objekt: ${t}`, pathNodeCount: t => `Es gibt ${t} sichtbare Pfad-Objekte.`, textNodeCount: t => `Es gibt ${t} sichtbare Text-Knotenpunkte.`, textNode: t => `Text: ${t}`, rerenderAsText: 'Als Text darstellen', accessibilityInputInstructions: 'Drücke ‚t‘, um den Inhalt des Ansichtsfensters als Text zu lesen. Verwende die Pfeiltasten, um die Ansicht zu verschieben, und klicke und ziehe, um Striche zu zeichnen. Drücke ‚w‘ zum Vergrößern und ‚s‘ zum Verkleinern der Ansicht.', loading: t => `Laden ${t}%...`, doneLoading: 'Laden fertig', imageEditor: 'Bild-Editor', undoAnnouncement: t => `Rückgangig gemacht ${t}`, redoAnnouncement: t => `Wiederholt ${t}` });
 export default localization;

package/dist/mjs/src/localizations/en.d.ts

@@ -0,0 +1,3 @@
+import { EditorLocalization } from '../localization';
+declare const localization: EditorLocalization;
+export default localization;

package/dist/{src/localizations/en.js → mjs/src/localizations/en.mjs}

@@ -1,4 +1,4 @@
-import { defaultEditorLocalization } from '../localization';
+import  { defaultEditorLocalization }  from '../localization.mjs';
 // Default localizations are already in English.
 const localization = Object.assign({}, defaultEditorLocalization);
 export default localization;

package/dist/mjs/src/localizations/es.d.ts

@@ -0,0 +1,3 @@
+import { EditorLocalization } from '../localization';
+declare const localization: EditorLocalization;
+export default localization;

package/dist/{src/localizations/es.js → mjs/src/localizations/es.mjs}

@@ -1,4 +1,4 @@
-import { defaultEditorLocalization } from '../localization';
+import  { defaultEditorLocalization }  from '../localization.mjs';
 // A partial Spanish localization.
 const localization = Object.assign(Object.assign({}, defaultEditorLocalization), { 
     // Strings for the main editor interface

package/dist/mjs/src/localizations/getLocalizationTable.d.ts

@@ -0,0 +1,3 @@
+import { EditorLocalization } from '../localization';
+declare const getLocalizationTable: (userLocales?: readonly string[]) => EditorLocalization;
+export default getLocalizationTable;

package/dist/{src/localizations/getLocalizationTable.js → mjs/src/localizations/getLocalizationTable.mjs}

@@ -1,7 +1,7 @@
-import { defaultEditorLocalization } from '../localization';
-import de from './de';
-import en from './en';
-import es from './es';
+import  { defaultEditorLocalization }  from '../localization.mjs';
+import  de  from './de.mjs';
+import  en  from './en.mjs';
+import  es  from './es.mjs';
 const allLocales = {
     de,
     en,

package/dist/mjs/src/math/LineSegment2.d.ts

@@ -0,0 +1,24 @@
+import Mat33 from './Mat33';
+import Rect2 from './Rect2';
+import { Vec2, Point2 } from './Vec2';
+interface IntersectionResult {
+    point: Point2;
+    t: number;
+}
+export default class LineSegment2 {
+    private readonly point1;
+    private readonly point2;
+    readonly direction: Vec2;
+    readonly length: number;
+    readonly bbox: Rect2;
+    constructor(point1: Point2, point2: Point2);
+    get p1(): Point2;
+    get p2(): Point2;
+    get(t: number): Point2;
+    intersection(other: LineSegment2): IntersectionResult | null;
+    intersects(other: LineSegment2): boolean;
+    closestPointTo(target: Point2): import("./Vec3").default;
+    transformedBy(affineTransfm: Mat33): LineSegment2;
+    toString(): string;
+}
+export {};

package/dist/{src/math/LineSegment2.js → mjs/src/math/LineSegment2.mjs}

@@ -1,5 +1,5 @@
-import Rect2 from './Rect2';
-import { Vec2 } from './Vec2';
+import  Rect2  from './Rect2.mjs';
+import  { Vec2 }  from './Vec2.mjs';
 export default class LineSegment2 {
     constructor(point1, point2) {
         this.point1 = point1;

package/dist/mjs/src/math/Mat33.d.ts

@@ -0,0 +1,118 @@
+import { Point2, Vec2 } from './Vec2';
+import Vec3 from './Vec3';
+export type Mat33Array = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+/**
+ * Represents a three dimensional linear transformation or
+ * a two-dimensional affine transformation. (An affine transformation scales/rotates/shears
+ * **and** translates while a linear transformation just scales/rotates/shears).
+ */
+export default class Mat33 {
+    readonly a1: number;
+    readonly a2: number;
+    readonly a3: number;
+    readonly b1: number;
+    readonly b2: number;
+    readonly b3: number;
+    readonly c1: number;
+    readonly c2: number;
+    readonly c3: number;
+    private readonly rows;
+    /**
+     * Creates a matrix from inputs in the form,
+     * ```
+     * ⎡ a1 a2 a3 ⎤
+     * ⎢ b1 b2 b3 ⎥
+     * ⎣ c1 c2 c3 ⎦
+     * ```
+     */
+    constructor(a1: number, a2: number, a3: number, b1: number, b2: number, b3: number, c1: number, c2: number, c3: number);
+    /**
+     * Creates a matrix from the given rows:
+     * ```
+     *  ⎡ r1.x r1.y r1.z ⎤
+     *  ⎢ r2.x r2.y r2.z ⎥
+     *  ⎣ r3.x r3.y r3.z ⎦
+     * ```
+     */
+    static ofRows(r1: Vec3, r2: Vec3, r3: Vec3): Mat33;
+    static identity: Mat33;
+    /**
+     * Either returns the inverse of this, or, if this matrix is singular/uninvertable,
+     * returns Mat33.identity.
+     *
+     * This may cache the computed inverse and return the cached version instead of recomputing
+     * it.
+     */
+    inverse(): Mat33;
+    invertable(): boolean;
+    private cachedInverse;
+    private computeInverse;
+    transposed(): Mat33;
+    rightMul(other: Mat33): Mat33;
+    /**
+     * Applies this as an affine transformation to the given vector.
+     * Returns a transformed version of `other`.
+     */
+    transformVec2(other: Vec2): Vec2;
+    /**
+     * Applies this as a linear transformation to the given vector (doesn't translate).
+     * This is the standard way of transforming vectors in ℝ³.
+     */
+    transformVec3(other: Vec3): Vec3;
+    /** @returns true iff this is the identity matrix. */
+    isIdentity(): boolean;
+    /** Returns true iff this = other ± fuzz */
+    eq(other: Mat33, fuzz?: number): boolean;
+    toString(): string;
+    /**
+     * ```
+     * result[0] = top left element
+     * result[1] = element at row zero, column 1
+     * ...
+     * ```
+     */
+    toArray(): Mat33Array;
+    /**
+     * @example
+     * ```
+     * new Mat33(
+     *  1, 2, 3,
+     *  4, 5, 6,
+     *  7, 8, 9,
+     * ).mapEntries(component => component - 1);
+     * // → ⎡ 0, 1, 2 ⎤
+     * //   ⎢ 3, 4, 5 ⎥
+     * //   ⎣ 6, 7, 8 ⎦
+     * ```
+     */
+    mapEntries(mapping: (component: number) => number): Mat33;
+    /** Estimate the scale factor of this matrix (based on the first row). */
+    getScaleFactor(): number;
+    /** Constructs a 3x3 translation matrix (for translating `Vec2`s) */
+    static translation(amount: Vec2): Mat33;
+    static zRotation(radians: number, center?: Point2): Mat33;
+    static scaling2D(amount: number | Vec2, center?: Point2): Mat33;
+    /** @see {@link fromCSSMatrix} */
+    toCSSMatrix(): string;
+    /**
+     * Converts a CSS-form `matrix(a, b, c, d, e, f)` to a Mat33.
+     *
+     * Note that such a matrix has the form,
+     * ```
+     * ⎡ a c e ⎤
+     * ⎢ b d f ⎥
+     * ⎣ 0 0 1 ⎦
+     * ```
+     */
+    static fromCSSMatrix(cssString: string): Mat33;
+}

package/dist/{src/math/Mat33.js → mjs/src/math/Mat33.mjs}

@@ -1,5 +1,5 @@
-import { Vec2 } from './Vec2';
-import Vec3 from './Vec3';
+import  { Vec2 }  from './Vec2.mjs';
+import  Vec3  from './Vec3.mjs';
 /**
  * Represents a three dimensional linear transformation or
  * a two-dimensional affine transformation. (An affine transformation scales/rotates/shears

package/dist/mjs/src/math/Path.d.ts

@@ -0,0 +1,71 @@
+import { Bezier } from 'bezier-js';
+import { RenderablePathSpec } from '../rendering/renderers/AbstractRenderer';
+import RenderingStyle from '../rendering/RenderingStyle';
+import LineSegment2 from './LineSegment2';
+import Mat33 from './Mat33';
+import Rect2 from './Rect2';
+import { Point2 } from './Vec2';
+export declare enum PathCommandType {
+    LineTo = 0,
+    MoveTo = 1,
+    CubicBezierTo = 2,
+    QuadraticBezierTo = 3
+}
+export interface CubicBezierPathCommand {
+    kind: PathCommandType.CubicBezierTo;
+    controlPoint1: Point2;
+    controlPoint2: Point2;
+    endPoint: Point2;
+}
+export interface QuadraticBezierPathCommand {
+    kind: PathCommandType.QuadraticBezierTo;
+    controlPoint: Point2;
+    endPoint: Point2;
+}
+export interface LinePathCommand {
+    kind: PathCommandType.LineTo;
+    point: Point2;
+}
+export interface MoveToPathCommand {
+    kind: PathCommandType.MoveTo;
+    point: Point2;
+}
+export type PathCommand = CubicBezierPathCommand | LinePathCommand | QuadraticBezierPathCommand | MoveToPathCommand;
+interface IntersectionResult {
+    curve: LineSegment2 | Bezier;
+    parameterValue: number;
+    point: Point2;
+}
+export default class Path {
+    readonly startPoint: Point2;
+    readonly parts: PathCommand[];
+    readonly bbox: Rect2;
+    constructor(startPoint: Point2, parts: PathCommand[]);
+    private cachedGeometry;
+    get geometry(): Array<LineSegment2 | Bezier>;
+    private cachedPolylineApproximation;
+    polylineApproximation(): LineSegment2[];
+    static computeBBoxForSegment(startPoint: Point2, part: PathCommand): Rect2;
+    intersection(line: LineSegment2): IntersectionResult[];
+    private static mapPathCommand;
+    mapPoints(mapping: (point: Point2) => Point2): Path;
+    transformedBy(affineTransfm: Mat33): Path;
+    union(other: Path | null): Path;
+    private getEndPoint;
+    roughlyIntersects(rect: Rect2, strokeWidth?: number): boolean;
+    closedRoughlyIntersects(rect: Rect2): boolean;
+    static fromRect(rect: Rect2, lineWidth?: number | null): Path;
+    static fromRenderable(renderable: RenderablePathSpec): Path;
+    toRenderable(fill: RenderingStyle): RenderablePathSpec;
+    /**
+     * @returns a Path that, when rendered, looks roughly equivalent to the given path.
+     */
+    static visualEquivalent(renderablePath: RenderablePathSpec, visibleRect: Rect2): RenderablePathSpec;
+    private cachedStringVersion;
+    toString(useNonAbsCommands?: boolean): string;
+    serialize(): string;
+    static toString(startPoint: Point2, parts: PathCommand[], onlyAbsCommands?: boolean): string;
+    static fromString(pathString: string): Path;
+    static empty: Path;
+}
+export {};

package/dist/{src/math/Path.js → mjs/src/math/Path.mjs}

@@ -1,9 +1,9 @@
 import { Bezier } from 'bezier-js';
-import { toRoundedString, toStringOfSamePrecision } from './rounding';
-import LineSegment2 from './LineSegment2';
-import Mat33 from './Mat33';
-import Rect2 from './Rect2';
-import { Vec2 } from './Vec2';
+import  { toRoundedString, toStringOfSamePrecision }  from './rounding.mjs';
+import  LineSegment2  from './LineSegment2.mjs';
+import  Mat33  from './Mat33.mjs';
+import  Rect2  from './Rect2.mjs';
+import  { Vec2 }  from './Vec2.mjs';
 export var PathCommandType;
 (function (PathCommandType) {
     PathCommandType[PathCommandType["LineTo"] = 0] = "LineTo";

package/dist/mjs/src/math/Rect2.d.ts

@@ -0,0 +1,52 @@
+import LineSegment2 from './LineSegment2';
+import Mat33 from './Mat33';
+import { Point2, Vec2 } from './Vec2';
+/** An object that can be converted to a Rect2. */
+export interface RectTemplate {
+    x: number;
+    y: number;
+    w?: number;
+    h?: number;
+    width?: number;
+    height?: number;
+}
+export default class Rect2 {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+    readonly topLeft: Point2;
+    readonly size: Vec2;
+    readonly bottomRight: Point2;
+    readonly center: Point2;
+    readonly area: number;
+    constructor(x: number, y: number, w: number, h: number);
+    translatedBy(vec: Vec2): Rect2;
+    resizedTo(size: Vec2): Rect2;
+    containsPoint(other: Point2): boolean;
+    containsRect(other: Rect2): boolean;
+    intersects(other: Rect2): boolean;
+    intersection(other: Rect2): Rect2 | null;
+    union(other: Rect2): Rect2;
+    divideIntoGrid(columns: number, rows: number): Rect2[];
+    grownToPoint(point: Point2, margin?: number): Rect2;
+    grownBy(margin: number): Rect2;
+    getClosestPointOnBoundaryTo(target: Point2): import("./Vec3").default;
+    get corners(): Point2[];
+    get maxDimension(): number;
+    get topRight(): import("./Vec3").default;
+    get bottomLeft(): import("./Vec3").default;
+    get width(): number;
+    get height(): number;
+    getEdges(): LineSegment2[];
+    transformedBoundingBox(affineTransform: Mat33): Rect2;
+    /** @return true iff this is equal to [other] ± fuzz */
+    eq(other: Rect2, fuzz?: number): boolean;
+    toString(): string;
+    static fromCorners(corner1: Point2, corner2: Point2): Rect2;
+    static bboxOf(points: Point2[], margin?: number): Rect2;
+    static union(...rects: Rect2[]): Rect2;
+    static of(template: RectTemplate): Rect2;
+    static empty: Rect2;
+    static unitSquare: Rect2;
+}

package/dist/{src/math/Rect2.js → mjs/src/math/Rect2.mjs}

@@ -1,5 +1,5 @@
-import LineSegment2 from './LineSegment2';
-import { Vec2 } from './Vec2';
+import  LineSegment2  from './LineSegment2.mjs';
+import  { Vec2 }  from './Vec2.mjs';
 // invariant: w ≥ 0, h ≥ 0.
 export default class Rect2 {
     constructor(x, y, w, h) {

package/dist/mjs/src/math/Triangle.d.ts

@@ -0,0 +1,11 @@
+import Mat33 from './Mat33';
+import Vec3 from './Vec3';
+export default class Triangle {
+    readonly vertex1: Vec3;
+    readonly vertex2: Vec3;
+    readonly vertex3: Vec3;
+    constructor(vertex1: Vec3, vertex2: Vec3, vertex3: Vec3);
+    map(mapping: (vertex: Vec3) => Vec3): Triangle;
+    transformed2DBy(affineTransform: Mat33): Triangle;
+    transformedBy(linearTransform: Mat33): Triangle;
+}

package/dist/mjs/src/math/Vec2.d.ts

@@ -0,0 +1,13 @@
+import Vec3 from './Vec3';
+export declare namespace Vec2 {
+    const of: (x: number, y: number) => Vec2;
+    const ofXY: ({ x, y }: {
+        x: number;
+        y: number;
+    }) => Vec2;
+    const unitX: Vec3;
+    const unitY: Vec3;
+    const zero: Vec3;
+}
+export type Point2 = Vec3;
+export type Vec2 = Vec3;

package/dist/{src/math/Vec2.js → mjs/src/math/Vec2.mjs}

@@ -1,4 +1,4 @@
-import Vec3 from './Vec3';
+import  Vec3  from './Vec3.mjs';
 export var Vec2;
 (function (Vec2) {
     Vec2.of = (x, y) => {