js-draw 0.25.1 → 1.0.1

package/dist/cjs/rendering/caching/CacheRecordManager.js

@@ -1,22 +1,25 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheRecordManager = void 0;
-var CacheRecord_1 = require("./CacheRecord");
-var debugMode = false;
-var CacheRecordManager = /** @class */ (function () {
-    function CacheRecordManager(cacheProps) {
+const CacheRecord_1 = __importDefault(require("./CacheRecord"));
+const debugMode = false;
+class CacheRecordManager {
+    constructor(cacheProps) {
         // Fixed-size array: Cache blocks are assigned indicies into [cachedCanvases].
         this.cacheRecords = [];
         this.maxCanvases = Math.ceil(
         // Assuming four components per pixel:
         cacheProps.cacheSize / 4 / cacheProps.blockResolution.x / cacheProps.blockResolution.y);
     }
-    CacheRecordManager.prototype.setSharedState = function (state) {
+    setSharedState(state) {
         this.cacheState = state;
-    };
-    CacheRecordManager.prototype.allocCanvas = function (drawTo, onDealloc) {
+    }
+    allocCanvas(drawTo, onDealloc) {
         if (this.cacheRecords.length < this.maxCanvases) {
-            var record = new CacheRecord_1.default(onDealloc, this.cacheState);
+            const record = new CacheRecord_1.default(onDealloc, this.cacheState);
             record.setRenderingRegion(drawTo);
             this.cacheRecords.push(record);
             if (debugMode) {
@@ -25,7 +28,7 @@ var CacheRecordManager = /** @class */ (function () {
             return record;
         }
         else {
-            var lru = this.getLeastRecentlyUsedRecord();
+            const lru = this.getLeastRecentlyUsedRecord();
             if (debugMode) {
                 console.log('[Cache] Re-alloc. Times allocated: ', lru.allocCount, '\nLast used cycle: ', lru.getLastUsedCycle(), '\nCurrent cycle: ', this.cacheState.currentRenderingCycle);
             }
@@ -37,12 +40,11 @@ var CacheRecordManager = /** @class */ (function () {
             }
             return lru;
         }
-    };
+    }
     // Returns null if there are no cache records. Returns an unalloc'd record if one exists.
-    CacheRecordManager.prototype.getLeastRecentlyUsedRecord = function () {
-        this.cacheRecords.sort(function (a, b) { return a.getLastUsedCycle() - b.getLastUsedCycle(); });
+    getLeastRecentlyUsedRecord() {
+        this.cacheRecords.sort((a, b) => a.getLastUsedCycle() - b.getLastUsedCycle());
         return this.cacheRecords[0];
-    };
-    return CacheRecordManager;
-}());
+    }
+}
 exports.CacheRecordManager = CacheRecordManager;

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

@@ -1,10 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-var Rect2_1 = require("../../math/shapes/Rect2");
-var RenderingCacheNode_1 = require("./RenderingCacheNode");
-var CacheRecordManager_1 = require("./CacheRecordManager");
-var RenderingCache = /** @class */ (function () {
-    function RenderingCache(cacheProps) {
+const math_1 = require("@js-draw/math");
+const RenderingCacheNode_1 = __importDefault(require("./RenderingCacheNode"));
+const CacheRecordManager_1 = require("./CacheRecordManager");
+class RenderingCache {
+    constructor(cacheProps) {
         this.recordManager = new CacheRecordManager_1.CacheRecordManager(cacheProps);
         this.sharedState = {
             props: cacheProps,
@@ -13,9 +16,8 @@ var RenderingCache = /** @class */ (function () {
         };
         this.recordManager.setSharedState(this.sharedState);
     }
-    RenderingCache.prototype.render = function (screenRenderer, image, viewport) {
-        var _a;
-        var visibleRect = viewport.visibleRect;
+    render(screenRenderer, image, viewport) {
+        const visibleRect = viewport.visibleRect;
         this.sharedState.currentRenderingCycle++;
         // If we can't use the cache,
         if (!this.sharedState.props.isOfCorrectType(screenRenderer)) {
@@ -24,18 +26,17 @@ var RenderingCache = /** @class */ (function () {
         }
         if (!this.rootNode) {
             // Adjust the node so that it has the correct aspect ratio
-            var res = this.sharedState.props.blockResolution;
-            var topLeft = visibleRect.topLeft;
-            this.rootNode = new RenderingCacheNode_1.default(new Rect2_1.default(topLeft.x, topLeft.y, res.x, res.y), this.sharedState);
+            const res = this.sharedState.props.blockResolution;
+            const topLeft = visibleRect.topLeft;
+            this.rootNode = new RenderingCacheNode_1.default(new math_1.Rect2(topLeft.x, topLeft.y, res.x, res.y), this.sharedState);
         }
         while (!this.rootNode.region.containsRect(visibleRect)) {
             this.rootNode = this.rootNode.generateParent();
         }
-        this.rootNode = (_a = this.rootNode.smallestChildContaining(visibleRect)) !== null && _a !== void 0 ? _a : this.rootNode;
-        var visibleLeaves = image.getLeavesIntersectingRegion(viewport.visibleRect, function (rect) { return screenRenderer.isTooSmallToRender(rect); });
-        var approxVisibleRenderTime = 0;
-        for (var _i = 0, visibleLeaves_1 = visibleLeaves; _i < visibleLeaves_1.length; _i++) {
-            var leaf = visibleLeaves_1[_i];
+        this.rootNode = this.rootNode.smallestChildContaining(visibleRect) ?? this.rootNode;
+        const visibleLeaves = image.getLeavesIntersectingRegion(viewport.visibleRect, rect => screenRenderer.isTooSmallToRender(rect));
+        let approxVisibleRenderTime = 0;
+        for (const leaf of visibleLeaves) {
             approxVisibleRenderTime += leaf.getContent().getProportionalRenderingTime();
         }
         if (approxVisibleRenderTime > this.sharedState.props.minProportionalRenderTimeToUseCache) {
@@ -44,7 +45,6 @@ var RenderingCache = /** @class */ (function () {
         else {
             image.render(screenRenderer, visibleRect);
         }
-    };
-    return RenderingCache;
-}());
+    }
+}
 exports.default = RenderingCache;

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

@@ -1,5 +1,5 @@
 import { ImageNode } from '../../EditorImage';
-import Rect2 from '../../math/shapes/Rect2';
+import { Rect2 } from '@js-draw/math';
 import Viewport from '../../Viewport';
 import AbstractRenderer from '../renderers/AbstractRenderer';
 import { CacheState } from './types';

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

@@ -1,15 +1,14 @@
 "use strict";
 // A cache record with sub-nodes.
 Object.defineProperty(exports, "__esModule", { value: true });
-var Color4_1 = require("../../Color4");
-var EditorImage_1 = require("../../EditorImage");
-var Rect2_1 = require("../../math/shapes/Rect2");
+const EditorImage_1 = require("../../EditorImage");
+const math_1 = require("@js-draw/math");
 // 3x3 divisions for each node.
-var cacheDivisionSize = 3;
+const cacheDivisionSize = 3;
 // True: Show rendering updates.
-var debugMode = false;
-var RenderingCacheNode = /** @class */ (function () {
-    function RenderingCacheNode(region, cacheState) {
+const debugMode = false;
+class RenderingCacheNode {
+    constructor(region, cacheState) {
         this.region = region;
         this.cacheState = cacheState;
         // invariant: instantiatedChildren.length === 9
@@ -23,16 +22,16 @@ var RenderingCacheNode = /** @class */ (function () {
     // Creates a previous layer of the cache tree and adds this as a child near the
     // center of the previous layer's children.
     // Returns this' parent if it already exists.
-    RenderingCacheNode.prototype.generateParent = function () {
+    generateParent() {
         if (this.parent) {
             return this.parent;
         }
-        var parentRegion = Rect2_1.default.fromCorners(this.region.topLeft.minus(this.region.size), this.region.bottomRight.plus(this.region.size));
-        var parent = new RenderingCacheNode(parentRegion, this.cacheState);
+        const parentRegion = math_1.Rect2.fromCorners(this.region.topLeft.minus(this.region.size), this.region.bottomRight.plus(this.region.size));
+        const parent = new RenderingCacheNode(parentRegion, this.cacheState);
         parent.generateChildren();
         // Ensure the new node is matches the middle child's region.
-        var checkTolerance = this.region.maxDimension / 100;
-        var middleChildIdx = (parent.instantiatedChildren.length - 1) / 2;
+        const checkTolerance = this.region.maxDimension / 100;
+        const middleChildIdx = (parent.instantiatedChildren.length - 1) / 2;
         if (!parent.instantiatedChildren[middleChildIdx].region.eq(this.region, checkTolerance)) {
             console.error(parent.instantiatedChildren[middleChildIdx].region, '≠', this.region);
             throw new Error('Logic error: [this] is not contained within its parent\'s center child');
@@ -41,62 +40,58 @@ var RenderingCacheNode = /** @class */ (function () {
         parent.instantiatedChildren[middleChildIdx] = this;
         this.parent = parent;
         return parent;
-    };
+    }
     // Generates children, if missing.
-    RenderingCacheNode.prototype.generateChildren = function () {
+    generateChildren() {
         if (this.instantiatedChildren.length === 0) {
-            var childRects = this.region.divideIntoGrid(cacheDivisionSize, cacheDivisionSize);
+            const childRects = this.region.divideIntoGrid(cacheDivisionSize, cacheDivisionSize);
             if (this.region.size.x === 0 || this.region.size.y === 0) {
                 console.warn('Cache element has zero size! Not generating children.');
                 return;
             }
-            for (var _i = 0, childRects_1 = childRects; _i < childRects_1.length; _i++) {
-                var rect = childRects_1[_i];
-                var child = new RenderingCacheNode(rect, this.cacheState);
+            for (const rect of childRects) {
+                const child = new RenderingCacheNode(rect, this.cacheState);
                 child.parent = this;
                 this.instantiatedChildren.push(child);
             }
         }
         this.checkRep();
-    };
+    }
     // Returns CacheNodes directly contained within this.
-    RenderingCacheNode.prototype.getChildren = function () {
+    getChildren() {
         this.checkRep();
         this.generateChildren();
         return this.instantiatedChildren;
-    };
-    RenderingCacheNode.prototype.smallestChildContaining = function (rect) {
-        var _a;
-        var largerThanChildren = rect.maxDimension > this.region.maxDimension / cacheDivisionSize;
+    }
+    smallestChildContaining(rect) {
+        const largerThanChildren = rect.maxDimension > this.region.maxDimension / cacheDivisionSize;
         if (!this.region.containsRect(rect) || largerThanChildren) {
             return null;
         }
-        for (var _i = 0, _b = this.getChildren(); _i < _b.length; _i++) {
-            var child = _b[_i];
+        for (const child of this.getChildren()) {
             if (child.region.containsRect(rect)) {
-                return (_a = child.smallestChildContaining(rect)) !== null && _a !== void 0 ? _a : child;
+                return child.smallestChildContaining(rect) ?? child;
             }
         }
         return null;
-    };
+    }
     // => [true] iff [this] can be rendered without too much scaling
-    RenderingCacheNode.prototype.renderingWouldBeHighEnoughResolution = function (viewport) {
+    renderingWouldBeHighEnoughResolution(viewport) {
         // Determine how 1px in this corresponds to 1px on the canvas.
         //  this.region.w is in canvas units. Thus,
-        var sizeOfThisPixelOnCanvas = this.region.w / this.cacheState.props.blockResolution.x;
-        var sizeOfThisPixelOnScreen = viewport.getScaleFactor() * sizeOfThisPixelOnCanvas;
+        const sizeOfThisPixelOnCanvas = this.region.w / this.cacheState.props.blockResolution.x;
+        const sizeOfThisPixelOnScreen = viewport.getScaleFactor() * sizeOfThisPixelOnCanvas;
         if (sizeOfThisPixelOnScreen > this.cacheState.props.maxScale) {
             return false;
         }
         return true;
-    };
+    }
     // => [true] if all children of this can be rendered from their caches.
-    RenderingCacheNode.prototype.allChildrenCanRender = function (viewport, leavesSortedById) {
+    allChildrenCanRender(viewport, leavesSortedById) {
         if (this.instantiatedChildren.length === 0) {
             return false;
         }
-        for (var _i = 0, _a = this.instantiatedChildren; _i < _a.length; _i++) {
-            var child = _a[_i];
+        for (const child of this.instantiatedChildren) {
             if (!child.region.intersects(viewport.visibleRect)) {
                 continue;
             }
@@ -105,61 +100,57 @@ var RenderingCacheNode = /** @class */ (function () {
             }
         }
         return true;
-    };
-    RenderingCacheNode.prototype.computeSortedByLeafIds = function (leaves) {
-        var ids = leaves.slice();
-        ids.sort(function (a, b) { return a.getId() - b.getId(); });
+    }
+    computeSortedByLeafIds(leaves) {
+        const ids = leaves.slice();
+        ids.sort((a, b) => a.getId() - b.getId());
         return ids;
-    };
+    }
     // Returns a list of the ids of the nodes intersecting this
-    RenderingCacheNode.prototype.idsOfIntersecting = function (nodes) {
-        var result = [];
-        for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
-            var node = nodes_1[_i];
+    idsOfIntersecting(nodes) {
+        const result = [];
+        for (const node of nodes) {
             if (node.getBBox().intersects(this.region)) {
                 result.push(node.getId());
             }
         }
         return result;
-    };
+    }
     // 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.)
-    RenderingCacheNode.prototype.allRenderedIdsIn = function (sortedIds) {
+    allRenderedIdsIn(sortedIds) {
         if (this.renderedIds.length > sortedIds.length) {
             return false;
         }
-        for (var i = 0; i < this.renderedIds.length; i++) {
+        for (let i = 0; i < this.renderedIds.length; i++) {
             if (sortedIds[i] !== this.renderedIds[i]) {
                 return false;
             }
         }
         return true;
-    };
-    RenderingCacheNode.prototype.renderingIsUpToDate = function (sortedIds) {
+    }
+    renderingIsUpToDate(sortedIds) {
         if (this.cachedRenderer === null || sortedIds.length !== this.renderedIds.length) {
             return false;
         }
         return this.allRenderedIdsIn(sortedIds);
-    };
+    }
     // Render all [items] within [viewport]
-    RenderingCacheNode.prototype.renderItems = function (screenRenderer, items, viewport) {
-        var _this = this;
-        var _a, _b;
+    renderItems(screenRenderer, items, viewport) {
         if (!viewport.visibleRect.intersects(this.region)
             || items.length === 0) {
             return;
         }
-        var newItems = [];
+        const newItems = [];
         // Divide [items] until nodes are leaves or smaller than this
-        for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
-            var item = items_1[_i];
-            var bbox = item.getBBox();
+        for (const item of items) {
+            const bbox = item.getBBox();
             if (!bbox.intersects(this.region)) {
                 continue;
             }
             if (bbox.maxDimension >= this.region.maxDimension) {
-                newItems.push.apply(newItems, item.getChildrenOrSelfIntersectingRegion(this.region));
+                newItems.push(...item.getChildrenOrSelfIntersectingRegion(this.region));
             }
             else {
                 newItems.push(item);
@@ -168,69 +159,62 @@ var RenderingCacheNode = /** @class */ (function () {
         items = newItems;
         // Can we cache at all?
         if (!this.cacheState.props.isOfCorrectType(screenRenderer)) {
-            items.forEach(function (item) { return item.render(screenRenderer, viewport.visibleRect); });
+            items.forEach(item => item.render(screenRenderer, viewport.visibleRect));
             return;
         }
         if (debugMode) {
-            screenRenderer.drawRect(this.region, 0.5 * viewport.getSizeOfPixelOnCanvas(), { fill: Color4_1.default.yellow });
+            screenRenderer.drawRect(this.region, 0.5 * viewport.getSizeOfPixelOnCanvas(), { fill: math_1.Color4.yellow });
         }
         // Could we render direclty from [this] or do we need to recurse?
-        var couldRender = this.renderingWouldBeHighEnoughResolution(viewport);
+        const couldRender = this.renderingWouldBeHighEnoughResolution(viewport);
         if (!couldRender) {
-            var _loop_1 = function (child) {
-                child.renderItems(screenRenderer, items.filter(function (item) {
+            for (const child of this.getChildren()) {
+                child.renderItems(screenRenderer, items.filter(item => {
                     return item.getBBox().intersects(child.region);
                 }), viewport);
-            };
-            for (var _c = 0, _d = this.getChildren(); _c < _d.length; _c++) {
-                var child = _d[_c];
-                _loop_1(child);
             }
         }
         else {
             // Determine whether we already have rendered the items
-            var tooSmallToRender = function (rect) { return rect.w / _this.region.w < 1 / _this.cacheState.props.blockResolution.x; };
-            var leaves = [];
-            for (var _e = 0, items_2 = items; _e < items_2.length; _e++) {
-                var item = items_2[_e];
-                leaves.push.apply(leaves, item.getLeavesIntersectingRegion(this.region, tooSmallToRender));
+            const tooSmallToRender = (rect) => rect.w / this.region.w < 1 / this.cacheState.props.blockResolution.x;
+            const leaves = [];
+            for (const item of items) {
+                leaves.push(...item.getLeavesIntersectingRegion(this.region, tooSmallToRender));
             }
             (0, EditorImage_1.sortLeavesByZIndex)(leaves);
-            var leavesByIds = this.computeSortedByLeafIds(leaves);
+            const leavesByIds = this.computeSortedByLeafIds(leaves);
             // No intersecting leaves? No need to render
             if (leavesByIds.length === 0) {
                 return;
             }
-            var leafIds = leavesByIds.map(function (leaf) { return leaf.getId(); });
-            var thisRenderer = void 0;
+            const leafIds = leavesByIds.map(leaf => leaf.getId());
+            let thisRenderer;
             if (!this.renderingIsUpToDate(leafIds)) {
                 if (this.allChildrenCanRender(viewport, leavesByIds)) {
-                    for (var _f = 0, _g = this.getChildren(); _f < _g.length; _f++) {
-                        var child = _g[_f];
+                    for (const child of this.getChildren()) {
                         child.renderItems(screenRenderer, items, viewport);
                     }
                     return;
                 }
-                var leafApproxRenderTime = 0;
-                for (var _h = 0, leavesByIds_1 = leavesByIds; _h < leavesByIds_1.length; _h++) {
-                    var leaf = leavesByIds_1[_h];
+                let leafApproxRenderTime = 0;
+                for (const leaf of leavesByIds) {
                     leafApproxRenderTime += leaf.getContent().getProportionalRenderingTime();
                 }
                 // Is it worth it to render the items?
                 if (leafApproxRenderTime > this.cacheState.props.minProportionalRenderTimePerCache) {
-                    var fullRerenderNeeded = true;
+                    let fullRerenderNeeded = true;
                     if (!this.cachedRenderer) {
-                        this.cachedRenderer = this.cacheState.recordManager.allocCanvas(this.region, function () { return _this.onRegionDealloc(); });
+                        this.cachedRenderer = this.cacheState.recordManager.allocCanvas(this.region, () => this.onRegionDealloc());
                     }
                     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.
-                        var newLeaves = [];
-                        var minNewZIndex = null;
-                        for (var i = 0; i < leavesByIds.length; i++) {
-                            var leaf = leavesByIds[i];
-                            var content = leaf.getContent();
-                            var zIndex = content.getZIndex();
+                        const newLeaves = [];
+                        let minNewZIndex = null;
+                        for (let i = 0; i < leavesByIds.length; i++) {
+                            const leaf = leavesByIds[i];
+                            const content = leaf.getContent();
+                            const zIndex = content.getZIndex();
                             if (i >= this.renderedIds.length || leaf.getId() !== this.renderedIds[i]) {
                                 newLeaves.push(leaf);
                                 if (minNewZIndex === null || zIndex < minNewZIndex) {
@@ -242,16 +226,16 @@ var RenderingCacheNode = /** @class */ (function () {
                             fullRerenderNeeded = false;
                             thisRenderer = this.cachedRenderer.startRender();
                             // Looping is faster than re-sorting.
-                            for (var i = 0; i < leaves.length; i++) {
-                                var leaf = leaves[i];
-                                var zIndex = leaf.getContent().getZIndex();
+                            for (let i = 0; i < leaves.length; i++) {
+                                const leaf = leaves[i];
+                                const zIndex = leaf.getContent().getZIndex();
                                 if (zIndex > this.renderedMaxZIndex) {
                                     leaf.render(thisRenderer, this.region);
                                     this.renderedMaxZIndex = zIndex;
                                 }
                             }
                             if (debugMode) {
-                                screenRenderer.drawRect(this.region, viewport.getSizeOfPixelOnCanvas(), { fill: Color4_1.default.clay });
+                                screenRenderer.drawRect(this.region, viewport.getSizeOfPixelOnCanvas(), { fill: math_1.Color4.clay });
                             }
                         }
                     }
@@ -262,29 +246,27 @@ var RenderingCacheNode = /** @class */ (function () {
                         thisRenderer = this.cachedRenderer.startRender();
                         thisRenderer.clear();
                         this.renderedMaxZIndex = null;
-                        for (var _j = 0, leaves_1 = leaves; _j < leaves_1.length; _j++) {
-                            var leaf = leaves_1[_j];
-                            var content = leaf.getContent();
-                            (_a = this.renderedMaxZIndex) !== null && _a !== void 0 ? _a : (this.renderedMaxZIndex = content.getZIndex());
+                        for (const leaf of leaves) {
+                            const content = leaf.getContent();
+                            this.renderedMaxZIndex ??= content.getZIndex();
                             this.renderedMaxZIndex = Math.max(this.renderedMaxZIndex, content.getZIndex());
                             leaf.render(thisRenderer, this.region);
                         }
                         if (debugMode) {
-                            screenRenderer.drawRect(this.region, viewport.getSizeOfPixelOnCanvas(), { fill: Color4_1.default.red });
+                            screenRenderer.drawRect(this.region, viewport.getSizeOfPixelOnCanvas(), { fill: math_1.Color4.red });
                         }
                     }
                     this.renderedIds = leafIds;
                 }
                 else {
-                    (_b = this.cachedRenderer) === null || _b === void 0 ? void 0 : _b.dealloc();
+                    this.cachedRenderer?.dealloc();
                     // Slightly increase the clip region to prevent seams.
                     // Divide by two because grownBy expands the rectangle on all sides.
-                    var pixelSize = viewport.getSizeOfPixelOnCanvas();
-                    var expandedRegion = new Rect2_1.default(this.region.x, this.region.y, this.region.w + pixelSize, this.region.h + pixelSize);
-                    var clip = true;
+                    const pixelSize = viewport.getSizeOfPixelOnCanvas();
+                    const expandedRegion = new math_1.Rect2(this.region.x, this.region.y, this.region.w + pixelSize, this.region.h + pixelSize);
+                    const clip = true;
                     screenRenderer.startObject(expandedRegion, clip);
-                    for (var _k = 0, leaves_2 = leaves; _k < leaves_2.length; _k++) {
-                        var leaf = leaves_2[_k];
+                    for (const leaf of leaves) {
                         leaf.render(screenRenderer, this.region.intersection(viewport.visibleRect));
                     }
                     screenRenderer.endObject();
@@ -294,39 +276,38 @@ var RenderingCacheNode = /** @class */ (function () {
                 thisRenderer = this.cachedRenderer.startRender();
             }
             if (thisRenderer) {
-                var transformMat = this.cachedRenderer.getTransform(this.region).inverse();
+                const transformMat = this.cachedRenderer.getTransform(this.region).inverse();
                 screenRenderer.renderFromOtherOfSameType(transformMat, thisRenderer);
             }
             // Can we clean up this' children? (Are they unused?)
-            if (this.instantiatedChildren.every(function (child) { return child.isEmpty(); })) {
+            if (this.instantiatedChildren.every(child => child.isEmpty())) {
                 this.instantiatedChildren = [];
             }
         }
         this.checkRep();
-    };
+    }
     // Returns true iff this/its children have no cached state.
-    RenderingCacheNode.prototype.isEmpty = function () {
+    isEmpty() {
         if (this.cachedRenderer !== null) {
             return false;
         }
-        return this.instantiatedChildren.every(function (child) { return child.isEmpty(); });
-    };
-    RenderingCacheNode.prototype.onRegionDealloc = function () {
+        return this.instantiatedChildren.every(child => child.isEmpty());
+    }
+    onRegionDealloc() {
         this.cachedRenderer = null;
         if (this.isEmpty()) {
             this.instantiatedChildren = [];
         }
-    };
-    RenderingCacheNode.prototype.checkRep = function () {
+    }
+    checkRep() {
         if (this.instantiatedChildren.length !== cacheDivisionSize * cacheDivisionSize && this.instantiatedChildren.length !== 0) {
-            throw new Error("Repcheck: Wrong number of children. Got ".concat(this.instantiatedChildren.length));
+            throw new Error(`Repcheck: Wrong number of children. Got ${this.instantiatedChildren.length}`);
         }
         if (this.renderedIds[1] !== undefined && this.renderedIds[0] >= this.renderedIds[1]) {
             console.error(this.renderedIds);
             throw new Error('Repcheck: First two ids are not in ascending order!');
         }
-        for (var _i = 0, _a = this.instantiatedChildren; _i < _a.length; _i++) {
-            var child = _a[_i];
+        for (const child of this.instantiatedChildren) {
             if (child.parent !== this) {
                 throw new Error('Children should be linked to their parents!');
             }
@@ -334,7 +315,6 @@ var RenderingCacheNode = /** @class */ (function () {
         if (this.cachedRenderer && !this.cachedRenderer.isAllocd()) {
             throw new Error('this\' cachedRenderer != null, but is dealloc\'d');
         }
-    };
-    return RenderingCacheNode;
-}());
+    }
+}
 exports.default = RenderingCacheNode;

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

@@ -1,34 +1,35 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCache = void 0;
-var Vec2_1 = require("../../math/Vec2");
-var DummyRenderer_1 = require("../renderers/DummyRenderer");
-var createEditor_1 = require("../../testing/createEditor");
-var RenderingCache_1 = require("./RenderingCache");
+const math_1 = require("@js-draw/math");
+const DummyRenderer_1 = __importDefault(require("../renderers/DummyRenderer"));
+const createEditor_1 = __importDefault(require("../../testing/createEditor"));
+const RenderingCache_1 = __importDefault(require("./RenderingCache"));
 // Override any default test options with [cacheOptions]
-var createCache = function (onRenderAlloc, cacheOptions) {
-    var editor = (0, createEditor_1.default)();
-    var cache = new RenderingCache_1.default(__assign({ createRenderer: function () {
-            var renderer = new DummyRenderer_1.default(editor.viewport);
-            onRenderAlloc === null || onRenderAlloc === void 0 ? void 0 : onRenderAlloc(renderer);
+const createCache = (onRenderAlloc, cacheOptions) => {
+    const editor = (0, createEditor_1.default)();
+    const cache = new RenderingCache_1.default({
+        createRenderer() {
+            const renderer = new DummyRenderer_1.default(editor.viewport);
+            onRenderAlloc?.(renderer);
             return renderer;
-        }, isOfCorrectType: function (renderer) {
+        },
+        isOfCorrectType(renderer) {
             return renderer instanceof DummyRenderer_1.default;
-        }, blockResolution: Vec2_1.Vec2.of(500, 500), cacheSize: 500 * 10 * 4, maxScale: 2, minProportionalRenderTimePerCache: 0, minProportionalRenderTimeToUseCache: 0 }, cacheOptions));
+        },
+        blockResolution: math_1.Vec2.of(500, 500),
+        cacheSize: 500 * 10 * 4,
+        maxScale: 2,
+        minProportionalRenderTimePerCache: 0,
+        minProportionalRenderTimeToUseCache: 0,
+        ...cacheOptions
+    });
     return {
-        cache: cache,
-        editor: editor
+        cache,
+        editor
     };
 };
 exports.createCache = createCache;

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

@@ -1,6 +1,6 @@
-import { Vec2 } from '../../math/Vec2';
-import AbstractRenderer from '../renderers/AbstractRenderer';
-import { CacheRecordManager } from './CacheRecordManager';
+import type { Vec2 } from '@js-draw/math';
+import type AbstractRenderer from '../renderers/AbstractRenderer';
+import type { CacheRecordManager } from './CacheRecordManager';
 export type CacheAddress = number;
 export type BeforeDeallocCallback = () => void;
 export interface CacheProps {