js-draw 0.1.9 → 0.1.12

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

@@ -1,4 +1,5 @@
 import { Bezier } from 'bezier-js';
+import { toRoundedString, toStringOfSamePrecision } from './rounding';
 import LineSegment2 from './LineSegment2';
 import Rect2 from './Rect2';
 import { Vec2 } from './Vec2';
@@ -109,8 +110,8 @@ export default class Path {
         }
         return result;
     }
-    transformedBy(affineTransfm) {
-        const startPoint = affineTransfm.transformVec2(this.startPoint);
+    mapPoints(mapping) {
+        const startPoint = mapping(this.startPoint);
         const newParts = [];
         let exhaustivenessCheck;
         for (const part of this.parts) {
@@ -119,22 +120,22 @@ export default class Path {
                 case PathCommandType.LineTo:
                     newParts.push({
                         kind: part.kind,
-                        point: affineTransfm.transformVec2(part.point),
+                        point: mapping(part.point),
                     });
                     break;
                 case PathCommandType.CubicBezierTo:
                     newParts.push({
                         kind: part.kind,
-                        controlPoint1: affineTransfm.transformVec2(part.controlPoint1),
-                        controlPoint2: affineTransfm.transformVec2(part.controlPoint2),
-                        endPoint: affineTransfm.transformVec2(part.endPoint),
+                        controlPoint1: mapping(part.controlPoint1),
+                        controlPoint2: mapping(part.controlPoint2),
+                        endPoint: mapping(part.endPoint),
                     });
                     break;
                 case PathCommandType.QuadraticBezierTo:
                     newParts.push({
                         kind: part.kind,
-                        controlPoint: affineTransfm.transformVec2(part.controlPoint),
-                        endPoint: affineTransfm.transformVec2(part.endPoint),
+                        controlPoint: mapping(part.controlPoint),
+                        endPoint: mapping(part.endPoint),
                     });
                     break;
                 default:
@@ -144,6 +145,9 @@ export default class Path {
         }
         return new Path(startPoint, newParts);
     }
+    transformedBy(affineTransfm) {
+        return this.mapPoints(point => affineTransfm.transformVec2(point));
+    }
     // Creates a new path by joining [other] to the end of this path
     union(other) {
         if (!other) {
@@ -201,58 +205,61 @@ export default class Path {
         };
     }
     toString() {
-        return Path.toString(this.startPoint, this.parts);
+        // Hueristic: Try to determine whether converting absolute to relative commands is worth it.
+        //            If we're near (0, 0), it probably isn't worth it and if bounding boxes are large,
+        //            it also probably isn't worth it.
+        const makeRelativeCommands = Math.abs(this.bbox.topLeft.x) > 10 && Math.abs(this.bbox.size.x) < 2
+            && Math.abs(this.bbox.topLeft.y) > 10 && Math.abs(this.bbox.size.y) < 2;
+        return Path.toString(this.startPoint, this.parts, !makeRelativeCommands);
     }
     serialize() {
         return this.toString();
     }
-    static toString(startPoint, parts) {
+    // [onlyAbsCommands]: True if we should avoid converting absolute coordinates to relative offsets -- such
+    //                    conversions can lead to smaller output strings, but also take time.
+    static toString(startPoint, parts, onlyAbsCommands = true) {
         const result = [];
-        const toRoundedString = (num) => {
-            // Try to remove rounding errors. If the number ends in at least three/four zeroes
-            // (or nines) just one or two digits, it's probably a rounding error.
-            const fixRoundingUpExp = /^([-]?\d*\.\d{3,})0{4,}\d$/;
-            const hasRoundingDownExp = /^([-]?)(\d*)\.(\d{3,}9{4,}\d)$/;
-            let text = num.toString();
-            if (text.indexOf('.') === -1) {
-                return text;
-            }
-            const roundingDownMatch = hasRoundingDownExp.exec(text);
-            if (roundingDownMatch) {
-                const negativeSign = roundingDownMatch[1];
-                const lastDigit = parseInt(text.charAt(text.length - 1), 10);
-                const postDecimal = parseInt(roundingDownMatch[3], 10);
-                const preDecimal = parseInt(roundingDownMatch[2], 10);
-                const origPostDecimalString = roundingDownMatch[3];
-                let newPostDecimal = (postDecimal + 10 - lastDigit).toString();
-                let carry = 0;
-                if (newPostDecimal.length > postDecimal.toString().length) {
-                    // Left-shift
-                    newPostDecimal = newPostDecimal.substring(1);
-                    carry = 1;
+        let prevPoint;
+        const addCommand = (command, ...points) => {
+            const absoluteCommandParts = [];
+            const relativeCommandParts = [];
+            const makeAbsCommand = !prevPoint || onlyAbsCommands;
+            const roundedPrevX = prevPoint ? toRoundedString(prevPoint.x) : '';
+            const roundedPrevY = prevPoint ? toRoundedString(prevPoint.y) : '';
+            for (const point of points) {
+                // Relative commands are often shorter as strings than absolute commands.
+                if (!makeAbsCommand) {
+                    const xComponentRelative = toStringOfSamePrecision(point.x - prevPoint.x, roundedPrevX, roundedPrevY);
+                    const yComponentRelative = toStringOfSamePrecision(point.y - prevPoint.y, roundedPrevX, roundedPrevY);
+                    // No need for an additional separator if it starts with a '-'
+                    if (yComponentRelative.charAt(0) === '-') {
+                        relativeCommandParts.push(`${xComponentRelative}${yComponentRelative}`);
+                    }
+                    else {
+                        relativeCommandParts.push(`${xComponentRelative},${yComponentRelative}`);
+                    }
                 }
-                // parseInt(...).toString() removes leading zeroes. Add them back.
-                while (newPostDecimal.length < origPostDecimalString.length) {
-                    newPostDecimal = carry.toString(10) + newPostDecimal;
-                    carry = 0;
+                else {
+                    const xComponent = toRoundedString(point.x);
+                    const yComponent = toRoundedString(point.y);
+                    absoluteCommandParts.push(`${xComponent},${yComponent}`);
                 }
-                text = `${negativeSign + (preDecimal + carry).toString()}.${newPostDecimal}`;
             }
-            text = text.replace(fixRoundingUpExp, '$1');
-            // Remove trailing zeroes
-            text = text.replace(/([.]\d*[^0]+)0+$/, '$1');
-            text = text.replace(/[.]0+$/, '.');
-            // Remove trailing period
-            return text.replace(/[.]$/, '');
-        };
-        const addCommand = (command, ...points) => {
-            const parts = [];
-            for (const point of points) {
-                const xComponent = toRoundedString(point.x);
-                const yComponent = toRoundedString(point.y);
-                parts.push(`${xComponent},${yComponent}`);
+            let commandString;
+            if (makeAbsCommand) {
+                commandString = `${command}${absoluteCommandParts.join(' ')}`;
+            }
+            else {
+                commandString = `${command.toLowerCase()}${relativeCommandParts.join(' ')}`;
+            }
+            // Don't add no-ops.
+            if (commandString === 'l0,0') {
+                return;
+            }
+            result.push(commandString);
+            if (points.length > 0) {
+                prevPoint = points[points.length - 1];
             }
-            result.push(`${command}${parts.join(' ')}`);
         };
         addCommand('M', startPoint);
         let exhaustivenessCheck;

package/dist/src/{geometry → math}/Rect2.d.ts

@@ -30,6 +30,7 @@ export default class 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;

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

@@ -25,6 +25,7 @@ export default class Rect2 {
     translatedBy(vec) {
         return new Rect2(vec.x + this.x, vec.y + this.y, this.w, this.h);
     }
+    // Returns a copy of this with the given size (but same top-left).
     resizedTo(size) {
         return new Rect2(this.x, this.y, size.x, size.y);
     }
@@ -109,6 +110,21 @@ export default class Rect2 {
     grownBy(margin) {
         return new Rect2(this.x - margin, this.y - margin, this.w + margin * 2, this.h + margin * 2);
     }
+    getClosestPointOnBoundaryTo(target) {
+        const closestEdgePoints = this.getEdges().map(edge => {
+            return edge.closestPointTo(target);
+        });
+        let closest = null;
+        let closestDist = null;
+        for (const point of closestEdgePoints) {
+            const dist = point.minus(target).length();
+            if (closestDist === null || dist < closestDist) {
+                closest = point;
+                closestDist = dist;
+            }
+        }
+        return closest;
+    }
     get corners() {
         return [
             this.bottomRight,

package/dist/src/{geometry → math}/Vec3.d.ts

@@ -23,7 +23,7 @@ export default class Vec3 {
     extend(distance: number, direction: Vec3): Vec3;
     lerp(target: Vec3, fractionTo: number): Vec3;
     zip(other: Vec3, zip: (componentInThis: number, componentInOther: number) => number): Vec3;
-    map(fn: (component: number) => number): Vec3;
+    map(fn: (component: number, index: number) => number): Vec3;
     asArray(): number[];
     eq(other: Vec3, fuzz: number): boolean;
     toString(): string;

package/dist/src/{geometry → math}/Vec3.js

@@ -86,7 +86,7 @@ export default class Vec3 {
     }
     // Returns a vector with each component acted on by [fn]
     map(fn) {
-        return Vec3.of(fn(this.x), fn(this.y), fn(this.z));
+        return Vec3.of(fn(this.x, 0), fn(this.y, 1), fn(this.z, 2));
     }
     asArray() {
         return [this.x, this.y, this.z];

package/dist/src/math/rounding.d.ts

@@ -0,0 +1,3 @@
+export declare const toRoundedString: (num: number) => string;
+export declare const getLenAfterDecimal: (numberAsString: string) => number;
+export declare const toStringOfSamePrecision: (num: number, ...references: string[]) => string;

package/dist/src/math/rounding.js

@@ -0,0 +1,120 @@
+// Clean up stringified numbers
+const cleanUpNumber = (text) => {
+    // Regular expression substitions can be somewhat expensive. Only do them
+    // if necessary.
+    const lastChar = text.charAt(text.length - 1);
+    if (lastChar === '0' || lastChar === '.') {
+        // Remove trailing zeroes
+        text = text.replace(/([.]\d*[^0]+)0+$/, '$1');
+        text = text.replace(/[.]0+$/, '.');
+        // Remove trailing period
+        text = text.replace(/[.]$/, '');
+        if (text === '-0') {
+            return '0';
+        }
+    }
+    const firstChar = text.charAt(0);
+    if (firstChar === '0' || firstChar === '-') {
+        // Remove unnecessary leading zeroes.
+        text = text.replace(/^(0+)[.]/, '.');
+        text = text.replace(/^-(0+)[.]/, '-.');
+    }
+    return text;
+};
+export const toRoundedString = (num) => {
+    // Try to remove rounding errors. If the number ends in at least three/four zeroes
+    // (or nines) just one or two digits, it's probably a rounding error.
+    const fixRoundingUpExp = /^([-]?\d*\.\d{3,})0{4,}\d{1,2}$/;
+    const hasRoundingDownExp = /^([-]?)(\d*)\.(\d{3,}9{4,})\d{1,2}$/;
+    let text = num.toString(10);
+    if (text.indexOf('.') === -1) {
+        return text;
+    }
+    const roundingDownMatch = hasRoundingDownExp.exec(text);
+    if (roundingDownMatch) {
+        const negativeSign = roundingDownMatch[1];
+        const postDecimalString = roundingDownMatch[3];
+        const lastDigit = parseInt(postDecimalString.charAt(postDecimalString.length - 1), 10);
+        const postDecimal = parseInt(postDecimalString, 10);
+        const preDecimal = parseInt(roundingDownMatch[2], 10);
+        const origPostDecimalString = roundingDownMatch[3];
+        let newPostDecimal = (postDecimal + 10 - lastDigit).toString();
+        let carry = 0;
+        if (newPostDecimal.length > postDecimal.toString().length) {
+            // Left-shift
+            newPostDecimal = newPostDecimal.substring(1);
+            carry = 1;
+        }
+        // parseInt(...).toString() removes leading zeroes. Add them back.
+        while (newPostDecimal.length < origPostDecimalString.length) {
+            newPostDecimal = carry.toString(10) + newPostDecimal;
+            carry = 0;
+        }
+        text = `${negativeSign + (preDecimal + carry).toString()}.${newPostDecimal}`;
+    }
+    text = text.replace(fixRoundingUpExp, '$1');
+    return cleanUpNumber(text);
+};
+const numberExp = /^([-]?)(\d*)[.](\d+)$/;
+export const getLenAfterDecimal = (numberAsString) => {
+    const numberMatch = numberExp.exec(numberAsString);
+    if (!numberMatch) {
+        // If not a match, either the number is exponential notation (or is something
+        // like NaN or Infinity)
+        if (numberAsString.search(/[eE]/) !== -1 || /^[a-zA-Z]+$/.exec(numberAsString)) {
+            return -1;
+            // Or it has no decimal point
+        }
+        else {
+            return 0;
+        }
+    }
+    const afterDecimalLen = numberMatch[3].length;
+    return afterDecimalLen;
+};
+// [reference] should be a string representation of a base-10 number (no exponential (e.g. 10e10))
+export const toStringOfSamePrecision = (num, ...references) => {
+    const text = num.toString(10);
+    const textMatch = numberExp.exec(text);
+    if (!textMatch) {
+        return text;
+    }
+    let decimalPlaces = -1;
+    for (const reference of references) {
+        decimalPlaces = Math.max(getLenAfterDecimal(reference), decimalPlaces);
+    }
+    if (decimalPlaces === -1) {
+        return toRoundedString(num);
+    }
+    // Make text's after decimal length match [afterDecimalLen].
+    let postDecimal = textMatch[3].substring(0, decimalPlaces);
+    let preDecimal = textMatch[2];
+    const nextDigit = textMatch[3].charAt(decimalPlaces);
+    if (nextDigit !== '') {
+        const asNumber = parseInt(nextDigit, 10);
+        if (asNumber >= 5) {
+            // Don't attempt to parseInt() an empty string.
+            if (postDecimal.length > 0) {
+                const leadingZeroMatch = /^(0+)(\d*)$/.exec(postDecimal);
+                let leadingZeroes = '';
+                let postLeading = postDecimal;
+                if (leadingZeroMatch) {
+                    leadingZeroes = leadingZeroMatch[1];
+                    postLeading = leadingZeroMatch[2];
+                }
+                postDecimal = (parseInt(postDecimal) + 1).toString();
+                // If postDecimal got longer, remove leading zeroes if possible
+                if (postDecimal.length > postLeading.length && leadingZeroes.length > 0) {
+                    leadingZeroes = leadingZeroes.substring(1);
+                }
+                postDecimal = leadingZeroes + postDecimal;
+            }
+            if (postDecimal.length === 0 || postDecimal.length > decimalPlaces) {
+                preDecimal = (parseInt(preDecimal) + 1).toString();
+                postDecimal = postDecimal.substring(1);
+            }
+        }
+    }
+    const negativeSign = textMatch[1];
+    return cleanUpNumber(`${negativeSign}${preDecimal}.${postDecimal}`);
+};

package/dist/src/rendering/Display.d.ts

@@ -1,6 +1,6 @@
 import AbstractRenderer from './renderers/AbstractRenderer';
 import { Editor } from '../Editor';
-import { Point2 } from '../geometry/Vec2';
+import { Point2 } from '../math/Vec2';
 import RenderingCache from './caching/RenderingCache';
 import Color4 from '../Color4';
 export declare enum RenderingMode {
@@ -13,6 +13,7 @@ export default class Display {
     private dryInkRenderer;
     private wetInkRenderer;
     private textRenderer;
+    private textRerenderOutput;
     private cache;
     private resizeSurfacesCallback?;
     private flattenCallback?;
@@ -23,6 +24,7 @@ export default class Display {
     getColorAt: (_screenPos: Point2) => Color4 | null;
     private initializeCanvasRendering;
     private initializeTextRendering;
+    rerenderAsText(): void;
     startRerender(): AbstractRenderer;
     setDraftMode(draftMode: boolean): void;
     getDryInkRenderer(): AbstractRenderer;

package/dist/src/rendering/Display.js

@@ -1,7 +1,7 @@
 import CanvasRenderer from './renderers/CanvasRenderer';
 import { EditorEventType } from '../types';
 import DummyRenderer from './renderers/DummyRenderer';
-import { Vec2 } from '../geometry/Vec2';
+import { Vec2 } from '../math/Vec2';
 import RenderingCache from './caching/RenderingCache';
 import TextOnlyRenderer from './renderers/TextOnlyRenderer';
 import Color4 from '../Color4';
@@ -15,6 +15,7 @@ export default class Display {
     constructor(editor, mode, parent) {
         this.editor = editor;
         this.parent = parent;
+        this.textRerenderOutput = null;
         this.getColorAt = (_screenPos) => {
             return null;
         };
@@ -51,10 +52,10 @@ export default class Display {
                 return this.dryInkRenderer.canRenderFromWithoutDataLoss(renderer);
             },
             blockResolution: cacheBlockResolution,
-            cacheSize: 500 * 500 * 4 * 200,
+            cacheSize: 500 * 500 * 4 * 220,
             maxScale: 1.5,
-            minComponentsPerCache: 50,
-            minComponentsToUseCache: 120,
+            minComponentsPerCache: 45,
+            minComponentsToUseCache: 105,
         });
         this.editor.notifier.on(EditorEventType.DisplayResized, event => {
             var _a;
@@ -126,16 +127,21 @@ export default class Display {
         const rerenderButton = document.createElement('button');
         rerenderButton.classList.add('rerenderButton');
         rerenderButton.innerText = this.editor.localization.rerenderAsText;
-        const rerenderOutput = document.createElement('div');
-        rerenderOutput.ariaLive = 'polite';
+        this.textRerenderOutput = document.createElement('div');
+        this.textRerenderOutput.setAttribute('aria-live', 'polite');
         rerenderButton.onclick = () => {
-            this.textRenderer.clear();
-            this.editor.image.render(this.textRenderer, this.editor.viewport);
-            rerenderOutput.innerText = this.textRenderer.getDescription();
+            this.rerenderAsText();
         };
-        textRendererOutputContainer.replaceChildren(rerenderButton, rerenderOutput);
+        textRendererOutputContainer.replaceChildren(rerenderButton, this.textRerenderOutput);
         this.editor.createHTMLOverlay(textRendererOutputContainer);
     }
+    rerenderAsText() {
+        this.textRenderer.clear();
+        this.editor.image.render(this.textRenderer, this.editor.viewport);
+        if (this.textRerenderOutput) {
+            this.textRerenderOutput.innerText = this.textRenderer.getDescription();
+        }
+    }
     // Clears the drawing surfaces and otherwise prepares for a rerender.
     startRerender() {
         var _a;

package/dist/src/rendering/caching/CacheRecord.d.ts

@@ -1,5 +1,5 @@
-import Mat33 from '../../geometry/Mat33';
-import Rect2 from '../../geometry/Rect2';
+import Mat33 from '../../math/Mat33';
+import Rect2 from '../../math/Rect2';
 import AbstractRenderer from '../renderers/AbstractRenderer';
 import { BeforeDeallocCallback, CacheState } from './types';
 export default class CacheRecord {

package/dist/src/rendering/caching/CacheRecord.js

@@ -1,4 +1,4 @@
-import Mat33 from '../../geometry/Mat33';
+import Mat33 from '../../math/Mat33';
 // Represents a cached renderer/canvas
 // This is not a [CacheNode] -- it handles cached renderers and does not have sub-renderers.
 export default class CacheRecord {

package/dist/src/rendering/caching/CacheRecordManager.d.ts

@@ -1,6 +1,6 @@
 import { BeforeDeallocCallback, PartialCacheState } from './types';
 import CacheRecord from './CacheRecord';
-import Rect2 from '../../geometry/Rect2';
+import Rect2 from '../../math/Rect2';
 export declare class CacheRecordManager {
     private readonly cacheState;
     private cacheRecords;

package/dist/src/rendering/caching/RenderingCache.js

@@ -1,4 +1,4 @@
-import Rect2 from '../../geometry/Rect2';
+import Rect2 from '../../math/Rect2';
 import RenderingCacheNode from './RenderingCacheNode';
 import { CacheRecordManager } from './CacheRecordManager';
 export default class RenderingCache {

package/dist/src/rendering/caching/RenderingCacheNode.d.ts

@@ -1,5 +1,5 @@
 import { ImageNode } from '../../EditorImage';
-import Rect2 from '../../geometry/Rect2';
+import Rect2 from '../../math/Rect2';
 import Viewport from '../../Viewport';
 import AbstractRenderer from '../renderers/AbstractRenderer';
 import { CacheState } from './types';
@@ -20,6 +20,7 @@ export default class RenderingCacheNode {
     private allChildrenCanRender;
     private computeSortedByLeafIds;
     private idsOfIntersecting;
+    private allRenderedIdsIn;
     private renderingIsUpToDate;
     renderItems(screenRenderer: AbstractRenderer, items: ImageNode[], viewport: Viewport): void;
     private isEmpty;

package/dist/src/rendering/caching/RenderingCacheNode.js

@@ -1,7 +1,7 @@
 // A cache record with sub-nodes.
 import Color4 from '../../Color4';
 import { sortLeavesByZIndex } from '../../EditorImage';
-import Rect2 from '../../geometry/Rect2';
+import Rect2 from '../../math/Rect2';
 // 3x3 divisions for each node.
 const cacheDivisionSize = 3;
 // True: Show rendering updates.
@@ -116,17 +116,26 @@ export default class RenderingCacheNode {
         }
         return result;
     }
-    renderingIsUpToDate(sortedIds) {
-        if (this.cachedRenderer === null || sortedIds.length !== this.renderedIds.length) {
+    // Returns true iff all elems of this.renderedIds are in sortedIds.
+    // sortedIds should be sorted by z-index (or some other order, so long as they are
+    // sorted by the same thing as this.renderedIds.)
+    allRenderedIdsIn(sortedIds) {
+        if (this.renderedIds.length > sortedIds.length) {
             return false;
         }
-        for (let i = 0; i < sortedIds.length; i++) {
+        for (let i = 0; i < this.renderedIds.length; i++) {
             if (sortedIds[i] !== this.renderedIds[i]) {
                 return false;
             }
         }
         return true;
     }
+    renderingIsUpToDate(sortedIds) {
+        if (this.cachedRenderer === null || sortedIds.length !== this.renderedIds.length) {
+            return false;
+        }
+        return this.allRenderedIdsIn(sortedIds);
+    }
     // Render all [items] within [viewport]
     renderItems(screenRenderer, items, viewport) {
         var _a, _b;
@@ -188,14 +197,13 @@ export default class RenderingCacheNode {
                     return;
                 }
                 // Is it worth it to render the items?
-                // TODO: Replace this with something performace based.
-                // TODO: Determine whether it is 'worth it' to cache this depending on rendering time.
+                // TODO: Consider replacing this with something performace based.
                 if (leavesByIds.length > this.cacheState.props.minComponentsPerCache) {
                     let fullRerenderNeeded = true;
                     if (!this.cachedRenderer) {
                         this.cachedRenderer = this.cacheState.recordManager.allocCanvas(this.region, () => this.onRegionDealloc());
                     }
-                    else if (leavesByIds.length > this.renderedIds.length && this.renderedMaxZIndex !== null) {
+                    else if (leavesByIds.length > this.renderedIds.length && this.allRenderedIdsIn(leafIds) && this.renderedMaxZIndex !== null) {
                         // We often don't need to do a full re-render even if something's changed.
                         // Check whether we can just draw on top of the existing cache.
                         const newLeaves = [];
@@ -228,6 +236,9 @@ export default class RenderingCacheNode {
                             }
                         }
                     }
+                    else if (debugMode) {
+                        console.log('Decided on a full re-render. Reason: At least one of the following is false:', '\n leafIds.length > this.renderedIds.length: ', leafIds.length > this.renderedIds.length, '\n this.allRenderedIdsIn(leafIds): ', this.allRenderedIdsIn(leafIds), '\n this.renderedMaxZIndex !== null: ', this.renderedMaxZIndex !== null, '\n\nthis.rerenderedIds: ', this.renderedIds, ', leafIds: ', leafIds);
+                    }
                     if (fullRerenderNeeded) {
                         thisRenderer = this.cachedRenderer.startRender();
                         thisRenderer.clear();

package/dist/src/rendering/caching/testUtils.js

@@ -1,4 +1,4 @@
-import { Vec2 } from '../../geometry/Vec2';
+import { Vec2 } from '../../math/Vec2';
 import DummyRenderer from '../renderers/DummyRenderer';
 import createEditor from '../../testing/createEditor';
 import RenderingCache from './RenderingCache';

package/dist/src/rendering/caching/types.d.ts

@@ -1,4 +1,4 @@
-import { Vec2 } from '../../geometry/Vec2';
+import { Vec2 } from '../../math/Vec2';
 import AbstractRenderer from '../renderers/AbstractRenderer';
 import { CacheRecordManager } from './CacheRecordManager';
 export declare type CacheAddress = number;

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

@@ -1,4 +1,6 @@
 export interface TextRendererLocalization {
+    pathNodeCount(pathCount: number): string;
+    textNodeCount(nodeCount: number): string;
     textNode(content: string): string;
     rerenderAsText: string;
 }

package/dist/src/rendering/localization.js

@@ -1,4 +1,6 @@
 export const defaultTextRendererLocalization = {
+    pathNodeCount: (count) => `There are ${count} visible path objects.`,
+    textNodeCount: (count) => `There are ${count} visible text nodes.`,
     textNode: (content) => `Text: ${content}`,
     rerenderAsText: 'Re-render as text',
 };

package/dist/src/rendering/renderers/AbstractRenderer.d.ts

@@ -1,9 +1,9 @@
 import { LoadSaveDataTable } from '../../components/AbstractComponent';
 import { TextStyle } from '../../components/Text';
-import Mat33 from '../../geometry/Mat33';
-import { PathCommand } from '../../geometry/Path';
-import Rect2 from '../../geometry/Rect2';
-import { Point2, Vec2 } from '../../geometry/Vec2';
+import Mat33 from '../../math/Mat33';
+import { PathCommand } from '../../math/Path';
+import Rect2 from '../../math/Rect2';
+import { Point2, Vec2 } from '../../math/Vec2';
 import Viewport from '../../Viewport';
 import RenderingStyle from '../RenderingStyle';
 export interface RenderablePathSpec {

package/dist/src/rendering/renderers/AbstractRenderer.js

@@ -1,5 +1,5 @@
-import Path, { PathCommandType } from '../../geometry/Path';
-import { Vec2 } from '../../geometry/Vec2';
+import Path, { PathCommandType } from '../../math/Path';
+import { Vec2 } from '../../math/Vec2';
 import { stylesEqual } from '../RenderingStyle';
 export default class AbstractRenderer {
     constructor(viewport) {

package/dist/src/rendering/renderers/CanvasRenderer.d.ts

@@ -1,8 +1,8 @@
 import { TextStyle } from '../../components/Text';
-import Mat33 from '../../geometry/Mat33';
-import Rect2 from '../../geometry/Rect2';
-import { Point2, Vec2 } from '../../geometry/Vec2';
-import Vec3 from '../../geometry/Vec3';
+import Mat33 from '../../math/Mat33';
+import Rect2 from '../../math/Rect2';
+import { Point2, Vec2 } from '../../math/Vec2';
+import Vec3 from '../../math/Vec3';
 import Viewport from '../../Viewport';
 import RenderingStyle from '../RenderingStyle';
 import AbstractRenderer, { RenderablePathSpec } from './AbstractRenderer';

package/dist/src/rendering/renderers/CanvasRenderer.js

@@ -1,6 +1,6 @@
 import Color4 from '../../Color4';
 import Text from '../../components/Text';
-import { Vec2 } from '../../geometry/Vec2';
+import { Vec2 } from '../../math/Vec2';
 import AbstractRenderer from './AbstractRenderer';
 export default class CanvasRenderer extends AbstractRenderer {
     constructor(ctx, viewport) {

package/dist/src/rendering/renderers/DummyRenderer.d.ts

@@ -1,8 +1,8 @@
 import { TextStyle } from '../../components/Text';
-import Mat33 from '../../geometry/Mat33';
-import Rect2 from '../../geometry/Rect2';
-import { Point2, Vec2 } from '../../geometry/Vec2';
-import Vec3 from '../../geometry/Vec3';
+import Mat33 from '../../math/Mat33';
+import Rect2 from '../../math/Rect2';
+import { Point2, Vec2 } from '../../math/Vec2';
+import Vec3 from '../../math/Vec3';
 import Viewport from '../../Viewport';
 import RenderingStyle from '../RenderingStyle';
 import AbstractRenderer from './AbstractRenderer';