js-draw 0.17.3 → 0.18.0

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) => {

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

@@ -0,0 +1,106 @@
+/**
+ * A vector with three components. Can also be used to represent a two-component vector.
+ *
+ * A `Vec3` is immutable.
+ */
+export default class Vec3 {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    private constructor();
+    /** Returns the x, y components of this. */
+    get xy(): {
+        x: number;
+        y: number;
+    };
+    static of(x: number, y: number, z: number): Vec3;
+    /** Returns this' `idx`th component. For example, `Vec3.of(1, 2, 3).at(1) → 2`. */
+    at(idx: number): number;
+    /** Alias for this.magnitude. */
+    length(): number;
+    magnitude(): number;
+    magnitudeSquared(): number;
+    /**
+     * Return this' angle in the XY plane (treats this as a Vec2).
+     *
+     * This is equivalent to `Math.atan2(vec.y, vec.x)`.
+     */
+    angle(): number;
+    /**
+     * Returns a unit vector in the same direction as this.
+     *
+     * If `this` has zero length, the resultant vector has `NaN` components.
+     */
+    normalized(): Vec3;
+    /** @returns A copy of `this` multiplied by a scalar. */
+    times(c: number): Vec3;
+    plus(v: Vec3): Vec3;
+    minus(v: Vec3): Vec3;
+    dot(other: Vec3): number;
+    cross(other: Vec3): Vec3;
+    /**
+     * If `other` is a `Vec3`, multiplies `this` component-wise by `other`. Otherwise,
+     * if `other is a `number`, returns the result of scalar multiplication.
+     *
+     * @example
+     * ```
+     * Vec3.of(1, 2, 3).scale(Vec3.of(2, 4, 6)); // → Vec3(2, 8, 18)
+     * ```
+     */
+    scale(other: Vec3 | number): Vec3;
+    /**
+     * Returns a vector orthogonal to this. If this is a Vec2, returns `this` rotated
+     * 90 degrees counter-clockwise.
+     */
+    orthog(): Vec3;
+    /** Returns this plus a vector of length `distance` in `direction`. */
+    extend(distance: number, direction: Vec3): Vec3;
+    /** Returns a vector `fractionTo` of the way to target from this. */
+    lerp(target: Vec3, fractionTo: number): Vec3;
+    /**
+     * `zip` Maps a component of this and a corresponding component of
+     * `other` to a component of the output vector.
+     *
+     * @example
+     * ```
+     * const a = Vec3.of(1, 2, 3);
+     * const b = Vec3.of(0.5, 2.1, 2.9);
+     *
+     * const zipped = a.zip(b, (aComponent, bComponent) => {
+     *   return Math.min(aComponent, bComponent);
+     * });
+     *
+     * console.log(zipped.toString()); // → Vec(0.5, 2, 2.9)
+     * ```
+     */
+    zip(other: Vec3, zip: (componentInThis: number, componentInOther: number) => number): Vec3;
+    /**
+     * Returns a vector with each component acted on by `fn`.
+     *
+     * @example
+     * ```
+     * console.log(Vec3.of(1, 2, 3).map(val => val + 1)); // → Vec(2, 3, 4)
+     * ```
+     */
+    map(fn: (component: number, index: number) => number): Vec3;
+    asArray(): [number, number, number];
+    /**
+     * [fuzz] The maximum difference between two components for this and [other]
+     * to be considered equal.
+     *
+     * @example
+     * ```
+     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 100);  // → true
+     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 0.1);  // → false
+     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 3);    // → true
+     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 3.01); // → true
+     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 2.99); // → false
+     * ```
+     */
+    eq(other: Vec3, fuzz?: number): boolean;
+    toString(): string;
+    static unitX: Vec3;
+    static unitY: Vec3;
+    static unitZ: Vec3;
+    static zero: Vec3;
+}

package/dist/mjs/src/math/lib.mjs

@@ -0,0 +1,7 @@
+import  LineSegment2  from './LineSegment2.mjs';
+import  Mat33  from './Mat33.mjs';
+import  Path  from './Path.mjs';
+import  Rect2  from './Rect2.mjs';
+import  { Vec2 }  from './Vec2.mjs';
+import  Vec3  from './Vec3.mjs';
+export { LineSegment2, Mat33, Path, Rect2, Vec3, Vec2, };

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

@@ -0,0 +1,4 @@
+export declare const cleanUpNumber: (text: string) => string;
+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/mjs/src/rendering/Display.d.ts

@@ -0,0 +1,75 @@
+import AbstractRenderer from './renderers/AbstractRenderer';
+import { Editor } from '../Editor';
+import { Point2 } from '../math/Vec2';
+import RenderingCache from './caching/RenderingCache';
+import Color4 from '../Color4';
+export declare enum RenderingMode {
+    DummyRenderer = 0,
+    CanvasRenderer = 1
+}
+/**
+ * Handles `HTMLCanvasElement`s (or other drawing surfaces if being used) used to display the editor's contents.
+ *
+ * @example
+ * ```
+ * const editor = new Editor(document.body);
+ * const w = editor.display.width;
+ * const h = editor.display.height;
+ * const center = Vec2.of(w / 2, h / 2);
+ * const colorAtCenter = editor.display.getColorAt(center);
+ * ```
+ */
+export default class Display {
+    private editor;
+    private parent;
+    private dryInkRenderer;
+    private wetInkRenderer;
+    private textRenderer;
+    private textRerenderOutput;
+    private cache;
+    private resizeSurfacesCallback?;
+    private flattenCallback?;
+    /** @internal */
+    constructor(editor: Editor, mode: RenderingMode, parent: HTMLElement | null);
+    /**
+     * @returns the visible width of the display (e.g. how much
+     * space the display's element takes up in the x direction
+     * in the DOM).
+     */
+    get width(): number;
+    get height(): number;
+    /** @internal */
+    getCache(): RenderingCache;
+    /**
+     * @returns the color at the given point on the dry ink renderer, or `null` if `screenPos`
+     * 	is not on the display.
+     */
+    getColorAt: (_screenPos: Point2) => Color4 | null;
+    private initializeCanvasRendering;
+    private initializeTextRendering;
+    /**
+     * Rerenders the text-based display.
+     * The text-based display is intended for screen readers and can be navigated to by pressing `tab`.
+     */
+    rerenderAsText(): void;
+    /**
+     * Clears the drawing surfaces and otherwise prepares for a rerender.
+     *
+     * @returns the dry ink renderer.
+     */
+    startRerender(): AbstractRenderer;
+    /**
+     * If `draftMode`, the dry ink renderer is configured to render
+     * low-quality output.
+     */
+    setDraftMode(draftMode: boolean): void;
+    /** @internal */
+    getDryInkRenderer(): AbstractRenderer;
+    /**
+     * @returns The renderer used for showing action previews (e.g. an unfinished stroke).
+     * The `wetInkRenderer`'s surface is stacked above the `dryInkRenderer`'s.
+     */
+    getWetInkRenderer(): AbstractRenderer;
+    /** Re-renders the contents of the wetInkRenderer onto the dryInkRenderer. */
+    flatten(): void;
+}

package/dist/{src/rendering/Display.js → mjs/src/rendering/Display.mjs}

@@ -1,10 +1,10 @@
-import CanvasRenderer from './renderers/CanvasRenderer';
-import { EditorEventType } from '../types';
-import DummyRenderer from './renderers/DummyRenderer';
-import { Vec2 } from '../math/Vec2';
-import RenderingCache from './caching/RenderingCache';
-import TextOnlyRenderer from './renderers/TextOnlyRenderer';
-import Color4 from '../Color4';
+import  CanvasRenderer  from './renderers/CanvasRenderer.mjs';
+import  { EditorEventType }  from '../types.mjs';
+import  DummyRenderer  from './renderers/DummyRenderer.mjs';
+import  { Vec2 }  from '../math/Vec2.mjs';
+import  RenderingCache  from './caching/RenderingCache.mjs';
+import  TextOnlyRenderer  from './renderers/TextOnlyRenderer.mjs';
+import  Color4  from '../Color4.mjs';
 export var RenderingMode;
 (function (RenderingMode) {
     RenderingMode[RenderingMode["DummyRenderer"] = 0] = "DummyRenderer";

package/dist/mjs/src/rendering/RenderingStyle.d.ts

@@ -0,0 +1,31 @@
+import Color4 from '../Color4';
+interface RenderingStyle {
+    fill: Color4;
+    stroke?: {
+        color: Color4;
+        width: number;
+    };
+}
+export default RenderingStyle;
+export declare const cloneStyle: (style: RenderingStyle) => {
+    fill: Color4;
+    stroke: {
+        color: Color4;
+        width: number;
+    } | undefined;
+};
+export declare const stylesEqual: (a: RenderingStyle, b: RenderingStyle) => boolean;
+export declare const styleToJSON: (style: RenderingStyle) => {
+    fill: string;
+    stroke: {
+        color: string;
+        width: number;
+    } | undefined;
+};
+export declare const styleFromJSON: (json: Record<string, any>) => {
+    fill: Color4;
+    stroke: {
+        color: Color4;
+        width: any;
+    } | undefined;
+};

package/dist/{src/rendering/RenderingStyle.js → mjs/src/rendering/RenderingStyle.mjs}

@@ -1,4 +1,4 @@
-import Color4 from '../Color4';
+import  Color4  from '../Color4.mjs';
 export const cloneStyle = (style) => {
     return {
         fill: style.fill,

package/dist/mjs/src/rendering/TextRenderingStyle.d.ts

@@ -0,0 +1,36 @@
+import RenderingStyle from './RenderingStyle';
+export interface TextStyle {
+    size: number;
+    fontFamily: string;
+    fontWeight?: string;
+    fontVariant?: string;
+    renderingStyle: RenderingStyle;
+}
+export default TextStyle;
+export declare const cloneTextStyle: (style: TextStyle) => {
+    renderingStyle: {
+        fill: import("../Color4").default;
+        stroke: {
+            color: import("../Color4").default;
+            width: number;
+        } | undefined;
+    };
+    size: number;
+    fontFamily: string;
+    fontWeight?: string | undefined;
+    fontVariant?: string | undefined;
+};
+export declare const textStyleFromJSON: (json: any) => TextStyle;
+export declare const textStyleToJSON: (style: TextStyle) => {
+    renderingStyle: {
+        fill: string;
+        stroke: {
+            color: string;
+            width: number;
+        } | undefined;
+    };
+    size: number;
+    fontFamily: string;
+    fontWeight?: string | undefined;
+    fontVariant?: string | undefined;
+};

package/dist/{src/rendering/TextRenderingStyle.js → mjs/src/rendering/TextRenderingStyle.mjs}

@@ -1,4 +1,4 @@
-import { cloneStyle, styleFromJSON, styleToJSON } from './RenderingStyle';
+import  { cloneStyle, styleFromJSON, styleToJSON }  from './RenderingStyle.mjs';
 export const cloneTextStyle = (style) => {
     return Object.assign(Object.assign({}, style), { renderingStyle: cloneStyle(style.renderingStyle) });
 };

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

@@ -0,0 +1,20 @@
+import Mat33 from '../../math/Mat33';
+import Rect2 from '../../math/Rect2';
+import AbstractRenderer from '../renderers/AbstractRenderer';
+import { BeforeDeallocCallback, CacheState } from './types';
+export default class CacheRecord {
+    private onBeforeDeallocCallback;
+    private cacheState;
+    private renderer;
+    private lastUsedCycle;
+    private allocd;
+    allocCount: number;
+    constructor(onBeforeDeallocCallback: BeforeDeallocCallback | null, cacheState: CacheState);
+    startRender(): AbstractRenderer;
+    dealloc(): void;
+    isAllocd(): boolean;
+    realloc(newDeallocCallback: BeforeDeallocCallback): void;
+    getLastUsedCycle(): number;
+    getTransform(drawTo: Rect2): Mat33;
+    setRenderingRegion(drawTo: Rect2): void;
+}

package/dist/{src/rendering/caching/CacheRecord.js → mjs/src/rendering/caching/CacheRecord.mjs}

@@ -1,4 +1,4 @@
-import Mat33 from '../../math/Mat33';
+import  Mat33  from '../../math/Mat33.mjs';
 // 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/mjs/src/rendering/caching/CacheRecordManager.d.ts

@@ -0,0 +1,12 @@
+import { BeforeDeallocCallback, CacheProps, CacheState } from './types';
+import CacheRecord from './CacheRecord';
+import Rect2 from '../../math/Rect2';
+export declare class CacheRecordManager {
+    private cacheRecords;
+    private maxCanvases;
+    private cacheState;
+    constructor(cacheProps: CacheProps);
+    setSharedState(state: CacheState): void;
+    allocCanvas(drawTo: Rect2, onDealloc: BeforeDeallocCallback): CacheRecord;
+    private getLeastRecentlyUsedRecord;
+}

package/dist/{src/rendering/caching/CacheRecordManager.js → mjs/src/rendering/caching/CacheRecordManager.mjs}

@@ -1,4 +1,4 @@
-import CacheRecord from './CacheRecord';
+import  CacheRecord  from './CacheRecord.mjs';
 const debugMode = false;
 export class CacheRecordManager {
     constructor(cacheProps) {

package/dist/mjs/src/rendering/caching/RenderingCache.d.ts

@@ -0,0 +1,11 @@
+import { ImageNode } from '../../EditorImage';
+import Viewport from '../../Viewport';
+import AbstractRenderer from '../renderers/AbstractRenderer';
+import { CacheProps } from './types';
+export default class RenderingCache {
+    private sharedState;
+    private recordManager;
+    private rootNode;
+    constructor(cacheProps: CacheProps);
+    render(screenRenderer: AbstractRenderer, image: ImageNode, viewport: Viewport): void;
+}

package/dist/{src/rendering/caching/RenderingCache.js → mjs/src/rendering/caching/RenderingCache.mjs}

@@ -1,6 +1,6 @@
-import Rect2 from '../../math/Rect2';
-import RenderingCacheNode from './RenderingCacheNode';
-import { CacheRecordManager } from './CacheRecordManager';
+import  Rect2  from '../../math/Rect2.mjs';
+import  RenderingCacheNode  from './RenderingCacheNode.mjs';
+import  { CacheRecordManager }  from './CacheRecordManager.mjs';
 export default class RenderingCache {
     constructor(cacheProps) {
         this.recordManager = new CacheRecordManager(cacheProps);

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

@@ -0,0 +1,29 @@
+import { ImageNode } from '../../EditorImage';
+import Rect2 from '../../math/Rect2';
+import Viewport from '../../Viewport';
+import AbstractRenderer from '../renderers/AbstractRenderer';
+import { CacheState } from './types';
+export default class RenderingCacheNode {
+    readonly region: Rect2;
+    private readonly cacheState;
+    private instantiatedChildren;
+    private parent;
+    private cachedRenderer;
+    private renderedIds;
+    private renderedMaxZIndex;
+    constructor(region: Rect2, cacheState: CacheState);
+    generateParent(): RenderingCacheNode;
+    private generateChildren;
+    private getChildren;
+    smallestChildContaining(rect: Rect2): RenderingCacheNode | null;
+    private renderingWouldBeHighEnoughResolution;
+    private allChildrenCanRender;
+    private computeSortedByLeafIds;
+    private idsOfIntersecting;
+    private allRenderedIdsIn;
+    private renderingIsUpToDate;
+    renderItems(screenRenderer: AbstractRenderer, items: ImageNode[], viewport: Viewport): void;
+    private isEmpty;
+    private onRegionDealloc;
+    private checkRep;
+}

package/dist/{src/rendering/caching/RenderingCacheNode.js → mjs/src/rendering/caching/RenderingCacheNode.mjs}

@@ -1,7 +1,7 @@
 // A cache record with sub-nodes.
-import Color4 from '../../Color4';
-import { sortLeavesByZIndex } from '../../EditorImage';
-import Rect2 from '../../math/Rect2';
+import  Color4  from '../../Color4.mjs';
+import  { sortLeavesByZIndex }  from '../../EditorImage.mjs';
+import  Rect2  from '../../math/Rect2.mjs';
 // 3x3 divisions for each node.
 const cacheDivisionSize = 3;
 // True: Show rendering updates.

package/dist/mjs/src/rendering/caching/testUtils.d.ts

@@ -0,0 +1,9 @@
+import DummyRenderer from '../renderers/DummyRenderer';
+import RenderingCache from './RenderingCache';
+import { CacheProps } from './types';
+type RenderAllocCallback = (renderer: DummyRenderer) => void;
+export declare const createCache: (onRenderAlloc?: RenderAllocCallback, cacheOptions?: Partial<CacheProps>) => {
+    cache: RenderingCache;
+    editor: import("../../Editor").Editor;
+};
+export {};

package/dist/{src/rendering/caching/testUtils.js → mjs/src/rendering/caching/testUtils.mjs}

@@ -1,7 +1,7 @@
-import { Vec2 } from '../../math/Vec2';
-import DummyRenderer from '../renderers/DummyRenderer';
-import createEditor from '../../testing/createEditor';
-import RenderingCache from './RenderingCache';
+import  { Vec2 }  from '../../math/Vec2.mjs';
+import  DummyRenderer  from '../renderers/DummyRenderer.mjs';
+import  createEditor  from '../../testing/createEditor.mjs';
+import  RenderingCache  from './RenderingCache.mjs';
 // Override any default test options with [cacheOptions]
 export const createCache = (onRenderAlloc, cacheOptions) => {
     const editor = createEditor();

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

@@ -0,0 +1,19 @@
+import { Vec2 } from '../../math/Vec2';
+import AbstractRenderer from '../renderers/AbstractRenderer';
+import { CacheRecordManager } from './CacheRecordManager';
+export type CacheAddress = number;
+export type BeforeDeallocCallback = () => void;
+export interface CacheProps {
+    createRenderer(): AbstractRenderer;
+    isOfCorrectType(renderer: AbstractRenderer): boolean;
+    blockResolution: Vec2;
+    cacheSize: number;
+    maxScale: number;
+    minProportionalRenderTimePerCache: number;
+    minProportionalRenderTimeToUseCache: number;
+}
+export interface CacheState {
+    currentRenderingCycle: number;
+    props: CacheProps;
+    recordManager: CacheRecordManager;
+}

package/dist/mjs/src/rendering/caching/types.mjs

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

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

@@ -1,3 +1,5 @@
 export { default as AbstractRenderer } from './renderers/AbstractRenderer';
 export { default as DummyRenderer } from './renderers/DummyRenderer';
+export { default as SVGRenderer } from './renderers/SVGRenderer';
+export { default as CanvasRenderer } from './renderers/CanvasRenderer';
 export { default as Display } from './Display';

package/dist/mjs/src/rendering/lib.mjs

@@ -0,0 +1,5 @@
+export  { default as AbstractRenderer }  from './renderers/AbstractRenderer.mjs';
+export  { default as DummyRenderer }  from './renderers/DummyRenderer.mjs';
+export  { default as SVGRenderer }  from './renderers/SVGRenderer.mjs';
+export  { default as CanvasRenderer }  from './renderers/CanvasRenderer.mjs';
+export  { default as Display }  from './Display.mjs';