@woosh/meep-engine 2.47.8 → 2.47.11

package/build/meep.cjs

@@ -72146,7 +72146,7 @@ class Asset {
 
         /**
          *
-         * @type {Array.<AssetDescription>}
+         * @type {Array<AssetDescription>}
          */
         this.dependencies = [];
 
@@ -82767,223 +82767,6 @@ function tryResolve(unresolvedTask) {
     return ResolutionType.READY;
 }
 
-/**
- * Created by Alex on 21/03/2016.
- */
-
-/**
- *
- * @param {Number} currentValue
- * @param {Number} upperLimit
- * @param {Number} [lowerLimit=0]
- * @constructor
- */
-const BoundedValue = function (currentValue, upperLimit, lowerLimit) {
-    /**
-     * @property {Number}
-     * @private
-     */
-    this.__value = currentValue !== undefined ? currentValue : 0;
-    /**
-     * @property {Number}
-     * @private
-     */
-    this.__limitUpper = upperLimit !== undefined ? upperLimit : 0;
-
-    /**
-     * @type {Number}
-     * @private
-     */
-    this.__limitLower = lowerLimit !== undefined ? lowerLimit : 0;
-
-    this.onChanged = new Signal();
-    this.onOverflow = new Signal();
-    this.onFilled = new Signal();
-
-    this.on = {
-        changed: this.onChanged,
-        overflow: this.onOverflow
-    };
-};
-
-/**
- *
- * @param {Number} v
- */
-BoundedValue.prototype.setUpperLimit = function (v) {
-    const oldValue = this.__limitUpper;
-    if (v === oldValue) {
-        //no change
-        return;
-    }
-    this.__limitUpper = v;
-    this.onChanged.send4(this.__value, this.__limitUpper, this.__value, oldValue);
-};
-
-
-/**
- *
- * @returns {Number}
- */
-BoundedValue.prototype.getUpperLimit = function () {
-    return this.__limitUpper;
-};
-
-/**
- *
- * @returns {Number}
- */
-BoundedValue.prototype.getLowerLimit = function () {
-    return this.__limitLower;
-};
-/**
- *
- * @param {Number} v
- */
-BoundedValue.prototype.setLowerLimit = function (v) {
-    const old = this.__limitLower;
-
-    if (v === old) {
-        //no change
-        return;
-    }
-
-    this.__limitLower = v;
-
-    //TODO change signal signature to include lower limit
-    this.onChanged.dispatch();
-};
-
-/**
- *
- * @param {Number} v
- */
-BoundedValue.prototype.setValue = function (v) {
-    const oldValue = this.__value;
-    if (oldValue === v) {
-        //no change
-        return;
-    }
-
-    const spill = v - this.__limitUpper;
-    this.__value = v;
-    //dispatch change
-    this.onChanged.send4(this.__value, this.__limitUpper, oldValue, this.__limitUpper);
-    if (spill > 0) {
-        this.onOverflow.send1(spill);
-    }
-    if (spill >= 0) {
-        this.onFilled.send0();
-    }
-};
-
-/**
- *
- * @returns {Number}
- */
-BoundedValue.prototype.getValue = function () {
-    return this.__value;
-};
-
-
-/**
- *
- * @returns {number}
- */
-BoundedValue.prototype.getFraction = function () {
-    return inverseLerp(this.__limitLower, this.__limitUpper, this.__value);
-};
-
-/**
- *
- */
-BoundedValue.prototype.setValueToLimit = function () {
-    this.setValue(this.__limitUpper);
-};
-
-/**
- *
- * @return {boolean}
- */
-BoundedValue.prototype.isValueAtLimit = function () {
-    return this.__value === this.__limitUpper;
-};
-
-/**
- *
- * @param {Number} val
- */
-BoundedValue.prototype.addValue = function (val) {
-    this.setValue(this.__value + val);
-};
-
-/**
- *
- * @param {BoundedValue} other
- * @returns {BoundedValue}
- */
-BoundedValue.prototype.copy = function (other) {
-    this.setUpperLimit(other.getUpperLimit());
-    this.setValue(other.getValue());
-    return this;
-};
-
-/**
- *
- * @param {BoundedValue} other
- * @returns {boolean}
- */
-BoundedValue.prototype.equals = function (other) {
-    return this.__value === other.__value && this.__limitLower === other.__limitLower && this.__limitUpper === other.__limitUpper;
-};
-
-/**
- *
- * @returns {number}
- */
-BoundedValue.prototype.hash = function () {
-    const v0 = computeHashFloat(this.__value);
-    const v1 = computeHashFloat(this.__limitLower);
-    const v2 = computeHashFloat(this.__limitUpper);
-
-    const h0 = (v0 << 5) - v0 + v1;
-
-    return (h0 << 5) - h0 + v2;
-};
-
-BoundedValue.prototype.toJSON = function () {
-    return {
-        value: this.__value,
-        limit: this.__limitUpper
-    };
-};
-
-BoundedValue.prototype.fromJSON = function (json) {
-    this.setUpperLimit(json.limit);
-    this.setValue(json.value);
-};
-
-/**
- *
- * @param {BinaryBuffer} buffer
- */
-BoundedValue.prototype.toBinaryBuffer = function (buffer) {
-    buffer.writeFloat64(this.__value);
-    buffer.writeFloat64(this.__limitUpper);
-};
-
-/**
- *
- * @param {BinaryBuffer} buffer
- */
-BoundedValue.prototype.fromBinaryBuffer = function (buffer) {
-    const value = buffer.readFloat64();
-    const upperLimit = buffer.readFloat64();
-
-    this.setUpperLimit(upperLimit);
-    this.setValue(value);
-};
-
 class ObservedMap {
     /**
      * @template K,V
@@ -83986,10 +83769,6 @@ class BinaryHeap {
     }
 }
 
-/**
- * Created by Alex on 03/09/2014.
- */
-
 /**
  * @enum {number}
  */
@@ -83999,24 +83778,240 @@ const AssetLoadState = {
     Loading: 2,
     Succeeded: 3,
     Failed: 4
-};
-
+};
+
+/**
+ * Created by Alex on 21/03/2016.
+ */
 
-class PendingAsset {
+/**
+ *
+ * @param {Number} currentValue
+ * @param {Number} upperLimit
+ * @param {Number} [lowerLimit=0]
+ * @constructor
+ */
+const BoundedValue = function (currentValue, upperLimit, lowerLimit) {
     /**
-     *
-     * @param {AssetDescription} description
-     * @constructor
+     * @property {Number}
+     * @private
      */
-    constructor(description) {
-        /**
-         *
-         * @type {AssetDescription}
-         */
-        this.description = description;
+    this.__value = currentValue !== undefined ? currentValue : 0;
+    /**
+     * @property {Number}
+     * @private
+     */
+    this.__limitUpper = upperLimit !== undefined ? upperLimit : 0;
 
-        /**
-         *
+    /**
+     * @type {Number}
+     * @private
+     */
+    this.__limitLower = lowerLimit !== undefined ? lowerLimit : 0;
+
+    this.onChanged = new Signal();
+    this.onOverflow = new Signal();
+    this.onFilled = new Signal();
+
+    this.on = {
+        changed: this.onChanged,
+        overflow: this.onOverflow
+    };
+};
+
+/**
+ *
+ * @param {Number} v
+ */
+BoundedValue.prototype.setUpperLimit = function (v) {
+    const oldValue = this.__limitUpper;
+    if (v === oldValue) {
+        //no change
+        return;
+    }
+    this.__limitUpper = v;
+    this.onChanged.send4(this.__value, this.__limitUpper, this.__value, oldValue);
+};
+
+
+/**
+ *
+ * @returns {Number}
+ */
+BoundedValue.prototype.getUpperLimit = function () {
+    return this.__limitUpper;
+};
+
+/**
+ *
+ * @returns {Number}
+ */
+BoundedValue.prototype.getLowerLimit = function () {
+    return this.__limitLower;
+};
+/**
+ *
+ * @param {Number} v
+ */
+BoundedValue.prototype.setLowerLimit = function (v) {
+    const old = this.__limitLower;
+
+    if (v === old) {
+        //no change
+        return;
+    }
+
+    this.__limitLower = v;
+
+    //TODO change signal signature to include lower limit
+    this.onChanged.dispatch();
+};
+
+/**
+ *
+ * @param {Number} v
+ */
+BoundedValue.prototype.setValue = function (v) {
+    const oldValue = this.__value;
+    if (oldValue === v) {
+        //no change
+        return;
+    }
+
+    const spill = v - this.__limitUpper;
+    this.__value = v;
+    //dispatch change
+    this.onChanged.send4(this.__value, this.__limitUpper, oldValue, this.__limitUpper);
+    if (spill > 0) {
+        this.onOverflow.send1(spill);
+    }
+    if (spill >= 0) {
+        this.onFilled.send0();
+    }
+};
+
+/**
+ *
+ * @returns {Number}
+ */
+BoundedValue.prototype.getValue = function () {
+    return this.__value;
+};
+
+
+/**
+ *
+ * @returns {number}
+ */
+BoundedValue.prototype.getFraction = function () {
+    return inverseLerp(this.__limitLower, this.__limitUpper, this.__value);
+};
+
+/**
+ *
+ */
+BoundedValue.prototype.setValueToLimit = function () {
+    this.setValue(this.__limitUpper);
+};
+
+/**
+ *
+ * @return {boolean}
+ */
+BoundedValue.prototype.isValueAtLimit = function () {
+    return this.__value === this.__limitUpper;
+};
+
+/**
+ *
+ * @param {Number} val
+ */
+BoundedValue.prototype.addValue = function (val) {
+    this.setValue(this.__value + val);
+};
+
+/**
+ *
+ * @param {BoundedValue} other
+ * @returns {BoundedValue}
+ */
+BoundedValue.prototype.copy = function (other) {
+    this.setUpperLimit(other.getUpperLimit());
+    this.setValue(other.getValue());
+    return this;
+};
+
+/**
+ *
+ * @param {BoundedValue} other
+ * @returns {boolean}
+ */
+BoundedValue.prototype.equals = function (other) {
+    return this.__value === other.__value && this.__limitLower === other.__limitLower && this.__limitUpper === other.__limitUpper;
+};
+
+/**
+ *
+ * @returns {number}
+ */
+BoundedValue.prototype.hash = function () {
+    const v0 = computeHashFloat(this.__value);
+    const v1 = computeHashFloat(this.__limitLower);
+    const v2 = computeHashFloat(this.__limitUpper);
+
+    const h0 = (v0 << 5) - v0 + v1;
+
+    return (h0 << 5) - h0 + v2;
+};
+
+BoundedValue.prototype.toJSON = function () {
+    return {
+        value: this.__value,
+        limit: this.__limitUpper
+    };
+};
+
+BoundedValue.prototype.fromJSON = function (json) {
+    this.setUpperLimit(json.limit);
+    this.setValue(json.value);
+};
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ */
+BoundedValue.prototype.toBinaryBuffer = function (buffer) {
+    buffer.writeFloat64(this.__value);
+    buffer.writeFloat64(this.__limitUpper);
+};
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ */
+BoundedValue.prototype.fromBinaryBuffer = function (buffer) {
+    const value = buffer.readFloat64();
+    const upperLimit = buffer.readFloat64();
+
+    this.setUpperLimit(upperLimit);
+    this.setValue(value);
+};
+
+class PendingAsset {
+    /**
+     *
+     * @param {AssetDescription} description
+     * @constructor
+     */
+    constructor(description) {
+        /**
+         *
+         * @type {AssetDescription}
+         */
+        this.description = description;
+
+        /**
+         *
          * @type {AssetRequest[]}
          */
         this.requests = [];
@@ -84059,7 +84054,12 @@ class PendingAsset {
 
         return max_priority;
     }
-}
+}
+
+/**
+ * Created by Alex on 03/09/2014.
+ */
+
 
 let Response$1 = class Response {
     /**
@@ -84090,141 +84090,144 @@ function get_pending_asset_priority_score(pending_asset) {
 class AssetManager {
     /**
      *
-     * @param {Engine} engine
-     * @constructor
+     * @type {HashMap<AssetDescription, Asset>}
+     * @private
      */
-    constructor(engine) {
-        /**
-         *
-         * @type {HashMap<AssetDescription, Asset>}
-         * @private
-         */
-        this.assets = new HashMap({
-            capacity: 1024
-        });
+    assets = new HashMap({
+        capacity: 1024
+    });
 
-        /**
-         *
-         * @type {ObservedMap<AssetDescription, PendingAsset>}
-         * @private
-         */
-        this.request_map = new ObservedMap(new HashMap());
+    /**
+     *
+     * @type {ObservedMap<AssetDescription, PendingAsset>}
+     */
+    request_map = new ObservedMap(new HashMap());
 
-        /**
-         * Waiting queue for assets that haven't yet been scheduled (passed to relevant loader)
-         * @type {BinaryHeap<PendingAsset>}
-         * @private
-         */
-        this.__pending_asset_wait_queue = new BinaryHeap(get_pending_asset_priority_score);
-        /**
-         * Assets currently being processed by loaders
-         * @type {Set<PendingAsset>}
-         * @private
-         */
-        this.__pending_asset_active_load_set = new Set();
+    /**
+     * Waiting queue for assets that haven't yet been scheduled (passed to relevant loader)
+     * @type {BinaryHeap<PendingAsset>}
+     * @private
+     */
+    #pending_asset_wait_queue = new BinaryHeap(get_pending_asset_priority_score);
+    /**
+     * Assets currently being processed by #loaders
+     * @type {Set<PendingAsset>}
+     * @private
+     */
+    #pending_asset_active_load_set = new Set();
 
-        /**
-         * Maximum number of requests that can be handled at the same time
-         * Since most of the requests are handled over the network, this can help you control network concurrency,
-         * this can be useful to keep some network slots available for high-priority requests such as UI related ones
-         * TODO currently nested asset requests are not recognized, so if nesting level exceeds concurrency - it will lead to a deadlock
-         * @type {number}
-         */
-        this.load_concurrency = Infinity;
+    /**
+     * Maximum number of requests that can be handled at the same time
+     * Since most of the requests are handled over the network, this can help you control network concurrency,
+     * this can be useful to keep some network slots available for high-priority requests such as UI related ones
+     * TODO currently nested asset requests are not recognized, so if nesting level exceeds concurrency - it will lead to a deadlock
+     * @type {number}
+     */
+    load_concurrency = Infinity;
 
-        /**
-         * Registered loaders
-         * @private
-         * @type {Object<AssetLoader>}
-         */
-        this.loaders = {};
+    /**
+     * Registered #loaders
+     * @private
+     * @type {Object<AssetLoader>}
+     */
+    #loaders = {};
 
-        /**
-         * After asset is loaded, a chain of transforms can be applied to it, these are registered here
-         * Transformers are executed in the order in which they are added
-         * Identified by asset "type" string
-         * @type {Object<AssetTransformer[]>}
-         * @private
-         */
-        this.transformers = {};
+    /**
+     * After asset is loaded, a chain of transforms can be applied to it, these are registered here
+     * Transformers are executed in the order in which they are added
+     * Identified by asset "type" string
+     * @type {Object<AssetTransformer[]>}
+     * @private
+     */
+    #transformers = {};
 
-        /**
-         * Named links to specific assets. Useful to later re-mapping assets and having meaningful names for them
-         * @type {Map<string, AssetDescription>}
-         * @private
-         */
-        this.aliases = new Map();
+    /**
+     * Named links to specific assets. Useful to later re-mapping assets and having meaningful names for them
+     * @type {Map<string, AssetDescription>}
+     * @private
+     */
+    #aliases = new Map();
 
-        /**
-         * This will be added to asset path for actual network resolution
-         * @type {string}
-         * @private
-         */
-        this.rootPath = '';
+    /**
+     * This will be added to asset path for actual network resolution
+     * @type {string}
+     * @private
+     */
+    rootPath = '';
 
-        /**
-         *
-         * @type {Engine}
-         * @private
-         */
-        this.__engine = engine;
+    /**
+     *
+     * @type {CrossOriginConfig}
+     */
+    crossOriginConfig = new CrossOriginConfig();
 
-        /**
-         *
-         * @type {CrossOriginConfig}
-         */
-        this.crossOriginConfig = new CrossOriginConfig();
+    /**
+     *
+     * @type {HashSet<AssetDescription>}
+     * @private
+     */
+    #failures = new HashSet();
 
-        /**
-         *
-         * @type {HashSet<AssetDescription>}
-         * @private
-         */
-        this.failures = new HashSet();
+    /**
+     * Queue of responses that are waiting to be dispatched
+     * @type {Deque<Response>}
+     * @private
+     */
+    #response_queue = new Deque();
 
-        /**
-         * Queue of responses that are waiting to be dispatched
-         * @type {Deque<Response>}
-         * @private
-         */
-        this.__response_queue = new Deque();
+    /**
+     *
+     * @type {Task}
+     * @private
+     */
+    #response_processor = new Task({
+        name: "Asset Manager Response processor",
+        cycleFunction: () => {
+            if (this.#response_queue.isEmpty()) {
+                return TaskSignal.Yield;
+            }
 
-        /**
-         *
-         * @type {Task}
-         * @private
-         */
-        this.__response_processor = new Task({
-            name: "Asset Manager Response processor",
-            cycleFunction: () => {
-                if (this.__response_queue.isEmpty()) {
-                    return TaskSignal.Yield;
-                }
+            const response = this.#response_queue.removeFirst();
 
-                const response = this.__response_queue.removeFirst();
+            this.#process_response(response);
 
-                this.__process_response(response);
+            return TaskSignal.Continue;
+        }
+    });
 
-                return TaskSignal.Continue;
-            }
-        });
+    /**
+     *
+     * @type {boolean}
+     * @private
+     */
+    #is_running = false;
+
+    /**
+     *
+     * @type {Engine|null}
+     * @private
+     */
+    #engine = null;
+
+    /**
+     *
+     * @param {Engine} engine
+     * @constructor
+     */
+    constructor(engine) {
+
+        this.#engine = engine;
 
-        /**
-         *
-         * @type {boolean}
-         * @private
-         */
-        this.__is_running = false;
     }
 
     startup() {
-        if (this.__is_running) {
+        if (this.#is_running) {
             return;
         }
 
-        this.__engine.executor.run(this.__response_processor);
+        this.#engine.executor.run(this.#response_processor);
 
-        this.__is_running = true;
+        this.#is_running = true;
     }
 
     /**
@@ -84233,18 +84236,18 @@ class AssetManager {
      * @return {Promise<void>}
      */
     async shutdown(immediate = false) {
-        if (!this.__is_running) {
+        if (!this.#is_running) {
             return;
         }
 
         if (!immediate) {
             // wait until all responses have been processed
-            await Promise.allSettled([Task.promise(this.__response_processor)]);
+            await Promise.allSettled([Task.promise(this.#response_processor)]);
         }
 
-        this.__engine.executor.removeTask(this.__response_processor);
+        this.#engine.executor.removeTask(this.#response_processor);
 
-        this.__is_running = false;
+        this.#is_running = false;
     }
 
     /**
@@ -84333,6 +84336,8 @@ class AssetManager {
             console.warn(`Another asset under ${assetDescription} already exists and will be replaced`);
         }
 
+        // TODO check for assets in-flight
+
         this.assets.set(assetDescription, asset);
     }
 
@@ -84341,7 +84346,7 @@ class AssetManager {
      * @param {Response} response
      * @private
      */
-    __process_response(response) {
+    #process_response(response) {
 
         try {
             response.request.successCallback(response.asset);
@@ -84356,8 +84361,8 @@ class AssetManager {
      * @param {AssetRequest} request
      * @private
      */
-    __schedule_response(asset, request) {
-        this.__response_queue.add(new Response$1(asset, request));
+    #schedule_response(asset, request) {
+        this.#response_queue.add(new Response$1(asset, request));
     }
 
     /**
@@ -84365,11 +84370,11 @@ class AssetManager {
      * @param {PendingAsset} asset
      * @private
      */
-    __schedule_load(asset) {
-        if (this.__pending_asset_active_load_set.size < this.load_concurrency) {
-            this.__dispatch_pending_asset(asset);
+    #schedule_load(asset) {
+        if (this.#pending_asset_active_load_set.size < this.load_concurrency) {
+            this.#dispatch_pending_asset(asset);
         } else {
-            this.__pending_asset_wait_queue.push(asset);
+            this.#pending_asset_wait_queue.push(asset);
         }
     }
 
@@ -84378,17 +84383,17 @@ class AssetManager {
      * @param {PendingAsset} asset
      * @private
      */
-    __force_load(asset) {
+    #force_load(asset) {
         // check if the asset is already being loaded
-        if (this.__pending_asset_active_load_set.has(asset)) {
+        if (this.#pending_asset_active_load_set.has(asset)) {
             return;
         }
 
         // remove from queue
-        this.__pending_asset_wait_queue.delete(asset);
+        this.#pending_asset_wait_queue.delete(asset);
 
         // dispatch
-        this.__dispatch_pending_asset(asset);
+        this.#dispatch_pending_asset(asset);
 
     }
 
@@ -84397,21 +84402,21 @@ class AssetManager {
      * @param {PendingAsset} pending_asset
      * @private
      */
-    __handle_asset_resolved(pending_asset) {
+    #handle_asset_resolved(pending_asset) {
         // console.log(`Asset resolved ${pending_asset.description}`); // DEBUG
 
-        const active_set = this.__pending_asset_active_load_set;
+        const active_set = this.#pending_asset_active_load_set;
 
         this.request_map.delete(pending_asset.description);
         active_set.delete(pending_asset);
 
-        const queue = this.__pending_asset_wait_queue;
+        const queue = this.#pending_asset_wait_queue;
 
         // schedule more if possible
         while (!queue.isEmpty() && active_set.size < this.load_concurrency) {
             const load = queue.pop();
 
-            this.__dispatch_pending_asset(load);
+            this.#dispatch_pending_asset(load);
         }
     }
 
@@ -84420,7 +84425,7 @@ class AssetManager {
      * @param {PendingAsset} pendingAsset
      * @private
      */
-    __dispatch_pending_asset(pendingAsset) {
+    #dispatch_pending_asset(pendingAsset) {
         // console.log(`Asset load dispatched ${pendingAsset.description}`); // DEBUG
 
         const requests = pendingAsset.requests;
@@ -84428,7 +84433,7 @@ class AssetManager {
         const type = assetDescription.type;
         const path = assetDescription.path;
 
-        const loader = this.loaders[type];
+        const loader = this.#loaders[type];
 
         if (loader === undefined) {
             let reported_error = false;
@@ -84437,7 +84442,7 @@ class AssetManager {
                 const assetRequest = requests[i];
 
                 if (typeof assetRequest.failureCallback === "function") {
-                    assetRequest.failureCallback(`no loader exists for asset type '${type}', valid types are: ${Object.keys(this.loaders).join(', ')}`);
+                    assetRequest.failureCallback(`no loader exists for asset type '${type}', valid types are: ${Object.keys(this.#loaders).join(', ')}`);
                 } else {
                     //uncaught
                     if (!reported_error) {
@@ -84447,16 +84452,16 @@ class AssetManager {
                 }
             }
 
-            this.__handle_asset_resolved(pendingAsset);
+            this.#handle_asset_resolved(pendingAsset);
 
             return;
         }
 
         // mark as being loaded
-        this.__pending_asset_active_load_set.add(pendingAsset);
+        this.#pending_asset_active_load_set.add(pendingAsset);
 
         const assets = this.assets;
-        const failures = this.failures;
+        const failures = this.#failures;
 
 
         /**
@@ -84480,7 +84485,7 @@ class AssetManager {
             let asset = loaded_asset;
 
             // apply transform chain
-            const transformers = this.transformers[type];
+            const transformers = this.#transformers[type];
             if (transformers !== undefined) {
                 const transformer_count = transformers.length;
                 for (let i = 0; i < transformer_count; i++) {
@@ -84503,13 +84508,13 @@ class AssetManager {
             assets.set(assetDescription, asset);
 
             //clear callbacks etc.
-            this.__handle_asset_resolved(pendingAsset);
+            this.#handle_asset_resolved(pendingAsset);
 
 
             // process callbacks
             for (let i = 0; i < requests.length; i++) {
                 const request = requests[i];
-                this.__schedule_response(asset, request);
+                this.#schedule_response(asset, request);
             }
 
         };
@@ -84537,7 +84542,7 @@ class AssetManager {
             }
 
             //clear callbacks etc.
-            this.__handle_asset_resolved(pendingAsset);
+            this.#handle_asset_resolved(pendingAsset);
 
             // record failure
             failures.add(assetDescription);
@@ -84603,15 +84608,15 @@ class AssetManager {
 
         if (shouldSchedule) {
             // not loading yet, lets create a load container and schedule it
-            this.__schedule_load(pendingAsset);
+            this.#schedule_load(pendingAsset);
         } else {
             // update priority queue if necessary
-            this.__pending_asset_wait_queue.updateElementScore(pendingAsset);
+            this.#pending_asset_wait_queue.updateElementScore(pendingAsset);
         }
 
 
         if (request.getFlag(AssetRequestFlags.SkipQueue)) {
-            this.__force_load(pendingAsset);
+            this.#force_load(pendingAsset);
         }
     }
 
@@ -84633,7 +84638,7 @@ class AssetManager {
     getLoaderByType(type) {
         assert.isString(type, 'type');
 
-        return this.loaders[type];
+        return this.#loaders[type];
     }
 
     /**
@@ -84642,7 +84647,7 @@ class AssetManager {
      * @return {AssetDescription[]}
      * @private
      */
-    __getLoadedAssetDescriptorsByType(type) {
+    #getLoadedAssetDescriptorsByType(type) {
         const loaded_assets = Array.from(this.assets.keys());
         return loaded_assets.filter(t => t.type === type);
     }
@@ -84653,18 +84658,18 @@ class AssetManager {
      * @param {AssetTransformer<T>} transformer
      */
     registerTransformer(type, transformer) {
-        let transformers = this.transformers[type];
+        let transformers = this.#transformers[type];
 
         if (transformers === undefined) {
             transformers = [];
 
-            this.transformers[type] = transformers;
+            this.#transformers[type] = transformers;
         }
 
         transformers.push(transformer);
 
         // check for loaded assets
-        const matching_assets = this.__getLoadedAssetDescriptorsByType(type);
+        const matching_assets = this.#getLoadedAssetDescriptorsByType(type);
 
         if (matching_assets.length > 0) {
             console.warn(`Following assets of matching type '${type}' are already loaded and transform is not applied to them:\n\t${matching_assets.join('\n\t')}`);
@@ -84679,7 +84684,7 @@ class AssetManager {
      */
     unregisterTransformer(type, transformer) {
 
-        const transformers = this.transformers[type];
+        const transformers = this.#transformers[type];
 
         if (transformers === undefined) {
             // not found
@@ -84692,7 +84697,7 @@ class AssetManager {
         }
 
         // check for loaded assets
-        const matching_assets = this.__getLoadedAssetDescriptorsByType(type);
+        const matching_assets = this.#getLoadedAssetDescriptorsByType(type);
 
         if (matching_assets.length > 0) {
             console.warn(`Following assets of matching type '${type}' are already loaded and transform was probably already applied to them:\n\t${matching_assets.join('\n\t')}`);
@@ -84731,11 +84736,11 @@ class AssetManager {
 
         } else {
 
-            await loader.link(this, this.__engine);
+            await loader.link(this, this.#engine);
 
         }
 
-        this.loaders[type] = loader;
+        this.#loaders[type] = loader;
 
         return loader;
     }
@@ -84754,7 +84759,7 @@ class AssetManager {
         }
 
         // first remove the loader from registry so no further asset requests can be made
-        delete this.loaders[type];
+        delete this.#loaders[type];
 
         // TODO address all pending requests, possibly waiting for all of them to finalize
 
@@ -84790,7 +84795,7 @@ class AssetManager {
     isFailed(path, type) {
         const ad = new AssetDescription(path, type);
 
-        return this.failures.has(ad);
+        return this.#failures.has(ad);
     }
 
     /**
@@ -84802,7 +84807,7 @@ class AssetManager {
         assert.typeOf(alias, 'string', 'alias');
 
         // resolve alias
-        const assetDescription = this.aliases.get(alias);
+        const assetDescription = this.#aliases.get(alias);
 
         if (assetDescription === undefined) {
             return new Promise.reject(`Alias '${alias}' not found`);
@@ -84820,7 +84825,7 @@ class AssetManager {
 
         // todo consider cloning result to protect against mutation
 
-        return this.aliases.get(alias);
+        return this.#aliases.get(alias);
 
     }
 
@@ -84837,7 +84842,7 @@ class AssetManager {
 
         const assetDescription = new AssetDescription(path, type);
 
-        this.aliases.set(alias, assetDescription);
+        this.#aliases.set(alias, assetDescription);
     }
 }