js-draw 0.1.9 → 0.1.12

package/dist/src/Editor.d.ts

@@ -4,17 +4,19 @@ import { InputEvtType, EditorNotifier, ImageLoader } from './types';
 import Command from './commands/Command';
 import UndoRedoHistory from './UndoRedoHistory';
 import Viewport from './Viewport';
-import { Point2 } from './geometry/Vec2';
+import { Point2 } from './math/Vec2';
 import HTMLToolbar from './toolbar/HTMLToolbar';
 import { RenderablePathSpec } from './rendering/renderers/AbstractRenderer';
 import Display, { RenderingMode } from './rendering/Display';
 import Pointer from './Pointer';
-import Rect2 from './geometry/Rect2';
+import Rect2 from './math/Rect2';
 import { EditorLocalization } from './localization';
 export interface EditorSettings {
     renderingMode: RenderingMode;
     localization: Partial<EditorLocalization>;
     wheelEventsEnabled: boolean | 'only-if-focused';
+    minZoom: number;
+    maxZoom: number;
 }
 export declare class Editor {
     private container;
@@ -29,14 +31,17 @@ export declare class Editor {
     notifier: EditorNotifier;
     private loadingWarning;
     private accessibilityAnnounceArea;
+    private accessibilityControlArea;
     private settings;
     constructor(parent: HTMLElement, settings?: Partial<EditorSettings>);
     getRootElement(): HTMLElement;
     showLoadingWarning(fractionLoaded: number): void;
     hideLoadingWarning(): void;
+    private previousAccessibilityAnnouncement;
     announceForAccessibility(message: string): void;
     addToolbar(defaultLayout?: boolean): HTMLToolbar;
     private registerListeners;
+    handleKeyEventsFrom(elem: HTMLElement): void;
     dispatch(command: Command, addToHistory?: boolean): void;
     dispatchNoAnnounce(command: Command, addToHistory?: boolean): void;
     private asyncApplyOrUnapplyCommands;

package/dist/src/Editor.js

@@ -14,33 +14,35 @@ import Command from './commands/Command';
 import UndoRedoHistory from './UndoRedoHistory';
 import Viewport from './Viewport';
 import EventDispatcher from './EventDispatcher';
-import { Vec2 } from './geometry/Vec2';
-import Vec3 from './geometry/Vec3';
+import { Vec2 } from './math/Vec2';
+import Vec3 from './math/Vec3';
 import HTMLToolbar from './toolbar/HTMLToolbar';
 import Display, { RenderingMode } from './rendering/Display';
 import SVGRenderer from './rendering/renderers/SVGRenderer';
 import Color4 from './Color4';
 import SVGLoader from './SVGLoader';
 import Pointer from './Pointer';
-import Mat33 from './geometry/Mat33';
-import { defaultEditorLocalization } from './localization';
+import Mat33 from './math/Mat33';
+import getLocalizationTable from './localizations/getLocalizationTable';
 export class Editor {
     constructor(parent, settings = {}) {
-        var _a, _b;
-        this.localization = defaultEditorLocalization;
+        var _a, _b, _c, _d;
+        this.previousAccessibilityAnnouncement = '';
         this.announceUndoCallback = (command) => {
-            this.announceForAccessibility(this.localization.undoAnnouncement(command.description(this.localization)));
+            this.announceForAccessibility(this.localization.undoAnnouncement(command.description(this, this.localization)));
         };
         this.announceRedoCallback = (command) => {
-            this.announceForAccessibility(this.localization.redoAnnouncement(command.description(this.localization)));
+            this.announceForAccessibility(this.localization.redoAnnouncement(command.description(this, this.localization)));
         };
         this.rerenderQueued = false;
-        this.localization = Object.assign(Object.assign({}, this.localization), settings.localization);
+        this.localization = Object.assign(Object.assign({}, getLocalizationTable()), settings.localization);
         // Fill default settings.
         this.settings = {
             wheelEventsEnabled: (_a = settings.wheelEventsEnabled) !== null && _a !== void 0 ? _a : true,
             renderingMode: (_b = settings.renderingMode) !== null && _b !== void 0 ? _b : RenderingMode.CanvasRenderer,
             localization: this.localization,
+            minZoom: (_c = settings.minZoom) !== null && _c !== void 0 ? _c : 2e-10,
+            maxZoom: (_d = settings.maxZoom) !== null && _d !== void 0 ? _d : 1e12,
         };
         this.container = document.createElement('div');
         this.renderingRegion = document.createElement('div');
@@ -50,14 +52,21 @@ export class Editor {
         this.loadingWarning.classList.add('loadingMessage');
         this.loadingWarning.ariaLive = 'polite';
         this.container.appendChild(this.loadingWarning);
+        this.accessibilityControlArea = document.createElement('textarea');
+        this.accessibilityControlArea.setAttribute('placeholder', this.localization.accessibilityInputInstructions);
+        this.accessibilityControlArea.style.opacity = '0';
+        this.accessibilityControlArea.style.width = '0';
+        this.accessibilityControlArea.style.height = '0';
+        this.accessibilityControlArea.style.position = 'absolute';
         this.accessibilityAnnounceArea = document.createElement('div');
-        this.accessibilityAnnounceArea.ariaLive = 'assertive';
+        this.accessibilityAnnounceArea.setAttribute('aria-live', 'assertive');
         this.accessibilityAnnounceArea.className = 'accessibilityAnnouncement';
         this.container.appendChild(this.accessibilityAnnounceArea);
         this.renderingRegion.style.touchAction = 'none';
         this.renderingRegion.className = 'imageEditorRenderArea';
+        this.renderingRegion.appendChild(this.accessibilityControlArea);
         this.renderingRegion.setAttribute('tabIndex', '0');
-        this.renderingRegion.ariaLabel = this.localization.imageEditor;
+        this.renderingRegion.setAttribute('alt', '');
         this.notifier = new EventDispatcher();
         this.importExportViewport = new Viewport(this.notifier);
         this.viewport = new Viewport(this.notifier);
@@ -72,6 +81,20 @@ export class Editor {
         this.registerListeners();
         this.queueRerender();
         this.hideLoadingWarning();
+        // Enforce zoom limits.
+        this.notifier.on(EditorEventType.ViewportChanged, evt => {
+            if (evt.kind === EditorEventType.ViewportChanged) {
+                const zoom = evt.newTransform.transformVec3(Vec2.unitX).length();
+                if (zoom > this.settings.maxZoom || zoom < this.settings.minZoom) {
+                    const oldZoom = evt.oldTransform.transformVec3(Vec2.unitX).length();
+                    let resetTransform = Mat33.identity;
+                    if (oldZoom <= this.settings.maxZoom && oldZoom >= this.settings.minZoom) {
+                        resetTransform = evt.oldTransform;
+                    }
+                    this.viewport.resetTransform(resetTransform);
+                }
+            }
+        });
     }
     // Returns a reference to this' container.
     // Example usage:
@@ -90,7 +113,12 @@ export class Editor {
         this.announceForAccessibility(this.localization.doneLoading);
     }
     announceForAccessibility(message) {
+        // Force re-announcing an announcement if announced again.
+        if (message === this.previousAccessibilityAnnouncement) {
+            message = message + '. ';
+        }
         this.accessibilityAnnounceArea.innerText = message;
+        this.previousAccessibilityAnnouncement = message;
     }
     addToolbar(defaultLayout = true) {
         const toolbar = new HTMLToolbar(this, this.container, this.localization);
@@ -176,18 +204,7 @@ export class Editor {
         this.renderingRegion.addEventListener('pointercancel', evt => {
             pointerEnd(evt);
         });
-        this.renderingRegion.addEventListener('keydown', evt => {
-            if (this.toolController.dispatchInputEvent({
-                kind: InputEvtType.KeyPressEvent,
-                key: evt.key,
-                ctrlKey: evt.ctrlKey,
-            })) {
-                evt.preventDefault();
-            }
-            else if (evt.key === 'Escape') {
-                this.renderingRegion.blur();
-            }
-        });
+        this.handleKeyEventsFrom(this.renderingRegion);
         this.container.addEventListener('wheel', evt => {
             let delta = Vec3.of(evt.deltaX, evt.deltaY, evt.deltaZ);
             // Process wheel events if the ctrl key is down, even if disabled -- we do want to handle
@@ -233,6 +250,38 @@ export class Editor {
             });
             this.queueRerender();
         });
+        this.accessibilityControlArea.addEventListener('input', () => {
+            this.accessibilityControlArea.value = '';
+        });
+    }
+    // Adds event listners for keypresses to [elem] and forwards those events to the
+    // editor.
+    handleKeyEventsFrom(elem) {
+        elem.addEventListener('keydown', evt => {
+            if (evt.key === 't' || evt.key === 'T') {
+                evt.preventDefault();
+                this.display.rerenderAsText();
+            }
+            else if (this.toolController.dispatchInputEvent({
+                kind: InputEvtType.KeyPressEvent,
+                key: evt.key,
+                ctrlKey: evt.ctrlKey,
+            })) {
+                evt.preventDefault();
+            }
+            else if (evt.key === 'Escape') {
+                this.renderingRegion.blur();
+            }
+        });
+        elem.addEventListener('keyup', evt => {
+            if (this.toolController.dispatchInputEvent({
+                kind: InputEvtType.KeyUpEvent,
+                key: evt.key,
+                ctrlKey: evt.ctrlKey,
+            })) {
+                evt.preventDefault();
+            }
+        });
     }
     // Adds to history by default
     dispatch(command, addToHistory = true) {
@@ -243,7 +292,7 @@ export class Editor {
         else {
             command.apply(this);
         }
-        this.announceForAccessibility(command.description(this.localization));
+        this.announceForAccessibility(command.description(this, this.localization));
     }
     // Dispatches a command without announcing it. By default, does not add to history.
     dispatchNoAnnounce(command, addToHistory = false) {
@@ -420,7 +469,7 @@ export class Editor {
                 viewport.resetTransform(origTransform);
                 editor.queueRerender();
             }
-            description(localizationTable) {
+            description(_editor, localizationTable) {
                 return localizationTable.resizeOutputCommand(imageRect);
             }
         };

package/dist/src/EditorImage.d.ts

@@ -2,7 +2,7 @@ import AbstractRenderer from './rendering/renderers/AbstractRenderer';
 import Command from './commands/Command';
 import Viewport from './Viewport';
 import AbstractComponent from './components/AbstractComponent';
-import Rect2 from './geometry/Rect2';
+import Rect2 from './math/Rect2';
 import RenderingCache from './rendering/caching/RenderingCache';
 export declare const sortLeavesByZIndex: (leaves: Array<ImageNode>) => void;
 export default class EditorImage {

package/dist/src/EditorImage.js

@@ -1,6 +1,6 @@
 var _a;
 import AbstractComponent from './components/AbstractComponent';
-import Rect2 from './geometry/Rect2';
+import Rect2 from './math/Rect2';
 import SerializableCommand from './commands/SerializableCommand';
 export const sortLeavesByZIndex = (leaves) => {
     leaves.sort((a, b) => a.getContent().getZIndex() - b.getContent().getZIndex());
@@ -83,7 +83,7 @@ EditorImage.AddElementCommand = (_a = class extends SerializableCommand {
             container === null || container === void 0 ? void 0 : container.remove();
             editor.queueRerender();
         }
-        description(localization) {
+        description(editor, localization) {
             return localization.addElementAction(this.element.description(localization));
         }
         serializeToString() {

package/dist/src/Pointer.d.ts

@@ -1,4 +1,4 @@
-import { Point2 } from './geometry/Vec2';
+import { Point2 } from './math/Vec2';
 import Viewport from './Viewport';
 export declare enum PointerDevice {
     Pen = 0,

package/dist/src/Pointer.js

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

package/dist/src/SVGLoader.d.ts

@@ -1,4 +1,4 @@
-import Rect2 from './geometry/Rect2';
+import Rect2 from './math/Rect2';
 import { ComponentAddedListener, ImageLoader, OnDetermineExportRectListener, OnProgressListener } from './types';
 export declare const defaultSVGViewRect: Rect2;
 export declare const svgAttributesDataKey = "svgAttrs";

package/dist/src/SVGLoader.js

@@ -12,10 +12,10 @@ import Stroke from './components/Stroke';
 import SVGGlobalAttributesObject from './components/SVGGlobalAttributesObject';
 import Text from './components/Text';
 import UnknownSVGObject from './components/UnknownSVGObject';
-import Mat33 from './geometry/Mat33';
-import Path from './geometry/Path';
-import Rect2 from './geometry/Rect2';
-import { Vec2 } from './geometry/Vec2';
+import Mat33 from './math/Mat33';
+import Path from './math/Path';
+import Rect2 from './math/Rect2';
+import { Vec2 } from './math/Vec2';
 // Size of a loaded image if no size is specified.
 export const defaultSVGViewRect = new Rect2(0, 0, 500, 500);
 // Key to retrieve unrecognised attributes from an AbstractComponent
@@ -171,8 +171,16 @@ export default class SVGLoader {
         if (transformProperty === '' || transformProperty === 'none') {
             transformProperty = elem.style.transform || 'none';
         }
-        // Compute transform matrix
-        let transform = Mat33.fromCSSMatrix(transformProperty);
+        // Compute transform matrix. Prefer the actual .style.transform
+        // to the computed stylesheet -- in some browsers, the computedStyles version
+        // can have lower precision.
+        let transform;
+        try {
+            transform = Mat33.fromCSSMatrix(elem.style.transform);
+        }
+        catch (_e) {
+            transform = Mat33.fromCSSMatrix(transformProperty);
+        }
         const supportedAttrs = [];
         const elemX = elem.getAttribute('x');
         const elemY = elem.getAttribute('y');

package/dist/src/UndoRedoHistory.js

@@ -20,6 +20,9 @@ class UndoRedoHistory {
             command.apply(this.editor);
         }
         this.undoStack.push(command);
+        for (const elem of this.redoStack) {
+            elem.onDrop(this.editor);
+        }
         this.redoStack = [];
         this.fireUpdateEvent();
     }

package/dist/src/Viewport.d.ts

@@ -1,31 +1,16 @@
 import Command from './commands/Command';
-import { CommandLocalization } from './commands/localization';
-import Editor from './Editor';
-import Mat33 from './geometry/Mat33';
-import Rect2 from './geometry/Rect2';
-import { Point2, Vec2 } from './geometry/Vec2';
+import Mat33 from './math/Mat33';
+import Rect2 from './math/Rect2';
+import { Point2, Vec2 } from './math/Vec2';
 import { StrokeDataPoint } from './types';
 import { EditorNotifier } from './types';
 declare type PointDataType<T extends Point2 | StrokeDataPoint | number> = T extends Point2 ? Point2 : number;
+export declare abstract class ViewportTransform extends Command {
+    abstract readonly transform: Mat33;
+}
 export declare class Viewport {
     private notifier;
-    static ViewportTransform: {
-        new (transform: Mat33): {
-            readonly "__#679@#inverseTransform": Mat33;
-            readonly transform: Mat33;
-            apply(editor: Editor): void;
-            unapply(editor: Editor): void;
-            description(localizationTable: CommandLocalization): string;
-            onDrop(_editor: Editor): void;
-        };
-        union(a: Command, b: Command): Command;
-        readonly empty: {
-            description(_localizationTable: import("./localization").EditorLocalization): string;
-            apply(_editor: Editor): void;
-            unapply(_editor: Editor): void;
-            onDrop(_editor: Editor): void;
-        };
-    };
+    private static ViewportTransform;
     private transform;
     private inverseTransform;
     private screenRect;
@@ -34,6 +19,7 @@ export declare class Viewport {
     get visibleRect(): Rect2;
     screenToCanvas(screenPoint: Point2): Point2;
     canvasToScreen(canvasPoint: Point2): Point2;
+    static transformBy(transform: Mat33): ViewportTransform;
     resetTransform(newTransform?: Mat33): void;
     get screenToCanvasTransform(): Mat33;
     get canvasToScreenTransform(): Mat33;
@@ -45,7 +31,4 @@ export declare class Viewport {
     roundPoint(point: Point2): Point2;
     zoomTo(toMakeVisible: Rect2, allowZoomIn?: boolean, allowZoomOut?: boolean): Command;
 }
-export declare namespace Viewport {
-    type ViewportTransform = typeof Viewport.ViewportTransform.prototype;
-}
 export default Viewport;

package/dist/src/Viewport.js

@@ -11,11 +11,13 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _inverseTransform, _a;
 import Command from './commands/Command';
-import Mat33 from './geometry/Mat33';
-import Rect2 from './geometry/Rect2';
-import { Vec2 } from './geometry/Vec2';
-import Vec3 from './geometry/Vec3';
+import Mat33 from './math/Mat33';
+import Rect2 from './math/Rect2';
+import { Vec2 } from './math/Vec2';
+import Vec3 from './math/Vec3';
 import { EditorEventType } from './types';
+export class ViewportTransform extends Command {
+}
 export class Viewport {
     constructor(notifier) {
         this.notifier = notifier;
@@ -35,14 +37,19 @@ export class Viewport {
     canvasToScreen(canvasPoint) {
         return this.transform.transformVec2(canvasPoint);
     }
-    // Updates the transformation directly. Using ViewportTransform is preferred.
+    static transformBy(transform) {
+        return new Viewport.ViewportTransform(transform);
+    }
+    // Updates the transformation directly. Using transformBy is preferred.
     // [newTransform] should map from canvas coordinates to screen coordinates.
     resetTransform(newTransform = Mat33.identity) {
+        const oldTransform = this.transform;
         this.transform = newTransform;
         this.inverseTransform = newTransform.inverse();
         this.notifier.dispatch(EditorEventType.ViewportChanged, {
             kind: EditorEventType.ViewportChanged,
             newTransform,
+            oldTransform,
         });
     }
     get screenToCanvasTransform() {
@@ -130,7 +137,7 @@ export class Viewport {
     }
 }
 // Command that translates/scales the viewport.
-Viewport.ViewportTransform = (_a = class extends Command {
+Viewport.ViewportTransform = (_a = class extends ViewportTransform {
         constructor(transform) {
             super();
             this.transform = transform;
@@ -147,13 +154,13 @@ Viewport.ViewportTransform = (_a = class extends Command {
             viewport.resetTransform(viewport.transform.rightMul(__classPrivateFieldGet(this, _inverseTransform, "f")));
             editor.queueRerender();
         }
-        description(localizationTable) {
+        description(editor, localizationTable) {
             const result = [];
             // Describe the transformation's affect on the viewport (note that transformation transforms
             // the **elements** within the viewport). Assumes the transformation only does rotation/scale/translation.
-            const origVec = Vec2.unitX;
+            const origVec = editor.viewport.visibleRect.center;
             const linearTransformedVec = this.transform.transformVec3(Vec2.unitX);
-            const affineTransformedVec = this.transform.transformVec2(Vec2.unitX);
+            const affineTransformedVec = this.transform.transformVec2(origVec);
             const scale = linearTransformedVec.magnitude();
             const rotation = 180 / Math.PI * linearTransformedVec.angle();
             const translation = affineTransformedVec.minus(origVec);
@@ -173,7 +180,7 @@ Viewport.ViewportTransform = (_a = class extends Command {
             else if (translation.x < -minTranslation) {
                 result.push(localizationTable.movedRight);
             }
-            if (translation.y < minTranslation) {
+            if (translation.y < -minTranslation) {
                 result.push(localizationTable.movedDown);
             }
             else if (translation.y > minTranslation) {

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

@@ -1,4 +1,5 @@
 import '../styles';
 import Editor from '../Editor';
+import getLocalizationTable from '../localizations/getLocalizationTable';
 export default Editor;
-export { Editor };
+export { Editor, getLocalizationTable };

package/dist/src/bundle/bundled.js

@@ -1,5 +1,6 @@
 // Main entrypoint for Webpack when building a bundle for release.
 import '../styles';
 import Editor from '../Editor';
+import getLocalizationTable from '../localizations/getLocalizationTable';
 export default Editor;
-export { Editor };
+export { Editor, getLocalizationTable };

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

@@ -4,10 +4,10 @@ export declare abstract class Command {
     abstract apply(editor: Editor): void;
     abstract unapply(editor: Editor): void;
     onDrop(_editor: Editor): void;
-    abstract description(localizationTable: EditorLocalization): string;
+    abstract description(editor: Editor, localizationTable: EditorLocalization): string;
     static union(a: Command, b: Command): Command;
     static readonly empty: {
-        description(_localizationTable: EditorLocalization): string;
+        description(_editor: Editor, _localizationTable: EditorLocalization): string;
         apply(_editor: Editor): void;
         unapply(_editor: Editor): void;
         onDrop(_editor: Editor): void;

package/dist/src/commands/Command.js

@@ -11,9 +11,9 @@ export class Command {
                 b.unapply(editor);
                 a.unapply(editor);
             }
-            description(localizationTable) {
-                const aDescription = a.description(localizationTable);
-                const bDescription = b.description(localizationTable);
+            description(editor, localizationTable) {
+                const aDescription = a.description(editor, localizationTable);
+                const bDescription = b.description(editor, localizationTable);
                 if (aDescription === bDescription) {
                     return aDescription;
                 }
@@ -23,7 +23,7 @@ export class Command {
     }
 }
 Command.empty = new class extends Command {
-    description(_localizationTable) { return ''; }
+    description(_editor, _localizationTable) { return ''; }
     apply(_editor) { }
     unapply(_editor) { }
 };

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

@@ -9,6 +9,6 @@ export default class Duplicate extends SerializableCommand {
     constructor(toDuplicate: AbstractComponent[]);
     apply(editor: Editor): void;
     unapply(editor: Editor): void;
-    description(localizationTable: EditorLocalization): string;
+    description(_editor: Editor, localizationTable: EditorLocalization): string;
     protected serializeToString(): string;
 }

package/dist/src/commands/Duplicate.js

@@ -14,7 +14,7 @@ export default class Duplicate extends SerializableCommand {
     unapply(editor) {
         this.reverse.apply(editor);
     }
-    description(localizationTable) {
+    description(_editor, localizationTable) {
         var _a;
         if (this.duplicates.length === 0) {
             return localizationTable.duplicatedNoElements;

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

@@ -9,6 +9,6 @@ export default class Erase extends SerializableCommand {
     apply(editor: Editor): void;
     unapply(editor: Editor): void;
     onDrop(editor: Editor): void;
-    description(localizationTable: EditorLocalization): string;
+    description(_editor: Editor, localizationTable: EditorLocalization): string;
     protected serializeToString(): string;
 }

package/dist/src/commands/Erase.js

@@ -34,7 +34,7 @@ export default class Erase extends SerializableCommand {
             }
         }
     }
-    description(localizationTable) {
+    description(_editor, localizationTable) {
         var _a;
         if (this.toRemove.length === 0) {
             return localizationTable.erasedNoElements;

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

@@ -1,4 +1,4 @@
-import Rect2 from '../geometry/Rect2';
+import Rect2 from '../math/Rect2';
 export interface CommandLocalization {
     movedLeft: string;
     movedUp: string;

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

@@ -1,7 +1,7 @@
 import Command from '../commands/Command';
-import LineSegment2 from '../geometry/LineSegment2';
-import Mat33 from '../geometry/Mat33';
-import Rect2 from '../geometry/Rect2';
+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';
 declare type LoadSaveData = (string[] | Record<symbol, string | number>);

package/dist/src/components/AbstractComponent.js

@@ -1,7 +1,7 @@
 var _a;
 import SerializableCommand from '../commands/SerializableCommand';
 import EditorImage from '../EditorImage';
-import Mat33 from '../geometry/Mat33';
+import Mat33 from '../math/Mat33';
 export default class AbstractComponent {
     constructor(
     // A unique identifier for the type of component
@@ -132,7 +132,7 @@ AbstractComponent.TransformElementCommand = (_a = class extends SerializableComm
             this.updateTransform(editor, this.affineTransfm.inverse());
             editor.queueRerender();
         }
-        description(localizationTable) {
+        description(_editor, localizationTable) {
             return localizationTable.transformedElements(1);
         }
         serializeToString() {

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

@@ -1,6 +1,6 @@
-import LineSegment2 from '../geometry/LineSegment2';
-import Mat33 from '../geometry/Mat33';
-import Rect2 from '../geometry/Rect2';
+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';

package/dist/src/components/SVGGlobalAttributesObject.js

@@ -1,4 +1,4 @@
-import Rect2 from '../geometry/Rect2';
+import Rect2 from '../math/Rect2';
 import SVGRenderer from '../rendering/renderers/SVGRenderer';
 import AbstractComponent from './AbstractComponent';
 const componentKind = 'svg-global-attributes';

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

@@ -1,7 +1,7 @@
-import LineSegment2 from '../geometry/LineSegment2';
-import Mat33 from '../geometry/Mat33';
-import Path from '../geometry/Path';
-import Rect2 from '../geometry/Rect2';
+import LineSegment2 from '../math/LineSegment2';
+import Mat33 from '../math/Mat33';
+import Path from '../math/Path';
+import Rect2 from '../math/Rect2';
 import AbstractRenderer, { RenderablePathSpec } from '../rendering/renderers/AbstractRenderer';
 import AbstractComponent from './AbstractComponent';
 import { ImageComponentLocalization } from './localization';

package/dist/src/components/Stroke.js

@@ -1,5 +1,5 @@
-import Path from '../geometry/Path';
-import Rect2 from '../geometry/Rect2';
+import Path from '../math/Path';
+import Rect2 from '../math/Rect2';
 import { styleFromJSON, styleToJSON } from '../rendering/RenderingStyle';
 import AbstractComponent from './AbstractComponent';
 export default class Stroke extends AbstractComponent {

package/dist/src/components/Text.d.ts

@@ -1,6 +1,6 @@
-import LineSegment2 from '../geometry/LineSegment2';
-import Mat33 from '../geometry/Mat33';
-import Rect2 from '../geometry/Rect2';
+import LineSegment2 from '../math/LineSegment2';
+import Mat33 from '../math/Mat33';
+import Rect2 from '../math/Rect2';
 import AbstractRenderer from '../rendering/renderers/AbstractRenderer';
 import RenderingStyle from '../rendering/RenderingStyle';
 import AbstractComponent from './AbstractComponent';

package/dist/src/components/Text.js

@@ -1,6 +1,6 @@
-import LineSegment2 from '../geometry/LineSegment2';
-import Mat33 from '../geometry/Mat33';
-import Rect2 from '../geometry/Rect2';
+import LineSegment2 from '../math/LineSegment2';
+import Mat33 from '../math/Mat33';
+import Rect2 from '../math/Rect2';
 import { styleFromJSON, styleToJSON } from '../rendering/RenderingStyle';
 import AbstractComponent from './AbstractComponent';
 const componentTypeId = 'text';