@kithinji/orca 1.0.0

package/dist/browser/index.iife.js

@@ -0,0 +1,2093 @@
+"use strict";
+var kithinjiorca = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.browser.ts
+  var index_browser_exports = {};
+  __export(index_browser_exports, {
+    BOOTSTRAP: () => BOOTSTRAP,
+    BOOTSTRAP_VNODE: () => BOOTSTRAP_VNODE,
+    Body: () => Body,
+    BrowserFactory: () => BrowserFactory,
+    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,
+    assert$: () => assert$,
+    browser: () => browser_exports,
+    collectAllProvidersFromNode: () => collectAllProvidersFromNode,
+    computed: () => computed,
+    createComponent: () => createComponent,
+    effect: () => effect,
+    from: () => from,
+    getCurrentInjector: () => getCurrentInjector,
+    getSignatureMetadata: () => getSignatureMetadata,
+    hasSignature: () => hasSignature,
+    insert: () => insert,
+    interval: () => interval,
+    isClassComponent: () => isClassComponent,
+    isFragment: () => isFragment,
+    isIntrinsicElement: () => isIntrinsicElement,
+    isObservable: () => isObservable,
+    isSignal: () => isSignal,
+    jsx: () => jsx,
+    jsxs: () => jsxs,
+    observable: () => observable,
+    of: () => of,
+    parseSignatureSchemas: () => parseSignatureSchemas,
+    setCurrentInjector: () => setCurrentInjector,
+    shared: () => shared_exports,
+    signal: () => signal,
+    spread: () => spread,
+    style: () => style,
+    symbolValueReplacer: () => symbolValueReplacer,
+    symbolValueReviver: () => symbolValueReviver,
+    toSignal: () => toSignal
+  });
+  var import_reflect_metadata = __require("reflect-metadata");
+
+  // 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;
+  }
+
+  // src/shared/jsx/jsx-runtime.ts
+  var import_uuid = __require("uuid");
+  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: (0, import_uuid.v4)(),
+      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);
+    }
+  }
+  return __toCommonJS(index_browser_exports);
+})();
+//# sourceMappingURL=index.iife.js.map