js-draw 0.23.0 → 0.24.0

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

@@ -1,61 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const Mat33_1 = __importDefault(require("../../math/Mat33"));
-// Represents a cached renderer/canvas
-// This is not a [CacheNode] -- it handles cached renderers and does not have sub-renderers.
-class CacheRecord {
-    constructor(onBeforeDeallocCallback, cacheState) {
-        this.onBeforeDeallocCallback = onBeforeDeallocCallback;
-        this.cacheState = cacheState;
-        this.allocd = false;
-        // For debugging
-        this.allocCount = 0;
-        this.renderer = cacheState.props.createRenderer();
-        this.lastUsedCycle = -1;
-        this.allocd = true;
-    }
-    startRender() {
-        this.lastUsedCycle = this.cacheState.currentRenderingCycle;
-        if (!this.allocd) {
-            throw new Error('Only alloc\'d canvases can be rendered to');
-        }
-        return this.renderer;
-    }
-    dealloc() {
-        var _a;
-        (_a = this.onBeforeDeallocCallback) === null || _a === void 0 ? void 0 : _a.call(this);
-        this.allocd = false;
-        this.onBeforeDeallocCallback = null;
-        this.lastUsedCycle = 0;
-    }
-    isAllocd() {
-        return this.allocd;
-    }
-    realloc(newDeallocCallback) {
-        if (this.allocd) {
-            this.dealloc();
-        }
-        this.allocd = true;
-        this.onBeforeDeallocCallback = newDeallocCallback;
-        this.lastUsedCycle = this.cacheState.currentRenderingCycle;
-        this.allocCount++;
-    }
-    getLastUsedCycle() {
-        return this.lastUsedCycle;
-    }
-    // Returns the transformation that maps [drawTo] to this' renderable region
-    // (i.e. a [cacheProps.blockResolution]-sized rectangle with top left at (0, 0))
-    getTransform(drawTo) {
-        const transform = Mat33_1.default.scaling2D(this.cacheState.props.blockResolution.x / drawTo.size.x).rightMul(Mat33_1.default.translation(drawTo.topLeft.times(-1)));
-        return transform;
-    }
-    setRenderingRegion(drawTo) {
-        this.renderer.setTransform(
-        // Invert to map objects instead of the viewport
-        this.getTransform(drawTo));
-    }
-}
-exports.default = CacheRecord;

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

@@ -1,12 +0,0 @@
-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/cjs/src/rendering/caching/CacheRecordManager.js

@@ -1,50 +0,0 @@
-"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;
-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);
-    }
-    setSharedState(state) {
-        this.cacheState = state;
-    }
-    allocCanvas(drawTo, onDealloc) {
-        if (this.cacheRecords.length < this.maxCanvases) {
-            const record = new CacheRecord_1.default(onDealloc, this.cacheState);
-            record.setRenderingRegion(drawTo);
-            this.cacheRecords.push(record);
-            if (debugMode) {
-                console.log('[Cache] Cache spaces used: ', this.cacheRecords.length, ' of ', this.maxCanvases);
-            }
-            return record;
-        }
-        else {
-            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);
-            }
-            lru.realloc(onDealloc);
-            lru.setRenderingRegion(drawTo);
-            if (debugMode) {
-                console.log('[Cache] Now re-alloc\'d. Last used cycle: ', lru.getLastUsedCycle());
-                console.assert(lru['cacheState'] === this.cacheState, '[Cache] Unequal cache states! cacheState should be a shared object!');
-            }
-            return lru;
-        }
-    }
-    // Returns null if there are no cache records. Returns an unalloc'd record if one exists.
-    getLeastRecentlyUsedRecord() {
-        this.cacheRecords.sort((a, b) => a.getLastUsedCycle() - b.getLastUsedCycle());
-        return this.cacheRecords[0];
-    }
-}
-exports.CacheRecordManager = CacheRecordManager;

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

