js-draw 0.17.3 → 0.18.0

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

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}

@@ -1,6 +1,6 @@
 /**
  * The main entrypoint for the NPM package. Everything exported by this file
- * is available through the `js-draw` package.
+ * is available through the [`js-draw` package](https://www.npmjs.com/package/js-draw).
  *
  * @example
  * ```
@@ -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';
@@ -26,8 +26,9 @@ export * from './commands/lib';
 export * from './tools/lib';
 export * from './toolbar/lib';
 export * from './rendering/lib';
+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