@quick-threejs/reactive 0.1.15 → 0.1.17

package/dist/main.worker.mjs

@@ -0,0 +1,2959 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// ../../node_modules/.pnpm/reflect-metadata@0.2.2/node_modules/reflect-metadata/Reflect.js
+var require_Reflect = __commonJS({
+  "../../node_modules/.pnpm/reflect-metadata@0.2.2/node_modules/reflect-metadata/Reflect.js"() {
+    "use strict";
+    var Reflect2;
+    (function(Reflect3) {
+      (function(factory) {
+        var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
+        var exporter = makeExporter(Reflect3);
+        if (typeof root.Reflect !== "undefined") {
+          exporter = makeExporter(root.Reflect, exporter);
+        }
+        factory(exporter, root);
+        if (typeof root.Reflect === "undefined") {
+          root.Reflect = Reflect3;
+        }
+        function makeExporter(target, previous) {
+          return function(key, value) {
+            Object.defineProperty(target, key, { configurable: true, writable: true, value });
+            if (previous)
+              previous(key, value);
+          };
+        }
+        function functionThis() {
+          try {
+            return Function("return this;")();
+          } catch (_) {
+          }
+        }
+        function indirectEvalThis() {
+          try {
+            return (void 0, eval)("(function() { return this; })()");
+          } catch (_) {
+          }
+        }
+        function sloppyModeThis() {
+          return functionThis() || indirectEvalThis();
+        }
+      })(function(exporter, root) {
+        var hasOwn = Object.prototype.hasOwnProperty;
+        var supportsSymbol = typeof Symbol === "function";
+        var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
+        var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
+        var supportsCreate = typeof Object.create === "function";
+        var supportsProto = { __proto__: [] } instanceof Array;
+        var downLevel = !supportsCreate && !supportsProto;
+        var HashMap = {
+          // create an object in dictionary mode (a.k.a. "slow" mode in v8)
+          create: supportsCreate ? function() {
+            return MakeDictionary(/* @__PURE__ */ Object.create(null));
+          } : supportsProto ? function() {
+            return MakeDictionary({ __proto__: null });
+          } : function() {
+            return MakeDictionary({});
+          },
+          has: downLevel ? function(map, key) {
+            return hasOwn.call(map, key);
+          } : function(map, key) {
+            return key in map;
+          },
+          get: downLevel ? function(map, key) {
+            return hasOwn.call(map, key) ? map[key] : void 0;
+          } : function(map, key) {
+            return map[key];
+          }
+        };
+        var functionPrototype = Object.getPrototypeOf(Function);
+        var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
+        var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
+        var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
+        var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : void 0;
+        var metadataRegistry = GetOrCreateMetadataRegistry();
+        var metadataProvider = CreateMetadataProvider(metadataRegistry);
+        function decorate(decorators, target, propertyKey, attributes) {
+          if (!IsUndefined(propertyKey)) {
+            if (!IsArray(decorators))
+              throw new TypeError();
+            if (!IsObject(target))
+              throw new TypeError();
+            if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))
+              throw new TypeError();
+            if (IsNull(attributes))
+              attributes = void 0;
+            propertyKey = ToPropertyKey(propertyKey);
+            return DecorateProperty(decorators, target, propertyKey, attributes);
+          } else {
+            if (!IsArray(decorators))
+              throw new TypeError();
+            if (!IsConstructor(target))
+              throw new TypeError();
+            return DecorateConstructor(decorators, target);
+          }
+        }
+        exporter("decorate", decorate);
+        function metadata(metadataKey, metadataValue) {
+          function decorator(target, propertyKey) {
+            if (!IsObject(target))
+              throw new TypeError();
+            if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
+              throw new TypeError();
+            OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+          }
+          return decorator;
+        }
+        exporter("metadata", metadata);
+        function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+        }
+        exporter("defineMetadata", defineMetadata);
+        function hasMetadata(metadataKey, target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryHasMetadata(metadataKey, target, propertyKey);
+        }
+        exporter("hasMetadata", hasMetadata);
+        function hasOwnMetadata(metadataKey, target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
+        }
+        exporter("hasOwnMetadata", hasOwnMetadata);
+        function getMetadata(metadataKey, target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryGetMetadata(metadataKey, target, propertyKey);
+        }
+        exporter("getMetadata", getMetadata);
+        function getOwnMetadata(metadataKey, target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
+        }
+        exporter("getOwnMetadata", getOwnMetadata);
+        function getMetadataKeys(target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryMetadataKeys(target, propertyKey);
+        }
+        exporter("getMetadataKeys", getMetadataKeys);
+        function getOwnMetadataKeys(target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryOwnMetadataKeys(target, propertyKey);
+        }
+        exporter("getOwnMetadataKeys", getOwnMetadataKeys);
+        function deleteMetadata(metadataKey, target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          var provider = GetMetadataProvider(
+            target,
+            propertyKey,
+            /*Create*/
+            false
+          );
+          if (IsUndefined(provider))
+            return false;
+          return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
+        }
+        exporter("deleteMetadata", deleteMetadata);
+        function DecorateConstructor(decorators, target) {
+          for (var i = decorators.length - 1; i >= 0; --i) {
+            var decorator = decorators[i];
+            var decorated = decorator(target);
+            if (!IsUndefined(decorated) && !IsNull(decorated)) {
+              if (!IsConstructor(decorated))
+                throw new TypeError();
+              target = decorated;
+            }
+          }
+          return target;
+        }
+        function DecorateProperty(decorators, target, propertyKey, descriptor) {
+          for (var i = decorators.length - 1; i >= 0; --i) {
+            var decorator = decorators[i];
+            var decorated = decorator(target, propertyKey, descriptor);
+            if (!IsUndefined(decorated) && !IsNull(decorated)) {
+              if (!IsObject(decorated))
+                throw new TypeError();
+              descriptor = decorated;
+            }
+          }
+          return descriptor;
+        }
+        function OrdinaryHasMetadata(MetadataKey, O, P) {
+          var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+          if (hasOwn2)
+            return true;
+          var parent = OrdinaryGetPrototypeOf(O);
+          if (!IsNull(parent))
+            return OrdinaryHasMetadata(MetadataKey, parent, P);
+          return false;
+        }
+        function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
+          var provider = GetMetadataProvider(
+            O,
+            P,
+            /*Create*/
+            false
+          );
+          if (IsUndefined(provider))
+            return false;
+          return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
+        }
+        function OrdinaryGetMetadata(MetadataKey, O, P) {
+          var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+          if (hasOwn2)
+            return OrdinaryGetOwnMetadata(MetadataKey, O, P);
+          var parent = OrdinaryGetPrototypeOf(O);
+          if (!IsNull(parent))
+            return OrdinaryGetMetadata(MetadataKey, parent, P);
+          return void 0;
+        }
+        function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
+          var provider = GetMetadataProvider(
+            O,
+            P,
+            /*Create*/
+            false
+          );
+          if (IsUndefined(provider))
+            return;
+          return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
+        }
+        function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
+          var provider = GetMetadataProvider(
+            O,
+            P,
+            /*Create*/
+            true
+          );
+          provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
+        }
+        function OrdinaryMetadataKeys(O, P) {
+          var ownKeys = OrdinaryOwnMetadataKeys(O, P);
+          var parent = OrdinaryGetPrototypeOf(O);
+          if (parent === null)
+            return ownKeys;
+          var parentKeys = OrdinaryMetadataKeys(parent, P);
+          if (parentKeys.length <= 0)
+            return ownKeys;
+          if (ownKeys.length <= 0)
+            return parentKeys;
+          var set = new _Set();
+          var keys = [];
+          for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {
+            var key = ownKeys_1[_i];
+            var hasKey = set.has(key);
+            if (!hasKey) {
+              set.add(key);
+              keys.push(key);
+            }
+          }
+          for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {
+            var key = parentKeys_1[_a];
+            var hasKey = set.has(key);
+            if (!hasKey) {
+              set.add(key);
+              keys.push(key);
+            }
+          }
+          return keys;
+        }
+        function OrdinaryOwnMetadataKeys(O, P) {
+          var provider = GetMetadataProvider(
+            O,
+            P,
+            /*create*/
+            false
+          );
+          if (!provider) {
+            return [];
+          }
+          return provider.OrdinaryOwnMetadataKeys(O, P);
+        }
+        function Type(x) {
+          if (x === null)
+            return 1;
+          switch (typeof x) {
+            case "undefined":
+              return 0;
+            case "boolean":
+              return 2;
+            case "string":
+              return 3;
+            case "symbol":
+              return 4;
+            case "number":
+              return 5;
+            case "object":
+              return x === null ? 1 : 6;
+            default:
+              return 6;
+          }
+        }
+        function IsUndefined(x) {
+          return x === void 0;
+        }
+        function IsNull(x) {
+          return x === null;
+        }
+        function IsSymbol(x) {
+          return typeof x === "symbol";
+        }
+        function IsObject(x) {
+          return typeof x === "object" ? x !== null : typeof x === "function";
+        }
+        function ToPrimitive(input, PreferredType) {
+          switch (Type(input)) {
+            case 0:
+              return input;
+            case 1:
+              return input;
+            case 2:
+              return input;
+            case 3:
+              return input;
+            case 4:
+              return input;
+            case 5:
+              return input;
+          }
+          var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default";
+          var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
+          if (exoticToPrim !== void 0) {
+            var result = exoticToPrim.call(input, hint);
+            if (IsObject(result))
+              throw new TypeError();
+            return result;
+          }
+          return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
+        }
+        function OrdinaryToPrimitive(O, hint) {
+          if (hint === "string") {
+            var toString_1 = O.toString;
+            if (IsCallable(toString_1)) {
+              var result = toString_1.call(O);
+              if (!IsObject(result))
+                return result;
+            }
+            var valueOf = O.valueOf;
+            if (IsCallable(valueOf)) {
+              var result = valueOf.call(O);
+              if (!IsObject(result))
+                return result;
+            }
+          } else {
+            var valueOf = O.valueOf;
+            if (IsCallable(valueOf)) {
+              var result = valueOf.call(O);
+              if (!IsObject(result))
+                return result;
+            }
+            var toString_2 = O.toString;
+            if (IsCallable(toString_2)) {
+              var result = toString_2.call(O);
+              if (!IsObject(result))
+                return result;
+            }
+          }
+          throw new TypeError();
+        }
+        function ToBoolean(argument) {
+          return !!argument;
+        }
+        function ToString(argument) {
+          return "" + argument;
+        }
+        function ToPropertyKey(argument) {
+          var key = ToPrimitive(
+            argument,
+            3
+            /* String */
+          );
+          if (IsSymbol(key))
+            return key;
+          return ToString(key);
+        }
+        function IsArray(argument) {
+          return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
+        }
+        function IsCallable(argument) {
+          return typeof argument === "function";
+        }
+        function IsConstructor(argument) {
+          return typeof argument === "function";
+        }
+        function IsPropertyKey(argument) {
+          switch (Type(argument)) {
+            case 3:
+              return true;
+            case 4:
+              return true;
+            default:
+              return false;
+          }
+        }
+        function SameValueZero(x, y) {
+          return x === y || x !== x && y !== y;
+        }
+        function GetMethod(V, P) {
+          var func = V[P];
+          if (func === void 0 || func === null)
+            return void 0;
+          if (!IsCallable(func))
+            throw new TypeError();
+          return func;
+        }
+        function GetIterator(obj) {
+          var method = GetMethod(obj, iteratorSymbol);
+          if (!IsCallable(method))
+            throw new TypeError();
+          var iterator = method.call(obj);
+          if (!IsObject(iterator))
+            throw new TypeError();
+          return iterator;
+        }
+        function IteratorValue(iterResult) {
+          return iterResult.value;
+        }
+        function IteratorStep(iterator) {
+          var result = iterator.next();
+          return result.done ? false : result;
+        }
+        function IteratorClose(iterator) {
+          var f = iterator["return"];
+          if (f)
+            f.call(iterator);
+        }
+        function OrdinaryGetPrototypeOf(O) {
+          var proto = Object.getPrototypeOf(O);
+          if (typeof O !== "function" || O === functionPrototype)
+            return proto;
+          if (proto !== functionPrototype)
+            return proto;
+          var prototype = O.prototype;
+          var prototypeProto = prototype && Object.getPrototypeOf(prototype);
+          if (prototypeProto == null || prototypeProto === Object.prototype)
+            return proto;
+          var constructor = prototypeProto.constructor;
+          if (typeof constructor !== "function")
+            return proto;
+          if (constructor === O)
+            return proto;
+          return constructor;
+        }
+        function CreateMetadataRegistry() {
+          var fallback;
+          if (!IsUndefined(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") {
+            fallback = CreateFallbackProvider(root.Reflect);
+          }
+          var first;
+          var second;
+          var rest;
+          var targetProviderMap = new _WeakMap();
+          var registry = {
+            registerProvider,
+            getProvider,
+            setProvider
+          };
+          return registry;
+          function registerProvider(provider) {
+            if (!Object.isExtensible(registry)) {
+              throw new Error("Cannot add provider to a frozen registry.");
+            }
+            switch (true) {
+              case fallback === provider:
+                break;
+              case IsUndefined(first):
+                first = provider;
+                break;
+              case first === provider:
+                break;
+              case IsUndefined(second):
+                second = provider;
+                break;
+              case second === provider:
+                break;
+              default:
+                if (rest === void 0)
+                  rest = new _Set();
+                rest.add(provider);
+                break;
+            }
+          }
+          function getProviderNoCache(O, P) {
+            if (!IsUndefined(first)) {
+              if (first.isProviderFor(O, P))
+                return first;
+              if (!IsUndefined(second)) {
+                if (second.isProviderFor(O, P))
+                  return first;
+                if (!IsUndefined(rest)) {
+                  var iterator = GetIterator(rest);
+                  while (true) {
+                    var next = IteratorStep(iterator);
+                    if (!next) {
+                      return void 0;
+                    }
+                    var provider = IteratorValue(next);
+                    if (provider.isProviderFor(O, P)) {
+                      IteratorClose(iterator);
+                      return provider;
+                    }
+                  }
+                }
+              }
+            }
+            if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {
+              return fallback;
+            }
+            return void 0;
+          }
+          function getProvider(O, P) {
+            var providerMap = targetProviderMap.get(O);
+            var provider;
+            if (!IsUndefined(providerMap)) {
+              provider = providerMap.get(P);
+            }
+            if (!IsUndefined(provider)) {
+              return provider;
+            }
+            provider = getProviderNoCache(O, P);
+            if (!IsUndefined(provider)) {
+              if (IsUndefined(providerMap)) {
+                providerMap = new _Map();
+                targetProviderMap.set(O, providerMap);
+              }
+              providerMap.set(P, provider);
+            }
+            return provider;
+          }
+          function hasProvider(provider) {
+            if (IsUndefined(provider))
+              throw new TypeError();
+            return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
+          }
+          function setProvider(O, P, provider) {
+            if (!hasProvider(provider)) {
+              throw new Error("Metadata provider not registered.");
+            }
+            var existingProvider = getProvider(O, P);
+            if (existingProvider !== provider) {
+              if (!IsUndefined(existingProvider)) {
+                return false;
+              }
+              var providerMap = targetProviderMap.get(O);
+              if (IsUndefined(providerMap)) {
+                providerMap = new _Map();
+                targetProviderMap.set(O, providerMap);
+              }
+              providerMap.set(P, provider);
+            }
+            return true;
+          }
+        }
+        function GetOrCreateMetadataRegistry() {
+          var metadataRegistry2;
+          if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+            metadataRegistry2 = root.Reflect[registrySymbol];
+          }
+          if (IsUndefined(metadataRegistry2)) {
+            metadataRegistry2 = CreateMetadataRegistry();
+          }
+          if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+            Object.defineProperty(root.Reflect, registrySymbol, {
+              enumerable: false,
+              configurable: false,
+              writable: false,
+              value: metadataRegistry2
+            });
+          }
+          return metadataRegistry2;
+        }
+        function CreateMetadataProvider(registry) {
+          var metadata2 = new _WeakMap();
+          var provider = {
+            isProviderFor: function(O, P) {
+              var targetMetadata = metadata2.get(O);
+              if (IsUndefined(targetMetadata))
+                return false;
+              return targetMetadata.has(P);
+            },
+            OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata2,
+            OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata2,
+            OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata2,
+            OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys2,
+            OrdinaryDeleteMetadata
+          };
+          metadataRegistry.registerProvider(provider);
+          return provider;
+          function GetOrCreateMetadataMap(O, P, Create) {
+            var targetMetadata = metadata2.get(O);
+            var createdTargetMetadata = false;
+            if (IsUndefined(targetMetadata)) {
+              if (!Create)
+                return void 0;
+              targetMetadata = new _Map();
+              metadata2.set(O, targetMetadata);
+              createdTargetMetadata = true;
+            }
+            var metadataMap = targetMetadata.get(P);
+            if (IsUndefined(metadataMap)) {
+              if (!Create)
+                return void 0;
+              metadataMap = new _Map();
+              targetMetadata.set(P, metadataMap);
+              if (!registry.setProvider(O, P, provider)) {
+                targetMetadata.delete(P);
+                if (createdTargetMetadata) {
+                  metadata2.delete(O);
+                }
+                throw new Error("Wrong provider for target.");
+              }
+            }
+            return metadataMap;
+          }
+          function OrdinaryHasOwnMetadata2(MetadataKey, O, P) {
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(metadataMap))
+              return false;
+            return ToBoolean(metadataMap.has(MetadataKey));
+          }
+          function OrdinaryGetOwnMetadata2(MetadataKey, O, P) {
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(metadataMap))
+              return void 0;
+            return metadataMap.get(MetadataKey);
+          }
+          function OrdinaryDefineOwnMetadata2(MetadataKey, MetadataValue, O, P) {
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              true
+            );
+            metadataMap.set(MetadataKey, MetadataValue);
+          }
+          function OrdinaryOwnMetadataKeys2(O, P) {
+            var keys = [];
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(metadataMap))
+              return keys;
+            var keysObj = metadataMap.keys();
+            var iterator = GetIterator(keysObj);
+            var k = 0;
+            while (true) {
+              var next = IteratorStep(iterator);
+              if (!next) {
+                keys.length = k;
+                return keys;
+              }
+              var nextValue = IteratorValue(next);
+              try {
+                keys[k] = nextValue;
+              } catch (e) {
+                try {
+                  IteratorClose(iterator);
+                } finally {
+                  throw e;
+                }
+              }
+              k++;
+            }
+          }
+          function OrdinaryDeleteMetadata(MetadataKey, O, P) {
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(metadataMap))
+              return false;
+            if (!metadataMap.delete(MetadataKey))
+              return false;
+            if (metadataMap.size === 0) {
+              var targetMetadata = metadata2.get(O);
+              if (!IsUndefined(targetMetadata)) {
+                targetMetadata.delete(P);
+                if (targetMetadata.size === 0) {
+                  metadata2.delete(targetMetadata);
+                }
+              }
+            }
+            return true;
+          }
+        }
+        function CreateFallbackProvider(reflect) {
+          var defineMetadata2 = reflect.defineMetadata, hasOwnMetadata2 = reflect.hasOwnMetadata, getOwnMetadata2 = reflect.getOwnMetadata, getOwnMetadataKeys2 = reflect.getOwnMetadataKeys, deleteMetadata2 = reflect.deleteMetadata;
+          var metadataOwner = new _WeakMap();
+          var provider = {
+            isProviderFor: function(O, P) {
+              var metadataPropertySet = metadataOwner.get(O);
+              if (!IsUndefined(metadataPropertySet) && metadataPropertySet.has(P)) {
+                return true;
+              }
+              if (getOwnMetadataKeys2(O, P).length) {
+                if (IsUndefined(metadataPropertySet)) {
+                  metadataPropertySet = new _Set();
+                  metadataOwner.set(O, metadataPropertySet);
+                }
+                metadataPropertySet.add(P);
+                return true;
+              }
+              return false;
+            },
+            OrdinaryDefineOwnMetadata: defineMetadata2,
+            OrdinaryHasOwnMetadata: hasOwnMetadata2,
+            OrdinaryGetOwnMetadata: getOwnMetadata2,
+            OrdinaryOwnMetadataKeys: getOwnMetadataKeys2,
+            OrdinaryDeleteMetadata: deleteMetadata2
+          };
+          return provider;
+        }
+        function GetMetadataProvider(O, P, Create) {
+          var registeredProvider = metadataRegistry.getProvider(O, P);
+          if (!IsUndefined(registeredProvider)) {
+            return registeredProvider;
+          }
+          if (Create) {
+            if (metadataRegistry.setProvider(O, P, metadataProvider)) {
+              return metadataProvider;
+            }
+            throw new Error("Illegal state.");
+          }
+          return void 0;
+        }
+        function CreateMapPolyfill() {
+          var cacheSentinel = {};
+          var arraySentinel = [];
+          var MapIterator = (
+            /** @class */
+            function() {
+              function MapIterator2(keys, values, selector) {
+                this._index = 0;
+                this._keys = keys;
+                this._values = values;
+                this._selector = selector;
+              }
+              MapIterator2.prototype["@@iterator"] = function() {
+                return this;
+              };
+              MapIterator2.prototype[iteratorSymbol] = function() {
+                return this;
+              };
+              MapIterator2.prototype.next = function() {
+                var index = this._index;
+                if (index >= 0 && index < this._keys.length) {
+                  var result = this._selector(this._keys[index], this._values[index]);
+                  if (index + 1 >= this._keys.length) {
+                    this._index = -1;
+                    this._keys = arraySentinel;
+                    this._values = arraySentinel;
+                  } else {
+                    this._index++;
+                  }
+                  return { value: result, done: false };
+                }
+                return { value: void 0, done: true };
+              };
+              MapIterator2.prototype.throw = function(error) {
+                if (this._index >= 0) {
+                  this._index = -1;
+                  this._keys = arraySentinel;
+                  this._values = arraySentinel;
+                }
+                throw error;
+              };
+              MapIterator2.prototype.return = function(value) {
+                if (this._index >= 0) {
+                  this._index = -1;
+                  this._keys = arraySentinel;
+                  this._values = arraySentinel;
+                }
+                return { value, done: true };
+              };
+              return MapIterator2;
+            }()
+          );
+          var Map2 = (
+            /** @class */
+            function() {
+              function Map3() {
+                this._keys = [];
+                this._values = [];
+                this._cacheKey = cacheSentinel;
+                this._cacheIndex = -2;
+              }
+              Object.defineProperty(Map3.prototype, "size", {
+                get: function() {
+                  return this._keys.length;
+                },
+                enumerable: true,
+                configurable: true
+              });
+              Map3.prototype.has = function(key) {
+                return this._find(
+                  key,
+                  /*insert*/
+                  false
+                ) >= 0;
+              };
+              Map3.prototype.get = function(key) {
+                var index = this._find(
+                  key,
+                  /*insert*/
+                  false
+                );
+                return index >= 0 ? this._values[index] : void 0;
+              };
+              Map3.prototype.set = function(key, value) {
+                var index = this._find(
+                  key,
+                  /*insert*/
+                  true
+                );
+                this._values[index] = value;
+                return this;
+              };
+              Map3.prototype.delete = function(key) {
+                var index = this._find(
+                  key,
+                  /*insert*/
+                  false
+                );
+                if (index >= 0) {
+                  var size = this._keys.length;
+                  for (var i = index + 1; i < size; i++) {
+                    this._keys[i - 1] = this._keys[i];
+                    this._values[i - 1] = this._values[i];
+                  }
+                  this._keys.length--;
+                  this._values.length--;
+                  if (SameValueZero(key, this._cacheKey)) {
+                    this._cacheKey = cacheSentinel;
+                    this._cacheIndex = -2;
+                  }
+                  return true;
+                }
+                return false;
+              };
+              Map3.prototype.clear = function() {
+                this._keys.length = 0;
+                this._values.length = 0;
+                this._cacheKey = cacheSentinel;
+                this._cacheIndex = -2;
+              };
+              Map3.prototype.keys = function() {
+                return new MapIterator(this._keys, this._values, getKey);
+              };
+              Map3.prototype.values = function() {
+                return new MapIterator(this._keys, this._values, getValue);
+              };
+              Map3.prototype.entries = function() {
+                return new MapIterator(this._keys, this._values, getEntry);
+              };
+              Map3.prototype["@@iterator"] = function() {
+                return this.entries();
+              };
+              Map3.prototype[iteratorSymbol] = function() {
+                return this.entries();
+              };
+              Map3.prototype._find = function(key, insert) {
+                if (!SameValueZero(this._cacheKey, key)) {
+                  this._cacheIndex = -1;
+                  for (var i = 0; i < this._keys.length; i++) {
+                    if (SameValueZero(this._keys[i], key)) {
+                      this._cacheIndex = i;
+                      break;
+                    }
+                  }
+                }
+                if (this._cacheIndex < 0 && insert) {
+                  this._cacheIndex = this._keys.length;
+                  this._keys.push(key);
+                  this._values.push(void 0);
+                }
+                return this._cacheIndex;
+              };
+              return Map3;
+            }()
+          );
+          return Map2;
+          function getKey(key, _) {
+            return key;
+          }
+          function getValue(_, value) {
+            return value;
+          }
+          function getEntry(key, value) {
+            return [key, value];
+          }
+        }
+        function CreateSetPolyfill() {
+          var Set2 = (
+            /** @class */
+            function() {
+              function Set3() {
+                this._map = new _Map();
+              }
+              Object.defineProperty(Set3.prototype, "size", {
+                get: function() {
+                  return this._map.size;
+                },
+                enumerable: true,
+                configurable: true
+              });
+              Set3.prototype.has = function(value) {
+                return this._map.has(value);
+              };
+              Set3.prototype.add = function(value) {
+                return this._map.set(value, value), this;
+              };
+              Set3.prototype.delete = function(value) {
+                return this._map.delete(value);
+              };
+              Set3.prototype.clear = function() {
+                this._map.clear();
+              };
+              Set3.prototype.keys = function() {
+                return this._map.keys();
+              };
+              Set3.prototype.values = function() {
+                return this._map.keys();
+              };
+              Set3.prototype.entries = function() {
+                return this._map.entries();
+              };
+              Set3.prototype["@@iterator"] = function() {
+                return this.keys();
+              };
+              Set3.prototype[iteratorSymbol] = function() {
+                return this.keys();
+              };
+              return Set3;
+            }()
+          );
+          return Set2;
+        }
+        function CreateWeakMapPolyfill() {
+          var UUID_SIZE = 16;
+          var keys = HashMap.create();
+          var rootKey = CreateUniqueKey();
+          return (
+            /** @class */
+            function() {
+              function WeakMap2() {
+                this._key = CreateUniqueKey();
+              }
+              WeakMap2.prototype.has = function(target) {
+                var table = GetOrCreateWeakMapTable(
+                  target,
+                  /*create*/
+                  false
+                );
+                return table !== void 0 ? HashMap.has(table, this._key) : false;
+              };
+              WeakMap2.prototype.get = function(target) {
+                var table = GetOrCreateWeakMapTable(
+                  target,
+                  /*create*/
+                  false
+                );
+                return table !== void 0 ? HashMap.get(table, this._key) : void 0;
+              };
+              WeakMap2.prototype.set = function(target, value) {
+                var table = GetOrCreateWeakMapTable(
+                  target,
+                  /*create*/
+                  true
+                );
+                table[this._key] = value;
+                return this;
+              };
+              WeakMap2.prototype.delete = function(target) {
+                var table = GetOrCreateWeakMapTable(
+                  target,
+                  /*create*/
+                  false
+                );
+                return table !== void 0 ? delete table[this._key] : false;
+              };
+              WeakMap2.prototype.clear = function() {
+                this._key = CreateUniqueKey();
+              };
+              return WeakMap2;
+            }()
+          );
+          function CreateUniqueKey() {
+            var key;
+            do
+              key = "@@WeakMap@@" + CreateUUID();
+            while (HashMap.has(keys, key));
+            keys[key] = true;
+            return key;
+          }
+          function GetOrCreateWeakMapTable(target, create) {
+            if (!hasOwn.call(target, rootKey)) {
+              if (!create)
+                return void 0;
+              Object.defineProperty(target, rootKey, { value: HashMap.create() });
+            }
+            return target[rootKey];
+          }
+          function FillRandomBytes(buffer, size) {
+            for (var i = 0; i < size; ++i)
+              buffer[i] = Math.random() * 255 | 0;
+            return buffer;
+          }
+          function GenRandomBytes(size) {
+            if (typeof Uint8Array === "function") {
+              var array = new Uint8Array(size);
+              if (typeof crypto !== "undefined") {
+                crypto.getRandomValues(array);
+              } else if (typeof msCrypto !== "undefined") {
+                msCrypto.getRandomValues(array);
+              } else {
+                FillRandomBytes(array, size);
+              }
+              return array;
+            }
+            return FillRandomBytes(new Array(size), size);
+          }
+          function CreateUUID() {
+            var data = GenRandomBytes(UUID_SIZE);
+            data[6] = data[6] & 79 | 64;
+            data[8] = data[8] & 191 | 128;
+            var result = "";
+            for (var offset = 0; offset < UUID_SIZE; ++offset) {
+              var byte = data[offset];
+              if (offset === 4 || offset === 6 || offset === 8)
+                result += "-";
+              if (byte < 16)
+                result += "0";
+              result += byte.toString(16).toLowerCase();
+            }
+            return result;
+          }
+        }
+        function MakeDictionary(obj) {
+          obj.__ = void 0;
+          delete obj.__;
+          return obj;
+        }
+      });
+    })(Reflect2 || (Reflect2 = {}));
+  }
+});
+
+// src/core/app/app.module-worker.ts
+import { expose, registerSerializer } from "threads/worker";
+
+// src/core/app/app.module.ts
+var import_reflect_metadata = __toESM(require_Reflect());
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/types/lifecycle.js
+var Lifecycle;
+(function(Lifecycle2) {
+  Lifecycle2[Lifecycle2["Transient"] = 0] = "Transient";
+  Lifecycle2[Lifecycle2["Singleton"] = 1] = "Singleton";
+  Lifecycle2[Lifecycle2["ResolutionScoped"] = 2] = "ResolutionScoped";
+  Lifecycle2[Lifecycle2["ContainerScoped"] = 3] = "ContainerScoped";
+})(Lifecycle || (Lifecycle = {}));
+var lifecycle_default = Lifecycle;
+
+// ../../node_modules/.pnpm/tslib@1.14.1/node_modules/tslib/tslib.es6.js
+var extendStatics = function(d, b) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
+  };
+  return extendStatics(d, b);
+};
+function __extends(d, b) {
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+function __generator(thisArg, body) {
+  var _ = { label: 0, sent: function() {
+    if (t[0] & 1) throw t[1];
+    return t[1];
+  }, trys: [], ops: [] }, f, y, t, g;
+  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (_) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return { value: op[1], done: false };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return { value: op[0] ? op[1] : void 0, done: true };
+  }
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+}
+function __spread() {
+  for (var ar = [], i = 0; i < arguments.length; i++)
+    ar = ar.concat(__read(arguments[i]));
+  return ar;
+}
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/reflection-helpers.js
+var INJECTION_TOKEN_METADATA_KEY = "injectionTokens";
+function getParamInfo(target) {
+  var params = Reflect.getMetadata("design:paramtypes", target) || [];
+  var injectionTokens = Reflect.getOwnMetadata(INJECTION_TOKEN_METADATA_KEY, target) || {};
+  Object.keys(injectionTokens).forEach(function(key) {
+    params[+key] = injectionTokens[key];
+  });
+  return params;
+}
+function defineInjectionTokenMetadata(data, transform) {
+  return function(target, _propertyKey, parameterIndex) {
+    var descriptors = Reflect.getOwnMetadata(INJECTION_TOKEN_METADATA_KEY, target) || {};
+    descriptors[parameterIndex] = transform ? {
+      token: data,
+      transform: transform.transformToken,
+      transformArgs: transform.args || []
+    } : data;
+    Reflect.defineMetadata(INJECTION_TOKEN_METADATA_KEY, descriptors, target);
+  };
+}
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/providers/class-provider.js
+function isClassProvider(provider) {
+  return !!provider.useClass;
+}
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/providers/factory-provider.js
+function isFactoryProvider(provider) {
+  return !!provider.useFactory;
+}
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/lazy-helpers.js
+var DelayedConstructor = function() {
+  function DelayedConstructor2(wrap) {
+    this.wrap = wrap;
+    this.reflectMethods = [
+      "get",
+      "getPrototypeOf",
+      "setPrototypeOf",
+      "getOwnPropertyDescriptor",
+      "defineProperty",
+      "has",
+      "set",
+      "deleteProperty",
+      "apply",
+      "construct",
+      "ownKeys"
+    ];
+  }
+  DelayedConstructor2.prototype.createProxy = function(createObject) {
+    var _this = this;
+    var target = {};
+    var init = false;
+    var value;
+    var delayedObject = function() {
+      if (!init) {
+        value = createObject(_this.wrap());
+        init = true;
+      }
+      return value;
+    };
+    return new Proxy(target, this.createHandler(delayedObject));
+  };
+  DelayedConstructor2.prototype.createHandler = function(delayedObject) {
+    var handler = {};
+    var install = function(name) {
+      handler[name] = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        args[0] = delayedObject();
+        var method = Reflect[name];
+        return method.apply(void 0, __spread(args));
+      };
+    };
+    this.reflectMethods.forEach(install);
+    return handler;
+  };
+  return DelayedConstructor2;
+}();
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/providers/injection-token.js
+function isNormalToken(token) {
+  return typeof token === "string" || typeof token === "symbol";
+}
+function isTokenDescriptor(descriptor) {
+  return typeof descriptor === "object" && "token" in descriptor && "multiple" in descriptor;
+}
+function isTransformDescriptor(descriptor) {
+  return typeof descriptor === "object" && "token" in descriptor && "transform" in descriptor;
+}
+function isConstructorToken(token) {
+  return typeof token === "function" || token instanceof DelayedConstructor;
+}
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/providers/token-provider.js
+function isTokenProvider(provider) {
+  return !!provider.useToken;
+}
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/providers/value-provider.js
+function isValueProvider(provider) {
+  return provider.useValue != void 0;
+}
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/providers/provider.js
+function isProvider(provider) {
+  return isClassProvider(provider) || isValueProvider(provider) || isTokenProvider(provider) || isFactoryProvider(provider);
+}
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/registry-base.js
+var RegistryBase = function() {
+  function RegistryBase2() {
+    this._registryMap = /* @__PURE__ */ new Map();
+  }
+  RegistryBase2.prototype.entries = function() {
+    return this._registryMap.entries();
+  };
+  RegistryBase2.prototype.getAll = function(key) {
+    this.ensure(key);
+    return this._registryMap.get(key);
+  };
+  RegistryBase2.prototype.get = function(key) {
+    this.ensure(key);
+    var value = this._registryMap.get(key);
+    return value[value.length - 1] || null;
+  };
+  RegistryBase2.prototype.set = function(key, value) {
+    this.ensure(key);
+    this._registryMap.get(key).push(value);
+  };
+  RegistryBase2.prototype.setAll = function(key, value) {
+    this._registryMap.set(key, value);
+  };
+  RegistryBase2.prototype.has = function(key) {
+    this.ensure(key);
+    return this._registryMap.get(key).length > 0;
+  };
+  RegistryBase2.prototype.clear = function() {
+    this._registryMap.clear();
+  };
+  RegistryBase2.prototype.ensure = function(key) {
+    if (!this._registryMap.has(key)) {
+      this._registryMap.set(key, []);
+    }
+  };
+  return RegistryBase2;
+}();
+var registry_base_default = RegistryBase;
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/registry.js
+var Registry = function(_super) {
+  __extends(Registry2, _super);
+  function Registry2() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  return Registry2;
+}(registry_base_default);
+var registry_default = Registry;
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/resolution-context.js
+var ResolutionContext = /* @__PURE__ */ function() {
+  function ResolutionContext2() {
+    this.scopedResolutions = /* @__PURE__ */ new Map();
+  }
+  return ResolutionContext2;
+}();
+var resolution_context_default = ResolutionContext;
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/error-helpers.js
+function formatDependency(params, idx) {
+  if (params === null) {
+    return "at position #" + idx;
+  }
+  var argName = params.split(",")[idx].trim();
+  return '"' + argName + '" at position #' + idx;
+}
+function composeErrorMessage(msg, e, indent) {
+  if (indent === void 0) {
+    indent = "    ";
+  }
+  return __spread([msg], e.message.split("\n").map(function(l) {
+    return indent + l;
+  })).join("\n");
+}
+function formatErrorCtor(ctor, paramIdx, error) {
+  var _a = __read(ctor.toString().match(/constructor\(([\w, ]+)\)/) || [], 2), _b = _a[1], params = _b === void 0 ? null : _b;
+  var dep = formatDependency(params, paramIdx);
+  return composeErrorMessage("Cannot inject the dependency " + dep + ' of "' + ctor.name + '" constructor. Reason:', error);
+}
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/types/disposable.js
+function isDisposable(value) {
+  if (typeof value.dispose !== "function")
+    return false;
+  var disposeFun = value.dispose;
+  if (disposeFun.length > 0) {
+    return false;
+  }
+  return true;
+}
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/interceptors.js
+var PreResolutionInterceptors = function(_super) {
+  __extends(PreResolutionInterceptors2, _super);
+  function PreResolutionInterceptors2() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  return PreResolutionInterceptors2;
+}(registry_base_default);
+var PostResolutionInterceptors = function(_super) {
+  __extends(PostResolutionInterceptors2, _super);
+  function PostResolutionInterceptors2() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  return PostResolutionInterceptors2;
+}(registry_base_default);
+var Interceptors = /* @__PURE__ */ function() {
+  function Interceptors2() {
+    this.preResolution = new PreResolutionInterceptors();
+    this.postResolution = new PostResolutionInterceptors();
+  }
+  return Interceptors2;
+}();
+var interceptors_default = Interceptors;
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/dependency-container.js
+var typeInfo = /* @__PURE__ */ new Map();
+var InternalDependencyContainer = function() {
+  function InternalDependencyContainer2(parent) {
+    this.parent = parent;
+    this._registry = new registry_default();
+    this.interceptors = new interceptors_default();
+    this.disposed = false;
+    this.disposables = /* @__PURE__ */ new Set();
+  }
+  InternalDependencyContainer2.prototype.register = function(token, providerOrConstructor, options) {
+    if (options === void 0) {
+      options = { lifecycle: lifecycle_default.Transient };
+    }
+    this.ensureNotDisposed();
+    var provider;
+    if (!isProvider(providerOrConstructor)) {
+      provider = { useClass: providerOrConstructor };
+    } else {
+      provider = providerOrConstructor;
+    }
+    if (isTokenProvider(provider)) {
+      var path = [token];
+      var tokenProvider = provider;
+      while (tokenProvider != null) {
+        var currentToken = tokenProvider.useToken;
+        if (path.includes(currentToken)) {
+          throw new Error("Token registration cycle detected! " + __spread(path, [currentToken]).join(" -> "));
+        }
+        path.push(currentToken);
+        var registration = this._registry.get(currentToken);
+        if (registration && isTokenProvider(registration.provider)) {
+          tokenProvider = registration.provider;
+        } else {
+          tokenProvider = null;
+        }
+      }
+    }
+    if (options.lifecycle === lifecycle_default.Singleton || options.lifecycle == lifecycle_default.ContainerScoped || options.lifecycle == lifecycle_default.ResolutionScoped) {
+      if (isValueProvider(provider) || isFactoryProvider(provider)) {
+        throw new Error('Cannot use lifecycle "' + lifecycle_default[options.lifecycle] + '" with ValueProviders or FactoryProviders');
+      }
+    }
+    this._registry.set(token, { provider, options });
+    return this;
+  };
+  InternalDependencyContainer2.prototype.registerType = function(from, to) {
+    this.ensureNotDisposed();
+    if (isNormalToken(to)) {
+      return this.register(from, {
+        useToken: to
+      });
+    }
+    return this.register(from, {
+      useClass: to
+    });
+  };
+  InternalDependencyContainer2.prototype.registerInstance = function(token, instance2) {
+    this.ensureNotDisposed();
+    return this.register(token, {
+      useValue: instance2
+    });
+  };
+  InternalDependencyContainer2.prototype.registerSingleton = function(from, to) {
+    this.ensureNotDisposed();
+    if (isNormalToken(from)) {
+      if (isNormalToken(to)) {
+        return this.register(from, {
+          useToken: to
+        }, { lifecycle: lifecycle_default.Singleton });
+      } else if (to) {
+        return this.register(from, {
+          useClass: to
+        }, { lifecycle: lifecycle_default.Singleton });
+      }
+      throw new Error('Cannot register a type name as a singleton without a "to" token');
+    }
+    var useClass = from;
+    if (to && !isNormalToken(to)) {
+      useClass = to;
+    }
+    return this.register(from, {
+      useClass
+    }, { lifecycle: lifecycle_default.Singleton });
+  };
+  InternalDependencyContainer2.prototype.resolve = function(token, context) {
+    if (context === void 0) {
+      context = new resolution_context_default();
+    }
+    this.ensureNotDisposed();
+    var registration = this.getRegistration(token);
+    if (!registration && isNormalToken(token)) {
+      throw new Error('Attempted to resolve unregistered dependency token: "' + token.toString() + '"');
+    }
+    this.executePreResolutionInterceptor(token, "Single");
+    if (registration) {
+      var result = this.resolveRegistration(registration, context);
+      this.executePostResolutionInterceptor(token, result, "Single");
+      return result;
+    }
+    if (isConstructorToken(token)) {
+      var result = this.construct(token, context);
+      this.executePostResolutionInterceptor(token, result, "Single");
+      return result;
+    }
+    throw new Error("Attempted to construct an undefined constructor. Could mean a circular dependency problem. Try using `delay` function.");
+  };
+  InternalDependencyContainer2.prototype.executePreResolutionInterceptor = function(token, resolutionType) {
+    var e_1, _a;
+    if (this.interceptors.preResolution.has(token)) {
+      var remainingInterceptors = [];
+      try {
+        for (var _b = __values(this.interceptors.preResolution.getAll(token)), _c = _b.next(); !_c.done; _c = _b.next()) {
+          var interceptor = _c.value;
+          if (interceptor.options.frequency != "Once") {
+            remainingInterceptors.push(interceptor);
+          }
+          interceptor.callback(token, resolutionType);
+        }
+      } catch (e_1_1) {
+        e_1 = { error: e_1_1 };
+      } finally {
+        try {
+          if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        } finally {
+          if (e_1) throw e_1.error;
+        }
+      }
+      this.interceptors.preResolution.setAll(token, remainingInterceptors);
+    }
+  };
+  InternalDependencyContainer2.prototype.executePostResolutionInterceptor = function(token, result, resolutionType) {
+    var e_2, _a;
+    if (this.interceptors.postResolution.has(token)) {
+      var remainingInterceptors = [];
+      try {
+        for (var _b = __values(this.interceptors.postResolution.getAll(token)), _c = _b.next(); !_c.done; _c = _b.next()) {
+          var interceptor = _c.value;
+          if (interceptor.options.frequency != "Once") {
+            remainingInterceptors.push(interceptor);
+          }
+          interceptor.callback(token, result, resolutionType);
+        }
+      } catch (e_2_1) {
+        e_2 = { error: e_2_1 };
+      } finally {
+        try {
+          if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        } finally {
+          if (e_2) throw e_2.error;
+        }
+      }
+      this.interceptors.postResolution.setAll(token, remainingInterceptors);
+    }
+  };
+  InternalDependencyContainer2.prototype.resolveRegistration = function(registration, context) {
+    this.ensureNotDisposed();
+    if (registration.options.lifecycle === lifecycle_default.ResolutionScoped && context.scopedResolutions.has(registration)) {
+      return context.scopedResolutions.get(registration);
+    }
+    var isSingleton = registration.options.lifecycle === lifecycle_default.Singleton;
+    var isContainerScoped = registration.options.lifecycle === lifecycle_default.ContainerScoped;
+    var returnInstance = isSingleton || isContainerScoped;
+    var resolved;
+    if (isValueProvider(registration.provider)) {
+      resolved = registration.provider.useValue;
+    } else if (isTokenProvider(registration.provider)) {
+      resolved = returnInstance ? registration.instance || (registration.instance = this.resolve(registration.provider.useToken, context)) : this.resolve(registration.provider.useToken, context);
+    } else if (isClassProvider(registration.provider)) {
+      resolved = returnInstance ? registration.instance || (registration.instance = this.construct(registration.provider.useClass, context)) : this.construct(registration.provider.useClass, context);
+    } else if (isFactoryProvider(registration.provider)) {
+      resolved = registration.provider.useFactory(this);
+    } else {
+      resolved = this.construct(registration.provider, context);
+    }
+    if (registration.options.lifecycle === lifecycle_default.ResolutionScoped) {
+      context.scopedResolutions.set(registration, resolved);
+    }
+    return resolved;
+  };
+  InternalDependencyContainer2.prototype.resolveAll = function(token, context) {
+    var _this = this;
+    if (context === void 0) {
+      context = new resolution_context_default();
+    }
+    this.ensureNotDisposed();
+    var registrations = this.getAllRegistrations(token);
+    if (!registrations && isNormalToken(token)) {
+      throw new Error('Attempted to resolve unregistered dependency token: "' + token.toString() + '"');
+    }
+    this.executePreResolutionInterceptor(token, "All");
+    if (registrations) {
+      var result_1 = registrations.map(function(item) {
+        return _this.resolveRegistration(item, context);
+      });
+      this.executePostResolutionInterceptor(token, result_1, "All");
+      return result_1;
+    }
+    var result = [this.construct(token, context)];
+    this.executePostResolutionInterceptor(token, result, "All");
+    return result;
+  };
+  InternalDependencyContainer2.prototype.isRegistered = function(token, recursive) {
+    if (recursive === void 0) {
+      recursive = false;
+    }
+    this.ensureNotDisposed();
+    return this._registry.has(token) || recursive && (this.parent || false) && this.parent.isRegistered(token, true);
+  };
+  InternalDependencyContainer2.prototype.reset = function() {
+    this.ensureNotDisposed();
+    this._registry.clear();
+    this.interceptors.preResolution.clear();
+    this.interceptors.postResolution.clear();
+  };
+  InternalDependencyContainer2.prototype.clearInstances = function() {
+    var e_3, _a;
+    this.ensureNotDisposed();
+    try {
+      for (var _b = __values(this._registry.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+        var _d = __read(_c.value, 2), token = _d[0], registrations = _d[1];
+        this._registry.setAll(token, registrations.filter(function(registration) {
+          return !isValueProvider(registration.provider);
+        }).map(function(registration) {
+          registration.instance = void 0;
+          return registration;
+        }));
+      }
+    } catch (e_3_1) {
+      e_3 = { error: e_3_1 };
+    } finally {
+      try {
+        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+      } finally {
+        if (e_3) throw e_3.error;
+      }
+    }
+  };
+  InternalDependencyContainer2.prototype.createChildContainer = function() {
+    var e_4, _a;
+    this.ensureNotDisposed();
+    var childContainer = new InternalDependencyContainer2(this);
+    try {
+      for (var _b = __values(this._registry.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+        var _d = __read(_c.value, 2), token = _d[0], registrations = _d[1];
+        if (registrations.some(function(_a2) {
+          var options = _a2.options;
+          return options.lifecycle === lifecycle_default.ContainerScoped;
+        })) {
+          childContainer._registry.setAll(token, registrations.map(function(registration) {
+            if (registration.options.lifecycle === lifecycle_default.ContainerScoped) {
+              return {
+                provider: registration.provider,
+                options: registration.options
+              };
+            }
+            return registration;
+          }));
+        }
+      }
+    } catch (e_4_1) {
+      e_4 = { error: e_4_1 };
+    } finally {
+      try {
+        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+      } finally {
+        if (e_4) throw e_4.error;
+      }
+    }
+    return childContainer;
+  };
+  InternalDependencyContainer2.prototype.beforeResolution = function(token, callback, options) {
+    if (options === void 0) {
+      options = { frequency: "Always" };
+    }
+    this.interceptors.preResolution.set(token, {
+      callback,
+      options
+    });
+  };
+  InternalDependencyContainer2.prototype.afterResolution = function(token, callback, options) {
+    if (options === void 0) {
+      options = { frequency: "Always" };
+    }
+    this.interceptors.postResolution.set(token, {
+      callback,
+      options
+    });
+  };
+  InternalDependencyContainer2.prototype.dispose = function() {
+    return __awaiter(this, void 0, void 0, function() {
+      var promises;
+      return __generator(this, function(_a) {
+        switch (_a.label) {
+          case 0:
+            this.disposed = true;
+            promises = [];
+            this.disposables.forEach(function(disposable) {
+              var maybePromise = disposable.dispose();
+              if (maybePromise) {
+                promises.push(maybePromise);
+              }
+            });
+            return [4, Promise.all(promises)];
+          case 1:
+            _a.sent();
+            return [2];
+        }
+      });
+    });
+  };
+  InternalDependencyContainer2.prototype.getRegistration = function(token) {
+    if (this.isRegistered(token)) {
+      return this._registry.get(token);
+    }
+    if (this.parent) {
+      return this.parent.getRegistration(token);
+    }
+    return null;
+  };
+  InternalDependencyContainer2.prototype.getAllRegistrations = function(token) {
+    if (this.isRegistered(token)) {
+      return this._registry.getAll(token);
+    }
+    if (this.parent) {
+      return this.parent.getAllRegistrations(token);
+    }
+    return null;
+  };
+  InternalDependencyContainer2.prototype.construct = function(ctor, context) {
+    var _this = this;
+    if (ctor instanceof DelayedConstructor) {
+      return ctor.createProxy(function(target) {
+        return _this.resolve(target, context);
+      });
+    }
+    var instance2 = function() {
+      var paramInfo = typeInfo.get(ctor);
+      if (!paramInfo || paramInfo.length === 0) {
+        if (ctor.length === 0) {
+          return new ctor();
+        } else {
+          throw new Error('TypeInfo not known for "' + ctor.name + '"');
+        }
+      }
+      var params = paramInfo.map(_this.resolveParams(context, ctor));
+      return new (ctor.bind.apply(ctor, __spread([void 0], params)))();
+    }();
+    if (isDisposable(instance2)) {
+      this.disposables.add(instance2);
+    }
+    return instance2;
+  };
+  InternalDependencyContainer2.prototype.resolveParams = function(context, ctor) {
+    var _this = this;
+    return function(param, idx) {
+      var _a, _b, _c;
+      try {
+        if (isTokenDescriptor(param)) {
+          if (isTransformDescriptor(param)) {
+            return param.multiple ? (_a = _this.resolve(param.transform)).transform.apply(_a, __spread([_this.resolveAll(param.token)], param.transformArgs)) : (_b = _this.resolve(param.transform)).transform.apply(_b, __spread([_this.resolve(param.token, context)], param.transformArgs));
+          } else {
+            return param.multiple ? _this.resolveAll(param.token) : _this.resolve(param.token, context);
+          }
+        } else if (isTransformDescriptor(param)) {
+          return (_c = _this.resolve(param.transform, context)).transform.apply(_c, __spread([_this.resolve(param.token, context)], param.transformArgs));
+        }
+        return _this.resolve(param, context);
+      } catch (e) {
+        throw new Error(formatErrorCtor(ctor, idx, e));
+      }
+    };
+  };
+  InternalDependencyContainer2.prototype.ensureNotDisposed = function() {
+    if (this.disposed) {
+      throw new Error("This container has been disposed, you cannot interact with a disposed container");
+    }
+  };
+  return InternalDependencyContainer2;
+}();
+var instance = new InternalDependencyContainer();
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/decorators/inject.js
+function inject(token) {
+  return defineInjectionTokenMetadata(token);
+}
+var inject_default = inject;
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/decorators/injectable.js
+function injectable() {
+  return function(target) {
+    typeInfo.set(target, getParamInfo(target));
+  };
+}
+var injectable_default = injectable;
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/decorators/singleton.js
+function singleton() {
+  return function(target) {
+    injectable_default()(target);
+    instance.registerSingleton(target);
+  };
+}
+var singleton_default = singleton;
+
+// ../../node_modules/.pnpm/tsyringe@4.8.0/node_modules/tsyringe/dist/esm5/index.js
+if (typeof Reflect === "undefined" || !Reflect.getMetadata) {
+  throw new Error(`tsyringe requires a reflect polyfill. Please add 'import "reflect-metadata"' to the top of your entry point.`);
+}
+
+// src/core/app/app.controller.ts
+import { Subject } from "rxjs";
+
+// src/core/app/app.component.ts
+import { ProxyReceiver } from "@quick-threejs/utils";
+var AppComponent = class {
+  proxyReceiver = new ProxyReceiver();
+  initialized = false;
+  canvas;
+};
+AppComponent = __decorateClass([
+  singleton_default()
+], AppComponent);
+
+// src/common/models/proxy-event-subjects.models.ts
+var ProxyEventSubjectsModel = class {
+  contextmenu$$;
+  resize$$;
+  mousedown$$;
+  mousemove$$;
+  mouseup$$;
+  pointerdown$$;
+  pointermove$$;
+  pointercancel$$;
+  pointerup$$;
+  touchstart$$;
+  touchmove$$;
+  touchend$$;
+  wheel$$;
+  keydown$$;
+};
+
+// src/common/models/proxy-event-observables.model.ts
+var ProxyEventObservablesModel = class extends ProxyEventSubjectsModel {
+  contextmenu$;
+  resize$;
+  mousedown$;
+  mousemove$;
+  mouseup$;
+  pointerdown$;
+  pointermove$;
+  pointercancel$;
+  pointerup$;
+  touchstart$;
+  touchmove$;
+  touchend$;
+  wheel$;
+  keydown$;
+};
+
+// src/common/models/proxy-event-handler.model.ts
+var ProxyEventHandlersModel = class extends ProxyEventObservablesModel {
+  contextmenu;
+  resize;
+  mousedown;
+  mousemove;
+  mouseup;
+  pointerdown;
+  pointermove;
+  pointercancel;
+  pointerup;
+  touchstart;
+  touchmove;
+  touchend;
+  wheel;
+  keydown;
+};
+
+// src/common/constants/event.constants.ts
+var PROXY_EVENT_LISTENERS = [
+  "contextmenu",
+  "resize",
+  "mousedown",
+  "mousemove",
+  "mouseup",
+  "pointerdown",
+  "pointermove",
+  "pointercancel",
+  "pointerup",
+  "touchstart",
+  "touchmove",
+  "touchend",
+  "wheel",
+  "keydown"
+];
+
+// src/core/app/app.controller.ts
+var AppController = class extends ProxyEventHandlersModel {
+  constructor(component) {
+    super();
+    this.component = component;
+    for (const eventType of PROXY_EVENT_LISTENERS) {
+      this[`${eventType}$$`] = new Subject();
+      this[`${eventType}$`] = this[`${eventType}$$`].pipe();
+      this[eventType] = (event) => {
+        this.component.proxyReceiver.handleEvent({
+          ...event,
+          type: event.type || eventType
+        });
+        this[`${eventType}$$`].next(event);
+      };
+    }
+  }
+  lifecycle$$ = new Subject();
+  lifecycle$ = this.lifecycle$$.pipe();
+};
+AppController = __decorateClass([
+  singleton_default(),
+  __decorateParam(0, inject_default(AppComponent))
+], AppController);
+
+// src/core/app/timer/timer.component.ts
+import { Clock } from "three";
+var TimerComponent = class {
+  clock = new Clock();
+  frame = 1e3 / 60;
+  delta = 0;
+  deltaRatio = 0;
+  enabled = false;
+};
+TimerComponent = __decorateClass([
+  singleton_default()
+], TimerComponent);
+
+// src/core/app/renderer/renderer.component.ts
+import {
+  Camera as Camera3,
+  CineonToneMapping,
+  PCFSoftShadowMap,
+  SRGBColorSpace,
+  WebGLRenderer
+} from "three";
+
+// src/core/app/world/world.component.ts
+import { Scene } from "three";
+var WorldComponent = class {
+  scene = new Scene();
+  enabled = true;
+};
+WorldComponent = __decorateClass([
+  singleton_default()
+], WorldComponent);
+
+// src/core/app/camera/camera.component.ts
+import {
+  Camera,
+  OrthographicCamera,
+  PerspectiveCamera
+} from "three";
+
+// src/core/app/sizes/sizes.component.ts
+var SizesComponent = class {
+  width = 0;
+  height = 0;
+  aspect = 0;
+  pixelRatio = 0;
+  frustrum = 5;
+  enabled = true;
+  init(canvas, enabled) {
+    this.height = Number(canvas.height ?? this.height);
+    this.width = Number(canvas.width ?? this.width);
+    this.aspect = this.width / this.height;
+    this.enabled = enabled === void 0 ? true : !!enabled;
+  }
+};
+SizesComponent = __decorateClass([
+  singleton_default()
+], SizesComponent);
+
+// src/core/app/camera/camera.component.ts
+var CameraComponent = class {
+  constructor(sizesComponent) {
+    this.sizesComponent = sizesComponent;
+  }
+  instance;
+  miniCamera;
+  enabled = true;
+  set aspectRatio(ratio) {
+    if (this.instance instanceof PerspectiveCamera)
+      this.instance.aspect = ratio;
+    if (this.instance instanceof PerspectiveCamera || this.instance instanceof OrthographicCamera)
+      this.instance?.updateProjectionMatrix();
+  }
+  set quaternion(quaternion) {
+    this.instance?.quaternion.copy(quaternion);
+  }
+  set position(position) {
+    this.instance?.position.copy(position);
+  }
+  set rotation(rotation) {
+    this.instance?.rotation.copy(rotation);
+  }
+  initDefaultCamera(cameraType) {
+    this.removeCamera();
+    if (cameraType === 0 /* PERSPECTIVE */ || cameraType === void 0) {
+      this.instance = new PerspectiveCamera(
+        70,
+        this.sizesComponent.width / this.sizesComponent.height,
+        1e-4,
+        100
+      );
+      this.instance.position.z = 8;
+      return;
+    }
+    if (cameraType === 1 /* ORTHOGRAPHIC */) {
+      this.instance = new OrthographicCamera(
+        -this.sizesComponent.aspect * this.sizesComponent.frustrum / 2,
+        this.sizesComponent.aspect * this.sizesComponent.frustrum / 2,
+        this.sizesComponent.frustrum / 2,
+        -this.sizesComponent.frustrum / 2,
+        -50,
+        50
+      );
+    }
+  }
+  setMiniCamera() {
+    this.removeMiniCamera();
+    this.miniCamera = new PerspectiveCamera(
+      75,
+      this.sizesComponent.width / this.sizesComponent.height,
+      0.1,
+      500
+    );
+    this.miniCamera.position.z = 10;
+    this.miniCamera.position.x = -5;
+  }
+  removeCamera() {
+    if (!(this.instance instanceof Camera)) return;
+    if (this.instance instanceof PerspectiveCamera || this.instance instanceof OrthographicCamera)
+      this.instance.clearViewOffset();
+    this.instance.clear();
+    this.instance = void 0;
+  }
+  removeMiniCamera() {
+    if (!(this.miniCamera instanceof Camera)) return;
+    this.miniCamera.clearViewOffset();
+    this.miniCamera.clear();
+    this.miniCamera = void 0;
+  }
+};
+CameraComponent = __decorateClass([
+  singleton_default(),
+  __decorateParam(0, inject_default(SizesComponent))
+], CameraComponent);
+
+// src/core/app/debug/debug.component.ts
+import { AxesHelper, Camera as Camera2, CameraHelper, GridHelper } from "three";
+import { OrbitControls } from "three/examples/jsm/Addons";
+var DebugComponent = class {
+  constructor(appComponent, cameraComponent, worldComponent) {
+    this.appComponent = appComponent;
+    this.cameraComponent = cameraComponent;
+    this.worldComponent = worldComponent;
+  }
+  enabled = true;
+  cameraControls;
+  miniCameraControls;
+  cameraHelper;
+  axesHelper;
+  gridHelper;
+  _setCameraOrbitControl() {
+    if (this.cameraControls) {
+      this.cameraControls?.dispose();
+      this.cameraControls = void 0;
+    }
+    if (!this.enabled || !(this.cameraComponent.instance instanceof Camera2))
+      return;
+    if (this.cameraComponent.instance instanceof Camera2) {
+      this.cameraControls = new OrbitControls(
+        this.cameraComponent.instance,
+        this.appComponent.proxyReceiver
+      );
+      if (this.cameraControls) this.cameraControls.enableDamping = true;
+    }
+  }
+  _setMiniCameraOrbitControls() {
+    if (this.miniCameraControls) {
+      this.miniCameraControls.dispose();
+      this.miniCameraControls = void 0;
+    }
+    if (!this.enabled) return;
+    if (this.cameraComponent.miniCamera) {
+      this.miniCameraControls = new OrbitControls(
+        this.cameraComponent.miniCamera,
+        this.appComponent.proxyReceiver
+      );
+      this.miniCameraControls.enableDamping = true;
+    }
+  }
+  _setCameraHelper() {
+    if (this.cameraHelper) {
+      this.worldComponent.scene.remove(this.cameraHelper);
+      this.cameraHelper = void 0;
+    }
+    if (!this.enabled) return;
+    if (this.cameraComponent.instance) {
+      this.cameraHelper = new CameraHelper(this.cameraComponent.instance);
+      this.worldComponent.scene.add(this.cameraHelper);
+    }
+  }
+  _setAxesHelper(axesSizes) {
+    const axesHelper = new AxesHelper(axesSizes);
+    this.worldComponent.scene.add(axesHelper);
+  }
+  _setGridHelper(gridSizes) {
+    const axesHelper = new GridHelper(gridSizes, gridSizes);
+    this.worldComponent.scene.add(axesHelper);
+  }
+  init(props) {
+    this._setCameraOrbitControl();
+    this._setMiniCameraOrbitControls();
+    this._setCameraHelper();
+    if (typeof props?.axesSizes === "number")
+      this._setAxesHelper(props.axesSizes);
+    if (typeof props?.gridSizes === "number")
+      this._setGridHelper(props.gridSizes);
+  }
+  update() {
+    if (!this.enabled) return;
+    this.cameraControls?.update();
+    this.miniCameraControls?.update();
+  }
+  dispose() {
+    if (this.cameraHelper) {
+      this.worldComponent.scene.remove(this.cameraHelper);
+      this.cameraHelper = void 0;
+    }
+    if (this.cameraControls) {
+      this.cameraControls.dispose();
+      this.cameraControls = void 0;
+    }
+    if (this.miniCameraControls) {
+      this.miniCameraControls.dispose();
+      this.miniCameraControls = void 0;
+    }
+  }
+};
+DebugComponent = __decorateClass([
+  singleton_default(),
+  __decorateParam(0, inject_default(AppComponent)),
+  __decorateParam(1, inject_default(CameraComponent)),
+  __decorateParam(2, inject_default(WorldComponent))
+], DebugComponent);
+
+// src/core/app/renderer/renderer.component.ts
+var RendererComponent = class {
+  constructor(worldComponent, cameraComponent, sizesComponent, debugComponent) {
+    this.worldComponent = worldComponent;
+    this.cameraComponent = cameraComponent;
+    this.sizesComponent = sizesComponent;
+    this.debugComponent = debugComponent;
+  }
+  enabled = true;
+  instance;
+  init(canvas) {
+    this.instance = new WebGLRenderer({
+      canvas,
+      context: canvas.getContext("webgl2", {
+        stencil: true,
+        powerPreference: "high-performance"
+      }),
+      powerPreference: "high-performance",
+      depth: true,
+      antialias: true
+    });
+    this.instance.autoClear = false;
+    this.instance.setPixelRatio(RendererComponent.RENDERER_PIXEL_RATIO);
+    this.instance.setClearColor(0, 0);
+    this.instance.shadowMap.enabled = true;
+    this.instance.shadowMap.type = PCFSoftShadowMap;
+    this.instance.outputColorSpace = SRGBColorSpace;
+    this.instance.toneMapping = CineonToneMapping;
+    this.instance.toneMappingExposure = 1.75;
+  }
+  setSize(width, height) {
+    this.instance?.setSize(width, height);
+  }
+  render() {
+    if (!(this.enabled && this.cameraComponent.instance instanceof Camera3 && this.instance instanceof WebGLRenderer))
+      return;
+    this.instance.setViewport(
+      0,
+      0,
+      this.sizesComponent.width,
+      this.sizesComponent.height
+    );
+    this.instance.render(
+      this.worldComponent.scene,
+      this.cameraComponent.instance
+    );
+    if (this.debugComponent.enabled && this.cameraComponent.miniCamera) {
+      this.instance.setScissorTest(true);
+      this.instance.setViewport(
+        this.sizesComponent.width - this.sizesComponent.width / 3,
+        this.sizesComponent.height - this.sizesComponent.height / 3,
+        this.sizesComponent.width / 3,
+        this.sizesComponent.height / 3
+      );
+      this.instance.setScissor(
+        this.sizesComponent.width - this.sizesComponent.width / 3,
+        this.sizesComponent.height - this.sizesComponent.height / 3,
+        this.sizesComponent.width / 3,
+        this.sizesComponent.height / 3
+      );
+      this.instance.render(
+        this.worldComponent.scene,
+        this.cameraComponent.miniCamera
+      );
+      this.instance.setScissorTest(false);
+    }
+  }
+};
+__publicField(RendererComponent, "RENDERER_PIXEL_RATIO", 1);
+RendererComponent = __decorateClass([
+  singleton_default(),
+  __decorateParam(0, inject_default(WorldComponent)),
+  __decorateParam(1, inject_default(CameraComponent)),
+  __decorateParam(2, inject_default(SizesComponent)),
+  __decorateParam(3, inject_default(DebugComponent))
+], RendererComponent);
+
+// src/core/app/timer/timer.controller.ts
+import { Subject as Subject2 } from "rxjs";
+var TimerController = class {
+  constructor(component, appController) {
+    this.component = component;
+    this.appController = appController;
+  }
+  step$$ = new Subject2();
+  enable$$ = new Subject2();
+  step$ = this.step$$.pipe();
+  enable$ = this.enable$$.pipe();
+  step() {
+    this.appController.lifecycle$$.next(1 /* STEP_STARTED */);
+    if (this.component.enabled) {
+      this.component.delta = this.component.clock.getDelta() ?? this.component.frame;
+      this.component.deltaRatio = this.component.delta * 1e3 / this.component.frame;
+      this.step$$.next({
+        delta: this.component.delta,
+        deltaRatio: this.component.deltaRatio
+      });
+    }
+    this.appController.lifecycle$$.next(2 /* STEP_ENDED */);
+  }
+};
+TimerController = __decorateClass([
+  singleton_default(),
+  __decorateParam(0, inject_default(TimerComponent)),
+  __decorateParam(1, inject_default(AppController))
+], TimerController);
+
+// src/core/app/timer/timer.module.ts
+var TimerModule = class {
+  constructor(component, controller, rendererComponent) {
+    this.component = component;
+    this.controller = controller;
+    this.rendererComponent = rendererComponent;
+  }
+  init(startTimer) {
+    this.controller.enable$.subscribe((status) => {
+      this.component.enabled = !!status;
+      if (status)
+        this.rendererComponent.instance?.setAnimationLoop(
+          this.controller.step.bind(this.controller)
+        );
+      else this.rendererComponent.instance?.setAnimationLoop(null);
+    });
+    if (startTimer) this.enabled(true);
+  }
+  clock() {
+    return this.component.clock;
+  }
+  frame() {
+    return this.component.frame;
+  }
+  delta(value) {
+    if (typeof value === "number") this.component.delta = value;
+    return this.component.delta;
+  }
+  deltaRatio(value) {
+    if (typeof value === "number") this.component.deltaRatio = value;
+    return this.component.deltaRatio;
+  }
+  enabled(value) {
+    if (typeof value === "boolean") this.controller.enable$$.next(value);
+    return this.component.enabled;
+  }
+  dispose() {
+    this.controller.step$$.complete();
+    this.controller.enable$$.complete();
+  }
+  enabled$() {
+    return this.controller.enable$;
+  }
+  step$() {
+    return this.controller.step$;
+  }
+};
+TimerModule = __decorateClass([
+  singleton_default(),
+  __decorateParam(0, inject_default(TimerComponent)),
+  __decorateParam(1, inject_default(TimerController)),
+  __decorateParam(2, inject_default(RendererComponent))
+], TimerModule);
+
+// src/core/app/camera/camera.module.ts
+import {
+  OrthographicCamera as OrthographicCamera2,
+  PerspectiveCamera as PerspectiveCamera2
+} from "three";
+
+// src/core/app/camera/camera.controller.ts
+import { filter, Subject as Subject3 } from "rxjs";
+var CameraController = class {
+  constructor(component, timerController) {
+    this.component = component;
+    this.timerController = timerController;
+    this.step$ = this.timerController.step$.pipe(
+      filter(() => this.component.enabled)
+    );
+  }
+  enable$$ = new Subject3();
+  enable$ = this.enable$$.pipe();
+  step$;
+};
+CameraController = __decorateClass([
+  singleton_default(),
+  __decorateParam(0, inject_default(CameraComponent)),
+  __decorateParam(1, inject_default(TimerController))
+], CameraController);
+
+// src/core/app/camera/camera.module.ts
+var CameraModule = class {
+  constructor(component, sizesComponent, controller) {
+    this.component = component;
+    this.sizesComponent = sizesComponent;
+    this.controller = controller;
+  }
+  init(withMiniCamera) {
+    this.component.initDefaultCamera();
+    if (withMiniCamera) this.component.setMiniCamera();
+    this.controller.enable$.subscribe((status) => {
+      this.component.enabled = !!status;
+    });
+    this.controller.step$.subscribe(() => {
+      if (!this.component.enabled) return;
+      this.component.aspectRatio = this.sizesComponent.aspect;
+      if (this.component.instance instanceof PerspectiveCamera2 || this.component.instance instanceof OrthographicCamera2)
+        this.component.instance?.updateProjectionMatrix();
+      this.component.miniCamera?.updateProjectionMatrix();
+    });
+  }
+  dispose() {
+    this.component.removeCamera();
+    this.component.removeMiniCamera();
+  }
+  aspectRatio(value) {
+    if (value) this.component.aspectRatio = value;
+    return this.component.aspectRatio;
+  }
+  enabled(value) {
+    if (typeof value === "boolean") this.controller.enable$$.next(value);
+    return this.component.enabled;
+  }
+  instance(value) {
+    if (value) this.component.instance = value;
+    return this.component.instance;
+  }
+  miniCamera(value) {
+    if (value) this.component.miniCamera = value;
+    return this.component.miniCamera;
+  }
+  position(value) {
+    if (value) this.component.position = value;
+    return this.component.position;
+  }
+  quaternion(value) {
+    if (value) this.component.quaternion = value;
+    return this.component.quaternion;
+  }
+  enabled$() {
+    return this.controller.enable$;
+  }
+};
+CameraModule = __decorateClass([
+  singleton_default(),
+  __decorateParam(0, inject_default(CameraComponent)),
+  __decorateParam(1, inject_default(SizesComponent)),
+  __decorateParam(2, inject_default(CameraController))
+], CameraModule);
+
+// src/core/app/renderer/renderer.controller.ts
+import { filter as filter3, Subject as Subject5 } from "rxjs";
+
+// src/core/app/sizes/sizes.controller.ts
+import { filter as filter2, Subject as Subject4 } from "rxjs";
+var SizesController = class {
+  constructor(appController, component) {
+    this.appController = appController;
+    this.component = component;
+    this.resize$ = this.appController.resize$$.pipe(
+      filter2(() => this.component.enabled)
+    );
+  }
+  enable$$ = new Subject4();
+  enable$ = this.enable$$.pipe();
+  resize$;
+};
+SizesController = __decorateClass([
+  singleton_default(),
+  __decorateParam(0, inject_default(AppController)),
+  __decorateParam(1, inject_default(SizesComponent))
+], SizesController);
+
+// src/core/app/renderer/renderer.controller.ts
+var RendererController = class {
+  constructor(rendererComponent, timerController, sizesController) {
+    this.rendererComponent = rendererComponent;
+    this.timerController = timerController;
+    this.sizesController = sizesController;
+    this.step$ = this.timerController.step$.pipe(
+      filter3(() => this.rendererComponent.enabled)
+    );
+    this.resize$ = this.sizesController.resize$.pipe(
+      filter3(() => this.rendererComponent.enabled)
+    );
+  }
+  enable$$ = new Subject5();
+  enable$ = this.enable$$.pipe();
+  step$;
+  resize$;
+};
+RendererController = __decorateClass([
+  singleton_default(),
+  __decorateParam(0, inject_default(RendererComponent)),
+  __decorateParam(1, inject_default(TimerController)),
+  __decorateParam(2, inject_default(SizesController))
+], RendererController);
+
+// src/core/app/renderer/renderer.module.ts
+var RendererModule = class {
+  constructor(component, controller) {
+    this.component = component;
+    this.controller = controller;
+  }
+  init(canvas) {
+    this.controller.enable$.subscribe((status) => {
+      this.component.enabled = !!status;
+    });
+    this.controller.step$.subscribe(() => this.component.render());
+    this.controller.resize$.subscribe(
+      (size) => this.component.setSize(size.windowWidth, size.windowHeight)
+    );
+    this.component.init(canvas);
+  }
+  dispose() {
+    this.controller.enable$$.unsubscribe();
+  }
+  enabled(value) {
+    if (typeof value === "boolean") this.controller.enable$$.next(value);
+    return this.component.enabled;
+  }
+  instance() {
+    return this.component.instance;
+  }
+  setSize(value) {
+    return this.component.setSize(value.x, value.y);
+  }
+  render() {
+    return this.component.render();
+  }
+  enabled$() {
+    return this.controller.enable$;
+  }
+};
+RendererModule = __decorateClass([
+  singleton_default(),
+  __decorateParam(0, inject_default(RendererComponent)),
+  __decorateParam(1, inject_default(RendererController))
+], RendererModule);
+
+// src/core/app/sizes/sizes.module.ts
+var SizesModule = class {
+  constructor(component, controller) {
+    this.component = component;
+    this.controller = controller;
+  }
+  init(canvas) {
+    this.controller.enable$.subscribe((status) => {
+      this.component.enabled = !!status;
+    });
+    this.controller.resize$.subscribe((size) => {
+      this.component.width = size.windowWidth;
+      this.component.height = size.windowHeight;
+      this.component.aspect = size.windowWidth / size.windowHeight;
+    });
+    this.component.init(canvas);
+  }
+  dispose() {
+  }
+  aspect(value) {
+    if (typeof value === "number") this.component.aspect = value;
+    return this.component.aspect;
+  }
+  enabled(value) {
+    if (typeof value === "boolean") this.controller.enable$$.next(value);
+    return this.component.enabled;
+  }
+  frustrum(value) {
+    if (typeof value === "number") this.component.frustrum = value;
+    return this.component.frustrum;
+  }
+  height(value) {
+    if (typeof value === "number") this.component.height = value;
+    return this.component.height;
+  }
+  pixelRatio(value) {
+    if (typeof value === "number") this.component.pixelRatio = value;
+    return this.component.pixelRatio;
+  }
+  width(value) {
+    if (typeof value === "number") this.component.width = value;
+    return this.component.width;
+  }
+  enabled$() {
+    return this.controller.enable$;
+  }
+  resize$() {
+    return this.controller.resize$;
+  }
+};
+SizesModule = __decorateClass([
+  singleton_default(),
+  __decorateParam(0, inject_default(SizesComponent)),
+  __decorateParam(1, inject_default(SizesController))
+], SizesModule);
+
+// src/core/app/world/world.module.ts
+import { Scene as Scene2 } from "three";
+
+// src/core/app/world/world.controller.ts
+import { Subject as Subject6 } from "rxjs";
+var WorldController = class {
+  enable$$ = new Subject6();
+  enable$ = this.enable$$.pipe();
+};
+WorldController = __decorateClass([
+  singleton_default()
+], WorldController);
+
+// src/core/app/world/world.module.ts
+var WorldModule = class {
+  constructor(component, controller) {
+    this.component = component;
+    this.controller = controller;
+  }
+  init() {
+    this.controller.enable$.subscribe((status) => {
+      this.component.enabled = !!status;
+    });
+  }
+  dispose() {
+  }
+  scene(value) {
+    if (value instanceof Scene2) this.component.scene = value;
+    return this.component.scene;
+  }
+  enabled(value) {
+    if (typeof value === "boolean") this.controller.enable$$.next(value);
+    return this.component.enabled;
+  }
+  get enable$() {
+    return this.controller.enable$;
+  }
+};
+WorldModule = __decorateClass([
+  singleton_default(),
+  __decorateParam(0, inject_default(WorldComponent)),
+  __decorateParam(1, inject_default(WorldController))
+], WorldModule);
+
+// src/core/app/debug/debug.controller.ts
+import { Subject as Subject7 } from "rxjs";
+var DebugController = class {
+  constructor(timerController) {
+    this.timerController = timerController;
+    this.step$ = this.timerController.step$;
+  }
+  enable$$ = new Subject7();
+  enable$ = this.enable$$.pipe();
+  step$;
+};
+DebugController = __decorateClass([
+  singleton_default(),
+  __decorateParam(0, inject_default(TimerController))
+], DebugController);
+
+// src/core/app/debug/debug.module.ts
+var DebugModule = class {
+  constructor(component, controller) {
+    this.component = component;
+    this.controller = controller;
+    this.controller.step$.subscribe(() => {
+      this.component.update();
+    });
+  }
+  init(props) {
+    this.component.init(props);
+  }
+  dispose() {
+    this.component.dispose();
+  }
+  axesHelper() {
+    return this.component.axesHelper;
+  }
+  cameraControls() {
+    return this.component.cameraControls;
+  }
+  cameraHelper() {
+    return this.component.cameraHelper;
+  }
+  enabled(value) {
+    if (value) this.component.enabled = value;
+    return this.component.enabled;
+  }
+  gridHelper() {
+    return this.component.gridHelper;
+  }
+  miniCameraControls() {
+    return this.component.miniCameraControls;
+  }
+  enabled$() {
+    return this.controller.enable$;
+  }
+};
+DebugModule = __decorateClass([
+  singleton_default(),
+  __decorateParam(0, inject_default(DebugComponent)),
+  __decorateParam(1, inject_default(DebugController))
+], DebugModule);
+
+// src/common/models/app-proxy-event-handler.model.ts
+var AppProxyEventHandlersModel = class {
+  contextmenu$;
+  resize$;
+  mousedown$;
+  mousemove$;
+  mouseup$;
+  pointerdown$;
+  pointermove$;
+  pointercancel$;
+  pointerup$;
+  touchstart$;
+  touchmove$;
+  touchend$;
+  wheel$;
+  keydown$;
+  contextmenu;
+  resize;
+  mousedown;
+  mousemove;
+  mouseup;
+  pointerdown;
+  pointermove;
+  pointercancel;
+  pointerup;
+  touchstart;
+  touchmove;
+  touchend;
+  wheel;
+  keydown;
+};
+
+// src/core/app/app.module.ts
+var AppModule = class extends AppProxyEventHandlersModel {
+  constructor(controller, component, timer, sizes, camera, world, renderer, debug) {
+    super();
+    this.controller = controller;
+    this.component = component;
+    this.timer = timer;
+    this.sizes = sizes;
+    this.camera = camera;
+    this.world = world;
+    this.renderer = renderer;
+    this.debug = debug;
+    this._initProxyEvents();
+    self.addEventListener("message", this._onMessage.bind(this));
+  }
+  _initProxyEvents() {
+    PROXY_EVENT_LISTENERS.forEach((key) => {
+      this[`${key}$`] = () => this.controller?.[`${key}$`];
+      this[key] = (event) => this.controller?.[key]?.(event);
+    });
+  }
+  _onMessage(event) {
+    if (!event.data?.canvas || this.component.initialized) return;
+    const startTimer = !!event.data?.startTimer;
+    const withMiniCamera = !!event.data?.withMiniCamera;
+    const fullScreen = !!event.data?.fullScreen;
+    this.init({
+      ...event.data,
+      startTimer,
+      withMiniCamera,
+      fullScreen
+    });
+  }
+  init(props) {
+    if (!props.canvas || this.component.initialized) return;
+    this.component.initialized = true;
+    props.canvas["style"] = {
+      width: props.canvas.width + "",
+      height: props.canvas.height + ""
+    };
+    const canvas = props.canvas;
+    this.component.canvas = canvas;
+    this.sizes.init(canvas);
+    this.camera.init(props.withMiniCamera);
+    this.world.init();
+    this.renderer.init(canvas);
+    this.timer.init(props.startTimer);
+    this.debug.init(props);
+    this.controller.lifecycle$$.next(0 /* INITIALIZED */);
+  }
+  get canvas() {
+    return this.component.canvas;
+  }
+  get initialized() {
+    return this.component.initialized;
+  }
+  isInitialized() {
+    return this.component.initialized;
+  }
+  dispose() {
+    this.sizes.dispose();
+    this.camera.dispose();
+    this.world.dispose();
+    this.renderer.dispose();
+    this.timer.dispose();
+    this.debug.dispose();
+    this.controller.lifecycle$$.next(3 /* DISPOSED */);
+    this.controller.lifecycle$$.complete();
+    self.removeEventListener("message", this._onMessage.bind(this));
+  }
+  lifecycle$() {
+    return this.controller.lifecycle$;
+  }
+};
+AppModule = __decorateClass([
+  singleton_default(),
+  __decorateParam(0, inject_default(AppController)),
+  __decorateParam(1, inject_default(AppComponent)),
+  __decorateParam(2, inject_default(TimerModule)),
+  __decorateParam(3, inject_default(SizesModule)),
+  __decorateParam(4, inject_default(CameraModule)),
+  __decorateParam(5, inject_default(WorldModule)),
+  __decorateParam(6, inject_default(RendererModule)),
+  __decorateParam(7, inject_default(DebugModule))
+], AppModule);
+var appModule = instance.resolve(AppModule);
+
+// src/common/serializers/object3d.serializer.ts
+import { Object3D, ObjectLoader } from "three";
+import { deserializeJSON, toSerializedJSON } from "@quick-threejs/utils";
+var objectLoader = new ObjectLoader();
+var object3DSerializer = {
+  deserialize(message, defaultHandler) {
+    if (message?.isSerialized) return deserializeJSON(message, objectLoader);
+    return defaultHandler(message);
+  },
+  serialize(thing, defaultHandler) {
+    if (thing instanceof Object3D) return toSerializedJSON(thing);
+    return defaultHandler(thing);
+  }
+};
+
+// src/core/app/app.module-worker.ts
+registerSerializer(object3DSerializer);
+var launchApp = (props) => {
+  appModule.lifecycle$().subscribe((state) => {
+    if (state === 0 /* INITIALIZED */ && props?.onReady) {
+      props.onReady(appModule);
+    }
+  });
+  return appModule;
+};
+var proxyEventHandlers = {};
+var proxyObservables = {};
+PROXY_EVENT_LISTENERS.forEach((key) => {
+  proxyEventHandlers[key] = appModule[key]?.bind?.(appModule);
+});
+expose({
+  ...proxyEventHandlers,
+  ...proxyObservables,
+  init: appModule.init.bind(appModule),
+  dispose: appModule.dispose.bind(appModule),
+  isInitialized: appModule.isInitialized.bind(appModule),
+  lifecycle$: appModule.lifecycle$.bind(appModule)
+});
+export {
+  launchApp
+};
+/*! Bundled license information:
+
+reflect-metadata/Reflect.js:
+  (*! *****************************************************************************
+  Copyright (C) Microsoft. All rights reserved.
+  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of the
+  License at http://www.apache.org/licenses/LICENSE-2.0
+  
+  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+  MERCHANTABLITY OR NON-INFRINGEMENT.
+  
+  See the Apache Version 2.0 License for specific language governing permissions
+  and limitations under the License.
+  ***************************************************************************** *)
+
+tslib/tslib.es6.js:
+  (*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+  
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+  
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** *)
+*/
+//# sourceMappingURL=main.worker.mjs.map