@@ -1,51 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const Rect2_1 = __importDefault(require("../../math/Rect2"));
-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,
-            currentRenderingCycle: 0,
-            recordManager: this.recordManager,
-        };
-        this.recordManager.setSharedState(this.sharedState);
-    }
-    render(screenRenderer, image, viewport) {
-        var _a;
-        const visibleRect = viewport.visibleRect;
-        this.sharedState.currentRenderingCycle++;
-        // If we can't use the cache,
-        if (!this.sharedState.props.isOfCorrectType(screenRenderer)) {
-            image.render(screenRenderer, visibleRect);
-            return;
-        }
-        if (!this.rootNode) {
-            // Adjust the node so that it has the correct aspect ratio
-            const res = this.sharedState.props.blockResolution;
-            const topLeft = visibleRect.topLeft;
-            this.rootNode = new RenderingCacheNode_1.default(new Rect2_1.default(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;
-        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) {
-            this.rootNode.renderItems(screenRenderer, [image], viewport);
-        }
-        else {
-            image.render(screenRenderer, visibleRect);
-        }
-    }
-}
-exports.default = RenderingCache;

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

@@ -1,29 +0,0 @@
-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/cjs/src/rendering/caching/RenderingCacheNode.js

@@ -1,326 +0,0 @@
-"use strict";
-// A cache record with sub-nodes.
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const Color4_1 = __importDefault(require("../../Color4"));
-const EditorImage_1 = require("../../EditorImage");
-const Rect2_1 = __importDefault(require("../../math/Rect2"));
-// 3x3 divisions for each node.
-const cacheDivisionSize = 3;
-// True: Show rendering updates.
-const debugMode = false;
-class RenderingCacheNode {
-    constructor(region, cacheState) {
-        this.region = region;
-        this.cacheState = cacheState;
-        // invariant: instantiatedChildren.length === 9
-        this.instantiatedChildren = [];
-        this.parent = null;
-        this.cachedRenderer = null;
-        // invariant: sortedInAscendingOrder(renderedIds)
-        this.renderedIds = [];
-        this.renderedMaxZIndex = null;
-    }
-    // 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.
-    generateParent() {
-        if (this.parent) {
-            return this.parent;
-        }
-        const parentRegion = Rect2_1.default.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.
-        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');
-        }
-        // Replace the middle child
-        parent.instantiatedChildren[middleChildIdx] = this;
-        this.parent = parent;
-        return parent;
-    }
-    // Generates children, if missing.
-    generateChildren() {
-        if (this.instantiatedChildren.length === 0) {
-            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 (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.
-    getChildren() {
-        this.checkRep();
-        this.generateChildren();
-        return this.instantiatedChildren;
-    }
-    smallestChildContaining(rect) {
-        var _a;
-        const largerThanChildren = rect.maxDimension > this.region.maxDimension / cacheDivisionSize;
-        if (!this.region.containsRect(rect) || largerThanChildren) {
-            return null;
-        }
-        for (const child of this.getChildren()) {
-            if (child.region.containsRect(rect)) {
-                return (_a = child.smallestChildContaining(rect)) !== null && _a !== void 0 ? _a : child;
-            }
-        }
-        return null;
-    }
-    // => [true] iff [this] can be rendered without too much scaling
-    renderingWouldBeHighEnoughResolution(viewport) {
-        // Determine how 1px in this corresponds to 1px on the canvas.
-        //  this.region.w is in canvas units. Thus,
-        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.
-    allChildrenCanRender(viewport, leavesSortedById) {
-        if (this.instantiatedChildren.length === 0) {
-            return false;
-        }
-        for (const child of this.instantiatedChildren) {
-            if (!child.region.intersects(viewport.visibleRect)) {
-                continue;
-            }
-            if (!child.renderingIsUpToDate(this.idsOfIntersecting(leavesSortedById))) {
-                return false;
-            }
-        }
-        return true;
-    }
-    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
-    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.)
-    allRenderedIdsIn(sortedIds) {
-        if (this.renderedIds.length > sortedIds.length) {
-            return false;
-        }
-        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;
-        if (!viewport.visibleRect.intersects(this.region)
-            || items.length === 0) {
-            return;
-        }
-        const newItems = [];
-        // Divide [items] until nodes are leaves or smaller than this
-        for (const item of items) {
-            const bbox = item.getBBox();
-            if (!bbox.intersects(this.region)) {
-                continue;
-            }
-            if (bbox.maxDimension >= this.region.maxDimension) {
-                newItems.push(...item.getChildrenOrSelfIntersectingRegion(this.region));
-            }
-            else {
-                newItems.push(item);
-            }
-        }
-        items = newItems;
-        // Can we cache at all?
-        if (!this.cacheState.props.isOfCorrectType(screenRenderer)) {
-            items.forEach(item => item.render(screenRenderer, viewport.visibleRect));
-            return;
-        }
-        if (debugMode) {
-            screenRenderer.drawRect(this.region, 0.5 * viewport.getSizeOfPixelOnCanvas(), { fill: Color4_1.default.yellow });
-        }
-        // Could we render direclty from [this] or do we need to recurse?
-        const couldRender = this.renderingWouldBeHighEnoughResolution(viewport);
-        if (!couldRender) {
-            for (const child of this.getChildren()) {
-                child.renderItems(screenRenderer, items.filter(item => {
-                    return item.getBBox().intersects(child.region);
-                }), viewport);
-            }
-        }
-        else {
-            // Determine whether we already have rendered the items
-            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);
-            const leavesByIds = this.computeSortedByLeafIds(leaves);
-            // No intersecting leaves? No need to render
-            if (leavesByIds.length === 0) {
-                return;
-            }
-            const leafIds = leavesByIds.map(leaf => leaf.getId());
-            let thisRenderer;
-            if (!this.renderingIsUpToDate(leafIds)) {
-                if (this.allChildrenCanRender(viewport, leavesByIds)) {
-                    for (const child of this.getChildren()) {
-                        child.renderItems(screenRenderer, items, viewport);
-                    }
-                    return;
-                }
-                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) {
-                    let fullRerenderNeeded = true;
-                    if (!this.cachedRenderer) {
-                        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.
-                        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) {
-                                    minNewZIndex = zIndex;
-                                }
-                            }
-                        }
-                        if (minNewZIndex !== null && minNewZIndex > this.renderedMaxZIndex) {
-                            fullRerenderNeeded = false;
-                            thisRenderer = this.cachedRenderer.startRender();
-                            // Looping is faster than re-sorting.
-                            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 });
-                            }
-                        }
-                    }
-                    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();
-                        this.renderedMaxZIndex = null;
-                        for (const leaf of leaves) {
-                            const content = leaf.getContent();
-                            (_a = this.renderedMaxZIndex) !== null && _a !== void 0 ? _a : (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 });
-                        }
-                    }
-                    this.renderedIds = leafIds;
-                }
-                else {
-                    (_b = this.cachedRenderer) === null || _b === void 0 ? void 0 : _b.dealloc();
-                    // Slightly increase the clip region to prevent seams.
-                    // Divide by two because grownBy expands the rectangle on all sides.
-                    const pixelSize = viewport.getSizeOfPixelOnCanvas();
-                    const expandedRegion = new Rect2_1.default(this.region.x, this.region.y, this.region.w + pixelSize, this.region.h + pixelSize);
-                    const clip = true;
-                    screenRenderer.startObject(expandedRegion, clip);
-                    for (const leaf of leaves) {
-                        leaf.render(screenRenderer, this.region.intersection(viewport.visibleRect));
-                    }
-                    screenRenderer.endObject();
-                }
-            }
-            else {
-                thisRenderer = this.cachedRenderer.startRender();
-            }
-            if (thisRenderer) {
-                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(child => child.isEmpty())) {
-                this.instantiatedChildren = [];
-            }
-        }
-        this.checkRep();
-    }
-    // Returns true iff this/its children have no cached state.
-    isEmpty() {
-        if (this.cachedRenderer !== null) {
-            return false;
-        }
-        return this.instantiatedChildren.every(child => child.isEmpty());
-    }
-    onRegionDealloc() {
-        this.cachedRenderer = null;
-        if (this.isEmpty()) {
-            this.instantiatedChildren = [];
-        }
-    }
-    checkRep() {
-        if (this.instantiatedChildren.length !== cacheDivisionSize * cacheDivisionSize && this.instantiatedChildren.length !== 0) {
-            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 (const child of this.instantiatedChildren) {
-            if (child.parent !== this) {
-                throw new Error('Children should be linked to their parents!');
-            }
-        }
-        if (this.cachedRenderer && !this.cachedRenderer.isAllocd()) {
-            throw new Error('this\' cachedRenderer != null, but is dealloc\'d');
-        }
-    }
-}
-exports.default = RenderingCacheNode;

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

