@kithinji/orca 1.0.16 → 1.0.17

package/dist/browser/index.iife.js

@@ -30,6 +30,7 @@ var kithinjiorca = (() => {
   __export(index_browser_exports, {
     BOOTSTRAP: () => BOOTSTRAP,
     BOOTSTRAP_VNODE: () => BOOTSTRAP_VNODE,
+    BehaviorSubject: () => BehaviorSubject,
     Body: () => Body,
     BrowserFactory: () => BrowserFactory,
     COMPONENT: () => COMPONENT,
@@ -76,18 +77,27 @@ var kithinjiorca = (() => {
     Param: () => Param,
     Post: () => Post,
     ProviderNormalizer: () => ProviderNormalizer,
+    Query: () => Query,
     RouterModule: () => RouterModule,
     RouterOutlet: () => RouterOutlet,
     SIGNATURE_METADATA_KEY: () => SIGNATURE_METADATA_KEY,
+    SSE_ROUTE: () => SSE_ROUTE,
     Signature: () => Signature,
+    Sse: () => Sse,
+    Subject: () => Subject,
     assert$: () => assert$,
     batch: () => batch,
     browser: () => browser_exports,
+    catchError: () => catchError,
     collectAllProvidersFromNode: () => collectAllProvidersFromNode,
     computed: () => computed,
+    concatMap: () => concatMap,
     createComponent: () => createComponent,
     createRoot: () => createRoot,
+    debounceTime: () => debounceTime,
+    distinctUntilChanged: () => distinctUntilChanged,
     effect: () => effect,
+    filter: () => filter,
     from: () => from,
     getCurrentInjector: () => getCurrentInjector,
     getSignatureMetadata: () => getSignatureMetadata,
@@ -101,16 +111,26 @@ var kithinjiorca = (() => {
     isSignal: () => isSignal,
     jsx: () => jsx,
     jsxs: () => jsxs,
+    map: () => map,
+    mergeMap: () => mergeMap,
     observable: () => observable,
     of: () => of,
     parseSignatureSchemas: () => parseSignatureSchemas,
+    reduce: () => reduce,
+    scan: () => scan,
     setCurrentInjector: () => setCurrentInjector,
     shared: () => shared_exports,
     signal: () => signal,
+    skip: () => skip,
     spread: () => spread,
+    startWith: () => startWith,
     style: () => style,
+    switchMap: () => switchMap,
     symbolValueReplacer: () => symbolValueReplacer,
     symbolValueReviver: () => symbolValueReviver,
+    take: () => take,
+    tap: () => tap,
+    throttleTime: () => throttleTime,
     toSignal: () => toSignal,
     untracked: () => untracked
   });
@@ -121,6 +141,7 @@ var kithinjiorca = (() => {
   __export(shared_exports, {
     BOOTSTRAP: () => BOOTSTRAP,
     BOOTSTRAP_VNODE: () => BOOTSTRAP_VNODE,
+    BehaviorSubject: () => BehaviorSubject,
     Body: () => Body,
     COMPONENT: () => COMPONENT,
     COMPONENT_DEPS: () => COMPONENT_DEPS,
@@ -166,19 +187,28 @@ var kithinjiorca = (() => {
     Param: () => Param,
     Post: () => Post,
     ProviderNormalizer: () => ProviderNormalizer,
+    Query: () => Query,
     RouterModule: () => RouterModule,
     RouterOutlet: () => RouterOutlet,
     SIGNATURE_METADATA_KEY: () => SIGNATURE_METADATA_KEY,
+    SSE_ROUTE: () => SSE_ROUTE,
     Signature: () => Signature,
+    Sse: () => Sse,
     StreamRenderer: () => StreamRenderer,
     StringRenderer: () => StringRenderer,
+    Subject: () => Subject,
     VNode: () => VNode,
     assert$: () => assert$,
     batch: () => batch,
+    catchError: () => catchError,
     collectAllProvidersFromNode: () => collectAllProvidersFromNode,
     computed: () => computed,
+    concatMap: () => concatMap,
     createRoot: () => createRoot,
+    debounceTime: () => debounceTime,
+    distinctUntilChanged: () => distinctUntilChanged,
     effect: () => effect,
+    filter: () => filter,
     from: () => from,
     getCurrentInjector: () => getCurrentInjector,
     getSignatureMetadata: () => getSignatureMetadata,
@@ -191,14 +221,24 @@ var kithinjiorca = (() => {
     isSignal: () => isSignal,
     jsx: () => jsx,
     jsxs: () => jsxs,
+    map: () => map,
+    mergeMap: () => mergeMap,
     observable: () => observable,
     of: () => of,
     parseSignatureSchemas: () => parseSignatureSchemas,
+    reduce: () => reduce,
+    scan: () => scan,
     setCurrentInjector: () => setCurrentInjector,
     signal: () => signal,
+    skip: () => skip,
+    startWith: () => startWith,
     store: () => store,
+    switchMap: () => switchMap,
     symbolValueReplacer: () => symbolValueReplacer,
     symbolValueReviver: () => symbolValueReviver,
+    take: () => take,
+    tap: () => tap,
+    throttleTime: () => throttleTime,
     toSignal: () => toSignal,
     untracked: () => untracked
   });
@@ -244,6 +284,7 @@ var kithinjiorca = (() => {
   var PATH_KEY = Symbol("orca:path");
   var EXPRESS_ADAPTER_HOST = Symbol("orca:express");
   var SIGNATURE_METADATA_KEY = Symbol("orca:signature:schemas");
+  var SSE_ROUTE = Symbol("orca:sse:route");
   var ERROR_ELEMENT = Symbol.for("orca:error");
   var ORCA_ELEMENT_TYPE = Symbol.for("orca:element");
   var ORCA_FRAGMENT_TYPE = Symbol.for("orca:fragment");
@@ -254,6 +295,10 @@ var kithinjiorca = (() => {
   var HandlerParamType = /* @__PURE__ */ ((HandlerParamType2) => {
     HandlerParamType2["ROUTE_PARAM"] = "ROUTE_PARAM";
     HandlerParamType2["BODY"] = "BODY";
+    HandlerParamType2["QUERY"] = "QUERY";
+    HandlerParamType2["HEADERS"] = "HEADERS";
+    HandlerParamType2["REQUEST"] = "REQUEST";
+    HandlerParamType2["RESPONSE"] = "RESPONSE";
     return HandlerParamType2;
   })(HandlerParamType || {});
   var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
@@ -329,6 +374,9 @@ var kithinjiorca = (() => {
   function Body(key) {
     return getHandlerParamDecorator("BODY" /* BODY */, key);
   }
+  function Query(key) {
+    return getHandlerParamDecorator("QUERY" /* QUERY */, key);
+  }
   function getRouteDecorator(httpMethod, path) {
     return function(target, key, descriptor) {
       Reflect.defineMetadata(HTTP_METHOD_KEY, httpMethod, target, key);
@@ -341,6 +389,13 @@ var kithinjiorca = (() => {
   function Post(path) {
     return getRouteDecorator("post" /* POST */, path ?? "");
   }
+  function Sse(path) {
+    return function(target, propertyKey, descriptor) {
+      Reflect.defineMetadata(SSE_ROUTE, true, target, propertyKey);
+      Reflect.defineMetadata(PATH_KEY, path, target, propertyKey);
+      Reflect.defineMetadata(HTTP_METHOD_KEY, "get" /* GET */, target, propertyKey);
+    };
+  }
   function Signature(...schemas) {
     return function(target, propertyKey, descriptor) {
       Reflect.defineMetadata(SIGNATURE_METADATA_KEY, schemas, target, propertyKey);
@@ -877,14 +932,14 @@ var kithinjiorca = (() => {
       return "";
     }
     escapeHtml(text) {
-      const map = {
+      const map2 = {
         "&": "&",
         "<": "&lt;",
         ">": "&gt;",
         '"': "&quot;",
         "'": "&#039;"
       };
-      return text.replace(/[&<>"']/g, (m) => map[m]);
+      return text.replace(/[&<>"']/g, (m) => map2[m]);
     }
   };
 
@@ -1232,10 +1287,11 @@ var kithinjiorca = (() => {
     let value = initialValue;
     const subscribers = /* @__PURE__ */ new Set();
     const notify = () => {
-      if (batchDepth > 0) {
-        subscribers.forEach((sub) => pendingEffects.add(sub));
-      } else {
-        subscribers.forEach((sub) => sub.execute());
+      subscribers.forEach((sub) => pendingEffects.add(sub));
+      if (batchDepth === 0) {
+        const effects = Array.from(pendingEffects);
+        pendingEffects.clear();
+        effects.forEach((effect2) => effect2.execute());
       }
     };
     return {
@@ -1355,67 +1411,40 @@ var kithinjiorca = (() => {
     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;
+      let isUnsubscribed = false;
       if (this.producer) {
         try {
           cleanup = this.producer(observer);
         } catch (err) {
           if (observer.error) {
-            observer.error(err);
+            try {
+              observer.error(err);
+            } catch (e) {
+              console.error("Error in error handler during subscription:", e);
+            }
+          } else {
+            throw 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);
+          if (isUnsubscribed)
+            return;
+          isUnsubscribed = true;
+          if (cleanup) {
+            try {
+              cleanup();
+            } catch (err) {
+              console.error("Error during cleanup:", err);
+            }
           }
         }
-      });
-      this.subscribers.clear();
+      };
     }
     pipe(...operations) {
       if (operations.length === 0) {
@@ -1426,10 +1455,14 @@ var kithinjiorca = (() => {
   };
   function from(iterable) {
     return new Observable((observer) => {
-      for (const value of iterable) {
-        observer.next(value);
+      try {
+        for (const value of iterable) {
+          observer.next(value);
+        }
+        observer.complete?.();
+      } catch (err) {
+        observer.error?.(err);
       }
-      observer.complete?.();
     });
   }
   function interval(ms) {
@@ -1443,8 +1476,12 @@ var kithinjiorca = (() => {
   }
   function of(...values) {
     return new Observable((observer) => {
-      values.forEach((value) => observer.next(value));
-      observer.complete?.();
+      try {
+        values.forEach((value) => observer.next(value));
+        observer.complete?.();
+      } catch (err) {
+        observer.error?.(err);
+      }
     });
   }
   function observable(producer) {
@@ -1455,12 +1492,484 @@ var kithinjiorca = (() => {
     const subst = obs.subscribe((val) => {
       sig.value = val;
     });
-    instance.__cleanup = [...instance.__cleanup ?? [], () => subst.unsubscribe()];
+    instance.__cleanup = [
+      ...instance.__cleanup || [],
+      () => subst.unsubscribe()
+    ];
     return sig;
   }
   function isObservable(value) {
     return value && value.__isObservable === true;
   }
+  function map(fn) {
+    return (source) => {
+      return new Observable((observer) => {
+        const subscription = source.subscribe(
+          (value) => {
+            try {
+              observer.next(fn(value));
+            } catch (err) {
+              observer.error?.(err);
+            }
+          },
+          (err) => observer.error?.(err),
+          () => observer.complete?.()
+        );
+        return () => subscription.unsubscribe();
+      });
+    };
+  }
+  function filter(predicate) {
+    return (source) => {
+      return new Observable((observer) => {
+        const subscription = source.subscribe(
+          (value) => {
+            try {
+              if (predicate(value)) {
+                observer.next(value);
+              }
+            } catch (err) {
+              observer.error?.(err);
+            }
+          },
+          (err) => observer.error?.(err),
+          () => observer.complete?.()
+        );
+        return () => subscription.unsubscribe();
+      });
+    };
+  }
+  function tap(fn) {
+    return (source) => {
+      return new Observable((observer) => {
+        const subscription = source.subscribe(
+          (value) => {
+            try {
+              fn(value);
+              observer.next(value);
+            } catch (err) {
+              observer.error?.(err);
+            }
+          },
+          (err) => observer.error?.(err),
+          () => observer.complete?.()
+        );
+        return () => subscription.unsubscribe();
+      });
+    };
+  }
+  function take(count) {
+    return (source) => {
+      return new Observable((observer) => {
+        let taken = 0;
+        const subscription = source.subscribe(
+          (value) => {
+            if (taken < count) {
+              observer.next(value);
+              taken++;
+              if (taken === count) {
+                observer.complete?.();
+                subscription.unsubscribe();
+              }
+            }
+          },
+          (err) => observer.error?.(err),
+          () => observer.complete?.()
+        );
+        return () => subscription.unsubscribe();
+      });
+    };
+  }
+  function skip(count) {
+    return (source) => {
+      return new Observable((observer) => {
+        let skipped = 0;
+        const subscription = source.subscribe(
+          (value) => {
+            if (skipped < count) {
+              skipped++;
+            } else {
+              observer.next(value);
+            }
+          },
+          (err) => observer.error?.(err),
+          () => observer.complete?.()
+        );
+        return () => subscription.unsubscribe();
+      });
+    };
+  }
+  function debounceTime(ms) {
+    return (source) => {
+      return new Observable((observer) => {
+        let timeoutId;
+        const subscription = source.subscribe(
+          (value) => {
+            clearTimeout(timeoutId);
+            timeoutId = setTimeout(() => {
+              observer.next(value);
+            }, ms);
+          },
+          (err) => observer.error?.(err),
+          () => observer.complete?.()
+        );
+        return () => {
+          clearTimeout(timeoutId);
+          subscription.unsubscribe();
+        };
+      });
+    };
+  }
+  function throttleTime(ms) {
+    return (source) => {
+      return new Observable((observer) => {
+        let lastEmit = 0;
+        const subscription = source.subscribe(
+          (value) => {
+            const now = Date.now();
+            if (now - lastEmit >= ms) {
+              lastEmit = now;
+              observer.next(value);
+            }
+          },
+          (err) => observer.error?.(err),
+          () => observer.complete?.()
+        );
+        return () => subscription.unsubscribe();
+      });
+    };
+  }
+  function distinctUntilChanged(compare) {
+    return (source) => {
+      return new Observable((observer) => {
+        let hasLast = false;
+        let last;
+        const subscription = source.subscribe(
+          (value) => {
+            const isDistinct = !hasLast || (compare ? !compare(last, value) : last !== value);
+            if (isDistinct) {
+              hasLast = true;
+              last = value;
+              observer.next(value);
+            }
+          },
+          (err) => observer.error?.(err),
+          () => observer.complete?.()
+        );
+        return () => subscription.unsubscribe();
+      });
+    };
+  }
+  function switchMap(fn) {
+    return (source) => {
+      return new Observable((observer) => {
+        let innerSubscription = null;
+        const outerSubscription = source.subscribe(
+          (value) => {
+            if (innerSubscription) {
+              innerSubscription.unsubscribe();
+            }
+            try {
+              const innerObservable = fn(value);
+              innerSubscription = innerObservable.subscribe(
+                (innerValue) => observer.next(innerValue),
+                (err) => observer.error?.(err)
+              );
+            } catch (err) {
+              observer.error?.(err);
+            }
+          },
+          (err) => observer.error?.(err),
+          () => observer.complete?.()
+        );
+        return () => {
+          if (innerSubscription) {
+            innerSubscription.unsubscribe();
+          }
+          outerSubscription.unsubscribe();
+        };
+      });
+    };
+  }
+  function mergeMap(fn) {
+    return (source) => {
+      return new Observable((observer) => {
+        const innerSubscriptions = [];
+        let outerComplete = false;
+        let activeCount = 0;
+        const checkComplete = () => {
+          if (outerComplete && activeCount === 0) {
+            observer.complete?.();
+          }
+        };
+        const outerSubscription = source.subscribe(
+          (value) => {
+            try {
+              const innerObservable = fn(value);
+              activeCount++;
+              const innerSub = innerObservable.subscribe(
+                (innerValue) => observer.next(innerValue),
+                (err) => observer.error?.(err),
+                () => {
+                  activeCount--;
+                  checkComplete();
+                }
+              );
+              innerSubscriptions.push(innerSub);
+            } catch (err) {
+              observer.error?.(err);
+            }
+          },
+          (err) => observer.error?.(err),
+          () => {
+            outerComplete = true;
+            checkComplete();
+          }
+        );
+        return () => {
+          innerSubscriptions.forEach((sub) => sub.unsubscribe());
+          outerSubscription.unsubscribe();
+        };
+      });
+    };
+  }
+  function concatMap(fn) {
+    return (source) => {
+      return new Observable((observer) => {
+        const queue = [];
+        let innerSubscription = null;
+        let outerComplete = false;
+        let isProcessing = false;
+        const processNext = () => {
+          if (isProcessing || queue.length === 0) {
+            if (outerComplete && queue.length === 0) {
+              observer.complete?.();
+            }
+            return;
+          }
+          isProcessing = true;
+          const value = queue.shift();
+          try {
+            const innerObservable = fn(value);
+            innerSubscription = innerObservable.subscribe(
+              (innerValue) => observer.next(innerValue),
+              (err) => observer.error?.(err),
+              () => {
+                isProcessing = false;
+                processNext();
+              }
+            );
+          } catch (err) {
+            observer.error?.(err);
+          }
+        };
+        const outerSubscription = source.subscribe(
+          (value) => {
+            queue.push(value);
+            processNext();
+          },
+          (err) => observer.error?.(err),
+          () => {
+            outerComplete = true;
+            if (queue.length === 0 && !isProcessing) {
+              observer.complete?.();
+            }
+          }
+        );
+        return () => {
+          if (innerSubscription) {
+            innerSubscription.unsubscribe();
+          }
+          outerSubscription.unsubscribe();
+        };
+      });
+    };
+  }
+  function catchError(handler) {
+    return (source) => {
+      return new Observable((observer) => {
+        const subscription = source.subscribe(
+          (value) => observer.next(value),
+          (err) => {
+            try {
+              const fallback = handler(err);
+              const fallbackSub = fallback.subscribe(
+                (value) => observer.next(value),
+                (e) => observer.error?.(e),
+                () => observer.complete?.()
+              );
+              subscription.__fallback = fallbackSub;
+            } catch (e) {
+              observer.error?.(e);
+            }
+          },
+          () => observer.complete?.()
+        );
+        return () => {
+          if (subscription.__fallback) {
+            subscription.__fallback.unsubscribe();
+          }
+          subscription.unsubscribe();
+        };
+      });
+    };
+  }
+  function startWith(...values) {
+    return (source) => {
+      return new Observable((observer) => {
+        values.forEach((value) => observer.next(value));
+        const subscription = source.subscribe(
+          (value) => observer.next(value),
+          (err) => observer.error?.(err),
+          () => observer.complete?.()
+        );
+        return () => subscription.unsubscribe();
+      });
+    };
+  }
+  function scan(accumulator, seed) {
+    return (source) => {
+      return new Observable((observer) => {
+        let acc = seed;
+        const subscription = source.subscribe(
+          (value) => {
+            try {
+              acc = accumulator(acc, value);
+              observer.next(acc);
+            } catch (err) {
+              observer.error?.(err);
+            }
+          },
+          (err) => observer.error?.(err),
+          () => observer.complete?.()
+        );
+        return () => subscription.unsubscribe();
+      });
+    };
+  }
+  function reduce(accumulator, seed) {
+    return (source) => {
+      return new Observable((observer) => {
+        let acc = seed;
+        const subscription = source.subscribe(
+          (value) => {
+            try {
+              acc = accumulator(acc, value);
+            } catch (err) {
+              observer.error?.(err);
+            }
+          },
+          (err) => observer.error?.(err),
+          () => {
+            observer.next(acc);
+            observer.complete?.();
+          }
+        );
+        return () => subscription.unsubscribe();
+      });
+    };
+  }
+
+  // src/shared/observable/subject.ts
+  var Subject = class extends Observable {
+    constructor() {
+      super();
+      this.subscribers = /* @__PURE__ */ new Set();
+      this._isCompleted = false;
+      this._hasError = false;
+    }
+    subscribe(observerOrNext, error, complete) {
+      if (this._isCompleted) {
+        const obs = typeof observerOrNext === "function" ? { complete } : observerOrNext;
+        obs.complete?.();
+        return { unsubscribe: () => {
+        } };
+      }
+      if (this._hasError) {
+        return { unsubscribe: () => {
+        } };
+      }
+      const observer = typeof observerOrNext === "function" ? { next: observerOrNext, error, complete } : observerOrNext;
+      this.subscribers.add(observer);
+      return {
+        unsubscribe: () => {
+          this.subscribers.delete(observer);
+        }
+      };
+    }
+    next(value) {
+      if (this._isCompleted || this._hasError)
+        return;
+      const currentSubscribers = Array.from(this.subscribers);
+      currentSubscribers.forEach((observer) => {
+        if (this.subscribers.has(observer)) {
+          try {
+            observer.next(value);
+          } catch (err) {
+            console.error("Error in observer:", err);
+          }
+        }
+      });
+    }
+    error(err) {
+      if (this._isCompleted || this._hasError)
+        return;
+      this._hasError = true;
+      const currentSubscribers = Array.from(this.subscribers);
+      currentSubscribers.forEach((observer) => {
+        if (observer.error) {
+          try {
+            observer.error(err);
+          } catch (e) {
+            console.error("Error in error handler:", e);
+          }
+        }
+      });
+      this.subscribers.clear();
+    }
+    complete() {
+      if (this._isCompleted || this._hasError)
+        return;
+      this._isCompleted = true;
+      const currentSubscribers = Array.from(this.subscribers);
+      currentSubscribers.forEach((observer) => {
+        if (observer.complete) {
+          try {
+            observer.complete();
+          } catch (err) {
+            console.error("Error in complete handler:", err);
+          }
+        }
+      });
+      this.subscribers.clear();
+    }
+  };
+
+  // src/shared/observable/bsubject.ts
+  var BehaviorSubject = class extends Subject {
+    constructor(initialValue) {
+      super();
+      this._value = initialValue;
+    }
+    get $value() {
+      return this._value;
+    }
+    next(value) {
+      this._value = value;
+      super.next(value);
+    }
+    subscribe(observerOrNext, error, complete) {
+      const observer = typeof observerOrNext === "function" ? { next: observerOrNext, error, complete } : observerOrNext;
+      try {
+        observer.next(this._value);
+      } catch (err) {
+        if (observer.error) {
+          observer.error(err);
+        }
+      }
+      return super.subscribe(observer);
+    }
+  };
 
   // src/shared/component.ts
   var OrcaComponent = class {
@@ -1508,7 +2017,6 @@ var kithinjiorca = (() => {
       window.addEventListener("popstate", (e) => {
         const newIndex = e.state?.cursor ?? 0;
         this.cursor = newIndex;
-        this.pages.next([...this.pages.$value || []]);
       });
     }
     getHome() {
@@ -1519,18 +2027,20 @@ var kithinjiorca = (() => {
       });
     }
     push(component) {
-      const currentPages = this.pages.$value || [];
+      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 || []];
+      const currentPages = [.../*this.pages.$value ||*/
+      []];
       currentPages[this.cursor] = component;
       history.replaceState({ cursor: this.cursor }, "");
-      this.pages.next(currentPages);
     }
     goBack() {
       if (this.cursor > 0) {
@@ -1538,7 +2048,10 @@ var kithinjiorca = (() => {
       }
     }
     goForward() {
-      const currentPages = this.pages.$value || [];
+      const currentPages = (
+        /*this.pages.$value ||*/
+        []
+      );
       if (this.cursor < currentPages.length - 1) {
         history.forward();
       }
@@ -1547,16 +2060,21 @@ var kithinjiorca = (() => {
       return this.cursor > 0;
     }
     canGoForward() {
-      const currentPages = this.pages.$value || [];
+      const currentPages = (
+        /*this.pages.$value ||*/
+        []
+      );
       return this.cursor < currentPages.length - 1;
     }
     getCurrentPage() {
-      const currentPages = this.pages.$value || [];
+      const currentPages = (
+        /*this.pages.$value ||*/
+        []
+      );
       return currentPages[this.cursor];
     }
     clear() {
       this.cursor = 0;
-      this.pages.next([]);
       history.replaceState({ cursor: 0 }, "");
     }
   };
@@ -1603,7 +2121,6 @@ var kithinjiorca = (() => {
         }
       }, () => {
       }, () => {
-        this.navigate.pages.setValue([osc.tree.dom]);
       });
       const subscription = this.navigate.pages.subscribe((pages) => {
         const top = pages[this.navigate.cursor];
@@ -2165,12 +2682,6 @@ var kithinjiorca = (() => {
         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());