@polarfront-lab/ionian 1.0.0

package/dist/index.es.js

@@ -0,0 +1,3479 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import * as THREE from "three";
+import { Mesh, OrthographicCamera, BufferGeometry, Float32BufferAttribute, NearestFilter, ShaderMaterial, WebGLRenderTarget, FloatType, RGBAFormat, DataTexture, ClampToEdgeWrapping } from "three";
+const linear = (n) => n;
+function mitt(n) {
+  return { all: n = n || /* @__PURE__ */ new Map(), on: function(t, e) {
+    var i = n.get(t);
+    i ? i.push(e) : n.set(t, [e]);
+  }, off: function(t, e) {
+    var i = n.get(t);
+    i && (e ? i.splice(i.indexOf(e) >>> 0, 1) : n.set(t, []));
+  }, emit: function(t, e) {
+    var i = n.get(t);
+    i && i.slice().map(function(n2) {
+      n2(e);
+    }), (i = n.get("*")) && i.slice().map(function(n2) {
+      n2(t, e);
+    });
+  } };
+}
+class DefaultEventEmitter {
+  constructor() {
+    __publicField(this, "emitter", mitt());
+  }
+  emit(type, payload) {
+    this.emitter.emit(type, payload);
+  }
+  off(type, handler) {
+    this.emitter.off(type, handler);
+  }
+  on(type, handler) {
+    this.emitter.on(type, handler);
+  }
+  once(type, handler) {
+    this.emitter.on(type, (payload) => {
+      this.emitter.off(type, handler);
+      handler(payload);
+    });
+  }
+  dispose() {
+    this.emitter.all.clear();
+  }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const proxyMarker = Symbol("Comlink.proxy");
+const createEndpoint = Symbol("Comlink.endpoint");
+const releaseProxy = Symbol("Comlink.releaseProxy");
+const finalizer = Symbol("Comlink.finalizer");
+const throwMarker = Symbol("Comlink.thrown");
+const isObject = (val) => typeof val === "object" && val !== null || typeof val === "function";
+const proxyTransferHandler = {
+  canHandle: (val) => isObject(val) && val[proxyMarker],
+  serialize(obj) {
+    const { port1, port2 } = new MessageChannel();
+    expose(obj, port1);
+    return [port2, [port2]];
+  },
+  deserialize(port) {
+    port.start();
+    return wrap(port);
+  }
+};
+const throwTransferHandler = {
+  canHandle: (value) => isObject(value) && throwMarker in value,
+  serialize({ value }) {
+    let serialized;
+    if (value instanceof Error) {
+      serialized = {
+        isError: true,
+        value: {
+          message: value.message,
+          name: value.name,
+          stack: value.stack
+        }
+      };
+    } else {
+      serialized = { isError: false, value };
+    }
+    return [serialized, []];
+  },
+  deserialize(serialized) {
+    if (serialized.isError) {
+      throw Object.assign(new Error(serialized.value.message), serialized.value);
+    }
+    throw serialized.value;
+  }
+};
+const transferHandlers = /* @__PURE__ */ new Map([
+  ["proxy", proxyTransferHandler],
+  ["throw", throwTransferHandler]
+]);
+function isAllowedOrigin(allowedOrigins, origin) {
+  for (const allowedOrigin of allowedOrigins) {
+    if (origin === allowedOrigin || allowedOrigin === "*") {
+      return true;
+    }
+    if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
+      return true;
+    }
+  }
+  return false;
+}
+function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+  ep.addEventListener("message", function callback(ev) {
+    if (!ev || !ev.data) {
+      return;
+    }
+    if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+      console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
+      return;
+    }
+    const { id, type, path } = Object.assign({ path: [] }, ev.data);
+    const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+    let returnValue;
+    try {
+      const parent = path.slice(0, -1).reduce((obj2, prop) => obj2[prop], obj);
+      const rawValue = path.reduce((obj2, prop) => obj2[prop], obj);
+      switch (type) {
+        case "GET":
+          {
+            returnValue = rawValue;
+          }
+          break;
+        case "SET":
+          {
+            parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+            returnValue = true;
+          }
+          break;
+        case "APPLY":
+          {
+            returnValue = rawValue.apply(parent, argumentList);
+          }
+          break;
+        case "CONSTRUCT":
+          {
+            const value = new rawValue(...argumentList);
+            returnValue = proxy(value);
+          }
+          break;
+        case "ENDPOINT":
+          {
+            const { port1, port2 } = new MessageChannel();
+            expose(obj, port2);
+            returnValue = transfer(port1, [port1]);
+          }
+          break;
+        case "RELEASE":
+          {
+            returnValue = void 0;
+          }
+          break;
+        default:
+          return;
+      }
+    } catch (value) {
+      returnValue = { value, [throwMarker]: 0 };
+    }
+    Promise.resolve(returnValue).catch((value) => {
+      return { value, [throwMarker]: 0 };
+    }).then((returnValue2) => {
+      const [wireValue, transferables] = toWireValue(returnValue2);
+      ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+      if (type === "RELEASE") {
+        ep.removeEventListener("message", callback);
+        closeEndPoint(ep);
+        if (finalizer in obj && typeof obj[finalizer] === "function") {
+          obj[finalizer]();
+        }
+      }
+    }).catch((error) => {
+      const [wireValue, transferables] = toWireValue({
+        value: new TypeError("Unserializable return value"),
+        [throwMarker]: 0
+      });
+      ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+    });
+  });
+  if (ep.start) {
+    ep.start();
+  }
+}
+function isMessagePort(endpoint) {
+  return endpoint.constructor.name === "MessagePort";
+}
+function closeEndPoint(endpoint) {
+  if (isMessagePort(endpoint))
+    endpoint.close();
+}
+function wrap(ep, target) {
+  const pendingListeners = /* @__PURE__ */ new Map();
+  ep.addEventListener("message", function handleMessage(ev) {
+    const { data } = ev;
+    if (!data || !data.id) {
+      return;
+    }
+    const resolver = pendingListeners.get(data.id);
+    if (!resolver) {
+      return;
+    }
+    try {
+      resolver(data);
+    } finally {
+      pendingListeners.delete(data.id);
+    }
+  });
+  return createProxy(ep, pendingListeners, [], target);
+}
+function throwIfProxyReleased(isReleased) {
+  if (isReleased) {
+    throw new Error("Proxy has been released and is not useable");
+  }
+}
+function releaseEndpoint(ep) {
+  return requestResponseMessage(ep, /* @__PURE__ */ new Map(), {
+    type: "RELEASE"
+  }).then(() => {
+    closeEndPoint(ep);
+  });
+}
+const proxyCounter = /* @__PURE__ */ new WeakMap();
+const proxyFinalizers = "FinalizationRegistry" in globalThis && new FinalizationRegistry((ep) => {
+  const newCount = (proxyCounter.get(ep) || 0) - 1;
+  proxyCounter.set(ep, newCount);
+  if (newCount === 0) {
+    releaseEndpoint(ep);
+  }
+});
+function registerProxy(proxy2, ep) {
+  const newCount = (proxyCounter.get(ep) || 0) + 1;
+  proxyCounter.set(ep, newCount);
+  if (proxyFinalizers) {
+    proxyFinalizers.register(proxy2, ep, proxy2);
+  }
+}
+function unregisterProxy(proxy2) {
+  if (proxyFinalizers) {
+    proxyFinalizers.unregister(proxy2);
+  }
+}
+function createProxy(ep, pendingListeners, path = [], target = function() {
+}) {
+  let isProxyReleased = false;
+  const proxy2 = new Proxy(target, {
+    get(_target, prop) {
+      throwIfProxyReleased(isProxyReleased);
+      if (prop === releaseProxy) {
+        return () => {
+          unregisterProxy(proxy2);
+          releaseEndpoint(ep);
+          pendingListeners.clear();
+          isProxyReleased = true;
+        };
+      }
+      if (prop === "then") {
+        if (path.length === 0) {
+          return { then: () => proxy2 };
+        }
+        const r = requestResponseMessage(ep, pendingListeners, {
+          type: "GET",
+          path: path.map((p) => p.toString())
+        }).then(fromWireValue);
+        return r.then.bind(r);
+      }
+      return createProxy(ep, pendingListeners, [...path, prop]);
+    },
+    set(_target, prop, rawValue) {
+      throwIfProxyReleased(isProxyReleased);
+      const [value, transferables] = toWireValue(rawValue);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "SET",
+        path: [...path, prop].map((p) => p.toString()),
+        value
+      }, transferables).then(fromWireValue);
+    },
+    apply(_target, _thisArg, rawArgumentList) {
+      throwIfProxyReleased(isProxyReleased);
+      const last = path[path.length - 1];
+      if (last === createEndpoint) {
+        return requestResponseMessage(ep, pendingListeners, {
+          type: "ENDPOINT"
+        }).then(fromWireValue);
+      }
+      if (last === "bind") {
+        return createProxy(ep, pendingListeners, path.slice(0, -1));
+      }
+      const [argumentList, transferables] = processArguments(rawArgumentList);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "APPLY",
+        path: path.map((p) => p.toString()),
+        argumentList
+      }, transferables).then(fromWireValue);
+    },
+    construct(_target, rawArgumentList) {
+      throwIfProxyReleased(isProxyReleased);
+      const [argumentList, transferables] = processArguments(rawArgumentList);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "CONSTRUCT",
+        path: path.map((p) => p.toString()),
+        argumentList
+      }, transferables).then(fromWireValue);
+    }
+  });
+  registerProxy(proxy2, ep);
+  return proxy2;
+}
+function myFlat(arr) {
+  return Array.prototype.concat.apply([], arr);
+}
+function processArguments(argumentList) {
+  const processed = argumentList.map(toWireValue);
+  return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+}
+const transferCache = /* @__PURE__ */ new WeakMap();
+function transfer(obj, transfers) {
+  transferCache.set(obj, transfers);
+  return obj;
+}
+function proxy(obj) {
+  return Object.assign(obj, { [proxyMarker]: true });
+}
+function toWireValue(value) {
+  for (const [name, handler] of transferHandlers) {
+    if (handler.canHandle(value)) {
+      const [serializedValue, transferables] = handler.serialize(value);
+      return [
+        {
+          type: "HANDLER",
+          name,
+          value: serializedValue
+        },
+        transferables
+      ];
+    }
+  }
+  return [
+    {
+      type: "RAW",
+      value
+    },
+    transferCache.get(value) || []
+  ];
+}
+function fromWireValue(value) {
+  switch (value.type) {
+    case "HANDLER":
+      return transferHandlers.get(value.name).deserialize(value.value);
+    case "RAW":
+      return value.value;
+  }
+}
+function requestResponseMessage(ep, pendingListeners, msg, transfers) {
+  return new Promise((resolve) => {
+    const id = generateUUID();
+    pendingListeners.set(id, resolve);
+    if (ep.start) {
+      ep.start();
+    }
+    ep.postMessage(Object.assign({ id }, msg), transfers);
+  });
+}
+function generateUUID() {
+  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var events = { exports: {} };
+var hasRequiredEvents;
+function requireEvents() {
+  if (hasRequiredEvents) return events.exports;
+  hasRequiredEvents = 1;
+  var R = typeof Reflect === "object" ? Reflect : null;
+  var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
+    return Function.prototype.apply.call(target, receiver, args);
+  };
+  var ReflectOwnKeys;
+  if (R && typeof R.ownKeys === "function") {
+    ReflectOwnKeys = R.ownKeys;
+  } else if (Object.getOwnPropertySymbols) {
+    ReflectOwnKeys = function ReflectOwnKeys2(target) {
+      return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
+    };
+  } else {
+    ReflectOwnKeys = function ReflectOwnKeys2(target) {
+      return Object.getOwnPropertyNames(target);
+    };
+  }
+  function ProcessEmitWarning(warning) {
+    if (console && console.warn) console.warn(warning);
+  }
+  var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
+    return value !== value;
+  };
+  function EventEmitter() {
+    EventEmitter.init.call(this);
+  }
+  events.exports = EventEmitter;
+  events.exports.once = once;
+  EventEmitter.EventEmitter = EventEmitter;
+  EventEmitter.prototype._events = void 0;
+  EventEmitter.prototype._eventsCount = 0;
+  EventEmitter.prototype._maxListeners = void 0;
+  var defaultMaxListeners = 10;
+  function checkListener(listener) {
+    if (typeof listener !== "function") {
+      throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+    }
+  }
+  Object.defineProperty(EventEmitter, "defaultMaxListeners", {
+    enumerable: true,
+    get: function() {
+      return defaultMaxListeners;
+    },
+    set: function(arg) {
+      if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
+        throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
+      }
+      defaultMaxListeners = arg;
+    }
+  });
+  EventEmitter.init = function() {
+    if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
+      this._events = /* @__PURE__ */ Object.create(null);
+      this._eventsCount = 0;
+    }
+    this._maxListeners = this._maxListeners || void 0;
+  };
+  EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+    if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
+      throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
+    }
+    this._maxListeners = n;
+    return this;
+  };
+  function _getMaxListeners(that) {
+    if (that._maxListeners === void 0)
+      return EventEmitter.defaultMaxListeners;
+    return that._maxListeners;
+  }
+  EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+    return _getMaxListeners(this);
+  };
+  EventEmitter.prototype.emit = function emit(type) {
+    var args = [];
+    for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+    var doError = type === "error";
+    var events2 = this._events;
+    if (events2 !== void 0)
+      doError = doError && events2.error === void 0;
+    else if (!doError)
+      return false;
+    if (doError) {
+      var er;
+      if (args.length > 0)
+        er = args[0];
+      if (er instanceof Error) {
+        throw er;
+      }
+      var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
+      err.context = er;
+      throw err;
+    }
+    var handler = events2[type];
+    if (handler === void 0)
+      return false;
+    if (typeof handler === "function") {
+      ReflectApply(handler, this, args);
+    } else {
+      var len = handler.length;
+      var listeners = arrayClone(handler, len);
+      for (var i = 0; i < len; ++i)
+        ReflectApply(listeners[i], this, args);
+    }
+    return true;
+  };
+  function _addListener(target, type, listener, prepend) {
+    var m;
+    var events2;
+    var existing;
+    checkListener(listener);
+    events2 = target._events;
+    if (events2 === void 0) {
+      events2 = target._events = /* @__PURE__ */ Object.create(null);
+      target._eventsCount = 0;
+    } else {
+      if (events2.newListener !== void 0) {
+        target.emit(
+          "newListener",
+          type,
+          listener.listener ? listener.listener : listener
+        );
+        events2 = target._events;
+      }
+      existing = events2[type];
+    }
+    if (existing === void 0) {
+      existing = events2[type] = listener;
+      ++target._eventsCount;
+    } else {
+      if (typeof existing === "function") {
+        existing = events2[type] = prepend ? [listener, existing] : [existing, listener];
+      } else if (prepend) {
+        existing.unshift(listener);
+      } else {
+        existing.push(listener);
+      }
+      m = _getMaxListeners(target);
+      if (m > 0 && existing.length > m && !existing.warned) {
+        existing.warned = true;
+        var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+        w.name = "MaxListenersExceededWarning";
+        w.emitter = target;
+        w.type = type;
+        w.count = existing.length;
+        ProcessEmitWarning(w);
+      }
+    }
+    return target;
+  }
+  EventEmitter.prototype.addListener = function addListener(type, listener) {
+    return _addListener(this, type, listener, false);
+  };
+  EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+  EventEmitter.prototype.prependListener = function prependListener(type, listener) {
+    return _addListener(this, type, listener, true);
+  };
+  function onceWrapper() {
+    if (!this.fired) {
+      this.target.removeListener(this.type, this.wrapFn);
+      this.fired = true;
+      if (arguments.length === 0)
+        return this.listener.call(this.target);
+      return this.listener.apply(this.target, arguments);
+    }
+  }
+  function _onceWrap(target, type, listener) {
+    var state = { fired: false, wrapFn: void 0, target, type, listener };
+    var wrapped = onceWrapper.bind(state);
+    wrapped.listener = listener;
+    state.wrapFn = wrapped;
+    return wrapped;
+  }
+  EventEmitter.prototype.once = function once2(type, listener) {
+    checkListener(listener);
+    this.on(type, _onceWrap(this, type, listener));
+    return this;
+  };
+  EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
+    checkListener(listener);
+    this.prependListener(type, _onceWrap(this, type, listener));
+    return this;
+  };
+  EventEmitter.prototype.removeListener = function removeListener(type, listener) {
+    var list, events2, position, i, originalListener;
+    checkListener(listener);
+    events2 = this._events;
+    if (events2 === void 0)
+      return this;
+    list = events2[type];
+    if (list === void 0)
+      return this;
+    if (list === listener || list.listener === listener) {
+      if (--this._eventsCount === 0)
+        this._events = /* @__PURE__ */ Object.create(null);
+      else {
+        delete events2[type];
+        if (events2.removeListener)
+          this.emit("removeListener", type, list.listener || listener);
+      }
+    } else if (typeof list !== "function") {
+      position = -1;
+      for (i = list.length - 1; i >= 0; i--) {
+        if (list[i] === listener || list[i].listener === listener) {
+          originalListener = list[i].listener;
+          position = i;
+          break;
+        }
+      }
+      if (position < 0)
+        return this;
+      if (position === 0)
+        list.shift();
+      else {
+        spliceOne(list, position);
+      }
+      if (list.length === 1)
+        events2[type] = list[0];
+      if (events2.removeListener !== void 0)
+        this.emit("removeListener", type, originalListener || listener);
+    }
+    return this;
+  };
+  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+  EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
+    var listeners, events2, i;
+    events2 = this._events;
+    if (events2 === void 0)
+      return this;
+    if (events2.removeListener === void 0) {
+      if (arguments.length === 0) {
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+      } else if (events2[type] !== void 0) {
+        if (--this._eventsCount === 0)
+          this._events = /* @__PURE__ */ Object.create(null);
+        else
+          delete events2[type];
+      }
+      return this;
+    }
+    if (arguments.length === 0) {
+      var keys = Object.keys(events2);
+      var key;
+      for (i = 0; i < keys.length; ++i) {
+        key = keys[i];
+        if (key === "removeListener") continue;
+        this.removeAllListeners(key);
+      }
+      this.removeAllListeners("removeListener");
+      this._events = /* @__PURE__ */ Object.create(null);
+      this._eventsCount = 0;
+      return this;
+    }
+    listeners = events2[type];
+    if (typeof listeners === "function") {
+      this.removeListener(type, listeners);
+    } else if (listeners !== void 0) {
+      for (i = listeners.length - 1; i >= 0; i--) {
+        this.removeListener(type, listeners[i]);
+      }
+    }
+    return this;
+  };
+  function _listeners(target, type, unwrap) {
+    var events2 = target._events;
+    if (events2 === void 0)
+      return [];
+    var evlistener = events2[type];
+    if (evlistener === void 0)
+      return [];
+    if (typeof evlistener === "function")
+      return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+    return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+  }
+  EventEmitter.prototype.listeners = function listeners(type) {
+    return _listeners(this, type, true);
+  };
+  EventEmitter.prototype.rawListeners = function rawListeners(type) {
+    return _listeners(this, type, false);
+  };
+  EventEmitter.listenerCount = function(emitter, type) {
+    if (typeof emitter.listenerCount === "function") {
+      return emitter.listenerCount(type);
+    } else {
+      return listenerCount.call(emitter, type);
+    }
+  };
+  EventEmitter.prototype.listenerCount = listenerCount;
+  function listenerCount(type) {
+    var events2 = this._events;
+    if (events2 !== void 0) {
+      var evlistener = events2[type];
+      if (typeof evlistener === "function") {
+        return 1;
+      } else if (evlistener !== void 0) {
+        return evlistener.length;
+      }
+    }
+    return 0;
+  }
+  EventEmitter.prototype.eventNames = function eventNames() {
+    return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+  };
+  function arrayClone(arr, n) {
+    var copy = new Array(n);
+    for (var i = 0; i < n; ++i)
+      copy[i] = arr[i];
+    return copy;
+  }
+  function spliceOne(list, index) {
+    for (; index + 1 < list.length; index++)
+      list[index] = list[index + 1];
+    list.pop();
+  }
+  function unwrapListeners(arr) {
+    var ret = new Array(arr.length);
+    for (var i = 0; i < ret.length; ++i) {
+      ret[i] = arr[i].listener || arr[i];
+    }
+    return ret;
+  }
+  function once(emitter, name) {
+    return new Promise(function(resolve, reject) {
+      function errorListener(err) {
+        emitter.removeListener(name, resolver);
+        reject(err);
+      }
+      function resolver() {
+        if (typeof emitter.removeListener === "function") {
+          emitter.removeListener("error", errorListener);
+        }
+        resolve([].slice.call(arguments));
+      }
+      eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+      if (name !== "error") {
+        addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+      }
+    });
+  }
+  function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+    if (typeof emitter.on === "function") {
+      eventTargetAgnosticAddListener(emitter, "error", handler, flags);
+    }
+  }
+  function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+    if (typeof emitter.on === "function") {
+      if (flags.once) {
+        emitter.once(name, listener);
+      } else {
+        emitter.on(name, listener);
+      }
+    } else if (typeof emitter.addEventListener === "function") {
+      emitter.addEventListener(name, function wrapListener(arg) {
+        if (flags.once) {
+          emitter.removeEventListener(name, wrapListener);
+        }
+        listener(arg);
+      });
+    } else {
+      throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+    }
+  }
+  return events.exports;
+}
+var factoryValidator;
+var hasRequiredFactoryValidator;
+function requireFactoryValidator() {
+  if (hasRequiredFactoryValidator) return factoryValidator;
+  hasRequiredFactoryValidator = 1;
+  factoryValidator = function(factory) {
+    if (typeof factory.create !== "function") {
+      throw new TypeError("factory.create must be a function");
+    }
+    if (typeof factory.destroy !== "function") {
+      throw new TypeError("factory.destroy must be a function");
+    }
+    if (typeof factory.validate !== "undefined" && typeof factory.validate !== "function") {
+      throw new TypeError("factory.validate must be a function");
+    }
+  };
+  return factoryValidator;
+}
+var PoolDefaults_1;
+var hasRequiredPoolDefaults;
+function requirePoolDefaults() {
+  if (hasRequiredPoolDefaults) return PoolDefaults_1;
+  hasRequiredPoolDefaults = 1;
+  class PoolDefaults {
+    constructor() {
+      this.fifo = true;
+      this.priorityRange = 1;
+      this.testOnBorrow = false;
+      this.testOnReturn = false;
+      this.autostart = true;
+      this.evictionRunIntervalMillis = 0;
+      this.numTestsPerEvictionRun = 3;
+      this.softIdleTimeoutMillis = -1;
+      this.idleTimeoutMillis = 3e4;
+      this.acquireTimeoutMillis = null;
+      this.destroyTimeoutMillis = null;
+      this.maxWaitingClients = null;
+      this.min = null;
+      this.max = null;
+      this.Promise = Promise;
+    }
+  }
+  PoolDefaults_1 = PoolDefaults;
+  return PoolDefaults_1;
+}
+var PoolOptions_1;
+var hasRequiredPoolOptions;
+function requirePoolOptions() {
+  if (hasRequiredPoolOptions) return PoolOptions_1;
+  hasRequiredPoolOptions = 1;
+  const PoolDefaults = requirePoolDefaults();
+  class PoolOptions {
+    /**
+     * @param {Object} opts
+     *   configuration for the pool
+     * @param {Number} [opts.max=null]
+     *   Maximum number of items that can exist at the same time.  Default: 1.
+     *   Any further acquire requests will be pushed to the waiting list.
+     * @param {Number} [opts.min=null]
+     *   Minimum number of items in pool (including in-use). Default: 0.
+     *   When the pool is created, or a resource destroyed, this minimum will
+     *   be checked. If the pool resource count is below the minimum, a new
+     *   resource will be created and added to the pool.
+     * @param {Number} [opts.maxWaitingClients=null]
+     *   maximum number of queued requests allowed after which acquire calls will be rejected
+     * @param {Boolean} [opts.testOnBorrow=false]
+     *   should the pool validate resources before giving them to clients. Requires that
+     *   `factory.validate` is specified.
+     * @param {Boolean} [opts.testOnReturn=false]
+     *   should the pool validate resources before returning them to the pool.
+     * @param {Number} [opts.acquireTimeoutMillis=null]
+     *   Delay in milliseconds after which the an `acquire` call will fail. optional.
+     *   Default: undefined. Should be positive and non-zero
+     * @param {Number} [opts.destroyTimeoutMillis=null]
+     *   Delay in milliseconds after which the an `destroy` call will fail, causing it to emit a factoryDestroyError event. optional.
+     *   Default: undefined. Should be positive and non-zero
+     * @param {Number} [opts.priorityRange=1]
+     *   The range from 1 to be treated as a valid priority
+     * @param {Boolean} [opts.fifo=true]
+     *   Sets whether the pool has LIFO (last in, first out) behaviour with respect to idle objects.
+     *   if false then pool has FIFO behaviour
+     * @param {Boolean} [opts.autostart=true]
+     *   Should the pool start creating resources etc once the constructor is called
+     * @param {Number} [opts.evictionRunIntervalMillis=0]
+     *   How often to run eviction checks.  Default: 0 (does not run).
+     * @param {Number} [opts.numTestsPerEvictionRun=3]
+     *   Number of resources to check each eviction run.  Default: 3.
+     * @param {Number} [opts.softIdleTimeoutMillis=-1]
+     *   amount of time an object may sit idle in the pool before it is eligible
+     *   for eviction by the idle object evictor (if any), with the extra condition
+     *   that at least "min idle" object instances remain in the pool. Default -1 (nothing can get evicted)
+     * @param {Number} [opts.idleTimeoutMillis=30000]
+     *   the minimum amount of time that an object may sit idle in the pool before it is eligible for eviction
+     *   due to idle time. Supercedes "softIdleTimeoutMillis" Default: 30000
+     * @param {typeof Promise} [opts.Promise=Promise]
+     *   What promise implementation should the pool use, defaults to native promises.
+     */
+    constructor(opts) {
+      const poolDefaults = new PoolDefaults();
+      opts = opts || {};
+      this.fifo = typeof opts.fifo === "boolean" ? opts.fifo : poolDefaults.fifo;
+      this.priorityRange = opts.priorityRange || poolDefaults.priorityRange;
+      this.testOnBorrow = typeof opts.testOnBorrow === "boolean" ? opts.testOnBorrow : poolDefaults.testOnBorrow;
+      this.testOnReturn = typeof opts.testOnReturn === "boolean" ? opts.testOnReturn : poolDefaults.testOnReturn;
+      this.autostart = typeof opts.autostart === "boolean" ? opts.autostart : poolDefaults.autostart;
+      if (opts.acquireTimeoutMillis) {
+        this.acquireTimeoutMillis = parseInt(opts.acquireTimeoutMillis, 10);
+      }
+      if (opts.destroyTimeoutMillis) {
+        this.destroyTimeoutMillis = parseInt(opts.destroyTimeoutMillis, 10);
+      }
+      if (opts.maxWaitingClients !== void 0) {
+        this.maxWaitingClients = parseInt(opts.maxWaitingClients, 10);
+      }
+      this.max = parseInt(opts.max, 10);
+      this.min = parseInt(opts.min, 10);
+      this.max = Math.max(isNaN(this.max) ? 1 : this.max, 1);
+      this.min = Math.min(isNaN(this.min) ? 0 : this.min, this.max);
+      this.evictionRunIntervalMillis = opts.evictionRunIntervalMillis || poolDefaults.evictionRunIntervalMillis;
+      this.numTestsPerEvictionRun = opts.numTestsPerEvictionRun || poolDefaults.numTestsPerEvictionRun;
+      this.softIdleTimeoutMillis = opts.softIdleTimeoutMillis || poolDefaults.softIdleTimeoutMillis;
+      this.idleTimeoutMillis = opts.idleTimeoutMillis || poolDefaults.idleTimeoutMillis;
+      this.Promise = opts.Promise != null ? opts.Promise : poolDefaults.Promise;
+    }
+  }
+  PoolOptions_1 = PoolOptions;
+  return PoolOptions_1;
+}
+var Deferred_1;
+var hasRequiredDeferred;
+function requireDeferred() {
+  if (hasRequiredDeferred) return Deferred_1;
+  hasRequiredDeferred = 1;
+  class Deferred {
+    constructor(Promise2) {
+      this._state = Deferred.PENDING;
+      this._resolve = void 0;
+      this._reject = void 0;
+      this._promise = new Promise2((resolve, reject) => {
+        this._resolve = resolve;
+        this._reject = reject;
+      });
+    }
+    get state() {
+      return this._state;
+    }
+    get promise() {
+      return this._promise;
+    }
+    reject(reason) {
+      if (this._state !== Deferred.PENDING) {
+        return;
+      }
+      this._state = Deferred.REJECTED;
+      this._reject(reason);
+    }
+    resolve(value) {
+      if (this._state !== Deferred.PENDING) {
+        return;
+      }
+      this._state = Deferred.FULFILLED;
+      this._resolve(value);
+    }
+  }
+  Deferred.PENDING = "PENDING";
+  Deferred.FULFILLED = "FULFILLED";
+  Deferred.REJECTED = "REJECTED";
+  Deferred_1 = Deferred;
+  return Deferred_1;
+}
+var errors;
+var hasRequiredErrors;
+function requireErrors() {
+  if (hasRequiredErrors) return errors;
+  hasRequiredErrors = 1;
+  class ExtendableError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = this.constructor.name;
+      this.message = message;
+      if (typeof Error.captureStackTrace === "function") {
+        Error.captureStackTrace(this, this.constructor);
+      } else {
+        this.stack = new Error(message).stack;
+      }
+    }
+  }
+  class TimeoutError extends ExtendableError {
+    constructor(m) {
+      super(m);
+    }
+  }
+  errors = {
+    TimeoutError
+  };
+  return errors;
+}
+var ResourceRequest_1;
+var hasRequiredResourceRequest;
+function requireResourceRequest() {
+  if (hasRequiredResourceRequest) return ResourceRequest_1;
+  hasRequiredResourceRequest = 1;
+  const Deferred = requireDeferred();
+  const errors2 = requireErrors();
+  function fbind(fn, ctx) {
+    return function bound() {
+      return fn.apply(ctx, arguments);
+    };
+  }
+  class ResourceRequest extends Deferred {
+    /**
+     * [constructor description]
+     * @param  {Number} ttl     timeout
+     */
+    constructor(ttl, Promise2) {
+      super(Promise2);
+      this._creationTimestamp = Date.now();
+      this._timeout = null;
+      if (ttl !== void 0) {
+        this.setTimeout(ttl);
+      }
+    }
+    setTimeout(delay) {
+      if (this._state !== ResourceRequest.PENDING) {
+        return;
+      }
+      const ttl = parseInt(delay, 10);
+      if (isNaN(ttl) || ttl <= 0) {
+        throw new Error("delay must be a positive int");
+      }
+      const age = Date.now() - this._creationTimestamp;
+      if (this._timeout) {
+        this.removeTimeout();
+      }
+      this._timeout = setTimeout(
+        fbind(this._fireTimeout, this),
+        Math.max(ttl - age, 0)
+      );
+    }
+    removeTimeout() {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      this._timeout = null;
+    }
+    _fireTimeout() {
+      this.reject(new errors2.TimeoutError("ResourceRequest timed out"));
+    }
+    reject(reason) {
+      this.removeTimeout();
+      super.reject(reason);
+    }
+    resolve(value) {
+      this.removeTimeout();
+      super.resolve(value);
+    }
+  }
+  ResourceRequest_1 = ResourceRequest;
+  return ResourceRequest_1;
+}
+var ResourceLoan_1;
+var hasRequiredResourceLoan;
+function requireResourceLoan() {
+  if (hasRequiredResourceLoan) return ResourceLoan_1;
+  hasRequiredResourceLoan = 1;
+  const Deferred = requireDeferred();
+  class ResourceLoan extends Deferred {
+    /**
+     *
+     * @param  {any} pooledResource the PooledResource this loan belongs to
+     * @return {any}                [description]
+     */
+    constructor(pooledResource, Promise2) {
+      super(Promise2);
+      this._creationTimestamp = Date.now();
+      this.pooledResource = pooledResource;
+    }
+    reject() {
+    }
+  }
+  ResourceLoan_1 = ResourceLoan;
+  return ResourceLoan_1;
+}
+var PooledResourceStateEnum_1;
+var hasRequiredPooledResourceStateEnum;
+function requirePooledResourceStateEnum() {
+  if (hasRequiredPooledResourceStateEnum) return PooledResourceStateEnum_1;
+  hasRequiredPooledResourceStateEnum = 1;
+  const PooledResourceStateEnum = {
+    ALLOCATED: "ALLOCATED",
+    // In use
+    IDLE: "IDLE",
+    // In the queue, not in use.
+    INVALID: "INVALID",
+    // Failed validation
+    RETURNING: "RETURNING",
+    // Resource is in process of returning
+    VALIDATION: "VALIDATION"
+    // Currently being tested
+  };
+  PooledResourceStateEnum_1 = PooledResourceStateEnum;
+  return PooledResourceStateEnum_1;
+}
+var PooledResource_1;
+var hasRequiredPooledResource;
+function requirePooledResource() {
+  if (hasRequiredPooledResource) return PooledResource_1;
+  hasRequiredPooledResource = 1;
+  const PooledResourceStateEnum = requirePooledResourceStateEnum();
+  class PooledResource {
+    constructor(resource) {
+      this.creationTime = Date.now();
+      this.lastReturnTime = null;
+      this.lastBorrowTime = null;
+      this.lastIdleTime = null;
+      this.obj = resource;
+      this.state = PooledResourceStateEnum.IDLE;
+    }
+    // mark the resource as "allocated"
+    allocate() {
+      this.lastBorrowTime = Date.now();
+      this.state = PooledResourceStateEnum.ALLOCATED;
+    }
+    // mark the resource as "deallocated"
+    deallocate() {
+      this.lastReturnTime = Date.now();
+      this.state = PooledResourceStateEnum.IDLE;
+    }
+    invalidate() {
+      this.state = PooledResourceStateEnum.INVALID;
+    }
+    test() {
+      this.state = PooledResourceStateEnum.VALIDATION;
+    }
+    idle() {
+      this.lastIdleTime = Date.now();
+      this.state = PooledResourceStateEnum.IDLE;
+    }
+    returning() {
+      this.state = PooledResourceStateEnum.RETURNING;
+    }
+  }
+  PooledResource_1 = PooledResource;
+  return PooledResource_1;
+}
+var DefaultEvictor_1;
+var hasRequiredDefaultEvictor;
+function requireDefaultEvictor() {
+  if (hasRequiredDefaultEvictor) return DefaultEvictor_1;
+  hasRequiredDefaultEvictor = 1;
+  class DefaultEvictor {
+    evict(config, pooledResource, availableObjectsCount) {
+      const idleTime = Date.now() - pooledResource.lastIdleTime;
+      if (config.softIdleTimeoutMillis > 0 && config.softIdleTimeoutMillis < idleTime && config.min < availableObjectsCount) {
+        return true;
+      }
+      if (config.idleTimeoutMillis < idleTime) {
+        return true;
+      }
+      return false;
+    }
+  }
+  DefaultEvictor_1 = DefaultEvictor;
+  return DefaultEvictor_1;
+}
+var DoublyLinkedList_1;
+var hasRequiredDoublyLinkedList;
+function requireDoublyLinkedList() {
+  if (hasRequiredDoublyLinkedList) return DoublyLinkedList_1;
+  hasRequiredDoublyLinkedList = 1;
+  class DoublyLinkedList {
+    constructor() {
+      this.head = null;
+      this.tail = null;
+      this.length = 0;
+    }
+    insertBeginning(node) {
+      if (this.head === null) {
+        this.head = node;
+        this.tail = node;
+        node.prev = null;
+        node.next = null;
+        this.length++;
+      } else {
+        this.insertBefore(this.head, node);
+      }
+    }
+    insertEnd(node) {
+      if (this.tail === null) {
+        this.insertBeginning(node);
+      } else {
+        this.insertAfter(this.tail, node);
+      }
+    }
+    insertAfter(node, newNode) {
+      newNode.prev = node;
+      newNode.next = node.next;
+      if (node.next === null) {
+        this.tail = newNode;
+      } else {
+        node.next.prev = newNode;
+      }
+      node.next = newNode;
+      this.length++;
+    }
+    insertBefore(node, newNode) {
+      newNode.prev = node.prev;
+      newNode.next = node;
+      if (node.prev === null) {
+        this.head = newNode;
+      } else {
+        node.prev.next = newNode;
+      }
+      node.prev = newNode;
+      this.length++;
+    }
+    remove(node) {
+      if (node.prev === null) {
+        this.head = node.next;
+      } else {
+        node.prev.next = node.next;
+      }
+      if (node.next === null) {
+        this.tail = node.prev;
+      } else {
+        node.next.prev = node.prev;
+      }
+      node.prev = null;
+      node.next = null;
+      this.length--;
+    }
+    // FIXME: this should not live here and has become a dumping ground...
+    static createNode(data) {
+      return {
+        prev: null,
+        next: null,
+        data
+      };
+    }
+  }
+  DoublyLinkedList_1 = DoublyLinkedList;
+  return DoublyLinkedList_1;
+}
+var DoublyLinkedListIterator_1;
+var hasRequiredDoublyLinkedListIterator;
+function requireDoublyLinkedListIterator() {
+  if (hasRequiredDoublyLinkedListIterator) return DoublyLinkedListIterator_1;
+  hasRequiredDoublyLinkedListIterator = 1;
+  class DoublyLinkedListIterator {
+    /**
+     * @param  {Object} doublyLinkedList     a node that is part of a doublyLinkedList
+     * @param  {Boolean} [reverse=false]     is this a reverse iterator? default: false
+     */
+    constructor(doublyLinkedList, reverse) {
+      this._list = doublyLinkedList;
+      this._direction = reverse === true ? "prev" : "next";
+      this._startPosition = reverse === true ? "tail" : "head";
+      this._started = false;
+      this._cursor = null;
+      this._done = false;
+    }
+    _start() {
+      this._cursor = this._list[this._startPosition];
+      this._started = true;
+    }
+    _advanceCursor() {
+      if (this._started === false) {
+        this._started = true;
+        this._cursor = this._list[this._startPosition];
+        return;
+      }
+      this._cursor = this._cursor[this._direction];
+    }
+    reset() {
+      this._done = false;
+      this._started = false;
+      this._cursor = null;
+    }
+    remove() {
+      if (this._started === false || this._done === true || this._isCursorDetached()) {
+        return false;
+      }
+      this._list.remove(this._cursor);
+    }
+    next() {
+      if (this._done === true) {
+        return { done: true };
+      }
+      this._advanceCursor();
+      if (this._cursor === null || this._isCursorDetached()) {
+        this._done = true;
+        return { done: true };
+      }
+      return {
+        value: this._cursor,
+        done: false
+      };
+    }
+    /**
+     * Is the node detached from a list?
+     * NOTE: you can trick/bypass/confuse this check by removing a node from one DoublyLinkedList
+     * and adding it to another.
+     * TODO: We can make this smarter by checking the direction of travel and only checking
+     * the required next/prev/head/tail rather than all of them
+     * @return {Boolean}      [description]
+     */
+    _isCursorDetached() {
+      return this._cursor.prev === null && this._cursor.next === null && this._list.tail !== this._cursor && this._list.head !== this._cursor;
+    }
+  }
+  DoublyLinkedListIterator_1 = DoublyLinkedListIterator;
+  return DoublyLinkedListIterator_1;
+}
+var DequeIterator_1;
+var hasRequiredDequeIterator;
+function requireDequeIterator() {
+  if (hasRequiredDequeIterator) return DequeIterator_1;
+  hasRequiredDequeIterator = 1;
+  const DoublyLinkedListIterator = requireDoublyLinkedListIterator();
+  class DequeIterator extends DoublyLinkedListIterator {
+    next() {
+      const result = super.next();
+      if (result.value) {
+        result.value = result.value.data;
+      }
+      return result;
+    }
+  }
+  DequeIterator_1 = DequeIterator;
+  return DequeIterator_1;
+}
+var Deque_1;
+var hasRequiredDeque;
+function requireDeque() {
+  if (hasRequiredDeque) return Deque_1;
+  hasRequiredDeque = 1;
+  const DoublyLinkedList = requireDoublyLinkedList();
+  const DequeIterator = requireDequeIterator();
+  class Deque {
+    constructor() {
+      this._list = new DoublyLinkedList();
+    }
+    /**
+     * removes and returns the first element from the queue
+     * @return {any} [description]
+     */
+    shift() {
+      if (this.length === 0) {
+        return void 0;
+      }
+      const node = this._list.head;
+      this._list.remove(node);
+      return node.data;
+    }
+    /**
+     * adds one elemts to the beginning of the queue
+     * @param  {any} element [description]
+     * @return {any}         [description]
+     */
+    unshift(element) {
+      const node = DoublyLinkedList.createNode(element);
+      this._list.insertBeginning(node);
+    }
+    /**
+     * adds one to the end of the queue
+     * @param  {any} element [description]
+     * @return {any}         [description]
+     */
+    push(element) {
+      const node = DoublyLinkedList.createNode(element);
+      this._list.insertEnd(node);
+    }
+    /**
+     * removes and returns the last element from the queue
+     */
+    pop() {
+      if (this.length === 0) {
+        return void 0;
+      }
+      const node = this._list.tail;
+      this._list.remove(node);
+      return node.data;
+    }
+    [Symbol.iterator]() {
+      return new DequeIterator(this._list);
+    }
+    iterator() {
+      return new DequeIterator(this._list);
+    }
+    reverseIterator() {
+      return new DequeIterator(this._list, true);
+    }
+    /**
+     * get a reference to the item at the head of the queue
+     * @return {any} [description]
+     */
+    get head() {
+      if (this.length === 0) {
+        return void 0;
+      }
+      const node = this._list.head;
+      return node.data;
+    }
+    /**
+     * get a reference to the item at the tail of the queue
+     * @return {any} [description]
+     */
+    get tail() {
+      if (this.length === 0) {
+        return void 0;
+      }
+      const node = this._list.tail;
+      return node.data;
+    }
+    get length() {
+      return this._list.length;
+    }
+  }
+  Deque_1 = Deque;
+  return Deque_1;
+}
+var Queue_1;
+var hasRequiredQueue;
+function requireQueue() {
+  if (hasRequiredQueue) return Queue_1;
+  hasRequiredQueue = 1;
+  const DoublyLinkedList = requireDoublyLinkedList();
+  const Deque = requireDeque();
+  class Queue extends Deque {
+    /**
+     * Adds the obj to the end of the list for this slot
+     * we completely override the parent method because we need access to the
+     * node for our rejection handler
+     * @param {any} resourceRequest [description]
+     */
+    push(resourceRequest) {
+      const node = DoublyLinkedList.createNode(resourceRequest);
+      resourceRequest.promise.catch(this._createTimeoutRejectionHandler(node));
+      this._list.insertEnd(node);
+    }
+    _createTimeoutRejectionHandler(node) {
+      return (reason) => {
+        if (reason.name === "TimeoutError") {
+          this._list.remove(node);
+        }
+      };
+    }
+  }
+  Queue_1 = Queue;
+  return Queue_1;
+}
+var PriorityQueue_1;
+var hasRequiredPriorityQueue;
+function requirePriorityQueue() {
+  if (hasRequiredPriorityQueue) return PriorityQueue_1;
+  hasRequiredPriorityQueue = 1;
+  const Queue = requireQueue();
+  class PriorityQueue {
+    constructor(size) {
+      this._size = Math.max(+size | 0, 1);
+      this._slots = [];
+      for (let i = 0; i < this._size; i++) {
+        this._slots.push(new Queue());
+      }
+    }
+    get length() {
+      let _length = 0;
+      for (let i = 0, slots = this._slots.length; i < slots; i++) {
+        _length += this._slots[i].length;
+      }
+      return _length;
+    }
+    enqueue(obj, priority) {
+      priority = priority && +priority | 0 || 0;
+      if (priority) {
+        if (priority < 0 || priority >= this._size) {
+          priority = this._size - 1;
+        }
+      }
+      this._slots[priority].push(obj);
+    }
+    dequeue() {
+      for (let i = 0, sl = this._slots.length; i < sl; i += 1) {
+        if (this._slots[i].length) {
+          return this._slots[i].shift();
+        }
+      }
+      return;
+    }
+    get head() {
+      for (let i = 0, sl = this._slots.length; i < sl; i += 1) {
+        if (this._slots[i].length > 0) {
+          return this._slots[i].head;
+        }
+      }
+      return;
+    }
+    get tail() {
+      for (let i = this._slots.length - 1; i >= 0; i--) {
+        if (this._slots[i].length > 0) {
+          return this._slots[i].tail;
+        }
+      }
+      return;
+    }
+  }
+  PriorityQueue_1 = PriorityQueue;
+  return PriorityQueue_1;
+}
+var utils = {};
+var hasRequiredUtils;
+function requireUtils() {
+  if (hasRequiredUtils) return utils;
+  hasRequiredUtils = 1;
+  function noop() {
+  }
+  utils.reflector = function(promise) {
+    return promise.then(noop, noop);
+  };
+  return utils;
+}
+var Pool_1;
+var hasRequiredPool;
+function requirePool() {
+  if (hasRequiredPool) return Pool_1;
+  hasRequiredPool = 1;
+  const EventEmitter = requireEvents().EventEmitter;
+  const factoryValidator2 = requireFactoryValidator();
+  const PoolOptions = requirePoolOptions();
+  const ResourceRequest = requireResourceRequest();
+  const ResourceLoan = requireResourceLoan();
+  const PooledResource = requirePooledResource();
+  requireDefaultEvictor();
+  requireDeque();
+  const Deferred = requireDeferred();
+  requirePriorityQueue();
+  requireDequeIterator();
+  const reflector = requireUtils().reflector;
+  const FACTORY_CREATE_ERROR = "factoryCreateError";
+  const FACTORY_DESTROY_ERROR = "factoryDestroyError";
+  class Pool extends EventEmitter {
+    /**
+     * Generate an Object pool with a specified `factory` and `config`.
+     *
+     * @param {typeof DefaultEvictor} Evictor
+     * @param {typeof Deque} Deque
+     * @param {typeof PriorityQueue} PriorityQueue
+     * @param {Object} factory
+     *   Factory to be used for generating and destroying the items.
+     * @param {Function} factory.create
+     *   Should create the item to be acquired,
+     *   and call it's first callback argument with the generated item as it's argument.
+     * @param {Function} factory.destroy
+     *   Should gently close any resources that the item is using.
+     *   Called before the items is destroyed.
+     * @param {Function} factory.validate
+     *   Test if a resource is still valid .Should return a promise that resolves to a boolean, true if resource is still valid and false
+     *   If it should be removed from pool.
+     * @param {Object} options
+     */
+    constructor(Evictor, Deque, PriorityQueue, factory, options) {
+      super();
+      factoryValidator2(factory);
+      this._config = new PoolOptions(options);
+      this._Promise = this._config.Promise;
+      this._factory = factory;
+      this._draining = false;
+      this._started = false;
+      this._waitingClientsQueue = new PriorityQueue(this._config.priorityRange);
+      this._factoryCreateOperations = /* @__PURE__ */ new Set();
+      this._factoryDestroyOperations = /* @__PURE__ */ new Set();
+      this._availableObjects = new Deque();
+      this._testOnBorrowResources = /* @__PURE__ */ new Set();
+      this._testOnReturnResources = /* @__PURE__ */ new Set();
+      this._validationOperations = /* @__PURE__ */ new Set();
+      this._allObjects = /* @__PURE__ */ new Set();
+      this._resourceLoans = /* @__PURE__ */ new Map();
+      this._evictionIterator = this._availableObjects.iterator();
+      this._evictor = new Evictor();
+      this._scheduledEviction = null;
+      if (this._config.autostart === true) {
+        this.start();
+      }
+    }
+    _destroy(pooledResource) {
+      pooledResource.invalidate();
+      this._allObjects.delete(pooledResource);
+      const destroyPromise = this._factory.destroy(pooledResource.obj);
+      const wrappedDestroyPromise = this._config.destroyTimeoutMillis ? this._Promise.resolve(this._applyDestroyTimeout(destroyPromise)) : this._Promise.resolve(destroyPromise);
+      this._trackOperation(
+        wrappedDestroyPromise,
+        this._factoryDestroyOperations
+      ).catch((reason) => {
+        this.emit(FACTORY_DESTROY_ERROR, reason);
+      });
+      this._ensureMinimum();
+    }
+    _applyDestroyTimeout(promise) {
+      const timeoutPromise = new this._Promise((resolve, reject) => {
+        setTimeout(() => {
+          reject(new Error("destroy timed out"));
+        }, this._config.destroyTimeoutMillis).unref();
+      });
+      return this._Promise.race([timeoutPromise, promise]);
+    }
+    /**
+     * Attempt to move an available resource into test and then onto a waiting client
+     * @return {Boolean} could we move an available resource into test
+     */
+    _testOnBorrow() {
+      if (this._availableObjects.length < 1) {
+        return false;
+      }
+      const pooledResource = this._availableObjects.shift();
+      pooledResource.test();
+      this._testOnBorrowResources.add(pooledResource);
+      const validationPromise = this._factory.validate(pooledResource.obj);
+      const wrappedValidationPromise = this._Promise.resolve(validationPromise);
+      this._trackOperation(
+        wrappedValidationPromise,
+        this._validationOperations
+      ).then((isValid) => {
+        this._testOnBorrowResources.delete(pooledResource);
+        if (isValid === false) {
+          pooledResource.invalidate();
+          this._destroy(pooledResource);
+          this._dispense();
+          return;
+        }
+        this._dispatchPooledResourceToNextWaitingClient(pooledResource);
+      });
+      return true;
+    }
+    /**
+     * Attempt to move an available resource to a waiting client
+     * @return {Boolean} [description]
+     */
+    _dispatchResource() {
+      if (this._availableObjects.length < 1) {
+        return false;
+      }
+      const pooledResource = this._availableObjects.shift();
+      this._dispatchPooledResourceToNextWaitingClient(pooledResource);
+      return false;
+    }
+    /**
+     * Attempt to resolve an outstanding resource request using an available resource from
+     * the pool, or creating new ones
+     *
+     * @private
+     */
+    _dispense() {
+      const numWaitingClients = this._waitingClientsQueue.length;
+      if (numWaitingClients < 1) {
+        return;
+      }
+      const resourceShortfall = numWaitingClients - this._potentiallyAllocableResourceCount;
+      const actualNumberOfResourcesToCreate = Math.min(
+        this.spareResourceCapacity,
+        resourceShortfall
+      );
+      for (let i = 0; actualNumberOfResourcesToCreate > i; i++) {
+        this._createResource();
+      }
+      if (this._config.testOnBorrow === true) {
+        const desiredNumberOfResourcesToMoveIntoTest = numWaitingClients - this._testOnBorrowResources.size;
+        const actualNumberOfResourcesToMoveIntoTest = Math.min(
+          this._availableObjects.length,
+          desiredNumberOfResourcesToMoveIntoTest
+        );
+        for (let i = 0; actualNumberOfResourcesToMoveIntoTest > i; i++) {
+          this._testOnBorrow();
+        }
+      }
+      if (this._config.testOnBorrow === false) {
+        const actualNumberOfResourcesToDispatch = Math.min(
+          this._availableObjects.length,
+          numWaitingClients
+        );
+        for (let i = 0; actualNumberOfResourcesToDispatch > i; i++) {
+          this._dispatchResource();
+        }
+      }
+    }
+    /**
+     * Dispatches a pooledResource to the next waiting client (if any) else
+     * puts the PooledResource back on the available list
+     * @param  {PooledResource} pooledResource [description]
+     * @return {Boolean}                [description]
+     */
+    _dispatchPooledResourceToNextWaitingClient(pooledResource) {
+      const clientResourceRequest = this._waitingClientsQueue.dequeue();
+      if (clientResourceRequest === void 0 || clientResourceRequest.state !== Deferred.PENDING) {
+        this._addPooledResourceToAvailableObjects(pooledResource);
+        return false;
+      }
+      const loan = new ResourceLoan(pooledResource, this._Promise);
+      this._resourceLoans.set(pooledResource.obj, loan);
+      pooledResource.allocate();
+      clientResourceRequest.resolve(pooledResource.obj);
+      return true;
+    }
+    /**
+     * tracks on operation using given set
+     * handles adding/removing from the set and resolve/rejects the value/reason
+     * @param  {Promise} operation
+     * @param  {Set} set       Set holding operations
+     * @return {Promise}       Promise that resolves once operation has been removed from set
+     */
+    _trackOperation(operation, set) {
+      set.add(operation);
+      return operation.then(
+        (v) => {
+          set.delete(operation);
+          return this._Promise.resolve(v);
+        },
+        (e) => {
+          set.delete(operation);
+          return this._Promise.reject(e);
+        }
+      );
+    }
+    /**
+     * @private
+     */
+    _createResource() {
+      const factoryPromise = this._factory.create();
+      const wrappedFactoryPromise = this._Promise.resolve(factoryPromise).then((resource) => {
+        const pooledResource = new PooledResource(resource);
+        this._allObjects.add(pooledResource);
+        this._addPooledResourceToAvailableObjects(pooledResource);
+      });
+      this._trackOperation(wrappedFactoryPromise, this._factoryCreateOperations).then(() => {
+        this._dispense();
+        return null;
+      }).catch((reason) => {
+        this.emit(FACTORY_CREATE_ERROR, reason);
+        this._dispense();
+      });
+    }
+    /**
+     * @private
+     */
+    _ensureMinimum() {
+      if (this._draining === true) {
+        return;
+      }
+      const minShortfall = this._config.min - this._count;
+      for (let i = 0; i < minShortfall; i++) {
+        this._createResource();
+      }
+    }
+    _evict() {
+      const testsToRun = Math.min(
+        this._config.numTestsPerEvictionRun,
+        this._availableObjects.length
+      );
+      const evictionConfig = {
+        softIdleTimeoutMillis: this._config.softIdleTimeoutMillis,
+        idleTimeoutMillis: this._config.idleTimeoutMillis,
+        min: this._config.min
+      };
+      for (let testsHaveRun = 0; testsHaveRun < testsToRun; ) {
+        const iterationResult = this._evictionIterator.next();
+        if (iterationResult.done === true && this._availableObjects.length < 1) {
+          this._evictionIterator.reset();
+          return;
+        }
+        if (iterationResult.done === true && this._availableObjects.length > 0) {
+          this._evictionIterator.reset();
+          continue;
+        }
+        const resource = iterationResult.value;
+        const shouldEvict = this._evictor.evict(
+          evictionConfig,
+          resource,
+          this._availableObjects.length
+        );
+        testsHaveRun++;
+        if (shouldEvict === true) {
+          this._evictionIterator.remove();
+          this._destroy(resource);
+        }
+      }
+    }
+    _scheduleEvictorRun() {
+      if (this._config.evictionRunIntervalMillis > 0) {
+        this._scheduledEviction = setTimeout(() => {
+          this._evict();
+          this._scheduleEvictorRun();
+        }, this._config.evictionRunIntervalMillis).unref();
+      }
+    }
+    _descheduleEvictorRun() {
+      if (this._scheduledEviction) {
+        clearTimeout(this._scheduledEviction);
+      }
+      this._scheduledEviction = null;
+    }
+    start() {
+      if (this._draining === true) {
+        return;
+      }
+      if (this._started === true) {
+        return;
+      }
+      this._started = true;
+      this._scheduleEvictorRun();
+      this._ensureMinimum();
+    }
+    /**
+     * Request a new resource. The callback will be called,
+     * when a new resource is available, passing the resource to the callback.
+     * TODO: should we add a seperate "acquireWithPriority" function
+     *
+     * @param {Number} [priority=0]
+     *   Optional.  Integer between 0 and (priorityRange - 1).  Specifies the priority
+     *   of the caller if there are no available resources.  Lower numbers mean higher
+     *   priority.
+     *
+     * @returns {Promise}
+     */
+    acquire(priority) {
+      if (this._started === false && this._config.autostart === false) {
+        this.start();
+      }
+      if (this._draining) {
+        return this._Promise.reject(
+          new Error("pool is draining and cannot accept work")
+        );
+      }
+      if (this.spareResourceCapacity < 1 && this._availableObjects.length < 1 && this._config.maxWaitingClients !== void 0 && this._waitingClientsQueue.length >= this._config.maxWaitingClients) {
+        return this._Promise.reject(
+          new Error("max waitingClients count exceeded")
+        );
+      }
+      const resourceRequest = new ResourceRequest(
+        this._config.acquireTimeoutMillis,
+        this._Promise
+      );
+      this._waitingClientsQueue.enqueue(resourceRequest, priority);
+      this._dispense();
+      return resourceRequest.promise;
+    }
+    /**
+     * [use method, aquires a resource, passes the resource to a user supplied function and releases it]
+     * @param  {Function} fn [a function that accepts a resource and returns a promise that resolves/rejects once it has finished using the resource]
+     * @return {Promise}      [resolves once the resource is released to the pool]
+     */
+    use(fn, priority) {
+      return this.acquire(priority).then((resource) => {
+        return fn(resource).then(
+          (result) => {
+            this.release(resource);
+            return result;
+          },
+          (err) => {
+            this.destroy(resource);
+            throw err;
+          }
+        );
+      });
+    }
+    /**
+     * Check if resource is currently on loan from the pool
+     *
+     * @param {Function} resource
+     *    Resource for checking.
+     *
+     * @returns {Boolean}
+     *  True if resource belongs to this pool and false otherwise
+     */
+    isBorrowedResource(resource) {
+      return this._resourceLoans.has(resource);
+    }
+    /**
+     * Return the resource to the pool when it is no longer required.
+     *
+     * @param {Object} resource
+     *   The acquired object to be put back to the pool.
+     */
+    release(resource) {
+      const loan = this._resourceLoans.get(resource);
+      if (loan === void 0) {
+        return this._Promise.reject(
+          new Error("Resource not currently part of this pool")
+        );
+      }
+      this._resourceLoans.delete(resource);
+      loan.resolve();
+      const pooledResource = loan.pooledResource;
+      pooledResource.deallocate();
+      this._addPooledResourceToAvailableObjects(pooledResource);
+      this._dispense();
+      return this._Promise.resolve();
+    }
+    /**
+     * Request the resource to be destroyed. The factory's destroy handler
+     * will also be called.
+     *
+     * This should be called within an acquire() block as an alternative to release().
+     *
+     * @param {Object} resource
+     *   The acquired resource to be destoyed.
+     */
+    destroy(resource) {
+      const loan = this._resourceLoans.get(resource);
+      if (loan === void 0) {
+        return this._Promise.reject(
+          new Error("Resource not currently part of this pool")
+        );
+      }
+      this._resourceLoans.delete(resource);
+      loan.resolve();
+      const pooledResource = loan.pooledResource;
+      pooledResource.deallocate();
+      this._destroy(pooledResource);
+      this._dispense();
+      return this._Promise.resolve();
+    }
+    _addPooledResourceToAvailableObjects(pooledResource) {
+      pooledResource.idle();
+      if (this._config.fifo === true) {
+        this._availableObjects.push(pooledResource);
+      } else {
+        this._availableObjects.unshift(pooledResource);
+      }
+    }
+    /**
+     * Disallow any new acquire calls and let the request backlog dissapate.
+     * The Pool will no longer attempt to maintain a "min" number of resources
+     * and will only make new resources on demand.
+     * Resolves once all resource requests are fulfilled and all resources are returned to pool and available...
+     * Should probably be called "drain work"
+     * @returns {Promise}
+     */
+    drain() {
+      this._draining = true;
+      return this.__allResourceRequestsSettled().then(() => {
+        return this.__allResourcesReturned();
+      }).then(() => {
+        this._descheduleEvictorRun();
+      });
+    }
+    __allResourceRequestsSettled() {
+      if (this._waitingClientsQueue.length > 0) {
+        return reflector(this._waitingClientsQueue.tail.promise);
+      }
+      return this._Promise.resolve();
+    }
+    // FIXME: this is a horrific mess
+    __allResourcesReturned() {
+      const ps = Array.from(this._resourceLoans.values()).map((loan) => loan.promise).map(reflector);
+      return this._Promise.all(ps);
+    }
+    /**
+     * Forcibly destroys all available resources regardless of timeout.  Intended to be
+     * invoked as part of a drain.  Does not prevent the creation of new
+     * resources as a result of subsequent calls to acquire.
+     *
+     * Note that if factory.min > 0 and the pool isn't "draining", the pool will destroy all idle resources
+     * in the pool, but replace them with newly created resources up to the
+     * specified factory.min value.  If this is not desired, set factory.min
+     * to zero before calling clear()
+     *
+     */
+    clear() {
+      const reflectedCreatePromises = Array.from(
+        this._factoryCreateOperations
+      ).map(reflector);
+      return this._Promise.all(reflectedCreatePromises).then(() => {
+        for (const resource of this._availableObjects) {
+          this._destroy(resource);
+        }
+        const reflectedDestroyPromises = Array.from(
+          this._factoryDestroyOperations
+        ).map(reflector);
+        return reflector(this._Promise.all(reflectedDestroyPromises));
+      });
+    }
+    /**
+     * Waits until the pool is ready.
+     * We define ready by checking if the current resource number is at least
+     * the minimum number defined.
+     * @returns {Promise} that resolves when the minimum number is ready.
+     */
+    ready() {
+      return new this._Promise((resolve) => {
+        const isReady = () => {
+          if (this.available >= this.min) {
+            resolve();
+          } else {
+            setTimeout(isReady, 100);
+          }
+        };
+        isReady();
+      });
+    }
+    /**
+     * How many resources are available to allocated
+     * (includes resources that have not been tested and may faul validation)
+     * NOTE: internal for now as the name is awful and might not be useful to anyone
+     * @return {Number} number of resources the pool has to allocate
+     */
+    get _potentiallyAllocableResourceCount() {
+      return this._availableObjects.length + this._testOnBorrowResources.size + this._testOnReturnResources.size + this._factoryCreateOperations.size;
+    }
+    /**
+     * The combined count of the currently created objects and those in the
+     * process of being created
+     * Does NOT include resources in the process of being destroyed
+     * sort of legacy...
+     * @return {Number}
+     */
+    get _count() {
+      return this._allObjects.size + this._factoryCreateOperations.size;
+    }
+    /**
+     * How many more resources does the pool have room for
+     * @return {Number} number of resources the pool could create before hitting any limits
+     */
+    get spareResourceCapacity() {
+      return this._config.max - (this._allObjects.size + this._factoryCreateOperations.size);
+    }
+    /**
+     * see _count above
+     * @return {Number} [description]
+     */
+    get size() {
+      return this._count;
+    }
+    /**
+     * number of available resources
+     * @return {Number} [description]
+     */
+    get available() {
+      return this._availableObjects.length;
+    }
+    /**
+     * number of resources that are currently acquired
+     * @return {Number} [description]
+     */
+    get borrowed() {
+      return this._resourceLoans.size;
+    }
+    /**
+     * number of waiting acquire calls
+     * @return {Number} [description]
+     */
+    get pending() {
+      return this._waitingClientsQueue.length;
+    }
+    /**
+     * maximum size of the pool
+     * @return {Number} [description]
+     */
+    get max() {
+      return this._config.max;
+    }
+    /**
+     * minimum size of the pool
+     * @return {Number} [description]
+     */
+    get min() {
+      return this._config.min;
+    }
+  }
+  Pool_1 = Pool;
+  return Pool_1;
+}
+var genericPool$1;
+var hasRequiredGenericPool;
+function requireGenericPool() {
+  if (hasRequiredGenericPool) return genericPool$1;
+  hasRequiredGenericPool = 1;
+  const Pool = requirePool();
+  const Deque = requireDeque();
+  const PriorityQueue = requirePriorityQueue();
+  const DefaultEvictor = requireDefaultEvictor();
+  genericPool$1 = {
+    Pool,
+    Deque,
+    PriorityQueue,
+    DefaultEvictor,
+    createPool: function(factory, config) {
+      return new Pool(DefaultEvictor, Deque, PriorityQueue, factory, config);
+    }
+  };
+  return genericPool$1;
+}
+var genericPoolExports = requireGenericPool();
+const genericPool = /* @__PURE__ */ getDefaultExportFromCjs(genericPoolExports);
+const workerFactory = {
+  create: async () => {
+    const workerPath = new URL("data:video/mp2t;base64,aW1wb3J0IHsgTWVzaERhdGEgfSBmcm9tICdAL3R5cGVzJzsKaW1wb3J0ICogYXMgQ29tbGluayBmcm9tICdjb21saW5rJzsKaW1wb3J0ICogYXMgVEhSRUUgZnJvbSAndGhyZWUnOwppbXBvcnQgeyBNZXNoU3VyZmFjZVNhbXBsZXIgfSBmcm9tICd0aHJlZS9leGFtcGxlcy9qc20vbWF0aC9NZXNoU3VyZmFjZVNhbXBsZXInOwoKZXhwb3J0IGludGVyZmFjZSBNZXNoU2FtcGxlckFQSSB7CiAgc2FtcGxlTWVzaDogKG1lc2hEYXRhOiBNZXNoRGF0YSwgc2l6ZTogbnVtYmVyKSA9PiBQcm9taXNlPEZsb2F0MzJBcnJheT47Cn0KCmNvbnN0IGFwaSA9IHsKICBzYW1wbGVNZXNoOiAobWVzaERhdGE6IE1lc2hEYXRhLCBzaXplOiBudW1iZXIpOiBGbG9hdDMyQXJyYXkgPT4gewogICAgY29uc3QgZ2VvbWV0cnkgPSBuZXcgVEhSRUUuQnVmZmVyR2VvbWV0cnkoKTsKICAgIGdlb21ldHJ5LnNldEF0dHJpYnV0ZSgncG9zaXRpb24nLCBuZXcgVEhSRUUuQnVmZmVyQXR0cmlidXRlKG5ldyBGbG9hdDMyQXJyYXkobWVzaERhdGEucG9zaXRpb24pLCAzKSk7CiAgICBpZiAobWVzaERhdGEubm9ybWFsKSB7CiAgICAgIGdlb21ldHJ5LnNldEF0dHJpYnV0ZSgnbm9ybWFsJywgbmV3IFRIUkVFLkJ1ZmZlckF0dHJpYnV0ZShuZXcgRmxvYXQzMkFycmF5KG1lc2hEYXRhLm5vcm1hbCksIDMpKTsKICAgIH0KICAgIGNvbnN0IG1hdGVyaWFsID0gbmV3IFRIUkVFLk1lc2hCYXNpY01hdGVyaWFsKCk7CiAgICBjb25zdCBtZXNoID0gbmV3IFRIUkVFLk1lc2goZ2VvbWV0cnksIG1hdGVyaWFsKTsKICAgIG1lc2guc2NhbGUuc2V0KG1lc2hEYXRhLnNjYWxlLngsIG1lc2hEYXRhLnNjYWxlLnksIG1lc2hEYXRhLnNjYWxlLnopOwoKICAgIGNvbnN0IHNhbXBsZXIgPSBuZXcgTWVzaFN1cmZhY2VTYW1wbGVyKG1lc2gpLmJ1aWxkKCk7CiAgICBjb25zdCBkYXRhID0gbmV3IEZsb2F0MzJBcnJheShzaXplICogc2l6ZSAqIDQpOwogICAgY29uc3QgcG9zaXRpb24gPSBuZXcgVEhSRUUuVmVjdG9yMygpOwoKICAgIGZvciAobGV0IGkgPSAwOyBpIDwgc2l6ZTsgaSsrKSB7CiAgICAgIGZvciAobGV0IGogPSAwOyBqIDwgc2l6ZTsgaisrKSB7CiAgICAgICAgY29uc3QgaW5kZXggPSBpICogc2l6ZSArIGo7CiAgICAgICAgc2FtcGxlci5zYW1wbGUocG9zaXRpb24pOwogICAgICAgIGRhdGFbNCAqIGluZGV4XSA9IHBvc2l0aW9uLnggKiBtZXNoRGF0YS5zY2FsZS54OwogICAgICAgIGRhdGFbNCAqIGluZGV4ICsgMV0gPSBwb3NpdGlvbi55ICogbWVzaERhdGEuc2NhbGUueTsKICAgICAgICBkYXRhWzQgKiBpbmRleCArIDJdID0gcG9zaXRpb24ueiAqIG1lc2hEYXRhLnNjYWxlLno7CiAgICAgICAgZGF0YVs0ICogaW5kZXggKyAzXSA9IChNYXRoLnJhbmRvbSgpIC0gMC41KSAqIDAuMDE7CiAgICAgIH0KICAgIH0KCiAgICByZXR1cm4gZGF0YTsKICB9LAp9OwoKQ29tbGluay5leHBvc2UoYXBpKTsK", import.meta.url);
+    const worker = new Worker(workerPath, { type: "module" });
+    return wrap(worker);
+  },
+  destroy: async (worker) => {
+    return worker[releaseProxy]();
+  }
+};
+const pool = genericPool.createPool(workerFactory, {
+  max: navigator.hardwareConcurrency || 4,
+  min: 2
+});
+function createDataTexture(data, size) {
+  const texture = new THREE.DataTexture(data, size, size, THREE.RGBAFormat, THREE.FloatType);
+  texture.needsUpdate = true;
+  return texture;
+}
+function createBlankDataTexture(size) {
+  return createDataTexture(new Float32Array(4 * size * size), size);
+}
+function createSpherePoints(size) {
+  const data = new Float32Array(size * size * 4);
+  for (let i = 0; i < size; i++) {
+    for (let j = 0; j < size; j++) {
+      const index = i * size + j;
+      let theta = Math.random() * Math.PI * 2;
+      let phi = Math.acos(Math.random() * 2 - 1);
+      let x = Math.sin(phi) * Math.cos(theta);
+      let y = Math.sin(phi) * Math.sin(theta);
+      let z = Math.cos(phi);
+      data[4 * index] = x;
+      data[4 * index + 1] = y;
+      data[4 * index + 2] = z;
+      data[4 * index + 3] = (Math.random() - 0.5) * 0.01;
+    }
+  }
+  return createDataTexture(data, size);
+}
+function copyOf(source) {
+  const map = /* @__PURE__ */ new Map();
+  if (source) {
+    if (Array.isArray(source)) {
+      source.forEach(({ id, item }) => map.set(id, item));
+    } else {
+      map.set(source.id, source.item);
+    }
+  }
+  return map;
+}
+function clamp(value, min, max) {
+  value = Math.min(value, max);
+  value = Math.max(value, min);
+  return value;
+}
+class DataTextureService {
+  /**
+   * Creates a new DataTextureManager instance.
+   * @param eventEmitter
+   * @param textureSize
+   * @param meshes Optional initial meshes.
+   */
+  constructor(eventEmitter, textureSize, meshes) {
+    __publicField(this, "textureSize");
+    __publicField(this, "meshes");
+    __publicField(this, "dataTextures");
+    __publicField(this, "eventEmitter");
+    this.eventEmitter = eventEmitter;
+    this.textureSize = textureSize;
+    this.meshes = copyOf(meshes);
+    this.dataTextures = /* @__PURE__ */ new Map();
+    this.updateServiceState("ready");
+  }
+  /**
+   * Registers a mesh.
+   * @param id The ID of the mesh.
+   * @param mesh The mesh to register.
+   */
+  async register(id, mesh) {
+    this.meshes.set(id, mesh);
+  }
+  setTextureSize(textureSize) {
+    if (this.textureSize === textureSize) return;
+    this.textureSize = textureSize;
+    this.dataTextures.forEach((texture) => texture.dispose());
+    this.dataTextures.clear();
+  }
+  getMesh(id) {
+    return this.meshes.get(id);
+  }
+  /**
+   * Gets the data texture for the specified mesh ID and current texture size.
+   * Returns the fallback data texture if the specified mesh ID is not found.
+   * @param id The ID of the mesh.
+   * @returns The data texture, or undefined if not found and no fallback is available.
+   */
+  async getDataTexture(id) {
+    return await this.prepareMesh(id);
+  }
+  /**
+   * Prepares a mesh for sampling.
+   * @param id The ID of the mesh to prepare.
+   */
+  async prepareMesh(id) {
+    if (!this.meshes.has(id)) {
+      throw new Error(`Mesh with id "${id}" does not exist.`);
+    }
+    const texture = this.dataTextures.get(id);
+    if (texture) {
+      return texture;
+    }
+    const mesh = this.meshes.get(id);
+    const meshData = parseMeshData(mesh);
+    const worker = await pool.acquire();
+    try {
+      const data = await worker.sampleMesh(meshData, this.textureSize);
+      const texture2 = createDataTexture(data, this.textureSize);
+      texture2.name = id;
+      return texture2;
+    } finally {
+      await pool.release(worker);
+    }
+  }
+  async dispose() {
+    this.meshes.clear();
+    this.dataTextures.clear();
+    this.updateServiceState("disposed");
+  }
+  updateServiceState(serviceState) {
+    this.eventEmitter.emit("serviceStateUpdated", { type: "data-texture", state: serviceState });
+  }
+}
+function parseMeshData(mesh) {
+  var _a;
+  return {
+    position: mesh.geometry.attributes.position.array,
+    normal: (_a = mesh.geometry.attributes.normal) == null ? void 0 : _a.array,
+    scale: { x: mesh.scale.x, y: mesh.scale.y, z: mesh.scale.z }
+  };
+}
+const instanceFragmentShader = `
+varying vec2 vUv;
+uniform sampler2D uTexture;
+
+uniform sampler2D uSourceMatcap;
+uniform sampler2D uTargetMatcap;
+
+uniform float uProgress;
+varying vec3 vNormal;
+varying vec3 vViewPosition;
+void main() {
+    vec3 viewDir = normalize( vViewPosition );
+    vec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );
+    vec3 y = cross( viewDir, x );
+    vec2 uv = vec2( dot( x, vNormal ), dot( y, vNormal ) ) * 0.495 + 0.5; // 0.495 to remove artifacts caused by undersized matcap disks
+
+    vec4 sourceMatcap = texture2D( uSourceMatcap, uv );
+    vec4 targetMatcap = texture2D( uTargetMatcap, uv );
+
+    vec4 matcap = mix(sourceMatcap, targetMatcap, uProgress);
+    gl_FragColor = matcap;
+}
+`;
+const instanceVertexShader = `
+varying vec2 vUv;
+uniform sampler2D uTexture;
+uniform sampler2D uVelocity;
+uniform float uTime;
+varying vec3 vNormal;
+attribute vec2 uvRef;
+varying vec3 vViewPosition;
+
+vec3 rotate3D(vec3 v, vec3 vel) {
+    vec3 pos = v;
+    vec3 up = vec3(0, 1, 0);
+    vec3 axis = normalize(cross(up, vel));
+    float angle = acos(dot(up, normalize(vel)));
+    pos = pos * cos(angle) + cross(axis, pos) * sin(angle) + axis * dot(axis, pos) * (1. - cos(angle));
+    return pos;
+}
+
+void main() {
+    vUv = uv;
+    vNormal = normal;
+
+    vec4 color = texture2D(uTexture, uvRef);
+    vec4 velocity = texture2D(uVelocity, uvRef);
+    vec3 pos = color.xyz;// apply the texture to the vertex distribution.
+
+    vec3 localPosition = position.xyz;
+    if (length (velocity.xyz) < 0.0001) {
+        velocity.xyz = vec3(0.0, 0.0001, 0.0001);
+    }
+    localPosition.y *= max(1.0, length(velocity.xyz) * 1000.0);
+    localPosition = rotate3D(localPosition, velocity.xyz);
+    vNormal = rotate3D(normal, velocity.xyz);
+
+    mat4 instanceMat = instanceMatrix;
+    instanceMat[3].xyz = pos.xyz;
+
+    // unlike the traditional mvMatrix * position, we need to additional multiplication with the instance matrix.
+    vec4 modelViewPosition = modelViewMatrix * instanceMat * vec4(localPosition, 1.0);
+
+    vViewPosition = - modelViewPosition.xyz;
+
+    gl_Position = projectionMatrix * modelViewPosition;
+}
+`;
+class InstancedMeshManager {
+  /**
+   * Creates a new InstancedMeshManager instance.
+   * @param initialSize The initial size of the instanced mesh.
+   */
+  constructor(initialSize) {
+    __publicField(this, "size");
+    __publicField(this, "mesh");
+    __publicField(this, "matcapMaterial");
+    __publicField(this, "fallbackMaterial");
+    __publicField(this, "fallbackGeometry");
+    __publicField(this, "materials");
+    __publicField(this, "geometries");
+    __publicField(this, "uvRefsCache");
+    __publicField(this, "previousScale");
+    this.size = initialSize;
+    this.materials = /* @__PURE__ */ new Map();
+    this.geometries = /* @__PURE__ */ new Map();
+    this.uvRefsCache = /* @__PURE__ */ new Map();
+    this.previousScale = { x: 1, y: 1, z: 1 };
+    this.matcapMaterial = new THREE.ShaderMaterial({
+      uniforms: {
+        uTime: { value: 0 },
+        uProgress: { value: 0 },
+        uTexture: { value: null },
+        uVelocity: { value: null },
+        uSourceMatcap: { value: null },
+        uTargetMatcap: { value: null }
+      },
+      vertexShader: instanceVertexShader,
+      fragmentShader: instanceFragmentShader
+    });
+    this.fallbackMaterial = new THREE.MeshBasicMaterial({ color: 16777215 });
+    this.fallbackGeometry = new THREE.BoxGeometry(1e-3, 1e-3, 1e-3);
+    this.mesh = this.createInstancedMesh(initialSize, this.fallbackGeometry, this.fallbackMaterial);
+  }
+  /**
+   * Gets the instanced mesh.
+   * @returns The instanced mesh.
+   */
+  getMesh() {
+    return this.mesh;
+  }
+  /**
+   * Updates the instanced mesh.
+   * @param elapsedTime The elapsed time.
+   */
+  update(elapsedTime) {
+    const material = this.mesh.material;
+    if (material instanceof THREE.ShaderMaterial || material instanceof THREE.RawShaderMaterial) {
+      material.uniforms.uTime.value = elapsedTime;
+    }
+  }
+  /**
+   * Sets the matcap texture.
+   * @param matcap The matcap texture to set.
+   */
+  setOriginMatcap(matcap) {
+    console.log("set source matcap", matcap);
+    this.matcapMaterial.uniforms.uSourceMatcap.value = matcap;
+  }
+  setDestinationMatcap(matcap) {
+    console.log("set target matcap", matcap);
+    this.matcapMaterial.uniforms.uTargetMatcap.value = matcap;
+  }
+  setProgress(float) {
+    float = Math.max(0, float);
+    float = Math.min(1, float);
+    this.matcapMaterial.uniforms.uProgress.value = float;
+  }
+  setGeometrySize(size) {
+    this.mesh.geometry.scale(1 / this.previousScale.x, 1 / this.previousScale.y, 1 / this.previousScale.z);
+    this.mesh.geometry.scale(size.x, size.y, size.z);
+    this.previousScale = size;
+  }
+  /**
+   * Use the matcap material for the instanced mesh.
+   */
+  useMatcapMaterial() {
+    console.log("Using matcap material");
+    this.mesh.material = this.matcapMaterial;
+  }
+  /**
+   * Use the specified material for the instanced mesh.
+   * @param id The ID of the material to use.
+   */
+  useMaterial(id) {
+    const material = this.materials.get(id);
+    if (material) {
+      this.mesh.material = material;
+    } else {
+      console.warn(`material with id "${id}" not found`);
+    }
+  }
+  /**
+   * Use the specified geometry for the instanced mesh.
+   * @param id The ID of the geometry to use.
+   */
+  useGeometry(id) {
+    const geometry = this.geometries.get(id);
+    if (geometry) {
+      this.mesh.geometry = geometry;
+    } else {
+      console.warn(`geometry with id "${id}" not found`);
+    }
+  }
+  /**
+   * Updates the velocity texture.
+   * @param texture The velocity texture to update with.
+   */
+  updateVelocityTexture(texture) {
+    this.matcapMaterial.uniforms.uVelocity.value = texture;
+  }
+  /**
+   * Updates the position texture.
+   * @param texture The position texture to update with.
+   */
+  updatePositionTexture(texture) {
+    this.matcapMaterial.uniforms.uTexture.value = texture;
+  }
+  /**
+   * Resizes or replaces the instanced mesh.
+   * @param size The new size of the instanced mesh.
+   * @returns An object containing the updated mesh, the previous mesh, and a boolean indicating whether the mesh was updated.
+   */
+  resize(size) {
+    if (this.size === size) return { current: this.mesh, previous: this.mesh };
+    this.size = size;
+    const prev = this.mesh;
+    this.mesh = this.createInstancedMesh(size, prev.geometry, prev.material);
+    return { current: this.mesh, previous: prev };
+  }
+  /**
+   * Disposes the resources used by the InstancedMeshManager.
+   */
+  dispose() {
+    this.mesh.dispose();
+    this.geometries.forEach((geometry) => geometry.dispose());
+    this.materials.forEach((material) => material.dispose());
+    this.uvRefsCache.clear();
+    this.geometries.clear();
+    this.materials.clear();
+  }
+  /**
+   * Registers a geometry.
+   * @param id The ID of the geometry to register.
+   * @param geometry The geometry to register.
+   */
+  registerGeometry(id, geometry) {
+    const previous = this.geometries.get(id);
+    if (previous) {
+      if (previous === geometry) {
+        return;
+      }
+      console.log(`geometry with id "${id}" already exists. replacing...`);
+    }
+    const uvRefs = this.getUVRefs(this.size);
+    geometry.setAttribute("uvRef", uvRefs);
+    this.geometries.set(id, geometry);
+    if (this.mesh.geometry === previous) {
+      this.mesh.geometry = geometry;
+    }
+    previous == null ? void 0 : previous.dispose();
+  }
+  /**
+   * Registers a material.
+   * @param id The ID of the material to register.
+   * @param material The material to register.
+   */
+  registerMaterial(id, material) {
+    const previous = this.materials.get(id);
+    if (previous) {
+      if (previous === material) {
+        return;
+      }
+      console.log(`material with id "${id}" already exists. replacing...`);
+    }
+    if (this.mesh.material === previous) {
+      this.mesh.material = material;
+    }
+    this.materials.set(id, material);
+    previous == null ? void 0 : previous.dispose();
+  }
+  /**
+   * Gets the UV references for the specified size.
+   * @param size The size for which to generate UV references.
+   * @returns The UV references.
+   */
+  getUVRefs(size) {
+    const cached = this.uvRefsCache.get(size);
+    if (cached) {
+      return cached;
+    }
+    const uvRefs = new Float32Array(size * size * 2);
+    for (let i = 0; i < size; i++) {
+      for (let j = 0; j < size; j++) {
+        const index = i * size + j;
+        uvRefs[2 * index] = j / (size - 1);
+        uvRefs[2 * index + 1] = i / (size - 1);
+      }
+    }
+    const attr = new THREE.InstancedBufferAttribute(uvRefs, 2);
+    this.uvRefsCache.set(size, attr);
+    return attr;
+  }
+  /**
+   * Creates a new instanced mesh.
+   * @param size The size of the instanced mesh.
+   * @param geometry The geometry to use for the instanced mesh.
+   * @param material The material to use for the instanced mesh.
+   * @returns The created instanced mesh.
+   */
+  createInstancedMesh(size, geometry, material) {
+    geometry = geometry || this.fallbackGeometry;
+    geometry.setAttribute("uvRef", this.getUVRefs(size));
+    const count = size * size;
+    return new THREE.InstancedMesh(geometry, material, count);
+  }
+}
+class IntersectionService {
+  /**
+   * Creates a new IntersectionService instance.
+   * @param eventEmitter The event emitter used for emitting events.
+   * @param camera The camera used for raycasting.
+   * @param originGeometry The origin geometry.
+   * @param destinationGeometry The destination geometry.
+   */
+  constructor(eventEmitter, camera, originGeometry, destinationGeometry) {
+    __publicField(this, "raycaster", new THREE.Raycaster());
+    __publicField(this, "mousePosition", new THREE.Vector2());
+    __publicField(this, "mouseEntered", false);
+    __publicField(this, "mousePositionChanged", false);
+    __publicField(this, "camera");
+    __publicField(this, "originGeometry");
+    __publicField(this, "destinationGeometry");
+    __publicField(this, "progress", 0);
+    __publicField(this, "intersectionMesh", new THREE.Mesh());
+    __publicField(this, "geometryNeedsUpdate");
+    __publicField(this, "eventEmitter");
+    __publicField(this, "blendedGeometry");
+    __publicField(this, "intersection");
+    __publicField(this, "lastKnownOriginMeshID");
+    __publicField(this, "lastKnownDestinationMeshID");
+    this.camera = camera;
+    this.originGeometry = originGeometry;
+    this.eventEmitter = eventEmitter;
+    this.destinationGeometry = destinationGeometry;
+    this.geometryNeedsUpdate = true;
+  }
+  /**
+   * Set the camera used for raycasting.
+   * @param camera
+   */
+  setCamera(camera) {
+    this.camera = camera;
+  }
+  /**
+   * Set the origin geometry.
+   * @param source
+   */
+  setOriginGeometry(source) {
+    if (this.lastKnownOriginMeshID === source.uuid) return;
+    if (this.originGeometry) this.originGeometry.dispose();
+    this.lastKnownOriginMeshID = source.uuid;
+    this.originGeometry = source.geometry.clone();
+    this.originGeometry.applyMatrix4(source.matrixWorld);
+    this.geometryNeedsUpdate = true;
+  }
+  /**
+   * Set the destination geometry.
+   * @param source
+   */
+  setDestinationGeometry(source) {
+    if (this.lastKnownDestinationMeshID === source.uuid) return;
+    if (this.destinationGeometry) this.destinationGeometry.dispose();
+    this.lastKnownDestinationMeshID = source.uuid;
+    this.destinationGeometry = source.geometry.clone();
+    this.destinationGeometry.applyMatrix4(source.matrixWorld);
+    this.geometryNeedsUpdate = true;
+  }
+  /**
+   * Set the progress of the morphing animation.
+   * @param progress
+   */
+  setProgress(progress) {
+    this.progress = progress;
+    this.geometryNeedsUpdate = true;
+  }
+  /**
+   * Set the mouse position.
+   * @param mousePosition
+   */
+  setMousePosition(mousePosition) {
+    if (mousePosition) {
+      if (!this.mousePosition.equals(mousePosition)) {
+        this.mousePosition.copy(mousePosition);
+        this.mousePositionChanged = true;
+      }
+      this.mouseEntered = true;
+    } else {
+      this.mouseEntered = false;
+      this.mousePositionChanged = false;
+    }
+  }
+  /**
+   * Calculate the intersection.
+   * @returns The intersection point or undefined if no intersection was found.
+   */
+  calculate() {
+    if (!this.camera) return;
+    if (!this.mouseEntered) return;
+    if (this.geometryNeedsUpdate) {
+      this.geometryNeedsUpdate = false;
+      this.blendedGeometry = this.getBlendedGeometry();
+      this.mousePositionChanged = true;
+    }
+    if (this.mousePositionChanged) {
+      this.mousePositionChanged = false;
+      if (this.blendedGeometry) {
+        this.intersection = this.getFirstIntersection(this.blendedGeometry, this.camera);
+      } else {
+        this.intersection = void 0;
+      }
+    }
+    if (this.intersection) {
+      this.eventEmitter.emit("interactionPositionUpdated", { position: this.intersection });
+    } else {
+      this.eventEmitter.emit("interactionPositionUpdated", { position: { x: 0, y: 0, z: 0, w: 0 } });
+    }
+    return this.intersection;
+  }
+  /**
+   * Dispose the resources used by the IntersectionService.
+   */
+  dispose() {
+    var _a;
+    (_a = this.blendedGeometry) == null ? void 0 : _a.dispose();
+    this.intersectionMesh.geometry.dispose();
+  }
+  getFirstIntersection(geometry, camera) {
+    this.raycaster.setFromCamera(this.mousePosition, camera);
+    this.intersectionMesh.geometry = geometry;
+    const intersection = this.raycaster.intersectObject(this.intersectionMesh, false)[0];
+    if (intersection) {
+      return new THREE.Vector4(intersection.point.x, intersection.point.y, intersection.point.z, 1);
+    }
+  }
+  getBlendedGeometry() {
+    if (this.progress === 0) {
+      return this.originGeometry;
+    }
+    if (this.progress === 1) {
+      return this.destinationGeometry;
+    }
+    if (!this.originGeometry || !this.destinationGeometry) {
+      return;
+    }
+    if (this.originGeometry === this.destinationGeometry) {
+      return this.originGeometry;
+    }
+    return this.blendGeometry(this.originGeometry, this.destinationGeometry, this.progress);
+  }
+  blendGeometry(from, to, progress) {
+    const blended = new THREE.BufferGeometry();
+    const originPositions = from.attributes.position.array;
+    const destinationPositions = to.attributes.position.array;
+    const blendedPositions = new Float32Array(originPositions.length);
+    for (let i = 0; i < originPositions.length; i += 3) {
+      const originVert = new THREE.Vector3(originPositions[i], originPositions[i + 1], originPositions[i + 2]);
+      const destinationVert = new THREE.Vector3(destinationPositions[i], destinationPositions[i + 1], destinationPositions[i + 2]);
+      const blendedVert = new THREE.Vector3().lerpVectors(originVert, destinationVert, progress);
+      blendedPositions[i] = blendedVert.x;
+      blendedPositions[i + 1] = blendedVert.y;
+      blendedPositions[i + 2] = blendedVert.z;
+    }
+    blended.setAttribute("position", new THREE.BufferAttribute(blendedPositions, 3));
+    if (from.attributes.normal) blended.setAttribute("normal", from.attributes.normal.clone());
+    if (from.attributes.uv) blended.setAttribute("uv", from.attributes.uv.clone());
+    if (from.index) blended.setIndex(from.index.clone());
+    return blended;
+  }
+}
+class MatcapService {
+  constructor(eventEmitter, matcaps) {
+    __publicField(this, "matcaps", /* @__PURE__ */ new Map());
+    __publicField(this, "eventEmitter");
+    __publicField(this, "fallbackMatcap", new THREE.DataTexture(new Uint8Array([127, 127, 127, 255]), 1, 1, THREE.RGBAFormat));
+    this.eventEmitter = eventEmitter;
+    if (matcaps) {
+      matcaps.forEach(({ id, item }) => this.setMatcap(id, item));
+    }
+    this.updateServiceState("ready");
+  }
+  getMatcap(id) {
+    const texture = this.matcaps.get(id);
+    if (!texture) {
+      this.eventEmitter.emit("invalidRequest", { message: `invalid matcap request: ${id}` });
+      return this.fallbackMatcap;
+    } else {
+      return texture;
+    }
+  }
+  setMatcap(id, texture) {
+    const previous = this.matcaps.get(id);
+    if (previous === texture) return;
+    this.matcaps.set(id, texture);
+    if (previous) {
+      this.eventEmitter.emit("matcapReplaced", { id });
+      previous.dispose();
+    } else {
+      this.eventEmitter.emit("matcapRegistered", { id });
+    }
+  }
+  dispose() {
+    this.updateServiceState("disposed");
+    this.matcaps.forEach((texture) => texture.dispose());
+    this.matcaps.clear();
+  }
+  updateServiceState(serviceState) {
+    this.eventEmitter.emit("serviceStateUpdated", { type: "matcap", state: serviceState });
+  }
+}
+const _camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
+class FullscreenTriangleGeometry extends BufferGeometry {
+  constructor() {
+    super();
+    this.setAttribute("position", new Float32BufferAttribute([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3));
+    this.setAttribute("uv", new Float32BufferAttribute([0, 2, 0, 0, 2, 0], 2));
+  }
+}
+const _geometry = new FullscreenTriangleGeometry();
+class FullScreenQuad {
+  constructor(material) {
+    this._mesh = new Mesh(_geometry, material);
+  }
+  dispose() {
+    this._mesh.geometry.dispose();
+  }
+  render(renderer) {
+    renderer.render(this._mesh, _camera);
+  }
+  get material() {
+    return this._mesh.material;
+  }
+  set material(value) {
+    this._mesh.material = value;
+  }
+}
+class GPUComputationRenderer {
+  /**
+   * @param {Number} sizeX Computation problem size is always 2d: sizeX * sizeY elements.
+  	 * @param {Number} sizeY Computation problem size is always 2d: sizeX * sizeY elements.
+  	 * @param {WebGLRenderer} renderer The renderer
+   */
+  constructor(sizeX, sizeY, renderer) {
+    this.variables = [];
+    this.currentTextureIndex = 0;
+    let dataType = FloatType;
+    const passThruUniforms = {
+      passThruTexture: { value: null }
+    };
+    const passThruShader = createShaderMaterial(getPassThroughFragmentShader(), passThruUniforms);
+    const quad = new FullScreenQuad(passThruShader);
+    this.setDataType = function(type) {
+      dataType = type;
+      return this;
+    };
+    this.addVariable = function(variableName, computeFragmentShader, initialValueTexture) {
+      const material = this.createShaderMaterial(computeFragmentShader);
+      const variable = {
+        name: variableName,
+        initialValueTexture,
+        material,
+        dependencies: null,
+        renderTargets: [],
+        wrapS: null,
+        wrapT: null,
+        minFilter: NearestFilter,
+        magFilter: NearestFilter
+      };
+      this.variables.push(variable);
+      return variable;
+    };
+    this.setVariableDependencies = function(variable, dependencies) {
+      variable.dependencies = dependencies;
+    };
+    this.init = function() {
+      if (renderer.capabilities.maxVertexTextures === 0) {
+        return "No support for vertex shader textures.";
+      }
+      for (let i = 0; i < this.variables.length; i++) {
+        const variable = this.variables[i];
+        variable.renderTargets[0] = this.createRenderTarget(sizeX, sizeY, variable.wrapS, variable.wrapT, variable.minFilter, variable.magFilter);
+        variable.renderTargets[1] = this.createRenderTarget(sizeX, sizeY, variable.wrapS, variable.wrapT, variable.minFilter, variable.magFilter);
+        this.renderTexture(variable.initialValueTexture, variable.renderTargets[0]);
+        this.renderTexture(variable.initialValueTexture, variable.renderTargets[1]);
+        const material = variable.material;
+        const uniforms = material.uniforms;
+        if (variable.dependencies !== null) {
+          for (let d = 0; d < variable.dependencies.length; d++) {
+            const depVar = variable.dependencies[d];
+            if (depVar.name !== variable.name) {
+              let found = false;
+              for (let j = 0; j < this.variables.length; j++) {
+                if (depVar.name === this.variables[j].name) {
+                  found = true;
+                  break;
+                }
+              }
+              if (!found) {
+                return "Variable dependency not found. Variable=" + variable.name + ", dependency=" + depVar.name;
+              }
+            }
+            uniforms[depVar.name] = { value: null };
+            material.fragmentShader = "\nuniform sampler2D " + depVar.name + ";\n" + material.fragmentShader;
+          }
+        }
+      }
+      this.currentTextureIndex = 0;
+      return null;
+    };
+    this.compute = function() {
+      const currentTextureIndex = this.currentTextureIndex;
+      const nextTextureIndex = this.currentTextureIndex === 0 ? 1 : 0;
+      for (let i = 0, il = this.variables.length; i < il; i++) {
+        const variable = this.variables[i];
+        if (variable.dependencies !== null) {
+          const uniforms = variable.material.uniforms;
+          for (let d = 0, dl = variable.dependencies.length; d < dl; d++) {
+            const depVar = variable.dependencies[d];
+            uniforms[depVar.name].value = depVar.renderTargets[currentTextureIndex].texture;
+          }
+        }
+        this.doRenderTarget(variable.material, variable.renderTargets[nextTextureIndex]);
+      }
+      this.currentTextureIndex = nextTextureIndex;
+    };
+    this.getCurrentRenderTarget = function(variable) {
+      return variable.renderTargets[this.currentTextureIndex];
+    };
+    this.getAlternateRenderTarget = function(variable) {
+      return variable.renderTargets[this.currentTextureIndex === 0 ? 1 : 0];
+    };
+    this.dispose = function() {
+      quad.dispose();
+      const variables = this.variables;
+      for (let i = 0; i < variables.length; i++) {
+        const variable = variables[i];
+        if (variable.initialValueTexture) variable.initialValueTexture.dispose();
+        const renderTargets = variable.renderTargets;
+        for (let j = 0; j < renderTargets.length; j++) {
+          const renderTarget = renderTargets[j];
+          renderTarget.dispose();
+        }
+      }
+    };
+    function addResolutionDefine(materialShader) {
+      materialShader.defines.resolution = "vec2( " + sizeX.toFixed(1) + ", " + sizeY.toFixed(1) + " )";
+    }
+    this.addResolutionDefine = addResolutionDefine;
+    function createShaderMaterial(computeFragmentShader, uniforms) {
+      uniforms = uniforms || {};
+      const material = new ShaderMaterial({
+        name: "GPUComputationShader",
+        uniforms,
+        vertexShader: getPassThroughVertexShader(),
+        fragmentShader: computeFragmentShader
+      });
+      addResolutionDefine(material);
+      return material;
+    }
+    this.createShaderMaterial = createShaderMaterial;
+    this.createRenderTarget = function(sizeXTexture, sizeYTexture, wrapS, wrapT, minFilter, magFilter) {
+      sizeXTexture = sizeXTexture || sizeX;
+      sizeYTexture = sizeYTexture || sizeY;
+      wrapS = wrapS || ClampToEdgeWrapping;
+      wrapT = wrapT || ClampToEdgeWrapping;
+      minFilter = minFilter || NearestFilter;
+      magFilter = magFilter || NearestFilter;
+      const renderTarget = new WebGLRenderTarget(sizeXTexture, sizeYTexture, {
+        wrapS,
+        wrapT,
+        minFilter,
+        magFilter,
+        format: RGBAFormat,
+        type: dataType,
+        depthBuffer: false
+      });
+      return renderTarget;
+    };
+    this.createTexture = function() {
+      const data = new Float32Array(sizeX * sizeY * 4);
+      const texture = new DataTexture(data, sizeX, sizeY, RGBAFormat, FloatType);
+      texture.needsUpdate = true;
+      return texture;
+    };
+    this.renderTexture = function(input, output) {
+      passThruUniforms.passThruTexture.value = input;
+      this.doRenderTarget(passThruShader, output);
+      passThruUniforms.passThruTexture.value = null;
+    };
+    this.doRenderTarget = function(material, output) {
+      const currentRenderTarget = renderer.getRenderTarget();
+      const currentXrEnabled = renderer.xr.enabled;
+      const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
+      renderer.xr.enabled = false;
+      renderer.shadowMap.autoUpdate = false;
+      quad.material = material;
+      renderer.setRenderTarget(output);
+      quad.render(renderer);
+      quad.material = passThruShader;
+      renderer.xr.enabled = currentXrEnabled;
+      renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
+      renderer.setRenderTarget(currentRenderTarget);
+    };
+    function getPassThroughVertexShader() {
+      return "void main()	{\n\n	gl_Position = vec4( position, 1.0 );\n\n}\n";
+    }
+    function getPassThroughFragmentShader() {
+      return "uniform sampler2D passThruTexture;\n\nvoid main() {\n\n	vec2 uv = gl_FragCoord.xy / resolution.xy;\n\n	gl_FragColor = texture2D( passThruTexture, uv );\n\n}\n";
+    }
+  }
+}
+const mixShader = `
+uniform sampler2D uPositionA;
+uniform sampler2D uPositionB;
+uniform float uProgress;
+
+void main() {
+    vec2 uv = gl_FragCoord.xy / resolution.xy;
+    vec3 positionA = texture2D(uPositionA, uv).xyz;
+    vec3 positionB = texture2D(uPositionB, uv).xyz;
+    vec3 mixedPosition = mix(positionA, positionB, uProgress);
+    gl_FragColor = vec4(mixedPosition, 1.0);
+}
+`;
+const positionShader = `
+uniform float uProgress;
+uniform vec4 uInteractionPosition;
+uniform float uTime;
+uniform float uTractionForce;
+
+float rand(vec2 co) {
+    return fract(sin(dot(co, vec2(12.9898, 78.233))) * 43758.5453);
+}
+
+void main() {
+
+    // in GPGPU, we calculate the uv on each fragment shader, not using the static varying passed over from the v shader.
+    vec2 uv = gl_FragCoord.xy / resolution.xy;
+    float offset = rand(uv);
+
+    vec3 position = texture2D(uCurrentPosition, uv).xyz;
+    vec3 velocity = texture2D(uCurrentVelocity, uv).xyz;
+    vec3 mixedPosition = texture2D(uMixedPosition, uv).xyz;
+
+    // particle attraction to original position.
+    vec3 direction = normalize(mixedPosition - position); // direction vector
+    float dist = length ( mixedPosition - position ); // distance from where it was supposed to be, and currently are.
+
+    if (dist > 0.01) {
+        position = mix(position, mixedPosition, 0.1 * uTractionForce); // 0.1 ~ 0.001 (faster, slower)
+    }
+
+    position += velocity;
+    gl_FragColor = vec4(position, 1.0);
+}
+`;
+const velocityShader = `
+uniform float uProgress;
+uniform vec4 uInteractionPosition;
+uniform float uTime;
+uniform float uTractionForce;
+uniform float uMaxRepelDistance;
+
+float rand(vec2 co) {
+    return fract(sin(dot(co, vec2(12.9898, 78.233))) * 43758.5453);
+}
+
+void main() {
+    vec2 uv = gl_FragCoord.xy / resolution.xy;
+    float offset = rand(uv);
+
+    vec3 position = texture2D(uCurrentPosition, uv).xyz;
+    vec3 velocity = texture2D(uCurrentVelocity, uv).xyz;
+    vec3 mixedPosition = texture2D(uMixedPosition, uv).xyz;
+
+    velocity *= 0.9;
+
+    // particle traction
+    vec3 direction = normalize(mixedPosition - position); // direction vector
+    float dist = length ( mixedPosition - position ); // distance from where it was supposed to be, and currently are.
+    if (dist > 0.01) {
+        position += direction * 0.1 * uTractionForce; // uTractionForce defaults to 0.1
+    }
+
+    // mouse repel force
+    float pointerDistance = distance(position, uInteractionPosition.xyz);
+    float mouseRepelModifier = clamp(uMaxRepelDistance - pointerDistance, 0.0, 1.0);
+    float normalizedDistance = pointerDistance / uMaxRepelDistance;
+    float repulsionStrength = (1.0 - normalizedDistance) * uInteractionPosition.w;
+    direction = normalize(position - uInteractionPosition.xyz);
+    velocity += (direction * 0.01 * repulsionStrength) * mouseRepelModifier;
+
+    float lifespan = 20.0;
+    float age = mod(uTime + lifespan * offset, lifespan);
+
+    if (age < 0.1) {
+        position.xyz = mixedPosition;
+    }
+
+    gl_FragColor = vec4(velocity, 1.0);
+}
+`;
+class SimulationRenderer {
+  /**
+   * Creates a new SimulationRenderer instance.
+   * @param size The size of the simulation textures.
+   * @param webGLRenderer The WebGL renderer.
+   * @param initialPosition The initial position data texture. If not provided, a default sphere will be used.
+   */
+  constructor(size, webGLRenderer, initialPosition) {
+    __publicField(this, "gpuComputationRenderer");
+    __publicField(this, "webGLRenderer");
+    // calculations
+    __publicField(this, "positionDataTexture");
+    __publicField(this, "velocityDataTexture");
+    // GPUComputationRenderer variables
+    __publicField(this, "mixPositionsVar");
+    __publicField(this, "velocityVar");
+    __publicField(this, "positionVar");
+    __publicField(this, "interactionPosition");
+    __publicField(this, "lastKnownPositionDataTexture");
+    __publicField(this, "lastKnownVelocityDataTexture");
+    __publicField(this, "lastKnownMixProgress");
+    __publicField(this, "initialDataTexture");
+    this.initialDataTexture = initialPosition ?? createSpherePoints(size);
+    this.positionDataTexture = this.initialDataTexture;
+    this.webGLRenderer = webGLRenderer;
+    this.gpuComputationRenderer = new GPUComputationRenderer(size, size, this.webGLRenderer);
+    this.lastKnownMixProgress = 0;
+    if (!webGLRenderer.capabilities.isWebGL2) {
+      this.gpuComputationRenderer.setDataType(THREE.HalfFloatType);
+    }
+    this.velocityDataTexture = createBlankDataTexture(size);
+    this.interactionPosition = new THREE.Vector4(0, 0, 0, 0);
+    this.mixPositionsVar = this.gpuComputationRenderer.addVariable("uMixedPosition", mixShader, this.positionDataTexture);
+    this.velocityVar = this.gpuComputationRenderer.addVariable("uCurrentVelocity", velocityShader, this.velocityDataTexture);
+    this.positionVar = this.gpuComputationRenderer.addVariable("uCurrentPosition", positionShader, this.positionDataTexture);
+    this.mixPositionsVar.material.uniforms.uProgress = { value: 0 };
+    this.mixPositionsVar.material.uniforms.uPositionA = { value: this.initialDataTexture };
+    this.mixPositionsVar.material.uniforms.uPositionB = { value: this.initialDataTexture };
+    this.velocityVar.material.uniforms.uTime = { value: 0 };
+    this.velocityVar.material.uniforms.uInteractionPosition = { value: this.interactionPosition };
+    this.velocityVar.material.uniforms.uCurrentPosition = { value: this.positionDataTexture };
+    this.velocityVar.material.uniforms.uTractionForce = { value: 0.1 };
+    this.velocityVar.material.uniforms.uMaxRepelDistance = { value: 0.3 };
+    this.positionVar.material.uniforms.uTime = { value: 0 };
+    this.positionVar.material.uniforms.uProgress = { value: 0 };
+    this.positionVar.material.uniforms.uTractionForce = { value: 0.1 };
+    this.positionVar.material.uniforms.uInteractionPosition = { value: this.interactionPosition };
+    this.positionVar.material.uniforms.uCurrentPosition = { value: this.positionDataTexture };
+    this.gpuComputationRenderer.setVariableDependencies(this.positionVar, [this.velocityVar, this.positionVar, this.mixPositionsVar]);
+    this.gpuComputationRenderer.setVariableDependencies(this.velocityVar, [this.velocityVar, this.positionVar, this.mixPositionsVar]);
+    const err = this.gpuComputationRenderer.init();
+    if (err) {
+      throw new Error("failed to initialize SimulationRenderer: " + err);
+    }
+    this.lastKnownVelocityDataTexture = this.getVelocityTexture();
+    this.lastKnownPositionDataTexture = this.getPositionTexture();
+  }
+  /**
+   * Sets the source data texture for morphing.
+   * @param texture The source data texture.
+   */
+  setMorphSourceDataTexture(texture) {
+    this.mixPositionsVar.material.uniforms.uPositionA.value = texture;
+  }
+  /**
+   * Sets the destination data texture for morphing.
+   * @param texture The destination data texture.
+   */
+  setMorphDestinationDataTexture(texture) {
+    this.mixPositionsVar.material.uniforms.uPositionB.value = texture;
+  }
+  setMaxRepelDistance(distance) {
+    this.velocityVar.material.uniforms.uMaxRepelDistance.value = distance;
+  }
+  /**
+   * Sets the progress of the morphing animation.
+   * @param progress The progress value, between 0 and 1.
+   */
+  setProgress(progress) {
+    this.lastKnownMixProgress = clamp(progress, 0, 1);
+    this.mixPositionsVar.material.uniforms.uProgress.value = this.lastKnownMixProgress;
+  }
+  setVelocityTractionForce(force) {
+    this.velocityVar.material.uniforms.uTractionForce.value = force;
+  }
+  setPositionalTractionForce(force) {
+    this.positionVar.material.uniforms.uTractionForce.value = force;
+  }
+  setInteractionPosition(position) {
+    this.interactionPosition.copy(position);
+  }
+  /**
+   * Disposes the resources used by the simulation renderer.
+   */
+  dispose() {
+    this.mixPositionsVar.renderTargets.forEach((rtt) => rtt.dispose());
+    this.positionVar.renderTargets.forEach((rtt) => rtt.dispose());
+    this.velocityVar.renderTargets.forEach((rtt) => rtt.dispose());
+    this.positionDataTexture.dispose();
+    this.velocityDataTexture.dispose();
+    this.gpuComputationRenderer.dispose();
+  }
+  /**
+   * Computes the next step of the simulation.
+   * @param elapsedTime The elapsed time since the simulation started.
+   */
+  compute(elapsedTime) {
+    this.velocityVar.material.uniforms.uTime.value = elapsedTime;
+    this.positionVar.material.uniforms.uTime.value = elapsedTime;
+    this.gpuComputationRenderer.compute();
+  }
+  /**
+   * Gets the current velocity texture.
+   * @returns The current velocity texture.
+   */
+  getVelocityTexture() {
+    this.lastKnownVelocityDataTexture = this.gpuComputationRenderer.getCurrentRenderTarget(this.velocityVar).texture;
+    return this.lastKnownVelocityDataTexture;
+  }
+  /**
+   * Gets the current position texture.
+   * @returns The current position texture.
+   */
+  getPositionTexture() {
+    this.lastKnownPositionDataTexture = this.gpuComputationRenderer.getCurrentRenderTarget(this.positionVar).texture;
+    return this.lastKnownPositionDataTexture;
+  }
+}
+class SimulationRendererService {
+  constructor(eventEmitter, size, webGLRenderer) {
+    __publicField(this, "state");
+    __publicField(this, "textureSize");
+    __publicField(this, "dataTextureTransitionProgress");
+    __publicField(this, "velocityTractionForce");
+    __publicField(this, "positionalTractionForce");
+    __publicField(this, "simulationRenderer");
+    __publicField(this, "webGLRenderer");
+    __publicField(this, "eventEmitter");
+    __publicField(this, "lastKnownVelocityDataTexture");
+    __publicField(this, "lastKnownPositionDataTexture");
+    this.eventEmitter = eventEmitter;
+    this.webGLRenderer = webGLRenderer;
+    this.textureSize = size;
+    this.dataTextureTransitionProgress = 0;
+    this.velocityTractionForce = 0.1;
+    this.positionalTractionForce = 0.1;
+    this.updateServiceState("initializing");
+    this.simulationRenderer = new SimulationRenderer(this.textureSize, this.webGLRenderer);
+    this.lastKnownVelocityDataTexture = this.simulationRenderer.getVelocityTexture();
+    this.lastKnownPositionDataTexture = this.simulationRenderer.getPositionTexture();
+    this.updateServiceState("ready");
+  }
+  setTextureSize(size) {
+    this.updateServiceState("initializing");
+    this.simulationRenderer.dispose();
+    this.textureSize = size;
+    this.simulationRenderer = new SimulationRenderer(size, this.webGLRenderer);
+    this.updateServiceState("ready");
+  }
+  setOriginDataTexture(entry) {
+    if (this.textureSize !== entry.textureSize) {
+      this.eventEmitter.emit("invalidRequest", { message: `Texture size mismatch: ${entry.textureSize} vs ${this.textureSize}` });
+    } else {
+      this.simulationRenderer.setMorphSourceDataTexture(entry.dataTexture);
+    }
+  }
+  setDestinationDataTexture(entry) {
+    if (this.textureSize !== entry.textureSize) {
+      this.eventEmitter.emit("invalidRequest", { message: `Texture size mismatch: ${entry.textureSize} vs ${this.textureSize}` });
+    } else {
+      this.simulationRenderer.setMorphDestinationDataTexture(entry.dataTexture);
+    }
+  }
+  setDataTextureTransitionProgress(progress) {
+    this.dataTextureTransitionProgress = progress;
+    this.simulationRenderer.setProgress(this.dataTextureTransitionProgress);
+  }
+  setVelocityTractionForce(force) {
+    this.velocityTractionForce = force;
+    this.simulationRenderer.setVelocityTractionForce(this.velocityTractionForce);
+  }
+  setPositionalTractionForce(force) {
+    this.positionalTractionForce = force;
+    this.simulationRenderer.setPositionalTractionForce(this.positionalTractionForce);
+  }
+  compute(elapsedTime) {
+    this.simulationRenderer.compute(elapsedTime);
+  }
+  getVelocityTexture() {
+    if (this.state === "ready") this.lastKnownVelocityDataTexture = this.simulationRenderer.getVelocityTexture();
+    return this.lastKnownVelocityDataTexture;
+  }
+  getPositionTexture() {
+    if (this.state === "ready") this.lastKnownPositionDataTexture = this.simulationRenderer.getPositionTexture();
+    return this.lastKnownPositionDataTexture;
+  }
+  dispose() {
+    this.updateServiceState("disposed");
+    this.simulationRenderer.dispose();
+    this.lastKnownVelocityDataTexture.dispose();
+    this.lastKnownPositionDataTexture.dispose();
+  }
+  updateServiceState(serviceState) {
+    this.state = serviceState;
+    this.eventEmitter.emit("serviceStateUpdated", { type: "simulation", state: serviceState });
+  }
+  setInteractionPosition(position) {
+    this.simulationRenderer.setInteractionPosition(position);
+  }
+  setMaxRepelDistance(distance) {
+    this.simulationRenderer.setMaxRepelDistance(distance);
+  }
+}
+class ExecutionStatusMap {
+  constructor() {
+    __publicField(this, "execStatus", /* @__PURE__ */ new Map());
+  }
+  get(type) {
+    const status = this.execStatus.get(type);
+    if (!status) {
+      this.execStatus.set(type, "idle");
+      return "idle";
+    }
+    return status;
+  }
+  set(type, status) {
+    this.execStatus.set(type, status);
+  }
+}
+class TransitionService {
+  constructor(eventEmitter) {
+    __publicField(this, "eventEmitter");
+    __publicField(this, "transitions", /* @__PURE__ */ new Map());
+    __publicField(this, "execStatus");
+    __publicField(this, "ongoingTransitions", /* @__PURE__ */ new Map());
+    this.eventEmitter = eventEmitter;
+    this.execStatus = new ExecutionStatusMap();
+    this.eventEmitter.on("transitionCancelled", this.handleTransitionCancelledEvent.bind(this));
+  }
+  /**
+   * Enqueues a transition.
+   * @param type - The type of transition.
+   * @param transition - The transition details.
+   * @param options - Optional transition options.
+   */
+  enqueue(type, transition, options = {}) {
+    const transitionQueueItem = {
+      ...transition,
+      ...options,
+      cancelled: false,
+      duration: transition.duration * 1e-3
+      // convert to seconds
+    };
+    this.getQueue(type).push(transitionQueueItem);
+  }
+  compute(elapsedTime) {
+    this.transitions.forEach((queue, type) => {
+      var _a;
+      if (queue.length && !this.ongoingTransitions.has(type)) {
+        const transition = queue.shift();
+        if (transition) {
+          this.ongoingTransitions.set(type, { ...transition, startTime: elapsedTime });
+          (_a = transition.onTransitionBegin) == null ? void 0 : _a.call(transition);
+        }
+      }
+    });
+    this.ongoingTransitions.forEach((transition, type) => {
+      var _a, _b, _c;
+      if (transition.cancelled) {
+        (_a = transition.onTransitionCancelled) == null ? void 0 : _a.call(transition);
+        this.ongoingTransitions.delete(type);
+        return;
+      }
+      const { startTime, duration, easing } = transition;
+      const timeDistance = elapsedTime - startTime;
+      const progress = clamp(easing(Math.min(1, timeDistance / duration)), 0, 1);
+      this.emitTransitionProgress(type, progress);
+      (_b = transition.onTransitionProgress) == null ? void 0 : _b.call(transition, progress);
+      if (progress >= 1) {
+        this.emitTransitionFinished(type);
+        (_c = transition.onTransitionFinished) == null ? void 0 : _c.call(transition);
+        this.ongoingTransitions.delete(type);
+      }
+    });
+  }
+  getQueue(type) {
+    const queue = this.transitions.get(type);
+    if (!queue) {
+      this.transitions.set(type, []);
+      return this.transitions.get(type) ?? [];
+    }
+    return queue;
+  }
+  handleTransitionCancelledEvent({ type }) {
+    var _a;
+    const transitions = this.getQueue(type);
+    while (transitions.length) transitions.pop();
+    const ongoingTransition = this.ongoingTransitions.get(type);
+    if (ongoingTransition) {
+      ongoingTransition.cancelled = true;
+      (_a = ongoingTransition.onTransitionCancelled) == null ? void 0 : _a.call(ongoingTransition);
+    }
+  }
+  emitTransitionProgress(type, progress) {
+    this.eventEmitter.emit("transitionProgressed", { type, progress });
+  }
+  emitTransitionFinished(type) {
+    this.eventEmitter.emit("transitionFinished", { type });
+  }
+}
+class ParticlesEngine {
+  /**
+   * Creates a new ParticlesEngine instance.
+   * @param params The parameters for creating the instance.
+   */
+  constructor(params) {
+    __publicField(this, "simulationRendererService");
+    __publicField(this, "eventEmitter");
+    __publicField(this, "renderer");
+    __publicField(this, "scene");
+    __publicField(this, "serviceStates");
+    // assets
+    __publicField(this, "dataTextureManager");
+    __publicField(this, "matcapService");
+    __publicField(this, "instancedMeshManager");
+    __publicField(this, "transitionService");
+    __publicField(this, "engineState");
+    __publicField(this, "intersectionService");
+    this.eventEmitter = new DefaultEventEmitter();
+    this.serviceStates = this.initialServiceStates();
+    this.eventEmitter.on("serviceStateUpdated", this.handleServiceStateUpdated.bind(this));
+    this.scene = params.scene;
+    this.renderer = params.renderer;
+    this.engineState = this.initialEngineState(params.textureSize);
+    this.transitionService = new TransitionService(this.eventEmitter);
+    this.dataTextureManager = new DataTextureService(this.eventEmitter, params.textureSize, params.meshes);
+    this.matcapService = new MatcapService(this.eventEmitter, params.matcaps);
+    this.simulationRendererService = new SimulationRendererService(this.eventEmitter, params.textureSize, this.renderer);
+    this.instancedMeshManager = new InstancedMeshManager(params.textureSize);
+    this.instancedMeshManager.useMatcapMaterial();
+    this.scene.add(this.instancedMeshManager.getMesh());
+    this.intersectionService = new IntersectionService(this.eventEmitter, params.camera);
+    this.eventEmitter.on("transitionProgressed", this.handleTransitionProgress.bind(this));
+    this.eventEmitter.on("interactionPositionUpdated", this.handleInteractionPositionUpdated.bind(this));
+  }
+  /**
+   * Renders the scene.
+   * @param elapsedTime The elapsed time since the last frame.
+   */
+  render(elapsedTime) {
+    this.intersectionService.calculate();
+    this.transitionService.compute(elapsedTime);
+    this.simulationRendererService.compute(elapsedTime);
+    this.instancedMeshManager.update(elapsedTime);
+    this.instancedMeshManager.updateVelocityTexture(this.simulationRendererService.getVelocityTexture());
+    this.instancedMeshManager.updatePositionTexture(this.simulationRendererService.getPositionTexture());
+  }
+  setOriginDataTexture(meshID, override = false) {
+    if (override) this.eventEmitter.emit("transitionCancelled", { type: "data-texture" });
+    this.dataTextureManager.getDataTexture(meshID).then((texture) => {
+      this.engineState.originMeshID = meshID;
+      this.simulationRendererService.setOriginDataTexture({
+        dataTexture: texture,
+        textureSize: this.engineState.textureSize
+      });
+      this.intersectionService.setOriginGeometry(this.dataTextureManager.getMesh(meshID));
+    });
+  }
+  setDestinationDataTexture(meshID, override = false) {
+    if (override) this.eventEmitter.emit("transitionCancelled", { type: "data-texture" });
+    this.dataTextureManager.getDataTexture(meshID).then((texture) => {
+      this.engineState.destinationMeshID = meshID;
+      this.simulationRendererService.setDestinationDataTexture({
+        dataTexture: texture,
+        textureSize: this.engineState.textureSize
+      });
+      this.intersectionService.setDestinationGeometry(this.dataTextureManager.getMesh(meshID));
+    });
+  }
+  setDataTextureTransitionProgress(progress, override = false) {
+    if (override) this.eventEmitter.emit("transitionCancelled", { type: "data-texture" });
+    this.engineState.dataTextureTransitionProgress = progress;
+    this.simulationRendererService.setDataTextureTransitionProgress(progress);
+    this.intersectionService.setProgress(progress);
+  }
+  setOriginMatcap(matcapID, override = false) {
+    if (override) this.eventEmitter.emit("transitionCancelled", { type: "matcap" });
+    this.engineState.originMatcapID = matcapID;
+    this.instancedMeshManager.setOriginMatcap(this.matcapService.getMatcap(matcapID));
+  }
+  setDestinationMatcap(matcapID, override = false) {
+    if (override) this.eventEmitter.emit("transitionCancelled", { type: "matcap" });
+    this.engineState.destinationMatcapID = matcapID;
+    this.instancedMeshManager.setDestinationMatcap(this.matcapService.getMatcap(matcapID));
+  }
+  setMatcapProgress(progress, override = false) {
+    if (override) this.eventEmitter.emit("transitionCancelled", { type: "matcap" });
+    this.engineState.matcapTransitionProgress = progress;
+    this.instancedMeshManager.setProgress(progress);
+  }
+  async setTextureSize(size) {
+    this.engineState.textureSize = size;
+    this.dataTextureManager.setTextureSize(size);
+    this.simulationRendererService.setTextureSize(size);
+    this.instancedMeshManager.resize(size);
+    this.dataTextureManager.getDataTexture(this.engineState.originMeshID).then((texture) => this.simulationRendererService.setOriginDataTexture({ dataTexture: texture, textureSize: size }));
+    this.dataTextureManager.getDataTexture(this.engineState.destinationMeshID).then(
+      (texture) => this.simulationRendererService.setDestinationDataTexture({
+        dataTexture: texture,
+        textureSize: size
+      })
+    );
+    this.simulationRendererService.setDataTextureTransitionProgress(this.engineState.dataTextureTransitionProgress);
+    this.simulationRendererService.setVelocityTractionForce(this.engineState.velocityTractionForce);
+    this.simulationRendererService.setPositionalTractionForce(this.engineState.positionalTractionForce);
+    this.instancedMeshManager.setOriginMatcap(this.matcapService.getMatcap(this.engineState.originMatcapID));
+    this.instancedMeshManager.setDestinationMatcap(this.matcapService.getMatcap(this.engineState.destinationMatcapID));
+    this.instancedMeshManager.setProgress(this.engineState.matcapTransitionProgress);
+    this.instancedMeshManager.setGeometrySize(this.engineState.instanceGeometryScale);
+  }
+  setPointerPosition(position) {
+    this.engineState.pointerPosition = position;
+    this.intersectionService.setMousePosition(position);
+  }
+  setGeometrySize(geometrySize) {
+    this.engineState.instanceGeometryScale = geometrySize;
+    this.instancedMeshManager.setGeometrySize(geometrySize);
+  }
+  setVelocityTractionForce(force) {
+    this.engineState.velocityTractionForce = force;
+    this.simulationRendererService.setVelocityTractionForce(force);
+  }
+  setPositionalTractionForce(force) {
+    this.engineState.positionalTractionForce = force;
+    this.simulationRendererService.setPositionalTractionForce(force);
+  }
+  setMaxRepelDistance(distance) {
+    this.engineState.maxRepelDistance = distance;
+    this.simulationRendererService.setMaxRepelDistance(distance);
+  }
+  scheduleMeshTransition(originMeshID, destinationMeshID, easing = linear, duration = 1e3, override = false) {
+    this.transitionService.enqueue(
+      "data-texture",
+      { easing, duration },
+      {
+        onTransitionBegin: () => {
+          this.setOriginDataTexture(originMeshID, override);
+          this.setDestinationDataTexture(destinationMeshID, override);
+          this.setDataTextureTransitionProgress(0);
+        }
+      }
+    );
+  }
+  scheduleMatcapTransition(originMatcapID, destinationMatcapID, easing = linear, duration = 1e3, override = false) {
+    this.transitionService.enqueue(
+      "matcap",
+      { easing, duration },
+      {
+        onTransitionBegin: () => {
+          this.setOriginMatcap(originMatcapID, override);
+          this.setDestinationMatcap(destinationMatcapID, override);
+          this.setMatcapProgress(0);
+        }
+      }
+    );
+  }
+  handleServiceStateUpdated({ type, state }) {
+    console.log("service state updated", type, state);
+    this.serviceStates[type] = state;
+  }
+  /**
+   * Disposes the resources used by the engine.
+   */
+  dispose() {
+    this.scene.remove(this.instancedMeshManager.getMesh());
+    this.matcapService.dispose();
+    this.simulationRendererService.dispose();
+    this.instancedMeshManager.dispose();
+    this.intersectionService.dispose();
+    this.dataTextureManager.dispose().then(() => console.log("engine disposed"));
+  }
+  initialEngineState(textureSize) {
+    return {
+      textureSize,
+      originMeshID: "",
+      destinationMeshID: "",
+      dataTextureTransitionProgress: 0,
+      originMatcapID: "",
+      destinationMatcapID: "",
+      matcapTransitionProgress: 0,
+      velocityTractionForce: 0.1,
+      positionalTractionForce: 0.1,
+      maxRepelDistance: 0.3,
+      pointerPosition: { x: 0, y: 0 },
+      instanceGeometryScale: { x: 1, y: 1, z: 1 }
+    };
+  }
+  initialServiceStates() {
+    return {
+      "data-texture": "created",
+      "instanced-mesh": "created",
+      matcap: "created",
+      simulation: "created"
+    };
+  }
+  handleTransitionProgress({ type, progress }) {
+    switch (type) {
+      case "data-texture":
+        this.setDataTextureTransitionProgress(progress);
+        break;
+      case "matcap":
+        this.setMatcapProgress(progress);
+        break;
+    }
+  }
+  handleInteractionPositionUpdated({ position }) {
+    this.simulationRendererService.setInteractionPosition(position);
+  }
+}
+export {
+  ParticlesEngine
+};
+//# sourceMappingURL=index.es.js.map