@@ -1,27 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCache = void 0;
-const Vec2_1 = require("../../math/Vec2");
-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]
-const createCache = (onRenderAlloc, cacheOptions) => {
-    const editor = (0, createEditor_1.default)();
-    const cache = new RenderingCache_1.default(Object.assign({ createRenderer() {
-            const renderer = new DummyRenderer_1.default(editor.viewport);
-            onRenderAlloc === null || onRenderAlloc === void 0 ? void 0 : onRenderAlloc(renderer);
-            return 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));
-    return {
-        cache,
-        editor
-    };
-};
-exports.createCache = createCache;

package/dist/cjs/src/rendering/lib.js

@@ -1,17 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RenderingMode = exports.Display = exports.CanvasRenderer = exports.SVGRenderer = exports.DummyRenderer = exports.AbstractRenderer = void 0;
-var AbstractRenderer_1 = require("./renderers/AbstractRenderer");
-Object.defineProperty(exports, "AbstractRenderer", { enumerable: true, get: function () { return __importDefault(AbstractRenderer_1).default; } });
-var DummyRenderer_1 = require("./renderers/DummyRenderer");
-Object.defineProperty(exports, "DummyRenderer", { enumerable: true, get: function () { return __importDefault(DummyRenderer_1).default; } });
-var SVGRenderer_1 = require("./renderers/SVGRenderer");
-Object.defineProperty(exports, "SVGRenderer", { enumerable: true, get: function () { return __importDefault(SVGRenderer_1).default; } });
-var CanvasRenderer_1 = require("./renderers/CanvasRenderer");
-Object.defineProperty(exports, "CanvasRenderer", { enumerable: true, get: function () { return __importDefault(CanvasRenderer_1).default; } });
-var Display_1 = require("./Display");
-Object.defineProperty(exports, "Display", { enumerable: true, get: function () { return __importDefault(Display_1).default; } });
-Object.defineProperty(exports, "RenderingMode", { enumerable: true, get: function () { return Display_1.RenderingMode; } });

package/dist/cjs/src/rendering/localization.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultTextRendererLocalization = void 0;
-exports.defaultTextRendererLocalization = {
-    pathNodeCount: (count) => `There are ${count} visible path objects.`,
-    textNodeCount: (count) => `There are ${count} visible text nodes.`,
-    imageNodeCount: (nodeCount) => `There are ${nodeCount} visible image nodes.`,
-    textNode: (content) => `Text: ${content}`,
-    imageNode: (label) => `Image: ${label}`,
-    unlabeledImageNode: 'Unlabeled image',
-    rerenderAsText: 'Re-render as text',
-};