@alleninstitute/vis-core 0.0.6

package/dist/module.js

@@ -0,0 +1,1271 @@
+import $tmQ84$lodashpartial from "lodash/partial";
+import {Box2D as $tmQ84$Box2D, Vec2 as $tmQ84$Vec2} from "@alleninstitute/vis-geometry";
+import $tmQ84$regl from "regl";
+import $tmQ84$lodashuniqueId from "lodash/uniqueId";
+
+
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+
+function $e03391db1cf02961$export$8fbec945df051b82(maximumInflightAsyncTasks, queueProcessingIntervalMS, items, mutableCache, settings, requestsForItem, render, lifecycleCallback, cacheKeyForRequest = (key)=>key, queueTimeBudgetMS = queueProcessingIntervalMS / 3) {
+    const abort = new AbortController();
+    const queue = [];
+    const taskCancelCallbacks = [];
+    const reportNormalStatus = (status)=>{
+        // we want to report our status, however the flow of events can be confusing -
+        // our callers anticipate an asynchronous (long running) frame to be started,
+        // but there are scenarios in which the whole thing is completely synchronous
+        // callers who are scheduling things may be surprised that their frame finished
+        // before the code that handles it appears to start. thus, we make the entire lifecycle callback
+        // system async, to prevent surprises.
+        Promise.resolve().then(()=>lifecycleCallback({
+                status: status
+            }));
+    };
+    // when starting a frame, we greedily attempt to render any tasks that are already in the cache
+    // however, if there is too much overhead (or too many tasks) we would risk hogging the main thread
+    // thus - obey the limit (its a soft limit)
+    const startTime = performance.now();
+    for(let i = 0; i < items.length; i += 1){
+        const itemToRender = items[i];
+        const requestFns = requestsForItem(itemToRender, settings, abort.signal);
+        const cacheKey = (rq)=>cacheKeyForRequest(rq, itemToRender, settings);
+        const cacheKeys = Object.keys(requestFns).map(cacheKey);
+        if (mutableCache.areKeysAllCached(cacheKeys)) {
+            const result = mutableCache.cacheAndUse(requestFns, (0, $tmQ84$lodashpartial)(render, itemToRender, settings), cacheKey);
+            if (result !== undefined) // this is a problem - the cache reported that all the keys are in the cache, however this result is a cancellation callback,
+            // which indicates that the item could not be rendered right away, which should be impossible...
+            // TODO
+            taskCancelCallbacks.push(result);
+        } else // areKeysAllCached returned false - enqueue for later
+        queue.push(itemToRender);
+        if (performance.now() - startTime > queueTimeBudgetMS) {
+            // we've used up all our time - enqueue all remaining tasks
+            if (i < items.length - 1) queue.push(...items.slice(i + 1));
+            break;
+        }
+    }
+    if (queue.length === 0) {
+        // we did all the work - it was already cached
+        reportNormalStatus('finished_synchronously');
+        return {
+            cancelFrame: ()=>{}
+        };
+    }
+    // TODO: Re-examine lifecycle reporting, potentially unify all statuses into a single type
+    reportNormalStatus('begun');
+    if (queue.length !== items.length) // We did some work, but there's some left
+    reportNormalStatus('progress');
+    const doWorkOnQueue = (intervalId)=>{
+        // try our best to cleanup if something goes awry
+        const startWorkTime = performance.now();
+        const cleanupOnError = (err)=>{
+            // clear the queue and the staging area (inFlight)
+            for (const cancelMe of taskCancelCallbacks)cancelMe();
+            queue.splice(0, queue.length);
+            // stop fetching
+            abort.abort(err);
+            clearInterval(intervalId);
+            // pass the error somewhere better:
+            lifecycleCallback({
+                status: 'error',
+                error: err
+            });
+        };
+        while(mutableCache.getNumPendingTasks() < Math.max(maximumInflightAsyncTasks, 1)){
+            if (queue.length < 1) {
+                // we cant add anything to the in-flight staging area, the final task
+                // is already in flight
+                if (mutableCache.getNumPendingTasks() < 1) {
+                    // we do want to wait for that last in-flight task to actually finish though:
+                    clearInterval(intervalId);
+                    reportNormalStatus('finished');
+                }
+                return;
+            }
+            const itemToRender = queue.shift();
+            if (itemToRender === undefined) {
+                // This should logically never happen, but if it does something is wrong so we emit an error
+                cleanupOnError(new Error('Internal error: itemToRender was undefined'));
+                return;
+            }
+            const toCacheKey = (rq)=>cacheKeyForRequest(rq, itemToRender, settings);
+            try {
+                const result = mutableCache.cacheAndUse(requestsForItem(itemToRender, settings, abort.signal), (0, $tmQ84$lodashpartial)(render, itemToRender, settings), toCacheKey, ()=>reportNormalStatus('progress'));
+                if (result !== undefined) // put this cancel callback in a list where we can invoke if something goes wrong
+                // note that it is harmless to cancel a task that was completed
+                taskCancelCallbacks.push(result);
+            } catch (err) {
+                cleanupOnError(err);
+            }
+            if (performance.now() - startWorkTime > queueTimeBudgetMS) break;
+        }
+    };
+    const interval = setInterval(()=>doWorkOnQueue(interval), queueProcessingIntervalMS);
+    // return a function to allow our caller to cancel the frame - guaranteed that no settings/data will be
+    // touched/referenced after cancellation, unless the author of render() did some super weird bad things
+    return {
+        cancelFrame: (reason)=>{
+            for (const cancelMe of taskCancelCallbacks)cancelMe();
+            abort.abort(new DOMException(reason, 'AbortError'));
+            clearInterval(interval);
+            reportNormalStatus('cancelled');
+        }
+    };
+}
+
+
+// return true if the request is completely satisfied, false if its still awaiting more entries
+function $9fd71f854f4df31b$var$updatePendingRequest(req, key, cacheKey, item) {
+    if (req.awaiting.has(cacheKey)) {
+        const remaningAwaited = req.awaiting.get(cacheKey);
+        // we just fullfilled one - remove it from awaiting
+        remaningAwaited?.delete(key);
+        if ((remaningAwaited?.size ?? 0) < 1) req.awaiting.delete(cacheKey);
+        req.blocking.add(cacheKey);
+        req.ready[key] = item;
+    }
+    return req.awaiting.size === 0;
+}
+class $9fd71f854f4df31b$export$6893cac74ecce081 {
+    /**
+     * the intended use of this cache is to store resources used for rendering. Because the specific contents are generic, a simple interface must be provided
+     * to support LRU cache eviction
+     * occasionally, it can be necessary to manage these resources more explicitly (see https://stackoverflow.com/a/31250301 for a great example)
+     * @param destroy a function which safely releases the resources owned by an entry in this cache - for normal garbage-collected objects, a no-op function will suffice.
+     * @param size a function which returns the size of a resource - this is used only in relation to the cacheLimit
+     * @param cacheLimit a limit (in whatever units are returned by the size() parameter) to place on cache contents
+     * note that this limit is not a hard limit - old entries are evicted when new data is fetched, but the limit may be exceeded occasionally
+     * a reasonable implementation may simply return 1 for size, and a desired occupancy count for the limit
+     */ constructor(destroy, size, cacheLimit){
+        this.size = size;
+        this.destroyer = destroy;
+        this.limit = cacheLimit;
+        this.entries = new Map();
+        this.pendingRequests = new Set();
+    }
+    usedSpace() {
+        // Map uses iterators, so we're in for-loop territory here
+        let sum = 0;
+        for (const entry of this.entries.values())sum += entry.data instanceof Promise ? 0 : this.size(entry.data);
+        return sum;
+    }
+    countRequests() {
+        const reqCounts = {};
+        for (const req of this.pendingRequests)for (const key of [
+            ...req.blocking,
+            ...req.awaiting.keys()
+        ]){
+            if (!reqCounts[key]) reqCounts[key] = 0;
+            reqCounts[key] += 1;
+        }
+        return reqCounts;
+    }
+    // if the cache is full, sort candidates which are not currently requested by their last-used timestamps
+    // evict those items until the cache is no longer full
+    evictIfFull() {
+        // find entries which have 0 pending requests, and are not themselves promises...
+        let used = this.usedSpace();
+        const candidates = [];
+        if (used > this.limit) {
+            // its potentially a bit slow to do this:
+            const counts = this.countRequests();
+            this.entries.forEach((entry, key)=>{
+                if (!(entry.data instanceof Promise) && (counts[key] ?? 0) < 1) candidates.push({
+                    key: key,
+                    data: entry.data,
+                    lastRequestedTimestamp: entry.lastRequestedTimestamp
+                });
+            });
+            const priority = candidates.sort((a, b)=>a.lastRequestedTimestamp - b.lastRequestedTimestamp);
+            for (const evictMe of priority){
+                used -= this.size(evictMe.data);
+                this.destroyer(evictMe.data);
+                this.entries.delete(evictMe.key);
+                if (used < this.limit) return;
+            }
+        }
+    }
+    /**
+     * `isCached` checks if the entry is in the cache with a resolved promise.
+     *
+     * @param key The entry key to check for in the cache
+     * @returns True if the entry in the cache has been resolved, false if there is no entry with that key or the promise is still pending
+     */ isCached(key) {
+        // the key exists, and the value associated is not a promise
+        return this.entries.has(key) && !(this.entries.get(key)?.data instanceof Promise);
+    }
+    /**
+     * `areKeysAllCached` checks if all the keys provided are in the cache with resolved promises.
+     *
+     * Useful for checking if all the data needed for a particular operation is already in the cache.
+     *
+     * @param cacheKeys A list of keys to check for in the cache
+     * @returns True if all keys are cached, false if any are not in the cache
+     */ areKeysAllCached(cacheKeys) {
+        return cacheKeys.every((key)=>this.isCached(key));
+    }
+    /**
+     * @deprecated to alert (external) users to avoid calling this!
+     * `getCachedUNSAFE` gets an entry from the cache for the given key (if the promise is resolved).
+     * because of how eviction works - this method should be considered unsafe! consider the following
+     * @example
+     * const entry = cache.getCachedUnsafe('whatever')
+     * const otherStuff = await fetch('....')
+     * ... more code
+     * doSomethingCool(entry, otherStuff)
+     *
+     * by the time the caller gets to the doSomethingCool call, the resources bound to the cache entry
+     * may have been disposed!
+     * do note that if you use a cache-entry synchronously (no awaits!) after requesting it, you're likely to not
+     * encounter any issues, however its a much more robust practice to simply refactor like so:
+     *
+     * const otherStuff = await fetch('...')
+     * cache.cacheAndUse({...}, (...args)=>doSomethingCool(otherStuff, ..args), ...)
+     *
+     * @param key Entry key to look up in the cache
+     * @returns The entry (D) if it is present, or undefined if it is not
+     */ getCachedUNSAFE(key) {
+        const entry = this.entries.get(key);
+        if (!entry) return undefined;
+        entry.lastRequestedTimestamp = performance.now();
+        return entry.data instanceof Promise ? undefined : entry?.data;
+    }
+    getNumPendingTasks() {
+        return this.pendingRequests.size;
+    }
+    dataArrived(key, cacheKey, data) {
+        this.evictIfFull(); // we just got some data - is there room in the cache?
+        const mutableEntry = this.entries.get(cacheKey);
+        if (mutableEntry) mutableEntry.data = data;
+        const removeUs = [];
+        for (const req of this.pendingRequests)if ($9fd71f854f4df31b$var$updatePendingRequest(req, key, cacheKey, data)) {
+            req.runner(req.ready);
+            removeUs.push(req);
+        }
+        for (const finished of removeUs)this.pendingRequests.delete(finished);
+    }
+    prepareCache(semanticKey, cacheKey, getter) {
+        let promise;
+        const entry = this.entries.get(cacheKey);
+        const data = entry?.data;
+        // we either return early (data is cached)
+        // or we initialize promise (either getter() or a pre-existing request for the same cachekey)
+        // if we dont return early, we hook up a call to dataArrived to promise
+        if (data) {
+            if (data instanceof Promise) promise = data;
+            else {
+                // we could simply "return data"
+                // however getCachedUnsafe updates its "last-requested timestamp"
+                const resolvedCacheData = this.getCachedUNSAFE(cacheKey);
+                if (!resolvedCacheData) throw new Error('unexpected undefined data');
+                return resolvedCacheData;
+            }
+        } else {
+            const abort = new AbortController();
+            promise = getter(abort.signal);
+            this.entries.set(cacheKey, {
+                data: promise,
+                lastRequestedTimestamp: performance.now(),
+                abort: abort
+            });
+        }
+        return promise.then((data)=>{
+            this.dataArrived(semanticKey, cacheKey, data);
+        });
+    }
+    cacheAndUse(workingSet, use, toCacheKey, // TODO: consider removing taskFinished - it would be more simple to let the caller handle this in their use() function
+    taskFinished) {
+        const keys = Object.keys(workingSet);
+        const req = {
+            awaiting: new Map(),
+            ready: {},
+            runner: use,
+            blocking: new Set()
+        };
+        for (const k of keys)if (req.awaiting.has(toCacheKey(k))) req.awaiting.get(toCacheKey(k))?.add(k);
+        else req.awaiting.set(toCacheKey(k), new Set([
+            k
+        ]));
+        for (const semanticKey of keys){
+            const result = this.prepareCache(semanticKey, toCacheKey(semanticKey), workingSet[semanticKey]);
+            if (result instanceof Promise) {
+                const prom = taskFinished !== undefined ? result.then(taskFinished) : result;
+                prom.catch((_reason)=>{
+                    // delete the failed entry from the cache
+                    // also remove the entire request it belongs to
+                    this.entries.delete(toCacheKey(semanticKey));
+                    this.pendingRequests.delete(req);
+                // note that catches get chained - so any catch handlers that came in with this promise
+                // still get called
+                });
+            } else if ($9fd71f854f4df31b$var$updatePendingRequest(req, semanticKey, toCacheKey(semanticKey), result)) {
+                use(req.ready);
+                if (taskFinished !== undefined) Promise.resolve().then(taskFinished); // we did the task synchronously...
+                // early return in the case that everything was cached!
+                // the only thing this short-circuits is pendingRequests.add(req)
+                // (because of course it isn't pending, because we just did it!)
+                return undefined;
+            }
+        }
+        this.pendingRequests.add(req);
+        return ()=>{
+            this.pendingRequests.delete(req);
+        };
+    }
+}
+
+
+
+var $201a17180a2597e3$exports = {};
+
+$parcel$export($201a17180a2597e3$exports, "swapBuffers", () => $201a17180a2597e3$export$e3caf6d91837252d);
+function $201a17180a2597e3$export$e3caf6d91837252d(doubleBuffer) {
+    const { readFrom: readFrom, writeTo: writeTo } = doubleBuffer;
+    return {
+        readFrom: writeTo,
+        writeTo: readFrom
+    };
+}
+
+
+class $3901da79d5cf59d6$export$4fff234e4eb6b2b6 {
+    constructor(regl, imgRenderer, renderFn, resolution){
+        this.buffers = {
+            readFrom: {
+                resolution: resolution,
+                texture: regl.framebuffer(...resolution),
+                bounds: undefined
+            },
+            writeTo: {
+                resolution: resolution,
+                texture: regl.framebuffer(...resolution),
+                bounds: undefined
+            }
+        };
+        this.renderImg = imgRenderer;
+        this.regl = regl;
+        this.runningFrame = null;
+        this.renderFn = renderFn;
+    }
+    destroy() {
+        this.runningFrame?.cancelFrame('destroy this layer');
+        this.buffers.readFrom.texture.destroy();
+        this.buffers.writeTo.texture.destroy();
+    }
+    renderingInProgress() {
+        return this.runningFrame !== null;
+    }
+    getRenderResults(stage) {
+        return stage === 'cur' ? this.buffers.writeTo : this.buffers.readFrom;
+    }
+    onChange(props, cancel = true) {
+        if (cancel && this.runningFrame) {
+            this.runningFrame.cancelFrame();
+            this.runningFrame = null;
+            const { readFrom: readFrom, writeTo: writeTo } = this.buffers;
+            // copy our work to the prev-buffer...
+            if (readFrom.bounds && writeTo.bounds && (0, $tmQ84$Box2D).intersection(readFrom.bounds, writeTo.bounds)) {
+                const [width, height] = writeTo.resolution;
+                this.renderImg({
+                    box: (0, $tmQ84$Box2D).toFlatArray(writeTo.bounds),
+                    img: writeTo.texture,
+                    target: readFrom.texture,
+                    viewport: {
+                        x: 0,
+                        y: 0,
+                        width: width,
+                        height: height
+                    },
+                    view: (0, $tmQ84$Box2D).toFlatArray(readFrom.bounds)
+                });
+            }
+            this.regl.clear({
+                framebuffer: this.buffers.writeTo.texture,
+                color: [
+                    0,
+                    0,
+                    0,
+                    0
+                ],
+                depth: 1
+            });
+        }
+        const { data: data, settings: settings } = props;
+        const { camera: camera, callback: callback } = settings;
+        this.buffers.writeTo.bounds = camera.view;
+        const wrapCallback = {
+            ...settings,
+            callback: (ev)=>{
+                const { status: status } = ev;
+                switch(status){
+                    case 'finished':
+                    case 'finished_synchronously':
+                        this.buffers = (0, $201a17180a2597e3$export$e3caf6d91837252d)(this.buffers);
+                        // only erase... if we would have cancelled...
+                        if (cancel) this.regl.clear({
+                            framebuffer: this.buffers.writeTo.texture,
+                            color: [
+                                0,
+                                0,
+                                0,
+                                0
+                            ],
+                            depth: 1
+                        });
+                        this.runningFrame = null;
+                        break;
+                }
+                callback?.(ev);
+            }
+        };
+        this.runningFrame = this.renderFn(this.buffers.writeTo.texture, data, wrapCallback);
+    }
+}
+
+
+
+var $57582d9b80d114ba$exports = {};
+
+$parcel$export($57582d9b80d114ba$exports, "createHttpsResource", () => $57582d9b80d114ba$export$81e4895a4d9a9b60);
+$parcel$export($57582d9b80d114ba$exports, "createS3Resource", () => $57582d9b80d114ba$export$497a706b08a344d6);
+$parcel$export($57582d9b80d114ba$exports, "isS3Resource", () => $57582d9b80d114ba$export$ba8acc09153a66ca);
+$parcel$export($57582d9b80d114ba$exports, "isHttpsResource", () => $57582d9b80d114ba$export$5eb78fd524c7545f);
+$parcel$export($57582d9b80d114ba$exports, "getResourceUrl", () => $57582d9b80d114ba$export$d2c227b690e4eb28);
+var $3d0d2b554afda09c$exports = {};
+
+$parcel$export($3d0d2b554afda09c$exports, "VisError", () => $3d0d2b554afda09c$export$f6bd031016c938ca);
+class $3d0d2b554afda09c$export$f6bd031016c938ca extends Error {
+}
+
+
+const $57582d9b80d114ba$var$RESOURCE_TYPE_S3 = 's3';
+const $57582d9b80d114ba$var$RESOURCE_TYPE_HTTPS = 'https';
+function $57582d9b80d114ba$export$81e4895a4d9a9b60(url) {
+    return {
+        type: $57582d9b80d114ba$var$RESOURCE_TYPE_HTTPS,
+        url: url
+    };
+}
+function $57582d9b80d114ba$export$497a706b08a344d6(url, region) {
+    return {
+        type: $57582d9b80d114ba$var$RESOURCE_TYPE_S3,
+        region: region,
+        url: url
+    };
+}
+function $57582d9b80d114ba$export$ba8acc09153a66ca(res) {
+    return res && res.type === $57582d9b80d114ba$var$RESOURCE_TYPE_S3;
+}
+function $57582d9b80d114ba$export$5eb78fd524c7545f(res) {
+    return res && res.type === $57582d9b80d114ba$var$RESOURCE_TYPE_HTTPS;
+}
+const $57582d9b80d114ba$var$S3_REGION_BASIC_REGEX = /[a-z]+-[a-z]+-[1-9]/;
+function $57582d9b80d114ba$var$httpsFromS3Bucket(url, region) {
+    // maybe region is controlled via the url or another arg in the future, so lets make it a variable
+    const endOfBucket = url.indexOf('/', 5);
+    const bucket = url.slice(5, endOfBucket);
+    const path = url.slice(endOfBucket + 1);
+    return `https://${bucket}.s3.${region}.amazonaws.com/${path}`;
+}
+function $57582d9b80d114ba$var$isValidS3URL(url) {
+    return !!url && url.length >= 6 && url.slice(0, 5) === 's3://';
+}
+function $57582d9b80d114ba$var$isValidS3Region(region) {
+    return !!region && $57582d9b80d114ba$var$S3_REGION_BASIC_REGEX.test(region);
+}
+function $57582d9b80d114ba$export$d2c227b690e4eb28(res) {
+    if (res.type === 's3') {
+        if (!$57582d9b80d114ba$var$isValidS3URL(res.url)) throw new (0, $3d0d2b554afda09c$export$f6bd031016c938ca)('cannot get WebResource URL: invalid S3 URL');
+        if (!$57582d9b80d114ba$var$isValidS3Region(res.region)) throw new (0, $3d0d2b554afda09c$export$f6bd031016c938ca)('cannot get WebResource URL: invalid S3 Region');
+        return $57582d9b80d114ba$var$httpsFromS3Bucket(res.url, res.region);
+    }
+    return res.url;
+}
+
+
+
+var $d9c300243b26048c$exports = {};
+
+$parcel$export($d9c300243b26048c$exports, "makeRGBColorVector", () => $d9c300243b26048c$export$c34911d131211e50);
+$parcel$export($d9c300243b26048c$exports, "makeRGBAColorVector", () => $d9c300243b26048c$export$417d2e62b20fc31a);
+class $45f5cb22d200196a$export$efa9a398d6368992 {
+    constructor(name, level = 'warn'){
+        this.name = name;
+        this.level = level;
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    shouldLog(level) {
+        const levels = [
+            'debug',
+            'info',
+            'warn',
+            'error',
+            'none'
+        ];
+        return levels.indexOf(level) >= levels.indexOf(this.level);
+    }
+    formatMessage(level, message) {
+        const timestamp = new Date().toISOString();
+        return `[${timestamp}] [${this.name}] [${level.toUpperCase()}] ${message}`;
+    }
+    debug(message, ...optionalParams) {
+        if (this.shouldLog('debug')) // biome-ignore lint/suspicious/noConsole: This is a logger
+        console.debug(this.formatMessage('debug', message), ...optionalParams);
+    }
+    dir(obj, ...optionalParams) {
+        if (this.shouldLog('debug')) {
+            // biome-ignore lint/suspicious/noConsole: This is a logger
+            console.log(this.formatMessage('debug', 'See object below'), ...optionalParams);
+            // biome-ignore lint/suspicious/noConsole: This is a logger
+            console.dir(obj);
+        }
+    }
+    info(message, ...optionalParams) {
+        if (this.shouldLog('info')) // biome-ignore lint/suspicious/noConsole: This is a logger
+        console.info(this.formatMessage('info', message), ...optionalParams);
+    }
+    warn(message, ...optionalParams) {
+        if (this.shouldLog('warn')) // biome-ignore lint/suspicious/noConsole: This is a logger
+        console.warn(this.formatMessage('warn', message), ...optionalParams);
+    }
+    error(message, ...optionalParams) {
+        if (this.shouldLog('error')) // biome-ignore lint/suspicious/noConsole: This is a logger
+        console.error(this.formatMessage('error', message), ...optionalParams);
+    }
+}
+const $45f5cb22d200196a$export$af88d00dbe7f521 = new $45f5cb22d200196a$export$efa9a398d6368992('default');
+
+
+// Tests for optional #, then 3 or 6 hex digits
+const $d9c300243b26048c$var$RGB_COLOR_REGEX = /^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+// Tests for optional #, then 4 or 8 hex digits
+const $d9c300243b26048c$var$RGBA_COLOR_REGEX = /^#?([0-9a-fA-F]{4}|[0-9a-fA-F]{8})$/;
+function $d9c300243b26048c$export$c34911d131211e50(colorHashStr, normalized = true) {
+    if (!colorHashStr || !$d9c300243b26048c$var$RGB_COLOR_REGEX.test(colorHashStr)) {
+        (0, $45f5cb22d200196a$export$af88d00dbe7f521).warn('invalid color hash string; returning black color vector (0, 0, 0)');
+        return [
+            0,
+            0,
+            0
+        ];
+    }
+    const hasHash = colorHashStr.charAt(0) === '#';
+    const sanitizedColorHashStr = hasHash ? colorHashStr : `#${colorHashStr}`;
+    const redCode = sanitizedColorHashStr.length === 4 ? sanitizedColorHashStr.charAt(1) + sanitizedColorHashStr.charAt(1) : sanitizedColorHashStr.slice(1, 3);
+    const greenCode = sanitizedColorHashStr.length === 4 ? sanitizedColorHashStr.charAt(2) + sanitizedColorHashStr.charAt(2) : sanitizedColorHashStr.slice(3, 5);
+    const blueCode = sanitizedColorHashStr.length === 4 ? sanitizedColorHashStr.charAt(3) + sanitizedColorHashStr.charAt(3) : sanitizedColorHashStr.slice(5, 7);
+    const divisor = normalized ? 255 : 1;
+    return [
+        Number.parseInt(redCode, 16) / divisor,
+        Number.parseInt(greenCode, 16) / divisor,
+        Number.parseInt(blueCode, 16) / divisor
+    ];
+}
+function $d9c300243b26048c$export$417d2e62b20fc31a(colorHashStr, normalized = true) {
+    if (!colorHashStr) {
+        (0, $45f5cb22d200196a$export$af88d00dbe7f521).warn('invalid color hash string; returning transparent black color vector (0, 0, 0, 0)');
+        return [
+            0,
+            0,
+            0,
+            0
+        ];
+    }
+    if ($d9c300243b26048c$var$RGBA_COLOR_REGEX.test(colorHashStr)) {
+        const hashHash = colorHashStr.charAt(0) === '#';
+        const sanitizedColorHashStr = hashHash ? colorHashStr : `#${colorHashStr}`;
+        const redCode = sanitizedColorHashStr.length === 5 ? sanitizedColorHashStr.charAt(1) + sanitizedColorHashStr.charAt(1) : sanitizedColorHashStr.slice(1, 3);
+        const greenCode = sanitizedColorHashStr.length === 5 ? sanitizedColorHashStr.charAt(2) + sanitizedColorHashStr.charAt(2) : sanitizedColorHashStr.slice(3, 5);
+        const blueCode = sanitizedColorHashStr.length === 5 ? sanitizedColorHashStr.charAt(3) + sanitizedColorHashStr.charAt(3) : sanitizedColorHashStr.slice(5, 7);
+        const alphaCode = sanitizedColorHashStr.length === 5 ? sanitizedColorHashStr.charAt(4) + sanitizedColorHashStr.charAt(4) : sanitizedColorHashStr.slice(7, 9);
+        const divisor = normalized ? 255 : 1;
+        return [
+            Number.parseInt(redCode, 16) / divisor,
+            Number.parseInt(greenCode, 16) / divisor,
+            Number.parseInt(blueCode, 16) / divisor,
+            Number.parseInt(alphaCode, 16) / divisor
+        ];
+    }
+    if ($d9c300243b26048c$var$RGB_COLOR_REGEX.test(colorHashStr)) {
+        const rgb = $d9c300243b26048c$export$c34911d131211e50(colorHashStr, normalized);
+        return [
+            ...rgb,
+            normalized ? 1.0 : 255.0
+        ];
+    }
+    (0, $45f5cb22d200196a$export$af88d00dbe7f521).warn('invalid color hash string; returning transparent black color vector (0, 0, 0, 0)');
+    return [
+        0,
+        0,
+        0,
+        0
+    ];
+}
+
+
+
+function $b44d3a2c3b719253$export$67b5d71f9b7f0efa(config) {
+    const { maximumInflightAsyncTasks: maximumInflightAsyncTasks, queueTimeBudgetMS: queueTimeBudgetMS, queueProcessingIntervalMS: queueProcessingIntervalMS, cacheKeyForRequest: cacheKeyForRequest, settings: settings, items: items, mutableCache: mutableCache, lifecycleCallback: lifecycleCallback, renderItem: renderItem, requestsForItem: requestsForItem, isPrepared: isPrepared, dataset: dataset } = config;
+    const abort = new AbortController();
+    const queue = [
+        ...items
+    ];
+    const taskCancelCallbacks = [];
+    const renderItemWrapper = (itemToRender, maybe)=>{
+        if (isPrepared(maybe) && !abort.signal.aborted) renderItem(itemToRender, dataset, settings, maybe);
+    };
+    const reportStatus = (event, synchronous)=>{
+        if (event.status !== 'cancelled' && abort.signal.aborted) return;
+        // we want to report our status, however the flow of events can be confusing -
+        // our callers anticipate an asynchronous (long running) frame to be started,
+        // but there are scenarios in which the whole thing is completely synchronous
+        // callers who are scheduling things may be surprised that their frame finished
+        // before the code that handles it appears to start. thus, we make the entire lifecycle callback
+        // system async, to prevent surprises.
+        if (synchronous) lifecycleCallback(event);
+        else Promise.resolve().then(()=>lifecycleCallback(event));
+    };
+    const doWorkOnQueue = (intervalId, synchronous = false)=>{
+        // try our best to cleanup if something goes awry
+        const startWorkTime = performance.now();
+        const cleanupOnError = (err)=>{
+            // clear the queue and the staging area (inFlight)
+            for (const cancelMe of taskCancelCallbacks)cancelMe();
+            queue.splice(0, queue.length);
+            // stop fetching
+            abort.abort(err);
+            clearInterval(intervalId);
+            // pass the error somewhere better:
+            reportStatus({
+                status: 'error',
+                error: err
+            }, synchronous);
+        };
+        while(mutableCache.getNumPendingTasks() < Math.max(maximumInflightAsyncTasks, 1)){
+            // We know there are items in the queue because of the check above, so we assert the type exist
+            const itemToRender = queue.shift();
+            if (!itemToRender) break;
+            const toCacheKey = (rq)=>cacheKeyForRequest(itemToRender, rq, dataset, settings);
+            try {
+                const result = mutableCache.cacheAndUse(requestsForItem(itemToRender, dataset, settings, abort.signal), (0, $tmQ84$lodashpartial)(renderItemWrapper, itemToRender), toCacheKey, ()=>reportStatus({
+                        status: 'progress',
+                        dataset: dataset,
+                        renderedItems: [
+                            itemToRender
+                        ]
+                    }, synchronous));
+                if (result !== undefined) // put this cancel callback in a list where we can invoke if something goes wrong
+                // note that it is harmless to cancel a task that was completed
+                taskCancelCallbacks.push(result);
+            } catch (err) {
+                cleanupOnError(err);
+            }
+            if (performance.now() - startWorkTime > queueTimeBudgetMS) break;
+        }
+        if (queue.length < 1) {
+            // we cant add anything to the in-flight staging area, the final task
+            // is already in flight
+            if (mutableCache.getNumPendingTasks() < 1) {
+                // we do want to wait for that last in-flight task to actually finish though:
+                clearInterval(intervalId);
+                reportStatus({
+                    status: 'finished'
+                }, synchronous);
+            }
+            return;
+        }
+    };
+    reportStatus({
+        status: 'begin'
+    }, true);
+    const interval = setInterval(()=>doWorkOnQueue(interval), queueProcessingIntervalMS);
+    if (queue.length > 0) doWorkOnQueue(interval, false);
+    return {
+        cancelFrame: (reason)=>{
+            abort.abort(new DOMException(reason, 'AbortError'));
+            for (const cancelMe of taskCancelCallbacks)cancelMe();
+            clearInterval(interval);
+            reportStatus({
+                status: 'cancelled'
+            }, true);
+        }
+    };
+}
+const $b44d3a2c3b719253$var$defaultQueueOptions = {
+    queueProcessingIntervalMS: 33,
+    maximumInflightAsyncTasks: 5,
+    queueTimeBudgetMS: 16
+};
+function $b44d3a2c3b719253$export$c1ba6e228d66b8cd(renderer, queueOptions) {
+    return (data, settings, callback, target, cache)=>{
+        const { renderItem: renderItem, isPrepared: isPrepared, cacheKey: cacheKey, fetchItemContent: fetchItemContent, getVisibleItems: getVisibleItems } = renderer;
+        const config = {
+            ...$b44d3a2c3b719253$var$defaultQueueOptions,
+            ...queueOptions,
+            cacheKeyForRequest: cacheKey,
+            dataset: data,
+            isPrepared: isPrepared,
+            items: getVisibleItems(data, settings),
+            lifecycleCallback: callback,
+            mutableCache: cache,
+            renderItem: (0, $tmQ84$lodashpartial)(renderItem, target),
+            requestsForItem: fetchItemContent,
+            settings: settings
+        };
+        return $b44d3a2c3b719253$export$67b5d71f9b7f0efa(config);
+    };
+}
+
+
+
+
+
+
+function $813009929e026506$var$destroyer(item) {
+    switch(item.type){
+        case 'texture':
+            item.texture.destroy();
+            break;
+        case 'buffer':
+            item.buffer.destroy();
+            break;
+    }
+}
+// return the size, in bytes, of some cached entity!
+function $813009929e026506$var$sizeOf(item) {
+    return Math.max(1, item.bytes ?? 0);
+}
+const $813009929e026506$var$oneMB = 1048576;
+class $813009929e026506$export$b349b3e66cf46ed5 {
+    constructor(maxSize, extensions, cacheByteLimit = 2000 * $813009929e026506$var$oneMB){
+        this.canvas = new OffscreenCanvas(10, 10); // we always render to private buffers, so we dont need a real resolution here...
+        this.clients = new Map();
+        this.maxSize = maxSize;
+        this.refreshRequested = false;
+        const gl = this.canvas.getContext('webgl', {
+            alpha: true,
+            preserveDrawingBuffer: false,
+            antialias: true,
+            premultipliedAlpha: true
+        });
+        if (!gl) throw new Error('WebGL not supported!');
+        const regl = (0, $tmQ84$regl)({
+            gl: gl,
+            extensions: extensions
+        });
+        this.regl = regl;
+        this.cache = new (0, $9fd71f854f4df31b$export$6893cac74ecce081)($813009929e026506$var$destroyer, $813009929e026506$var$sizeOf, cacheByteLimit);
+    }
+    copyToClient(frameInfo, client) {
+        // note: compared transferImageFromBitmap(transferImageToBitmap()), drawImage(canvas) and a few other variations
+        // this method seems to have the most consistent performance across various browsers
+        const { resolution: resolution, copyBuffer: copyBuffer, image: image, updateRequested: updateRequested } = frameInfo;
+        const [width, height] = resolution;
+        if (updateRequested) try {
+            // read directly from the framebuffer to which we render:
+            this.regl?.read({
+                framebuffer: image,
+                x: 0,
+                y: 0,
+                width: width,
+                height: height,
+                data: new Uint8Array(copyBuffer)
+            });
+            // then put those bytes in the client canvas:
+            const ctx = client.getContext('2d');
+            if (!ctx) {
+                (0, $45f5cb22d200196a$export$af88d00dbe7f521).error('Could not get 2d context');
+                throw new Error('Could not get 2d context');
+            }
+            const img = new ImageData(new Uint8ClampedArray(copyBuffer), width, height);
+            updateRequested(ctx, img);
+        } catch  {
+            (0, $45f5cb22d200196a$export$af88d00dbe7f521).error('error - we tried to copy to a client buffer, but maybe it got unmounted? that can happen, its ok');
+        }
+    }
+    onAnimationFrame() {
+        if (this.refreshRequested) {
+            for (const [client, entry] of this.clients)if (entry.updateRequested) {
+                this.copyToClient(entry, client);
+                // mark our progress:
+                entry.updateRequested = null;
+            }
+            this.refreshRequested = false;
+        }
+    }
+    requestComposition(client, composite) {
+        const c = this.clients.get(client);
+        if (c) {
+            if (!c.updateRequested) {
+                c.updateRequested = composite;
+                if (!this.refreshRequested) {
+                    this.refreshRequested = true;
+                    // as of 2023, requestAnimationFrame should be generally available globally in both workers* and a window
+                    // if this becomes an issue, we can have our caller pass requestAnimationFrame in to the constructor
+                    requestAnimationFrame(()=>this.onAnimationFrame());
+                }
+            }
+        }
+    }
+    clientFrameFinished(client) {
+        const C = this.clients.get(client);
+        if (C) C.frame = null;
+    }
+    destroyClient(client) {
+        const C = this.clients.get(client);
+        if (C) C.frame?.cancelFrame();
+        this.clients.delete(client);
+    }
+    prepareToRenderToClient(client) {
+        const previousEntry = this.clients.get(client);
+        if (previousEntry) {
+            previousEntry.updateRequested = null;
+            // the client is mutable - so every time we get a request, we have to check to see if it got resized
+            if (client.width !== previousEntry.resolution[0] || client.height !== previousEntry.resolution[1]) // handle resizing by deleting previously allocated resources:
+            previousEntry.image.destroy();
+            else // use the existing resources!
+            return previousEntry;
+        }
+        const resolution = (0, $tmQ84$Vec2).min(this.maxSize, [
+            client.width,
+            client.height
+        ]);
+        const copyBuffer = new ArrayBuffer(resolution[0] * resolution[1] * 4);
+        const image = this.regl.framebuffer(...resolution);
+        return {
+            resolution: resolution,
+            copyBuffer: copyBuffer,
+            image: image
+        };
+    }
+    beginRendering(renderFn, callback, client) {
+        if (this.regl) {
+            const clientFrame = this.clients.get(client);
+            if (clientFrame?.frame) {
+                clientFrame.frame.cancelFrame();
+                this.regl.clear({
+                    framebuffer: clientFrame.image,
+                    color: [
+                        0,
+                        0,
+                        0,
+                        0
+                    ],
+                    depth: 1
+                });
+                clientFrame.updateRequested = null;
+            }
+            const { image: image, resolution: resolution, copyBuffer: copyBuffer } = this.prepareToRenderToClient(client);
+            const hijack = (e)=>{
+                callback({
+                    ...e,
+                    target: image,
+                    server: {
+                        copyToClient: (compose)=>{
+                            this.requestComposition(client, compose);
+                        }
+                    }
+                });
+                if (e.status === 'finished' || e.status === 'cancelled') this.clientFrameFinished(client);
+            };
+            this.clients.set(client, {
+                frame: null,
+                image: image,
+                copyBuffer: copyBuffer,
+                resolution: resolution,
+                updateRequested: null
+            });
+            // this is worded rather awkwardly, because sometimes the frameLifecycle object returned by renderFn() represents
+            // a frame that is already finished!
+            // this is a good thing for performance, but potentially confusing - so we do our book-keeping before we actually start rendering:
+            const aboutToStart = this.clients.get(client); // this is the record we just put into the clients map - TS just wants to be sure it really exists:
+            if (aboutToStart) {
+                const frame = renderFn(image, this.cache, hijack);
+                if (frame) aboutToStart.frame = {
+                    cancelFrame: (reason)=>{
+                        frame.cancelFrame(reason);
+                        aboutToStart.updateRequested = null;
+                    }
+                };
+            }
+        }
+    }
+}
+
+
+
+// TS note: T extends {} is saying "T may not be null"
+class $21d10294d81a9556$export$457b0b5893773add {
+    constructor(size, scoreSystem){
+        this.score = scoreSystem;
+        this.entries = new Array(size);
+        this.curSize = 0;
+    }
+    parent(i) {
+        return Math.floor((i - 1) / 2);
+    }
+    left(i) {
+        return Math.floor(2 * i + 1);
+    }
+    right(i) {
+        return Math.floor(2 * i + 2);
+    }
+    swap(i, j) {
+        const tmp = this.entries[i];
+        this.entries[i] = this.entries[j];
+        this.entries[j] = tmp;
+    }
+    addItem(t, score) {
+        this.entries[this.curSize] = t;
+        this.curSize += 1;
+        const myIndex = this.curSize - 1;
+        let i = myIndex;
+        const myScore = score ?? this.score(t);
+        while(i !== 0 && this.score(this.entries[this.parent(i)]) > (i === myIndex ? myScore : this.score(this.entries[i]))){
+            this.swap(i, this.parent(i));
+            i = this.parent(i);
+        }
+    }
+    heapify(i) {
+        const l = this.left(i);
+        const r = this.right(i);
+        let smallest = i;
+        if (l < this.curSize && this.score(this.entries[l]) < this.score(this.entries[i])) smallest = l;
+        if (r < this.curSize && this.score(this.entries[r]) < this.score(this.entries[smallest])) smallest = r;
+        if (smallest !== i) {
+            this.swap(i, smallest);
+            this.heapify(smallest);
+        }
+    }
+    rebuild(score) {
+        this.score = score ?? this.score;
+        for(let i = this.curSize - 1; i >= 0; i -= 1)this.heapify(i);
+    }
+    popItem(i) {
+        while(i !== 0){
+            this.swap(i, this.parent(i));
+            /** biome-ignore lint/style/noParameterAssign: a great example of why we should ditch this linter */ i = this.parent(i);
+        }
+        return this.popMinItem();
+    }
+    peekMinItem() {
+        if (this.curSize < 1) return null;
+        return this.entries[0];
+    }
+    popMinItem() {
+        if (this.curSize < 1) return null;
+        const item = this.entries[0];
+        this.curSize -= 1;
+        if (this.curSize > 0) {
+            this.entries[0] = this.entries[this.curSize];
+            this.heapify(0);
+        }
+        return item;
+    }
+    popMinItemWithScore() {
+        const t = this.popMinItem();
+        return t === null ? null : {
+            item: t,
+            score: this.score(t)
+        };
+    }
+}
+
+
+
+class $8256f9d6cfc7946b$export$a953a8a2f1eb4f9a {
+    constructor(size, scoreSystem, keyFn){
+        this.heap = new (0, $21d10294d81a9556$export$457b0b5893773add)(size, scoreSystem);
+        this.keyFn = keyFn;
+        this.items = new Map();
+    }
+    addItem(item) {
+        const key = this.keyFn(item);
+        if (!this.items.has(key)) {
+            this.heap.addItem(key);
+            this.items.set(key, item);
+        }
+    }
+    popMinItem() {
+        const min = this.heap.popMinItem();
+        if (min !== null) {
+            const item = this.items.get(min) ?? null;
+            this.items.delete(min);
+            return item;
+        }
+        return null;
+    }
+    popMinItemWithScore() {
+        const entry = this.heap.popMinItemWithScore();
+        if (entry !== null) {
+            const key = entry.item;
+            const item = this.items.get(key);
+            this.items.delete(key);
+            return item ? {
+                item: item,
+                score: entry.score
+            } : null;
+        }
+        return null;
+    }
+    has(item) {
+        return this.items.has(this.keyFn(item));
+    }
+    rebuild(score) {
+        this.heap.rebuild(score);
+    }
+    hasItemWithKey(k) {
+        return this.items.has(k);
+    }
+}
+
+
+function $a5339d2187c48f0b$var$negate(fn) {
+    return (k)=>-fn(k);
+}
+class $a5339d2187c48f0b$export$e473ef38ab8a510a {
+    // items with lower scores will be evicted before items with high scores
+    constructor(store, score, limitInBytes){
+        this.store = store;
+        this.evictPriority = new (0, $21d10294d81a9556$export$457b0b5893773add)(5000, score);
+        this.limit = limitInBytes;
+        this.used = 0;
+    }
+    // add {key:item} to the cache - return false (and fail) if the key is already present
+    // may evict items to make room
+    // return true on success
+    put(key, item) {
+        if (this.store.has(key)) return false;
+        const size = this.sanitizedSize(item);
+        if (this.used + size > this.limit) this.evictUntil(Math.max(0, this.limit - size));
+        this.evictPriority.addItem(key);
+        this.store.set(key, item);
+        this.used += size;
+        return true;
+    }
+    sanitizedSize(item) {
+        const givenSize = item.sizeInBytes?.() ?? 0;
+        const size = Number.isFinite(givenSize) ? Math.max(0, givenSize) : 0;
+        return size;
+    }
+    // it is expected that the score function is not "pure" -
+    // it has a closure over data that changes over time, representing changing priorities
+    // thus - the owner of this cache has a responsibility to notify the cache when significant
+    // changes in priority occur!
+    reprioritize(score) {
+        this.evictPriority.rebuild(score);
+    }
+    get(key) {
+        return this.store.get(key);
+    }
+    has(key) {
+        return this.store.has(key);
+    }
+    cached(key) {
+        return this.store.has(key);
+    }
+    isFull() {
+        return this.used >= this.limit;
+    }
+    evictLowestPriority() {
+        const evictMe = this.evictPriority.popMinItem();
+        if (evictMe === null) return false;
+        const data = this.store.get(evictMe);
+        if (data) {
+            data.destroy?.();
+            this.store.delete(evictMe);
+            const size = this.sanitizedSize(data);
+            this.used -= size;
+        }
+        return true;
+    }
+    evictUntil(targetUsedBytes) {
+        while(this.used > targetUsedBytes){
+            if (!this.evictLowestPriority()) // note: evictLowestPriority mutates this.used
+            return; // all items evicted...
+        }
+    }
+}
+class $a5339d2187c48f0b$export$1506b2eb9d10c110 extends $a5339d2187c48f0b$export$e473ef38ab8a510a {
+    // items with lower scores will be evicted before items with high scores
+    constructor(store, score, limitInBytes, maxFetches, onDataArrived){
+        super(store, score, limitInBytes);
+        this.fetchPriority = new (0, $8256f9d6cfc7946b$export$a953a8a2f1eb4f9a)(5000, $a5339d2187c48f0b$var$negate(score), (pr)=>pr.key);
+        this.pendingFetches = new Map();
+        this.MAX_INFLIGHT_FETCHES = maxFetches;
+        this.notify = onDataArrived;
+    }
+    enqueue(key, fetcher) {
+        // enqueue the item, if we dont already have it, or are not already asking
+        if (!this.has(key) && !this.pendingFetches.has(key) && !this.fetchPriority.hasItemWithKey(key)) {
+            this.fetchPriority.addItem({
+                key: key,
+                fetch: fetcher
+            });
+            this.fetchToLimit();
+            return true;
+        }
+        return false;
+    }
+    beginFetch({ key: key, fetch: fetch }) {
+        const abort = new AbortController();
+        this.pendingFetches.set(key, abort);
+        return fetch(abort.signal).then((resource)=>{
+            this.put(key, resource);
+            this.notify?.(key, {
+                status: 'success'
+            });
+        }).catch((reason)=>{
+            this.notify?.(key, {
+                status: 'failure',
+                reason: reason
+            });
+        }).finally(()=>{
+            this.pendingFetches.delete(key);
+            this.fetchToLimit();
+        });
+    }
+    fetchToLimit() {
+        let toFetch = Math.max(0, this.MAX_INFLIGHT_FETCHES - this.pendingFetches.size);
+        for(let i = 0; i < toFetch; i++){
+            const fetchMe = this.fetchPriority.popMinItemWithScore();
+            if (fetchMe !== null) {
+                if (fetchMe.score !== 0) this.beginFetch(fetchMe.item);
+                else toFetch += 1; // increasing the loop limit inside the loop... a bit sketchy
+            } else break;
+        }
+    }
+    // it is expected that the score function is not "pure" -
+    // it has a closure over data that changes over time, representing changing priorities
+    // thus - the owner of this cache has a responsibility to notify the cache when significant
+    // changes in priority occur!
+    reprioritize(score) {
+        super.reprioritize(score);
+        this.fetchPriority.rebuild($a5339d2187c48f0b$var$negate(score));
+        for (const [key, abort] of this.pendingFetches)if (score(key) === 0) {
+            abort.abort();
+            this.pendingFetches.delete(key);
+        }
+    }
+    cachedOrPending(key) {
+        return this.cached(key) || this.fetchPriority.hasItemWithKey(key) || this.pendingFetches.has(key);
+    }
+}
+
+
+
+function $7005d0cc41e13b37$export$4fc7dd386ddfb8ee(spec, items, priority) {
+    const pri = {};
+    for (const item of items){
+        const keys = spec.cacheKeys(item);
+        for (const cacheKey of Object.values(keys))pri[cacheKey] = (pri[cacheKey] ?? 0) + priority;
+    }
+    return pri;
+}
+function $7005d0cc41e13b37$export$9f8c9675958f3ef5(A, B) {
+    const sum = {};
+    for(const a in A)sum[a] = A[a] + (B[a] ?? 0);
+    for(const b in B)if (!(b in A)) sum[b] = B[b];
+     // else we've already dealt with it
+    return sum;
+}
+function $7005d0cc41e13b37$export$69e02f681d6313ec(old, current, update) {
+    for(const o in old){
+        const curPri = current[o] ?? 0;
+        const prevPri = old[o];
+        update(o, curPri - prevPri);
+    }
+    for(const c in current)if (!(c in old)) update(c, current[c]);
+     // else we've already dealt with the diff
+}
+
+
+
+function $e8f9d79d878cff91$var$entries(t) {
+    return Object.entries(t);
+}
+function $e8f9d79d878cff91$var$mapFields(r, fn) {
+    return $e8f9d79d878cff91$var$entries(r).reduce((acc, [k, v])=>({
+            ...acc,
+            [k]: fn(v)
+        }), {});
+}
+class $e8f9d79d878cff91$export$14c2e5c3395e07aa {
+    constructor(store, limitInBytes, max_concurrent_fetches = 10){
+        this.importance = {};
+        this.clients = {};
+        this.cache = new (0, $a5339d2187c48f0b$export$1506b2eb9d10c110)(store, (ck)=>this.importance[ck] ?? 0, limitInBytes, max_concurrent_fetches, (ck, result)=>this.onCacheEntryArrived(ck, result));
+    }
+    registerClient(spec) {
+        const id = (0, $tmQ84$lodashuniqueId)('client');
+        this.clients[id] = {
+            priorities: {},
+            notify: spec.onDataArrived
+        };
+        const enqueuePriorities = (spec, items)=>{
+            for (const item of items){
+                const keys = spec.cacheKeys(item);
+                Object.entries(spec.fetch(item)).forEach(([sk, fetcher])=>{
+                    const ck = keys[sk];
+                    if (ck !== undefined) this.cache.enqueue(ck, fetcher);
+                });
+            }
+        };
+        const setPriorities = (low, high)=>{
+            const client = this.clients[id];
+            if (!client) return; // the client can hold onto a reference to this interface, even after they call unregister - this prevents a crash in that scenario
+            const updated = (0, $7005d0cc41e13b37$export$9f8c9675958f3ef5)((0, $7005d0cc41e13b37$export$4fc7dd386ddfb8ee)(spec, low, 1), (0, $7005d0cc41e13b37$export$4fc7dd386ddfb8ee)(spec, high, 2));
+            let changed = 0;
+            (0, $7005d0cc41e13b37$export$69e02f681d6313ec)(client.priorities, updated, (cacheKey, delta)=>{
+                changed += delta !== 0 ? 1 : 0;
+                this.updateImportance(cacheKey, delta);
+            });
+            if (changed === 0) // nothing changed at all - no need to reprioritize, nor enqueue requests
+            return;
+            this.cache.reprioritize((ck)=>this.importance[ck] ?? 0);
+            client.priorities = updated;
+            // note: many keys may already be cached, or requested - its harmless to re-request them.
+            // there is obviously some overhead, but in testing it seems fine
+            enqueuePriorities(spec, high);
+            enqueuePriorities(spec, low);
+        };
+        return {
+            get: (k)=>{
+                const keys = spec.cacheKeys(k);
+                const v = $e8f9d79d878cff91$var$mapFields(keys, (k)=>this.cache.get(k));
+                return spec.isValue(v) ? v : undefined;
+            },
+            has: (k)=>{
+                const atLeastOneMissing = Object.values(spec.cacheKeys(k)).some((ck)=>!this.cache.has(ck));
+                return !atLeastOneMissing;
+            },
+            unsubscribeFromCache: ()=>{
+                setPriorities([], []); // mark that this client has no priorities, which will decrement the counts for all
+                // priorities it used to have
+                delete this.clients[id];
+            },
+            setPriorities: setPriorities
+        };
+    }
+    onCacheEntryArrived(key, result) {
+        // find any clients that want this...
+        // and notify them
+        for (const cid of Object.keys(this.clients)){
+            const client = this.clients[cid];
+            if ((client.priorities[key] ?? 0) > 0) client.notify?.(key, result);
+        }
+    }
+    updateImportance(key, delta) {
+        this.importance[key] = Math.max(0, (this.importance[key] ?? 0) + delta);
+    }
+}
+
+
+
+
+export {$e03391db1cf02961$export$8fbec945df051b82 as beginLongRunningFrame, $9fd71f854f4df31b$export$6893cac74ecce081 as AsyncDataCache, $3901da79d5cf59d6$export$4fff234e4eb6b2b6 as ReglLayer2D, $b44d3a2c3b719253$export$67b5d71f9b7f0efa as beginFrame, $b44d3a2c3b719253$export$c1ba6e228d66b8cd as buildAsyncRenderer, $813009929e026506$export$b349b3e66cf46ed5 as RenderServer, $45f5cb22d200196a$export$efa9a398d6368992 as Logger, $45f5cb22d200196a$export$af88d00dbe7f521 as logger, $a5339d2187c48f0b$export$e473ef38ab8a510a as PriorityCache, $a5339d2187c48f0b$export$1506b2eb9d10c110 as AsyncPriorityCache, $e8f9d79d878cff91$export$14c2e5c3395e07aa as SharedPriorityCache, $201a17180a2597e3$export$e3caf6d91837252d as swapBuffers, $57582d9b80d114ba$export$81e4895a4d9a9b60 as createHttpsResource, $57582d9b80d114ba$export$497a706b08a344d6 as createS3Resource, $57582d9b80d114ba$export$ba8acc09153a66ca as isS3Resource, $57582d9b80d114ba$export$5eb78fd524c7545f as isHttpsResource, $57582d9b80d114ba$export$d2c227b690e4eb28 as getResourceUrl, $3d0d2b554afda09c$export$f6bd031016c938ca as VisError, $d9c300243b26048c$export$c34911d131211e50 as makeRGBColorVector, $d9c300243b26048c$export$417d2e62b20fc31a as makeRGBAColorVector};
+//# sourceMappingURL=module.js.map