@kithinji/orca 1.0.0

package/dist/browser/index.mjs

@@ -0,0 +1,3250 @@
+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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, 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
+));
+
+// node_modules/reflect-metadata/Reflect.js
+var require_Reflect = __commonJS({
+  "node_modules/reflect-metadata/Reflect.js"() {
+    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 _a2 = 0, parentKeys_1 = parentKeys; _a2 < parentKeys_1.length; _a2++) {
+            var key = parentKeys_1[_a2];
+            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, insert2) {
+                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 && insert2) {
+                  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/index.browser.ts
+var import_reflect_metadata = __toESM(require_Reflect());
+
+// src/shared/index.ts
+var shared_exports = {};
+__export(shared_exports, {
+  BOOTSTRAP: () => BOOTSTRAP,
+  BOOTSTRAP_VNODE: () => BOOTSTRAP_VNODE,
+  Body: () => Body,
+  COMPONENT: () => COMPONENT,
+  COMPONENT_DEPS: () => COMPONENT_DEPS,
+  COMPONENT_PROVIDERS: () => COMPONENT_PROVIDERS,
+  CONTROLLER: () => CONTROLLER,
+  CONTROLLERS_KEY: () => CONTROLLERS_KEY,
+  CONTROLLER_PREFIX_KEY: () => CONTROLLER_PREFIX_KEY,
+  Compiler: () => Compiler,
+  Component: () => Component,
+  Controller: () => Controller,
+  DECLARATIONS_KEY: () => DECLARATIONS_KEY,
+  DESIGN_PARAMTYPES: () => DESIGN_PARAMTYPES,
+  ERROR_ELEMENT: () => ERROR_ELEMENT,
+  EXPORTS_KEY: () => EXPORTS_KEY,
+  EXPRESS_ADAPTER_HOST: () => EXPRESS_ADAPTER_HOST,
+  Fragment: () => Fragment,
+  Get: () => Get,
+  HTTP_METHOD_KEY: () => HTTP_METHOD_KEY,
+  HandlerParamType: () => HandlerParamType,
+  HttpClient: () => HttpClient,
+  HttpClientModule: () => HttpClientModule,
+  HttpMethod: () => HttpMethod,
+  IMPORTS_KEY: () => IMPORTS_KEY,
+  INJECTABLE: () => INJECTABLE,
+  INJECT_TOKENS_KEY: () => INJECT_TOKENS_KEY,
+  Inject: () => Inject,
+  Injectable: () => Injectable,
+  Injector: () => Injector,
+  Module: () => Module,
+  NODE: () => NODE,
+  Navigate: () => Navigate,
+  Node: () => Node2,
+  ORCA_CLIENT_COMPONENT: () => ORCA_CLIENT_COMPONENT,
+  ORCA_ELEMENT_TYPE: () => ORCA_ELEMENT_TYPE,
+  ORCA_FRAGMENT_TYPE: () => ORCA_FRAGMENT_TYPE,
+  OSC: () => OSC,
+  Observable: () => Observable,
+  OrcaComponent: () => OrcaComponent,
+  PARAMS_META_KEY: () => PARAMS_META_KEY,
+  PATH_KEY: () => PATH_KEY,
+  PENDING_REFERENCE_TYPE: () => PENDING_REFERENCE_TYPE,
+  PROVIDERS_KEY: () => PROVIDERS_KEY,
+  Param: () => Param,
+  Post: () => Post,
+  ProviderNormalizer: () => ProviderNormalizer,
+  RouterModule: () => RouterModule,
+  RouterOutlet: () => RouterOutlet,
+  SIGNATURE_METADATA_KEY: () => SIGNATURE_METADATA_KEY,
+  Signature: () => Signature,
+  StreamRenderer: () => StreamRenderer,
+  StringRenderer: () => StringRenderer,
+  VNode: () => VNode,
+  assert$: () => assert$,
+  collectAllProvidersFromNode: () => collectAllProvidersFromNode,
+  computed: () => computed,
+  effect: () => effect,
+  from: () => from,
+  getCurrentInjector: () => getCurrentInjector,
+  getSignatureMetadata: () => getSignatureMetadata,
+  hasSignature: () => hasSignature,
+  interval: () => interval,
+  isClassComponent: () => isClassComponent,
+  isFragment: () => isFragment,
+  isIntrinsicElement: () => isIntrinsicElement,
+  isObservable: () => isObservable,
+  isSignal: () => isSignal,
+  jsx: () => jsx,
+  jsxs: () => jsxs,
+  observable: () => observable,
+  of: () => of,
+  parseSignatureSchemas: () => parseSignatureSchemas,
+  setCurrentInjector: () => setCurrentInjector,
+  signal: () => signal,
+  store: () => store,
+  symbolValueReplacer: () => symbolValueReplacer,
+  symbolValueReviver: () => symbolValueReviver,
+  toSignal: () => toSignal
+});
+
+// src/shared/store.ts
+var Store = class {
+  constructor() {
+    this.namespace = /* @__PURE__ */ new Map();
+  }
+  set(name, value) {
+    this.namespace.set(name, value);
+  }
+  get(name) {
+    return this.namespace.get(name);
+  }
+  update(name, updater) {
+    const current = this.get(name);
+    const next = updater(current);
+    this.set(name, next);
+  }
+};
+var store = new Store();
+
+// src/shared/symbols.ts
+var DECLARATIONS_KEY = Symbol("orca:declarations");
+var PROVIDERS_KEY = Symbol("orca:providers");
+var CONTROLLERS_KEY = Symbol("orca:controllers");
+var BOOTSTRAP = Symbol("orca:bootstrap");
+var BOOTSTRAP_VNODE = Symbol("orca:bootstrap:vnode");
+var IMPORTS_KEY = Symbol("orca:imports");
+var EXPORTS_KEY = Symbol("orca:exports");
+var INJECTABLE = Symbol("orca:injectable");
+var COMPONENT = Symbol("orca:component");
+var COMPONENT_PROVIDERS = Symbol("orca:component:providers");
+var COMPONENT_DEPS = Symbol("orca:component:deps");
+var INJECT_TOKENS_KEY = Symbol("orca:injectTokens");
+var NODE = Symbol("orca:node");
+var DESIGN_PARAMTYPES = "design:paramtypes";
+var CONTROLLER = Symbol("orca:controller");
+var CONTROLLER_PREFIX_KEY = Symbol("orca:controllerPrefix");
+var PARAMS_META_KEY = Symbol("orca:paramsMeta");
+var HTTP_METHOD_KEY = Symbol("orca:method");
+var PATH_KEY = Symbol("orca:path");
+var EXPRESS_ADAPTER_HOST = Symbol("orca:express");
+var SIGNATURE_METADATA_KEY = Symbol("orca:signature:schemas");
+var ERROR_ELEMENT = Symbol.for("orca:error");
+var ORCA_ELEMENT_TYPE = Symbol.for("orca:element");
+var ORCA_FRAGMENT_TYPE = Symbol.for("orca:fragment");
+var ORCA_CLIENT_COMPONENT = Symbol.for("orca.client.component");
+var PENDING_REFERENCE_TYPE = Symbol.for("orca:pending_reference");
+
+// src/shared/types.ts
+var HandlerParamType = /* @__PURE__ */ ((HandlerParamType2) => {
+  HandlerParamType2["ROUTE_PARAM"] = "ROUTE_PARAM";
+  HandlerParamType2["BODY"] = "BODY";
+  return HandlerParamType2;
+})(HandlerParamType || {});
+var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
+  HttpMethod2["GET"] = "get";
+  HttpMethod2["POST"] = "post";
+  return HttpMethod2;
+})(HttpMethod || {});
+
+// src/shared/decorators.ts
+function Module(params = {}) {
+  return function(target) {
+    Reflect.defineMetadata(PROVIDERS_KEY, params.providers || [], target);
+    Reflect.defineMetadata(DECLARATIONS_KEY, params.declarations || [], target);
+    Reflect.defineMetadata(IMPORTS_KEY, params.imports || [], target);
+    Reflect.defineMetadata(EXPORTS_KEY, params.exports || [], target);
+    Reflect.defineMetadata(CONTROLLERS_KEY, params.controllers || [], target);
+    Reflect.defineMetadata(BOOTSTRAP, params.bootstrap || [], target);
+  };
+}
+function Injectable() {
+  return function(target) {
+    Reflect.defineMetadata(INJECTABLE, true, target);
+    return target;
+  };
+}
+function Component(params = {}) {
+  return function(target) {
+    store.update("components", (current) => {
+      const next = current ?? /* @__PURE__ */ new Map();
+      next.set(target.name, target);
+      return next;
+    });
+    Reflect.defineMetadata(COMPONENT, true, target);
+    Reflect.defineMetadata(COMPONENT_PROVIDERS, params.providers || [], target);
+    Reflect.defineMetadata(COMPONENT_DEPS, params.deps || [], target);
+    return target;
+  };
+}
+function Inject(token, params = {}) {
+  return function(target, _propertyKey, parameterIndex) {
+    const existingTokens = Reflect.getOwnMetadata(INJECT_TOKENS_KEY, target) || /* @__PURE__ */ new Map();
+    existingTokens.set(parameterIndex, {
+      token,
+      ...params
+    });
+    Reflect.defineMetadata(INJECT_TOKENS_KEY, existingTokens, target);
+  };
+}
+function Controller(prefix, options = {}) {
+  return function(target) {
+    Injectable()(target);
+    if (options.providedIn == "root") {
+      store.update("root_controllers", (current) => {
+        const next = current ?? /* @__PURE__ */ new Set();
+        next.add(target);
+        return next;
+      });
+    }
+    Reflect.defineMetadata(CONTROLLER_PREFIX_KEY, prefix ?? "/", target);
+    Reflect.defineMetadata(CONTROLLER, true, target);
+  };
+}
+function getHandlerParamDecorator(type, key) {
+  return function(target, methodName, index) {
+    const paramsMeta = Reflect.getMetadata(PARAMS_META_KEY, target, methodName) ?? {};
+    paramsMeta[index] = { key, type };
+    Reflect.defineMetadata(PARAMS_META_KEY, paramsMeta, target, methodName);
+  };
+}
+function Param(key) {
+  return getHandlerParamDecorator("ROUTE_PARAM" /* ROUTE_PARAM */, key);
+}
+function Body(key) {
+  return getHandlerParamDecorator("BODY" /* BODY */, key);
+}
+function getRouteDecorator(httpMethod, path) {
+  return function(target, key, descriptor) {
+    Reflect.defineMetadata(HTTP_METHOD_KEY, httpMethod, target, key);
+    Reflect.defineMetadata(PATH_KEY, path, target, key);
+  };
+}
+function Get(path) {
+  return getRouteDecorator("get" /* GET */, path ?? "");
+}
+function Post(path) {
+  return getRouteDecorator("post" /* POST */, path ?? "");
+}
+function Signature(...schemas) {
+  return function(target, propertyKey, descriptor) {
+    Reflect.defineMetadata(SIGNATURE_METADATA_KEY, schemas, target, propertyKey);
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      return originalMethod.apply(this, args);
+    };
+    return descriptor;
+  };
+}
+function getSignatureMetadata(target, propertyKey) {
+  return Reflect.getMetadata(SIGNATURE_METADATA_KEY, target, propertyKey);
+}
+function hasSignature(target, propertyKey) {
+  return Reflect.hasMetadata(SIGNATURE_METADATA_KEY, target, propertyKey);
+}
+function parseSignatureSchemas(schemas, paramCount) {
+  if (schemas.length === 0) {
+    return { paramSchemas: [] };
+  }
+  if (schemas.length === 1) {
+    return {
+      paramSchemas: [],
+      returnSchema: schemas[0]
+    };
+  }
+  const paramSchemas = schemas.slice(0, -1);
+  const returnSchema = schemas[schemas.length - 1];
+  if (paramSchemas.length !== paramCount) {
+    throw new Error(`@Signature decorator has ${paramSchemas.length} parameter schemas but method has ${paramCount} parameters. They must match.`);
+  }
+  return { paramSchemas, returnSchema };
+}
+
+// src/shared/module/node.ts
+var ProviderNormalizer = class {
+  static normalize(provider) {
+    if (typeof provider === "function") {
+      return { provide: provider, useClass: provider, scope: "singleton" };
+    }
+    return { scope: "singleton", ...provider };
+  }
+};
+var Node2 = class {
+  constructor(name) {
+    this.name = name;
+    this.children = [];
+    this.tokens = /* @__PURE__ */ new Map();
+    this.exports = /* @__PURE__ */ new Set();
+    this.providers = /* @__PURE__ */ new Map();
+  }
+  traverse(cb) {
+    cb(this);
+    this.children.forEach((child) => child.traverse(cb));
+  }
+  addProviders(providers) {
+    providers.forEach((p) => {
+      const normalized = ProviderNormalizer.normalize(p);
+      this.providers.set(normalized.provide, normalized);
+    });
+  }
+  getProviders() {
+    return this.providers;
+  }
+  setChildren(children) {
+    this.children = children;
+  }
+  addToken(token, dependencies) {
+    this.tokens.set(token, dependencies);
+  }
+  addExport(token) {
+    this.exports.add(token);
+  }
+  getTokens() {
+    return this.tokens;
+  }
+  getExports() {
+    return this.exports;
+  }
+  getChildren() {
+    return this.children;
+  }
+};
+
+// src/shared/module/compiler.ts
+var Compiler = class {
+  constructor() {
+    this.nodes = /* @__PURE__ */ new Map();
+  }
+  compile(rootModule) {
+    return this.createNode(rootModule);
+  }
+  createNode(moduleOrDynamic) {
+    const target = this.isDynamicModule(moduleOrDynamic) ? moduleOrDynamic.module : moduleOrDynamic;
+    if (this.nodes.has(target.name))
+      return this.nodes.get(target.name);
+    const node = new Node2(target.name);
+    this.nodes.set(target.name, node);
+    const imports = this.getImports(moduleOrDynamic);
+    node.setChildren(imports.map((imp) => this.createNode(imp)));
+    const providers = this.getProviders(moduleOrDynamic);
+    const controllers = this.getControllers(moduleOrDynamic);
+    const declarations = this.getDeclarations(moduleOrDynamic);
+    [...providers, ...controllers].forEach((item) => {
+      const token = this.getProviderToken(item);
+      const deps = this.extractDependencies(item);
+      node.addToken(token, deps);
+    });
+    node.addProviders(providers);
+    declarations.forEach((dec) => {
+      node.addProviders([{ provide: dec, useClass: dec, scope: "transient" }]);
+    });
+    controllers.forEach((ctrl) => {
+      node.addProviders([
+        { provide: ctrl, useClass: ctrl, scope: "singleton" }
+      ]);
+    });
+    [...declarations, ...controllers].forEach((comp) => {
+      if (Reflect.getMetadata(COMPONENT, comp)) {
+        const constructorDeps = this.getConstructorDependencies(comp);
+        node.addToken(comp, constructorDeps);
+        const componentDeps = Reflect.getMetadata(COMPONENT_DEPS, comp) || [];
+        const allDeps = [...constructorDeps, ...componentDeps];
+        node.addToken(comp, allDeps);
+        const localProviders = Reflect.getMetadata(COMPONENT_PROVIDERS, comp) || [];
+        node.addProviders(localProviders);
+        localProviders.forEach((lp) => {
+          const token = this.getProviderToken(lp);
+          const deps = this.extractDependencies(lp);
+          node.addToken(token, deps);
+        });
+      }
+    });
+    this.getExports(moduleOrDynamic).forEach((exp) => node.addExport(exp));
+    return node;
+  }
+  validate(rootNode) {
+    const errors = [];
+    const allNodes = /* @__PURE__ */ new Map();
+    this.collectAllNodes(rootNode, allNodes);
+    const tokenName = (token) => typeof token === "function" ? token.name : String(token);
+    allNodes.forEach((node) => {
+      const moduleName = node.name;
+      const providedTokens = node.getTokens();
+      const exportedTokens = node.getExports();
+      for (const exp of exportedTokens) {
+        if (!providedTokens.has(exp)) {
+          errors.push(`\u274C EXPORT ERROR in module "${moduleName}":
+   Exports token "${tokenName(exp)}" but this module does not provide it.
+   \u2192 Add it to providers/controllers/declarations, or remove from exports.`);
+        }
+      }
+      const seen = /* @__PURE__ */ new Set();
+      for (const token of providedTokens.keys()) {
+        if (seen.has(token)) {
+          errors.push(`\u274C DUPLICATE PROVIDER in module "${moduleName}":
+   Token "${tokenName(token)}" is registered more than once.
+   \u2192 Remove duplicate entries.`);
+        }
+        seen.add(token);
+      }
+      for (const [token, deps] of providedTokens) {
+        for (const dep of deps) {
+          if (providedTokens.has(dep))
+            continue;
+          const providingModule = this.findProvidingModule(dep, node, allNodes, /* @__PURE__ */ new Set());
+          if (!providingModule) {
+            const consumer = tokenName(token);
+            const missing = tokenName(dep);
+            const possibleProviders = Array.from(allNodes.values()).filter((n) => n.getTokens().has(dep)).map((n) => n.name);
+            let suggestion = "";
+            if (possibleProviders.length > 0) {
+              suggestion = `
+   \u2192 "${missing}" IS provided in: ${possibleProviders.join(", ")}
+   \u2192 Ensure one of those modules exports it AND "${moduleName}" imports that module.`;
+            } else {
+              suggestion = `
+   \u2192 "${missing}" is not provided anywhere. Add a provider for it.`;
+            }
+            errors.push(`\u274C UNRESOLVED DEPENDENCY in module "${moduleName}":
+   "${consumer}" requires "${missing}"${suggestion}`);
+          }
+        }
+      }
+      providedTokens.forEach((deps, token) => {
+        if (typeof token === "function" && Reflect.getMetadata(COMPONENT, token)) {
+          const componentDeps = Reflect.getMetadata(COMPONENT_DEPS, token) || [];
+          componentDeps.forEach((depComp) => {
+            if (typeof depComp === "function" && !Reflect.getMetadata(COMPONENT, depComp)) {
+              errors.push(`\u274C COMPONENT DEPENDENCY ERROR in module "${moduleName}":
+   Component "${tokenName(token)}" lists "${tokenName(depComp)}" in deps
+   \u2192 "${tokenName(depComp)}" is not a component (missing @Component decorator)`);
+            }
+            if (!providedTokens.has(depComp)) {
+              const providingMod = this.findProvidingModule(depComp, node, allNodes, /* @__PURE__ */ new Set());
+              if (!providingMod) {
+                errors.push(`\u274C COMPONENT DEPENDENCY ERROR in module "${moduleName}":
+   Component "${tokenName(token)}" renders "${tokenName(depComp)}"
+   \u2192 "${tokenName(depComp)}" must be in declarations or imported`);
+              }
+            }
+          });
+        }
+      });
+    });
+    return { valid: errors.length === 0, errors };
+  }
+  collectAllNodes(node, collected, visited = /* @__PURE__ */ new Set()) {
+    if (visited.has(node.name))
+      return;
+    visited.add(node.name);
+    collected.set(node.name, node);
+    node.getChildren().forEach((child) => this.collectAllNodes(child, collected, visited));
+  }
+  findProvidingModule(token, fromNode, allNodes, visited = /* @__PURE__ */ new Set()) {
+    if (visited.has(fromNode.name))
+      return null;
+    visited.add(fromNode.name);
+    for (const child of fromNode.getChildren()) {
+      if (child.getTokens().has(token) && child.getExports().has(token)) {
+        return child.name;
+      }
+      const found = this.findProvidingModule(token, child, allNodes, visited);
+      if (found)
+        return found;
+    }
+    return null;
+  }
+  getProviderToken(provider) {
+    return typeof provider === "function" ? provider : provider.provide;
+  }
+  extractDependencies(item) {
+    if (typeof item === "object" && "deps" in item && item.deps)
+      return item.deps;
+    if (typeof item === "object" && item.useClass)
+      return this.getConstructorDependencies(item.useClass);
+    if (typeof item === "function")
+      return this.getConstructorDependencies(item);
+    return [];
+  }
+  getConstructorDependencies(constructor) {
+    const injectTokens = Reflect.getOwnMetadata(INJECT_TOKENS_KEY, constructor) || /* @__PURE__ */ new Map();
+    const paramTypes = Reflect.getMetadata(DESIGN_PARAMTYPES, constructor) || [];
+    return paramTypes.map((type, index) => {
+      const injected = injectTokens.get(index);
+      if (injected?.maybe) {
+        return null;
+      }
+      return injected?.token ?? type;
+    }).filter((token) => Boolean(token));
+  }
+  isDynamicModule(m) {
+    return typeof m === "object" && "module" in m;
+  }
+  getImports(m) {
+    if (this.isDynamicModule(m))
+      return m.imports || [];
+    return Reflect.getMetadata(IMPORTS_KEY, m) || [];
+  }
+  getProviders(m) {
+    if (this.isDynamicModule(m))
+      return m.providers || [];
+    return Reflect.getMetadata(PROVIDERS_KEY, m) || [];
+  }
+  getControllers(m) {
+    if (this.isDynamicModule(m))
+      return m.controllers || [];
+    return Reflect.getMetadata(CONTROLLERS_KEY, m) || [];
+  }
+  getDeclarations(m) {
+    if (this.isDynamicModule(m))
+      return m.declarations || [];
+    return Reflect.getMetadata(DECLARATIONS_KEY, m) || [];
+  }
+  getExports(m) {
+    if (this.isDynamicModule(m))
+      return m.exports || [];
+    return Reflect.getMetadata(EXPORTS_KEY, m) || [];
+  }
+  printDAG(node, indent = "", visited = /* @__PURE__ */ new Set()) {
+    if (visited.has(node.name)) {
+      console.log(`${indent}${node.name} (circular)`);
+      return;
+    }
+    visited.add(node.name);
+    console.log(`${indent}${node.name}`);
+    const tokens = node.getTokens();
+    if (tokens.size > 0) {
+      console.log(`${indent}\u251C\u2500 Tokens:`);
+      Array.from(tokens.entries()).forEach(([token, deps], i, arr) => {
+        const prefix = i === arr.length - 1 ? "\u2514\u2500" : "\u251C\u2500";
+        const tokenName = typeof token === "function" ? token.name : String(token);
+        const depStr = deps.length ? ` \u2192 [${deps.map((d) => typeof d === "function" ? d.name : String(d)).join(", ")}]` : "";
+        console.log(`${indent}\u2502 ${prefix} ${tokenName}${depStr}`);
+      });
+    }
+    const exports = node.getExports();
+    if (exports.size > 0) {
+      const names = Array.from(exports).map((t) => typeof t === "function" ? t.name : String(t));
+      console.log(`${indent}\u251C\u2500 Exports: [${names.join(", ")}]`);
+    }
+    const children = node.getChildren();
+    if (children.length > 0) {
+      console.log(`${indent}\u2514\u2500 Imports:`);
+      children.forEach((child, i) => {
+        const isLast = i === children.length - 1;
+        const childIndent = indent + (isLast ? "   " : "\u2502  ");
+        this.printDAG(child, childIndent, new Set(visited));
+      });
+    }
+  }
+};
+
+// src/shared/module/injector.ts
+var Injector = class {
+  constructor(providers, parent) {
+    this.instanceCache = /* @__PURE__ */ new Map();
+    this.providerMap = /* @__PURE__ */ new Map();
+    this.parent = parent;
+    providers.forEach((p) => {
+      const normalized = ProviderNormalizer.normalize(p);
+      this.providerMap.set(normalized.provide, normalized);
+    });
+  }
+  addProvider(provider) {
+    const normalized = ProviderNormalizer.normalize(provider);
+    this.providerMap.set(normalized.provide, normalized);
+  }
+  resolve(token) {
+    if (this.instanceCache.has(token)) {
+      return this.instanceCache.get(token);
+    }
+    const provider = this.providerMap.get(token);
+    if (!provider) {
+      if (this.parent) {
+        return this.parent.resolve(token);
+      }
+      throw new Error(
+        `No provider for token: ${typeof token === "function" ? token.name : String(token)}`
+      );
+    }
+    const instance = this.createInstance(provider);
+    if (provider.scope !== "transient") {
+      this.instanceCache.set(token, instance);
+    }
+    return instance;
+  }
+  createInstance(provider) {
+    if ("useValue" in provider && provider.useValue !== void 0)
+      return provider.useValue;
+    if (provider.useExisting)
+      return this.resolve(provider.useExisting);
+    if (provider.useFactory) {
+      const deps2 = (provider.deps || []).map((d) => this.resolve(d));
+      return provider.useFactory(...deps2);
+    }
+    const Ctor = provider.useClass || provider.provide;
+    const deps = provider.deps || this.getConstructorDeps(Ctor);
+    return new Ctor(...deps.map((d) => this.resolve(d)));
+  }
+  getConstructorDeps(ctor) {
+    const injectTokens = Reflect.getOwnMetadata(INJECT_TOKENS_KEY, ctor) || /* @__PURE__ */ new Map();
+    const paramTypes = Reflect.getMetadata(DESIGN_PARAMTYPES, ctor) || [];
+    return paramTypes.map((type, index) => {
+      const injected = injectTokens.get(index);
+      return injected?.token ?? type;
+    }).filter((token) => Boolean(token));
+  }
+};
+function collectAllProvidersFromNode(node, collected = /* @__PURE__ */ new Set()) {
+  node.getProviders().forEach((p) => collected.add(p));
+  node.getChildren().forEach((child) => collectAllProvidersFromNode(child, collected));
+  return Array.from(collected);
+}
+
+// src/shared/module/context.ts
+var currentInjector = null;
+function setCurrentInjector(injector) {
+  currentInjector = injector;
+}
+function getCurrentInjector() {
+  return currentInjector;
+}
+
+// node_modules/uuid/dist/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+// node_modules/uuid/dist/rng.js
+var getRandomValues;
+var rnds8 = new Uint8Array(16);
+function rng() {
+  if (!getRandomValues) {
+    if (typeof crypto === "undefined" || !crypto.getRandomValues) {
+      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+    }
+    getRandomValues = crypto.getRandomValues.bind(crypto);
+  }
+  return getRandomValues(rnds8);
+}
+
+// node_modules/uuid/dist/native.js
+var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+var native_default = { randomUUID };
+
+// node_modules/uuid/dist/v4.js
+function _v4(options, buf, offset) {
+  options = options || {};
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  return _v4(options, buf, offset);
+}
+var v4_default = v4;
+
+// src/shared/jsx/jsx-runtime.ts
+function jsx(type, config, maybeKey) {
+  const key = maybeKey !== void 0 ? maybeKey : config?.key ?? null;
+  const props = {};
+  if (config) {
+    for (const propName in config) {
+      if (propName === "key")
+        continue;
+      if (propName === "ref")
+        continue;
+      props[propName] = config[propName];
+    }
+  }
+  if (props.children !== void 0) {
+    props.children = normalizeChildren(props.children);
+  }
+  if (typeof type === "function" && type.defaultProps) {
+    for (const propName in type.defaultProps) {
+      if (props[propName] === void 0) {
+        props[propName] = type.defaultProps[propName];
+      }
+    }
+  }
+  return createVNode(type, props, key);
+}
+var jsxs = jsx;
+function Fragment(props) {
+  return {
+    $$typeof: ORCA_ELEMENT_TYPE,
+    type: ORCA_FRAGMENT_TYPE,
+    id: "00000000-0000-0000-0000-000000000000",
+    props,
+    key: null
+  };
+}
+function createVNode(type, props, key) {
+  return {
+    $$typeof: ORCA_ELEMENT_TYPE,
+    id: v4_default(),
+    type,
+    props,
+    key
+  };
+}
+function normalizeChildren(children) {
+  if (children === null || children === void 0) {
+    return null;
+  }
+  if (!Array.isArray(children)) {
+    return normalizeChild(children);
+  }
+  const normalized = [];
+  for (let i = 0; i < children.length; i++) {
+    const child = normalizeChild(children[i]);
+    if (child === null)
+      continue;
+    if (Array.isArray(child)) {
+      normalized.push(...child);
+    } else {
+      normalized.push(child);
+    }
+  }
+  if (normalized.length === 0)
+    return null;
+  if (normalized.length === 1)
+    return normalized[0];
+  return normalized;
+}
+function normalizeChild(child) {
+  if (child === null || child === void 0 || typeof child === "boolean") {
+    return null;
+  }
+  if (typeof child === "number") {
+    return String(child);
+  }
+  if (typeof child === "string" || child.$$typeof === ORCA_ELEMENT_TYPE) {
+    return child;
+  }
+  if (Array.isArray(child)) {
+    return child.map(normalizeChild).filter((c) => c !== null);
+  }
+  return String(child);
+}
+function isClassComponent(jsx2) {
+  return typeof jsx2.type === "function" && jsx2.type.prototype && typeof jsx2.type.prototype.build === "function";
+}
+function isIntrinsicElement(jsx2) {
+  return typeof jsx2.type === "string";
+}
+function isFragment(jsx2) {
+  return typeof jsx2.type === "function" && jsx2.type()?.type == ORCA_FRAGMENT_TYPE;
+}
+
+// src/shared/renderers/string.ts
+var StringRenderer = class {
+  constructor(rootInjector) {
+    this.rootInjector = rootInjector;
+  }
+  render(vnode, parentInjector = this.rootInjector) {
+    if (typeof vnode.type === "function") {
+      const ComponentClass = vnode.type;
+      const isComponent = Reflect.getMetadata(COMPONENT, ComponentClass);
+      let componentInjector = parentInjector;
+      if (isComponent) {
+        const localProviders = Reflect.getMetadata(COMPONENT_PROVIDERS, ComponentClass) || [];
+        if (localProviders.length > 0) {
+          componentInjector = new Injector(
+            localProviders.map((p) => ProviderNormalizer.normalize(p)),
+            parentInjector
+          );
+        }
+      }
+      const instance = componentInjector.resolve(ComponentClass);
+      instance.props = vnode.props || {};
+      const childVNode = instance.build();
+      return this.render(childVNode, componentInjector);
+    }
+    if (typeof vnode.type === "string") {
+      const { children, ...attrs } = vnode.props;
+      const attrsStr = Object.entries(attrs).map(([key, value]) => {
+        if (value === true)
+          return key;
+        if (value === false || value === null || value === void 0)
+          return "";
+        return `${key}="${this.escapeHtml(String(value))}"`;
+      }).filter(Boolean).join(" ");
+      const openTag = attrsStr ? `<${vnode.type} ${attrsStr}>` : `<${vnode.type}>`;
+      const selfClosing = ["img", "br", "hr", "input", "meta", "link"];
+      if (selfClosing.includes(vnode.type)) {
+        return attrsStr ? `<${vnode.type} ${attrsStr} />` : `<${vnode.type} />`;
+      }
+      let childrenHtml = "";
+      if (children !== void 0 && children !== null) {
+        if (Array.isArray(children)) {
+          childrenHtml = children.map((child) => {
+            if (typeof child === "string" || typeof child === "number") {
+              return this.escapeHtml(String(child));
+            }
+            return this.render(child, parentInjector);
+          }).join("");
+        } else if (typeof children === "object" && "type" in children) {
+          childrenHtml = this.render(children, parentInjector);
+        } else {
+          childrenHtml = this.escapeHtml(String(children));
+        }
+      }
+      return `${openTag}${childrenHtml}</${vnode.type}>`;
+    }
+    return "";
+  }
+  escapeHtml(text) {
+    const map = {
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#039;"
+    };
+    return text.replace(/[&<>"']/g, (m) => map[m]);
+  }
+};
+
+// src/shared/renderers/stream.ts
+var StreamRenderer = class {
+  constructor(rootInjector, options = {}) {
+    this.rootInjector = rootInjector;
+    this.pending = /* @__PURE__ */ new Map();
+    this.processedIds = /* @__PURE__ */ new Set();
+    this.queueResolvers = [];
+    this.pushQueue = (u) => this.queueResolvers.shift()?.(u);
+    this.options = {
+      timeout: options.timeout ?? 3e4
+    };
+  }
+  render(vnode, parentInjector = this.rootInjector) {
+    return this.stream(vnode, parentInjector);
+  }
+  async *stream(vnode, parentInjector) {
+    this.pending.clear();
+    this.queueResolvers = [];
+    this.renderingNodes = /* @__PURE__ */ new WeakSet();
+    this.processedIds.clear();
+    const nextUpdate = () => new Promise((resolve) => this.queueResolvers.push(resolve));
+    try {
+      const root = this.buildSyncTree(vnode, parentInjector);
+      yield { ...root, action: "insert" };
+      while (this.pending.size > 0) {
+        const update = await nextUpdate();
+        yield update;
+      }
+    } finally {
+      this.cleanup();
+    }
+  }
+  buildSyncTree(vnode, injector) {
+    if (vnode == null || typeof vnode !== "object")
+      return vnode;
+    if (vnode.$$typeof !== ORCA_ELEMENT_TYPE)
+      return vnode;
+    if (this.renderingNodes.has(vnode)) {
+      throw new Error(
+        `Circular reference detected while rendering component "${vnode.type?.name}".`
+      );
+    }
+    this.renderingNodes.add(vnode);
+    try {
+      if (isClassComponent(vnode)) {
+        return this.renderClassComponent(vnode, injector);
+      }
+      if (isIntrinsicElement(vnode)) {
+        return {
+          $$typeof: ORCA_ELEMENT_TYPE,
+          type: vnode.type,
+          id: vnode.id,
+          props: {
+            ...vnode.props,
+            children: this.mapChildren(vnode.props?.children, injector)
+          },
+          key: vnode.key ?? null
+        };
+      }
+      if (isFragment(vnode)) {
+        return {
+          $$typeof: ORCA_ELEMENT_TYPE,
+          type: null,
+          id: vnode.id,
+          props: {
+            children: this.mapChildren(vnode.props?.children, injector)
+          },
+          key: null
+        };
+      }
+      return vnode;
+    } finally {
+      this.renderingNodes.delete(vnode);
+    }
+  }
+  renderClassComponent(vnode, injector) {
+    const ComponentClass = vnode.type;
+    const isComponent = Reflect.getMetadata(COMPONENT, ComponentClass);
+    let componentInjector = injector;
+    if (isComponent) {
+      const localProviders = Reflect.getMetadata(COMPONENT_PROVIDERS, ComponentClass) || [];
+      if (localProviders.length > 0) {
+        componentInjector = new Injector(
+          localProviders.map((p) => ProviderNormalizer.normalize(p)),
+          injector
+        );
+      }
+    }
+    const instance = componentInjector.resolve(ComponentClass);
+    instance.props = vnode.props || {};
+    const childVNode = instance.build();
+    if (childVNode instanceof Promise) {
+      return this.createPendingReference(vnode, childVNode, componentInjector);
+    }
+    return this.buildSyncTree(childVNode, componentInjector);
+  }
+  mapChildren(children, injector) {
+    if (children == null || typeof children === "string" || typeof children === "number") {
+      return children;
+    }
+    if (Array.isArray(children)) {
+      return children.map((c) => this.buildSyncTree(c, injector));
+    }
+    return this.buildSyncTree(children, injector);
+  }
+  createPendingReference(vnode, promise, injector) {
+    const id = vnode.id;
+    const abortController = new AbortController();
+    const timeoutPromise = new Promise((_, reject) => {
+      const timeoutId = setTimeout(() => {
+        abortController.abort();
+        reject(
+          new Error(
+            `Component ${vnode.type.name || "Unknown"} timed out after ${this.options.timeout}ms`
+          )
+        );
+      }, this.options.timeout);
+      abortController.signal.addEventListener("abort", () => {
+        clearTimeout(timeoutId);
+      });
+    });
+    const raced = Promise.race([promise, timeoutPromise]).then((result) => {
+      result.id = vnode.id;
+      return this.buildSyncTree(result, injector);
+    }).catch((err) => Promise.reject({ id, error: err }));
+    this.pending.set(id, { abortController, promise: raced });
+    raced.then((resolved) => {
+      if (this.processedIds.has(id))
+        return;
+      this.processedIds.add(id);
+      this.pushQueue({
+        ...resolved,
+        action: "update"
+      });
+      this.pending.delete(id);
+    }).catch((e) => {
+      this.pushQueue({
+        $$typeof: ERROR_ELEMENT,
+        type: "error",
+        action: "error",
+        id,
+        props: {
+          message: String(e?.error) || String(e)
+        },
+        key: null
+      });
+      this.pending.delete(id);
+    });
+    return {
+      $$typeof: PENDING_REFERENCE_TYPE,
+      id,
+      type: "ref",
+      props: vnode.props,
+      key: vnode.key ?? null
+    };
+  }
+  cleanup() {
+    for (const { abortController } of this.pending.values()) {
+      abortController.abort();
+    }
+    this.pending.clear();
+    this.processedIds.clear();
+    this.queueResolvers.length = 0;
+  }
+  cancel() {
+    this.cleanup();
+  }
+  async renderToCompletion(jsx2) {
+    const out = [];
+    for await (const upd of this.stream(jsx2, this.rootInjector)) {
+      out.push(upd);
+    }
+    return out;
+  }
+};
+
+// src/shared/renderers/vnode.ts
+var VNode = class {
+  constructor(dom, cb) {
+    this.dom = dom;
+    this.cb = cb;
+    this.children = [];
+  }
+  setId(id) {
+    this.id = id;
+  }
+  addChild(child) {
+    child.parent = this;
+    this.children.push(child);
+    return child;
+  }
+  removeChild(child) {
+    const index = this.children.indexOf(child);
+    if (index > -1) {
+      this.children.splice(index, 1);
+      child.parent = void 0;
+    }
+  }
+  findById(id) {
+    if (this.id === id)
+      return this;
+    for (const child of this.children) {
+      const found = child.findById(id);
+      if (found)
+        return found;
+    }
+    return null;
+  }
+  attach(nw) {
+    if (this.cb) {
+      this.cb(this.dom, nw);
+    } else {
+      if (this.dom.parentNode) {
+        this.dom.parentNode.replaceChild(nw, this.dom);
+      }
+    }
+    this.dom = nw;
+  }
+  unmount() {
+    for (const child of this.children) {
+      child.unmount();
+    }
+    if (this.dom.parentNode) {
+      this.dom.parentNode.removeChild(this.dom);
+    }
+    if (this.parent) {
+      this.parent.removeChild(this);
+    }
+  }
+};
+
+// src/shared/json.ts
+function symbolValueReplacer(key, value) {
+  if (typeof value === "symbol") {
+    return `@@Symbol:${value.description}`;
+  }
+  return value;
+}
+function symbolValueReviver(key, value) {
+  if (typeof value === "string" && value.startsWith("@@Symbol:")) {
+    return Symbol.for(value.slice(9));
+  }
+  return value;
+}
+
+// src/shared/signal/signal.ts
+var currentEffect = null;
+function signal(initialValue) {
+  let value = initialValue;
+  const subscribers = /* @__PURE__ */ new Set();
+  const notify = () => {
+    subscribers.forEach((sub) => sub());
+  };
+  return {
+    _isSignal: true,
+    _subscribers: subscribers,
+    get value() {
+      if (currentEffect) {
+        subscribers.add(currentEffect);
+      }
+      return value;
+    },
+    set value(newValue) {
+      if (value !== newValue) {
+        value = newValue;
+        notify();
+      }
+    }
+  };
+}
+function effect(fn) {
+  const execute = () => {
+    currentEffect = execute;
+    try {
+      fn();
+    } finally {
+      currentEffect = null;
+    }
+  };
+  execute();
+  return () => {
+    currentEffect = null;
+  };
+}
+function computed(fn) {
+  const sig = signal(fn());
+  effect(() => {
+    sig.value = fn();
+  });
+  return sig;
+}
+function isSignal(value) {
+  return value && value._isSignal === true;
+}
+
+// src/shared/observable/observable.ts
+var Observable = class {
+  constructor(producer) {
+    this.producer = producer;
+    this.__isObservable = true;
+    this.subscribers = /* @__PURE__ */ new Set();
+  }
+  get $value() {
+    return this._value;
+  }
+  setValue(newValue) {
+    this._value = newValue;
+  }
+  subscribe(observerOrNext, error, complete) {
+    const observer = typeof observerOrNext === "function" ? { next: observerOrNext, error, complete } : observerOrNext;
+    this.subscribers.add(observer);
+    let cleanup;
+    if (this.producer) {
+      try {
+        cleanup = this.producer(observer);
+      } catch (err) {
+        if (observer.error) {
+          observer.error(err);
+        }
+      }
+    }
+    return {
+      unsubscribe: () => {
+        this.subscribers.delete(observer);
+        if (cleanup)
+          cleanup();
+      }
+    };
+  }
+  next(value) {
+    this.setValue(value);
+    this.subscribers.forEach((observer) => {
+      try {
+        observer.next(value);
+      } catch (err) {
+        console.error("Error in observer:", err);
+      }
+    });
+  }
+  error(err) {
+    this.subscribers.forEach((observer) => {
+      if (observer.error) {
+        try {
+          observer.error(err);
+        } catch (e) {
+          console.error("Error in error handler:", e);
+        }
+      }
+    });
+  }
+  complete() {
+    this.subscribers.forEach((observer) => {
+      if (observer.complete) {
+        try {
+          observer.complete();
+        } catch (err) {
+          console.error("Error in complete handler:", err);
+        }
+      }
+    });
+    this.subscribers.clear();
+  }
+  pipe(...operations) {
+    if (operations.length === 0) {
+      return this;
+    }
+    return operations.reduce((prev, fn) => fn(prev), this);
+  }
+};
+function from(iterable) {
+  return new Observable((observer) => {
+    for (const value of iterable) {
+      observer.next(value);
+    }
+    observer.complete?.();
+  });
+}
+function interval(ms) {
+  return new Observable((observer) => {
+    let count = 0;
+    const id = setInterval(() => {
+      observer.next(count++);
+    }, ms);
+    return () => clearInterval(id);
+  });
+}
+function of(...values) {
+  return new Observable((observer) => {
+    values.forEach((value) => observer.next(value));
+    observer.complete?.();
+  });
+}
+function observable(producer) {
+  return new Observable(producer);
+}
+function toSignal(obs, instance) {
+  const sig = signal(void 0);
+  const subst = obs.subscribe((val) => {
+    sig.value = val;
+  });
+  instance.__drop = [...instance.__drop ?? [], () => subst.unsubscribe()];
+  return sig;
+}
+function isObservable(value) {
+  return value && value.__isObservable === true;
+}
+
+// src/shared/component.ts
+var OrcaComponent = class {
+  constructor() {
+    this.__cleanup = [];
+  }
+  onDestory() {
+    this.__cleanup.forEach((cb) => cb());
+  }
+  pushDrop(fn) {
+    this.__cleanup.push(fn);
+  }
+};
+
+// src/shared/module_libs/router_module/navigate.ts
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __param = function(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+};
+var Navigate = class Navigate2 {
+  constructor(oscUrl) {
+    this.oscUrl = oscUrl;
+    this.pages = from([]);
+    this.cursor = 0;
+    const initialState = history.state?.cursor ?? 0;
+    this.cursor = initialState;
+    if (!history.state) {
+      history.replaceState({ cursor: 0 }, "");
+    }
+    window.addEventListener("popstate", (e) => {
+      const newIndex = e.state?.cursor ?? 0;
+      this.cursor = newIndex;
+      this.pages.next([...this.pages.$value || []]);
+    });
+  }
+  getHome() {
+    const http = new HttpClient();
+    return http.post(this.oscUrl, {
+      stream: "ndjson",
+      reviver: symbolValueReviver
+    });
+  }
+  push(component) {
+    const currentPages = this.pages.$value || [];
+    const newPages = currentPages.slice(0, this.cursor + 1);
+    this.cursor++;
+    newPages.push(component);
+    history.pushState({ cursor: this.cursor }, "");
+    this.pages.next(newPages);
+  }
+  replace(component) {
+    const currentPages = [...this.pages.$value || []];
+    currentPages[this.cursor] = component;
+    history.replaceState({ cursor: this.cursor }, "");
+    this.pages.next(currentPages);
+  }
+  goBack() {
+    if (this.cursor > 0) {
+      history.back();
+    }
+  }
+  goForward() {
+    const currentPages = this.pages.$value || [];
+    if (this.cursor < currentPages.length - 1) {
+      history.forward();
+    }
+  }
+  canGoBack() {
+    return this.cursor > 0;
+  }
+  canGoForward() {
+    const currentPages = this.pages.$value || [];
+    return this.cursor < currentPages.length - 1;
+  }
+  getCurrentPage() {
+    const currentPages = this.pages.$value || [];
+    return currentPages[this.cursor];
+  }
+  clear() {
+    this.cursor = 0;
+    this.pages.next([]);
+    history.replaceState({ cursor: 0 }, "");
+  }
+};
+Navigate = __decorate([
+  __param(0, Inject("OSC_URL", { maybe: true })),
+  __metadata("design:paramtypes", [String])
+], Navigate);
+
+// src/shared/module_libs/router_module/outlet.ts
+var __decorate2 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata2 = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var _a;
+var RouterOutlet = class RouterOutlet2 extends OrcaComponent {
+  constructor(navigate) {
+    super();
+    this.navigate = navigate;
+  }
+  build() {
+    const anchor = document.createElement("div");
+    const root = document.createElement("div");
+    anchor.appendChild(root);
+    const osc = new OSC(root);
+    const stream = this.navigate.getHome();
+    const streamSubscription = stream.subscribe((jsx2) => {
+      const action = jsx2.action || "insert";
+      if (action === "insert") {
+        osc.handleInsert(jsx2);
+      } else if (action === "update") {
+        osc.handleUpdate(jsx2);
+      } else {
+        console.warn(`Unknown action: ${action}`);
+      }
+    }, () => {
+    }, () => {
+      this.navigate.pages.setValue([osc.tree.dom]);
+    });
+    const subscription = this.navigate.pages.subscribe((pages) => {
+      const top = pages[this.navigate.cursor];
+      anchor.replaceChildren(top);
+    });
+    this.pushDrop(() => subscription.unsubscribe());
+    this.pushDrop(() => streamSubscription.unsubscribe());
+    return anchor;
+  }
+};
+RouterOutlet = __decorate2([
+  Component(),
+  __metadata2("design:paramtypes", [typeof (_a = typeof Navigate !== "undefined" && Navigate) === "function" ? _a : Object])
+], RouterOutlet);
+
+// src/shared/module_libs/router_module/module.ts
+var RouterModule = class _RouterModule {
+  static forRoot() {
+    return {
+      module: _RouterModule,
+      declarations: [RouterOutlet],
+      providers: [Navigate],
+      exports: [Navigate, RouterOutlet]
+    };
+  }
+};
+
+// src/shared/module_libs/http_client/module.ts
+var __decorate3 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var HttpClient = class HttpClient2 {
+  get(url, { stream = "json", reviver, init } = {}) {
+    return new Observable((subscriber) => {
+      const controller = new AbortController();
+      fetch(url, {
+        method: "GET",
+        ...init,
+        signal: controller.signal
+      }).then(async (res) => {
+        if (!res.ok) {
+          throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+        }
+        if (stream === "json") {
+          const data = await res.json();
+          subscriber.next(reviver ? JSON.parse(JSON.stringify(data), reviver) : data);
+          subscriber.complete?.();
+          return;
+        }
+        if (stream === "raw") {
+          subscriber.next(res);
+          subscriber.complete?.();
+          return;
+        }
+        const reader = res.body?.getReader();
+        if (!reader) {
+          throw new Error("ReadableStream not supported");
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            if (stream === "ndjson" && buffer.trim()) {
+              try {
+                subscriber.next(JSON.parse(buffer, reviver));
+              } catch (err) {
+                console.warn("Failed to parse remaining buffer:", err);
+              }
+            }
+            break;
+          }
+          const chunk = decoder.decode(value, { stream: true });
+          if (stream === "text") {
+            subscriber.next(chunk);
+            continue;
+          }
+          if (stream === "ndjson") {
+            buffer += chunk;
+            const lines = buffer.split("\n");
+            buffer = lines.pop();
+            for (const line of lines) {
+              if (line.trim()) {
+                try {
+                  subscriber.next(JSON.parse(line, reviver));
+                } catch (err) {
+                  console.error("Failed to parse NDJSON line:", line, err);
+                }
+              }
+            }
+          }
+        }
+        subscriber.complete?.();
+      }).catch((err) => {
+        if (err.name === "AbortError") {
+          console.log("Request aborted");
+        }
+        subscriber.error?.(err);
+      });
+      return () => {
+        controller.abort();
+      };
+    });
+  }
+  post(url, { body, stream = "json", reviver, init } = {}) {
+    const headers = new Headers(init?.headers);
+    if (body && !headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    const processedBody = body !== void 0 ? typeof body === "string" ? body : JSON.stringify(body) : void 0;
+    return this.get(url, {
+      stream,
+      reviver,
+      init: {
+        ...init,
+        method: "POST",
+        headers,
+        body: processedBody
+      }
+    });
+  }
+  put(url, options) {
+    return this.request(url, "PUT", options);
+  }
+  patch(url, options) {
+    return this.request(url, "PATCH", options);
+  }
+  delete(url, options) {
+    return this.get(url, {
+      ...options,
+      init: {
+        ...options?.init,
+        method: "DELETE"
+      }
+    });
+  }
+  request(url, method, { body, stream = "json", reviver, init } = {}) {
+    const headers = new Headers(init?.headers);
+    if (body && !headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    const processedBody = body !== void 0 ? typeof body === "string" ? body : JSON.stringify(body) : void 0;
+    return this.get(url, {
+      stream,
+      reviver,
+      init: {
+        ...init,
+        method,
+        headers,
+        body: processedBody
+      }
+    });
+  }
+};
+HttpClient = __decorate3([
+  Injectable()
+], HttpClient);
+var HttpClientModule = class HttpClientModule2 {
+};
+HttpClientModule = __decorate3([
+  Module({
+    providers: [HttpClient],
+    exports: [HttpClient]
+  })
+], HttpClientModule);
+
+// src/shared/dom/osc.ts
+var OSC = class {
+  constructor(root) {
+    this.root = root;
+    this.pendingRefs = /* @__PURE__ */ new Map();
+    this.tree = new VNode(root, (old, nw) => {
+      old.replaceChildren(nw);
+    });
+  }
+  handleInsert(jsx2) {
+    const { domNode, vnode } = this.buildDOM(jsx2, this.tree);
+    if (jsx2.id && vnode) {
+      vnode.setId(jsx2.id);
+    }
+    this.tree.attach(domNode);
+  }
+  handleUpdate(jsx2) {
+    if (!jsx2.id) {
+      console.warn("Update action requires an id");
+      return;
+    }
+    const targetVNode = this.tree.findById(jsx2.id);
+    if (targetVNode) {
+      const oldChildren = [...targetVNode.children];
+      targetVNode.children = [];
+      const { domNode, vnode } = this.buildDOM(
+        jsx2,
+        targetVNode.parent || this.tree
+      );
+      targetVNode.attach(domNode);
+      if (vnode) {
+        targetVNode.children = vnode.children;
+      }
+    } else {
+      console.warn(`Update target ${jsx2.id} not found, inserting instead`);
+      this.handleInsert(jsx2);
+    }
+  }
+  buildDOM(jsx2, vparent) {
+    if (jsx2 == null) {
+      return { domNode: document.createDocumentFragment() };
+    }
+    if (Array.isArray(jsx2)) {
+      return this.buildArray(jsx2, vparent);
+    }
+    if (this.isPrimitive(jsx2)) {
+      return this.buildTextNode(String(jsx2), vparent);
+    }
+    if (jsx2.$$typeof === PENDING_REFERENCE_TYPE) {
+      return this.buildPendingReference(jsx2, vparent);
+    }
+    if (jsx2.$$typeof === ORCA_CLIENT_COMPONENT) {
+      return this.buildClientComponent(jsx2, vparent);
+    }
+    if (isIntrinsicElement(jsx2)) {
+      return this.buildIntrinsicElement(jsx2, vparent);
+    }
+    console.error("Unsupported node:", jsx2);
+    throw new Error(
+      `Unsupported node type: ${typeof jsx2}, $typeof: ${String(jsx2.$$typeof)}`
+    );
+  }
+  buildClientComponent(jsx2, parent) {
+    const componentInfo = jsx2.props.__clientComponent;
+    const { id, path, name } = componentInfo;
+    const container = document.createElement("div");
+    container.dataset.clientComponent = id;
+    const vnode = new VNode(container, (old, nw) => {
+      if (old.parentNode) {
+        old.parentNode.replaceChild(nw, old);
+      }
+    });
+    if (jsx2.id) {
+      vnode.setId(jsx2.id);
+    }
+    parent.addChild(vnode);
+    this.loadClientComponent(path, name, jsx2.props, container, vnode);
+    return { domNode: container, vnode };
+  }
+  buildPendingReference(jsx2, parent) {
+    const refId = jsx2.id;
+    const div = document.createElement("div");
+    div.dataset.ref = refId;
+    div.className = "loading";
+    div.textContent = "Loading...";
+    const vnode = new VNode(div, (old, nw) => {
+      if (old.parentNode) {
+        old.parentNode.replaceChild(nw, old);
+      }
+    });
+    vnode.setId(refId);
+    parent.addChild(vnode);
+    const pendingContent = this.pendingRefs.get(refId);
+    if (pendingContent) {
+      setTimeout(() => this.resolvePendingReference(refId, pendingContent), 0);
+    }
+    return { domNode: div, vnode };
+  }
+  resolvePendingReference(refId, content) {
+    const vnode = this.tree.findById(refId);
+    if (!vnode) {
+      console.warn(`Reference ${refId} not found`);
+      this.pendingRefs.set(refId, content);
+      return;
+    }
+    try {
+      vnode.children = [];
+      const { domNode, vnode: newVNode } = this.buildDOM(content, vnode);
+      vnode.attach(domNode);
+      if (newVNode) {
+        vnode.children = newVNode.children;
+      }
+      this.pendingRefs.delete(refId);
+    } catch (error) {
+      console.error(`Error resolving reference ${refId}:`, error);
+    }
+  }
+  buildTextNode(text, parent) {
+    const textNode = document.createTextNode(text);
+    const vnode = new VNode(textNode, (old, nw) => {
+      if (old.parentNode) {
+        old.parentNode.replaceChild(nw, old);
+      }
+    });
+    parent.addChild(vnode);
+    return { domNode: textNode, vnode };
+  }
+  isPrimitive(node) {
+    return typeof node === "string" || typeof node === "number" || typeof node === "boolean";
+  }
+  buildArray(nodes, parent) {
+    const fragment = document.createDocumentFragment();
+    const vnodes = [];
+    nodes.forEach((child) => {
+      const { domNode, vnode } = this.buildDOM(child, parent);
+      fragment.appendChild(domNode);
+      if (vnode) {
+        vnodes.push(vnode);
+      }
+    });
+    return { domNode: fragment };
+  }
+  buildIntrinsicElement(jsx2, parent) {
+    const tag = jsx2.type;
+    const dom = document.createElement(tag);
+    const vnode = new VNode(dom, (old, nw) => {
+      if (old.parentNode) {
+        old.parentNode.replaceChild(nw, old);
+      }
+    });
+    parent.addChild(vnode);
+    if (jsx2.id) {
+      vnode.setId(jsx2.id);
+    }
+    if (jsx2.props) {
+      this.buildAttributes(jsx2.props, dom, vnode);
+    }
+    if (jsx2.props?.children != null) {
+      const { domNode: childDom } = this.buildDOM(jsx2.props.children, vnode);
+      dom.appendChild(childDom);
+    }
+    return { domNode: dom, vnode };
+  }
+  buildAttributes(props, dom, vnode) {
+    for (const [key, value] of Object.entries(props)) {
+      if (key === "children" || value == null) {
+        continue;
+      }
+      const attrKey = this.normalizeAttributeKey(key);
+      if (attrKey === "style" && typeof value === "object") {
+        this.applyStyles(value, dom);
+        continue;
+      }
+      if (typeof value === "boolean") {
+        this.setBooleanAttribute(attrKey, value, dom);
+        continue;
+      }
+      dom.setAttribute(attrKey, String(value));
+    }
+  }
+  normalizeAttributeKey(key) {
+    if (key === "className")
+      return "class";
+    if (key === "htmlFor")
+      return "for";
+    return key;
+  }
+  applyStyles(styles, dom) {
+    const styleString = Object.entries(styles).map(([k, v]) => {
+      const kebabKey = k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+      return `${kebabKey}:${v}`;
+    }).join(";");
+    dom.setAttribute("style", styleString);
+  }
+  setBooleanAttribute(key, value, dom) {
+    if (value) {
+      dom.setAttribute(key, "");
+    } else {
+      dom.removeAttribute(key);
+    }
+  }
+  async loadClientComponent(path, name, props, container, vnode) {
+    try {
+      const module = await import(path);
+      const ComponentClass = module[name];
+      const params = Reflect.getMetadata(DESIGN_PARAMTYPES, ComponentClass) || [];
+      const injector = getCurrentInjector();
+      if (injector == null) {
+        throw new Error(`Couldn't find an injector`);
+      }
+      if (!ComponentClass) {
+        throw new Error(`Component ${name} not found in ${path}`);
+      }
+      [...params, ComponentClass].forEach((p) => injector.addProvider(p));
+      const cleanProps = { ...props };
+      delete cleanProps.__clientComponent;
+      const componentInstance = injector.resolve(ComponentClass);
+      componentInstance.__injector = injector;
+      componentInstance.props = cleanProps;
+      if (typeof componentInstance.build === "function") {
+        const rendered = componentInstance.build();
+        container.parentNode?.replaceChild(rendered, container);
+      } else {
+        throw new Error(`Component ${name} does not have a build method`);
+      }
+    } catch (error) {
+      console.error(`Failed to load client component ${name}:`, error);
+      container.textContent = `Error loading component: ${name}`;
+      container.className = "client-component-error";
+    }
+  }
+};
+
+// src/shared/macros/index.ts
+function assert$(context) {
+  return context?.factory.createStringLiteral("assert");
+}
+
+// src/browser/index.ts
+var browser_exports = {};
+__export(browser_exports, {
+  BrowserFactory: () => BrowserFactory,
+  createComponent: () => createComponent,
+  insert: () => insert,
+  spread: () => spread,
+  style: () => style
+});
+
+// src/browser/factory.ts
+var BrowserFactory = class {
+  static create(rootModule, rootElement) {
+    const compiler = new Compiler();
+    const appNode = compiler.compile(rootModule);
+    const validation = compiler.validate(appNode);
+    if (!validation.valid) {
+      throw new Error(
+        "\u274C Validation failed:\n" + validation.errors.join("\n\n")
+      );
+    }
+    const allProviders = collectAllProvidersFromNode(appNode);
+    const rootInjector = new Injector([
+      ...allProviders,
+      {
+        provide: "OSC_URL",
+        useValue: "/osc"
+      }
+    ]);
+    setCurrentInjector(rootInjector);
+    appNode.traverse((node) => {
+      const providers = [...node.getProviders().values()];
+      providers.filter((provider) => provider.eager).forEach((p) => rootInjector.resolve(p.provide));
+    });
+    const bootstrap = Reflect.getMetadata(BOOTSTRAP, rootModule);
+    const instance = rootInjector.resolve(bootstrap);
+    instance.__injector = rootInjector;
+    const childDom = instance.build();
+    rootElement.appendChild(childDom);
+  }
+};
+
+// src/browser/dom/dom.ts
+var elementEffects = /* @__PURE__ */ new WeakMap();
+var cleanupObserver = new MutationObserver((mutations) => {
+  mutations.forEach((mutation) => {
+    mutation.removedNodes.forEach((node) => {
+      cleanupElement(node);
+    });
+  });
+});
+if (typeof document !== "undefined" && document.body) {
+  cleanupObserver.observe(document.body, {
+    childList: true,
+    subtree: true
+  });
+} else if (typeof document !== "undefined") {
+  document.addEventListener("DOMContentLoaded", () => {
+    cleanupObserver.observe(document.body, {
+      childList: true,
+      subtree: true
+    });
+  });
+}
+function cleanupElement(node) {
+  const cleanups = elementEffects.get(node);
+  if (cleanups) {
+    cleanups.forEach((cleanup, idx) => {
+      cleanup();
+    });
+    elementEffects.delete(node);
+  }
+  if (node.childNodes && node.childNodes.length > 0) {
+    node.childNodes.forEach((child) => cleanupElement(child));
+  }
+}
+function registerEffect(el, cleanup) {
+  if (!elementEffects.has(el)) {
+    elementEffects.set(el, []);
+  }
+  elementEffects.get(el).push(cleanup);
+}
+function buildDOM(value) {
+  if (value instanceof Node) {
+    return value;
+  }
+  if (typeof value === "string" || typeof value === "number") {
+    return document.createTextNode(String(value));
+  }
+  if (value == null || typeof value === "boolean") {
+    return document.createTextNode("");
+  }
+  if (Array.isArray(value)) {
+    const fragment = document.createDocumentFragment();
+    for (const item of value) {
+      const node = buildDOM(item);
+      fragment.appendChild(node);
+    }
+    return fragment;
+  }
+  console.log("Unhandled value:", value);
+  throw new Error(`Cannot build DOM from value: ${value}`);
+}
+function insert(parent, value) {
+  if (value == null)
+    return;
+  let currentDOM;
+  function attach(value2) {
+    const newDOM = buildDOM(value2);
+    if (currentDOM) {
+      if (Array.isArray(currentDOM)) {
+        currentDOM.forEach((node) => {
+          if (node.parentNode) {
+            node.parentNode.removeChild(node);
+          }
+        });
+      } else {
+        if (currentDOM.parentNode) {
+          currentDOM.parentNode.removeChild(currentDOM);
+        }
+      }
+    }
+    if (newDOM instanceof DocumentFragment) {
+      const nodes = Array.from(newDOM.childNodes);
+      parent.appendChild(newDOM);
+      currentDOM = nodes;
+    } else {
+      parent.appendChild(newDOM);
+      currentDOM = newDOM;
+    }
+  }
+  if (isSignal(value)) {
+    const cleanup = effect(() => {
+      attach(value.value);
+    });
+    registerEffect(parent, cleanup);
+  } else if (isObservable(value)) {
+    const obs = value;
+    const subst = obs.subscribe((val) => {
+      attach(val);
+    });
+    registerEffect(parent, () => subst.unsubscribe());
+  } else if (typeof value == "function") {
+    const cleanup = effect(() => {
+      attach(value());
+    });
+    registerEffect(parent, cleanup);
+  } else {
+    const node = buildDOM(value);
+    parent.appendChild(node);
+  }
+}
+function autoCleanup(element, callback) {
+  const observer = new MutationObserver(() => {
+    if (!document.contains(element)) {
+      callback();
+      observer.disconnect();
+    }
+  });
+  setTimeout(() => {
+    if (element.parentNode) {
+      observer.observe(document.body, { childList: true, subtree: true });
+    }
+  }, 0);
+}
+function createComponent(ComponentClass, props = {}, parentComponent) {
+  let injector = parentComponent.__injector;
+  if (!injector) {
+    throw new Error(`Cannot create component ${ComponentClass.name} outside injection context. No injector available from current context or parent component.`);
+  }
+  const isComponent = Reflect.getMetadata(COMPONENT, ComponentClass);
+  if (!isComponent) {
+    throw new Error(`${ComponentClass.name} is not decorated with @Component()`);
+  }
+  let instance;
+  try {
+    instance = injector.resolve(ComponentClass);
+  } catch (e) {
+    injector.addProvider(ComponentClass);
+    instance = injector.resolve(ComponentClass);
+  }
+  const localProviders = Reflect.getMetadata(COMPONENT_PROVIDERS, ComponentClass) || [];
+  if (localProviders.length > 0) {
+    injector = new Injector(localProviders.map((p) => ProviderNormalizer.normalize(p)), parentComponent.__injector);
+    instance.__injector = injector;
+  }
+  instance.props = props;
+  const root = instance.build();
+  if (!(root instanceof Node)) {
+    throw new Error("Root is not instance of node");
+  }
+  const cleanup = () => {
+    instance.__cleanup?.forEach((cb) => cb());
+    instance.onDestory?.();
+  };
+  if (root.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+    const firstChild = root.firstChild;
+    if (firstChild) {
+      autoCleanup(firstChild, cleanup);
+    }
+  } else {
+    autoCleanup(root, cleanup);
+  }
+  return root;
+}
+function style(el, styleObj) {
+  if (typeof styleObj === "function") {
+    const cleanup = effect(() => {
+      const styles = styleObj();
+      if (!styles)
+        return;
+      for (const key in styles) {
+        const value = styles[key];
+        const actualValue = isSignal(value) ? value.value : value;
+        const cssKey = key.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+        el.style.setProperty(cssKey, actualValue);
+      }
+    });
+    registerEffect(el, cleanup);
+    return;
+  }
+  if (!styleObj)
+    return;
+  for (const key in styleObj) {
+    const cssKey = key.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+    el.style.setProperty(cssKey, styleObj[key]);
+  }
+}
+function spread(el, attrs) {
+  if (!attrs)
+    return;
+  for (const key in attrs) {
+    const value = attrs[key];
+    if (/^on[A-Z]/.test(key)) {
+      const eventName = key.slice(2).toLowerCase();
+      el.addEventListener(eventName, value);
+      continue;
+    }
+    if (key === "style" && typeof value === "object") {
+      style(el, value);
+      continue;
+    }
+    const attrName = key === "className" ? "class" : key;
+    el.setAttribute(attrName, value);
+  }
+}
+export {
+  BOOTSTRAP,
+  BOOTSTRAP_VNODE,
+  Body,
+  BrowserFactory,
+  COMPONENT,
+  COMPONENT_DEPS,
+  COMPONENT_PROVIDERS,
+  CONTROLLER,
+  CONTROLLERS_KEY,
+  CONTROLLER_PREFIX_KEY,
+  Compiler,
+  Component,
+  Controller,
+  DECLARATIONS_KEY,
+  DESIGN_PARAMTYPES,
+  ERROR_ELEMENT,
+  EXPORTS_KEY,
+  EXPRESS_ADAPTER_HOST,
+  Fragment,
+  Get,
+  HTTP_METHOD_KEY,
+  HandlerParamType,
+  HttpClient,
+  HttpClientModule,
+  HttpMethod,
+  IMPORTS_KEY,
+  INJECTABLE,
+  INJECT_TOKENS_KEY,
+  Inject,
+  Injectable,
+  Injector,
+  Module,
+  NODE,
+  Navigate,
+  Node2 as Node,
+  ORCA_CLIENT_COMPONENT,
+  ORCA_ELEMENT_TYPE,
+  ORCA_FRAGMENT_TYPE,
+  OSC,
+  Observable,
+  OrcaComponent,
+  PARAMS_META_KEY,
+  PATH_KEY,
+  PENDING_REFERENCE_TYPE,
+  PROVIDERS_KEY,
+  Param,
+  Post,
+  ProviderNormalizer,
+  RouterModule,
+  RouterOutlet,
+  SIGNATURE_METADATA_KEY,
+  Signature,
+  assert$,
+  browser_exports as browser,
+  collectAllProvidersFromNode,
+  computed,
+  createComponent,
+  effect,
+  from,
+  getCurrentInjector,
+  getSignatureMetadata,
+  hasSignature,
+  insert,
+  interval,
+  isClassComponent,
+  isFragment,
+  isIntrinsicElement,
+  isObservable,
+  isSignal,
+  jsx,
+  jsxs,
+  observable,
+  of,
+  parseSignatureSchemas,
+  setCurrentInjector,
+  shared_exports as shared,
+  signal,
+  spread,
+  style,
+  symbolValueReplacer,
+  symbolValueReviver,
+  toSignal
+};
+/*! 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.
+  ***************************************************************************** *)
+*/
+//# sourceMappingURL=index.mjs.map