synstate 2.0.2 → 3.0.1

package/dist/core/create/counter.mjs

@@ -1,58 +1,83 @@
-import { Optional, asSafeUint, SafeUint } from 'ts-data-forge';
-import '../utils/id-maker.mjs';
-import { RootObservableClass } from '../class/root-observable-class.mjs';
-
-const counter = (intervalMilliSeconds, options) => new CounterObservableClass(
-  intervalMilliSeconds,
-  options?.startManually ?? false
-);
-class CounterObservableClass extends RootObservableClass {
-  #intervalMilliSeconds;
-  #mut_counter;
-  #mut_timerId0;
-  #mut_timerId;
-  #mut_isStarted;
-  constructor(intervalMilliSeconds, startManually) {
-    super({ initialValue: Optional.none });
-    this.#intervalMilliSeconds = intervalMilliSeconds;
-    this.#mut_counter = asSafeUint(0);
-    this.#mut_timerId0 = void 0;
-    this.#mut_timerId = void 0;
-    this.#mut_isStarted = false;
-    if (!startManually) {
-      this.start();
-    }
-  }
-  #resetTimer() {
-    if (this.#mut_timerId0 === void 0 || this.#mut_timerId === void 0) {
-      return;
-    }
-    clearInterval(this.#mut_timerId0);
-    clearInterval(this.#mut_timerId);
-  }
-  start() {
-    if (this.#mut_isStarted) {
-      console.warn("cannot start twice");
-      return;
-    }
-    this.#mut_isStarted = true;
-    if (this.isCompleted) {
-      console.warn("cannot restart stopped CounterObservable");
-      return;
+import { asSafeUint, Optional, SafeUint } from 'ts-data-forge';
+import { createRootObservable } from '../base/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const counter = (intervalMilliSeconds, options) => {
+    let mut_counter = asSafeUint(0);
+    let mut_timerId0 = undefined;
+    let mut_timerId = undefined;
+    let mut_isStarted = false;
+    const resetTimer = () => {
+        if (mut_timerId0 === undefined || mut_timerId === undefined) {
+            return;
+        }
+        clearInterval(mut_timerId0);
+        clearInterval(mut_timerId);
+    };
+    const observable = createRootObservable({ initialValue: Optional.none, onComplete: resetTimer }, ({ startUpdate, isCompleted }) => ({
+        start: () => {
+            if (mut_isStarted) {
+                console.warn('cannot start twice');
+                return;
+            }
+            mut_isStarted = true;
+            if (isCompleted()) {
+                console.warn('cannot restart stopped CounterObservable');
+                return;
+            }
+            mut_timerId0 = setTimeout(() => {
+                startUpdate(mut_counter);
+            }, 0);
+            mut_timerId = setInterval(() => {
+                mut_counter = SafeUint.add(1, mut_counter);
+                startUpdate(mut_counter);
+            }, intervalMilliSeconds);
+        },
+    }));
+    if (!(options?.startManually ?? false)) {
+        observable.start();
     }
-    this.#mut_timerId0 = setTimeout(() => {
-      this.startUpdate(this.#mut_counter);
-    }, 0);
-    this.#mut_timerId = setInterval(() => {
-      this.#mut_counter = SafeUint.add(1, this.#mut_counter);
-      this.startUpdate(this.#mut_counter);
-    }, this.#intervalMilliSeconds);
-  }
-  complete() {
-    this.#resetTimer();
-    super.complete();
-  }
-}
-
-export { counter };
-//# sourceMappingURL=counter.mjs.map
+    return observable;
+};
+//# sourceMappingURL=counter.mjs.map

package/dist/core/create/counter.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"counter.mjs","sources":["../../../src/core/create/counter.mts"],"sourcesContent":["import { asSafeUint, Optional, SafeUint } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport { type CounterObservable, type TimerId } from '../types/index.mjs';\n\n/**\n * Creates an observable that emits incremental numbers at a specified interval.\n * Starts with 0 immediately after subscription, then emits 1, 2, 3, ... every interval.\n *\n * @param intervalMilliSeconds - The interval duration in milliseconds\n * @param startManually - If true, waits for manual start (default: false)\n * @returns An observable that emits sequential numbers\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  Time(s)   0     1     2     3     4     5\n * //  tick$     0     1     2     3     4     5     ...\n * //\n * //  Explanation:\n * //  - counter emits incrementing numbers at specified intervals\n * //  - Starts at 0 and continues indefinitely\n * //  - Useful for periodic tasks or animations\n *\n * const tick$ = counter(100);\n *\n * const valueHistory: number[] = [];\n *\n * const subscription = tick$.subscribe((count) => {\n *   valueHistory.push(count);\n * });\n *\n * await new Promise((resolve) => {\n *   setTimeout(resolve, 350);\n * });\n *\n * subscription.unsubscribe();\n *\n * assert.isTrue(Arr.isMinLengthArray(3, valueHistory));\n *\n * assert.deepStrictEqual(valueHistory[0], 0);\n *\n * assert.deepStrictEqual(valueHistory[1], 1);\n *\n * assert.deepStrictEqual(valueHistory[2], 2);\n * ```\n */\nexport const counter = (\n  intervalMilliSeconds: number,\n  options?: Readonly<{\n    startManually?: boolean;\n  }>,\n): CounterObservable =>\n  new CounterObservableClass(\n    intervalMilliSeconds,\n    options?.startManually ?? false,\n  );\n\nclass CounterObservableClass\n  extends RootObservableClass<SafeUint>\n  implements CounterObservable\n{\n  readonly #intervalMilliSeconds: number;\n  #mut_counter: SafeUint;\n  #mut_timerId0: TimerId | undefined;\n  #mut_timerId: TimerId | undefined;\n  #mut_isStarted: boolean;\n\n  constructor(intervalMilliSeconds: number, startManually: boolean) {\n    super({ initialValue: Optional.none });\n\n    this.#intervalMilliSeconds = intervalMilliSeconds;\n\n    this.#mut_counter = asSafeUint(0);\n\n    this.#mut_timerId0 = undefined;\n\n    this.#mut_timerId = undefined;\n\n    this.#mut_isStarted = false;\n\n    if (!startManually) {\n      this.start();\n    }\n  }\n\n  #resetTimer(): void {\n    if (this.#mut_timerId0 === undefined || this.#mut_timerId === undefined) {\n      return;\n    }\n\n    clearInterval(this.#mut_timerId0);\n\n    clearInterval(this.#mut_timerId);\n  }\n\n  start(): void {\n    if (this.#mut_isStarted) {\n      console.warn('cannot start twice');\n\n      return;\n    }\n\n    this.#mut_isStarted = true;\n\n    if (this.isCompleted) {\n      console.warn('cannot restart stopped CounterObservable');\n\n      return;\n    }\n\n    this.#mut_timerId0 = setTimeout(() => {\n      this.startUpdate(this.#mut_counter);\n    }, 0);\n\n    this.#mut_timerId = setInterval(() => {\n      this.#mut_counter = SafeUint.add(1, this.#mut_counter);\n\n      this.startUpdate(this.#mut_counter);\n    }, this.#intervalMilliSeconds);\n  }\n\n  override complete(): void {\n    this.#resetTimer();\n\n    super.complete();\n  }\n}\n"],"names":[],"mappings":";;;;AA+CO,MAAM,OAAA,GAAU,CACrB,oBAAA,EACA,OAAA,KAIA,IAAI,sBAAA;AAAA,EACF,oBAAA;AAAA,EACA,SAAS,aAAA,IAAiB;AAC5B;AAEF,MAAM,+BACI,mBAAA,CAEV;AAAA,EACW,qBAAA;AAAA,EACT,YAAA;AAAA,EACA,aAAA;AAAA,EACA,YAAA;AAAA,EACA,cAAA;AAAA,EAEA,WAAA,CAAY,sBAA8B,aAAA,EAAwB;AAChE,IAAA,KAAA,CAAM,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,EAAM,CAAA;AAErC,IAAA,IAAA,CAAK,qBAAA,GAAwB,oBAAA;AAE7B,IAAA,IAAA,CAAK,YAAA,GAAe,WAAW,CAAC,CAAA;AAEhC,IAAA,IAAA,CAAK,aAAA,GAAgB,MAAA;AAErB,IAAA,IAAA,CAAK,YAAA,GAAe,MAAA;AAEpB,IAAA,IAAA,CAAK,cAAA,GAAiB,KAAA;AAEtB,IAAA,IAAI,CAAC,aAAA,EAAe;AAClB,MAAA,IAAA,CAAK,KAAA,EAAM;AAAA,IACb;AAAA,EACF;AAAA,EAEA,WAAA,GAAoB;AAClB,IAAA,IAAI,IAAA,CAAK,aAAA,KAAkB,MAAA,IAAa,IAAA,CAAK,iBAAiB,MAAA,EAAW;AACvE,MAAA;AAAA,IACF;AAEA,IAAA,aAAA,CAAc,KAAK,aAAa,CAAA;AAEhC,IAAA,aAAA,CAAc,KAAK,YAAY,CAAA;AAAA,EACjC;AAAA,EAEA,KAAA,GAAc;AACZ,IAAA,IAAI,KAAK,cAAA,EAAgB;AACvB,MAAA,OAAA,CAAQ,KAAK,oBAAoB,CAAA;AAEjC,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,cAAA,GAAiB,IAAA;AAEtB,IAAA,IAAI,KAAK,WAAA,EAAa;AACpB,MAAA,OAAA,CAAQ,KAAK,0CAA0C,CAAA;AAEvD,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,aAAA,GAAgB,WAAW,MAAM;AACpC,MAAA,IAAA,CAAK,WAAA,CAAY,KAAK,YAAY,CAAA;AAAA,IACpC,GAAG,CAAC,CAAA;AAEJ,IAAA,IAAA,CAAK,YAAA,GAAe,YAAY,MAAM;AACpC,MAAA,IAAA,CAAK,YAAA,GAAe,QAAA,CAAS,GAAA,CAAI,CAAA,EAAG,KAAK,YAAY,CAAA;AAErD,MAAA,IAAA,CAAK,WAAA,CAAY,KAAK,YAAY,CAAA;AAAA,IACpC,CAAA,EAAG,KAAK,qBAAqB,CAAA;AAAA,EAC/B;AAAA,EAES,QAAA,GAAiB;AACxB,IAAA,IAAA,CAAK,WAAA,EAAY;AAEjB,IAAA,KAAA,CAAM,QAAA,EAAS;AAAA,EACjB;AACF;;;;"}
+{"version":3,"file":"counter.mjs","sourceRoot":"","sources":["../../../src/core/create/counter.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CACrB,oBAA4B,EAC5B,OAEE,EACiB,EAAE;IACrB,IAAI,WAAW,GAAa,UAAU,CAAC,CAAC,CAAC,CAAC;IAE1C,IAAI,YAAY,GAAwB,SAAS,CAAC;IAElD,IAAI,WAAW,GAAwB,SAAS,CAAC;IAEjD,IAAI,aAAa,GAAG,KAAK,CAAC;IAE1B,MAAM,UAAU,GAAG,GAAS,EAAE;QAC5B,IAAI,YAAY,KAAK,SAAS,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC5D,OAAO;QACT,CAAC;QAED,aAAa,CAAC,YAAY,CAAC,CAAC;QAE5B,aAAa,CAAC,WAAW,CAAC,CAAC;IAC7B,CAAC,CAAC;IAEF,MAAM,UAAU,GAAG,oBAAoB,CAIrC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,EACvD,CAAC,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC;QACjC,KAAK,EAAE,GAAG,EAAE;YACV,IAAI,aAAa,EAAE,CAAC;gBAClB,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;gBAEnC,OAAO;YACT,CAAC;YAED,aAAa,GAAG,IAAI,CAAC;YAErB,IAAI,WAAW,EAAE,EAAE,CAAC;gBAClB,OAAO,CAAC,IAAI,CAAC,0CAA0C,CAAC,CAAC;gBAEzD,OAAO;YACT,CAAC;YAED,YAAY,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC7B,WAAW,CAAC,WAAW,CAAC,CAAC;YAC3B,CAAC,EAAE,CAAC,CAAC,CAAC;YAEN,WAAW,GAAG,WAAW,CAAC,GAAG,EAAE;gBAC7B,WAAW,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;gBAE3C,WAAW,CAAC,WAAW,CAAC,CAAC;YAC3B,CAAC,EAAE,oBAAoB,CAAC,CAAC;QAC3B,CAAC;KACF,CAAC,CACH,CAAC;IAEF,IAAI,CAAC,CAAC,OAAO,EAAE,aAAa,IAAI,KAAK,CAAC,EAAE,CAAC;QACvC,UAAU,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC"}

package/dist/core/create/from-abortable-promise.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"from-abortable-promise.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-abortable-promise.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,WAExC,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,KAC3C,qBAAqB,CAAC,CAAC,EAAE,CAAC,CACqB,CAAC"}
+{"version":3,"file":"from-abortable-promise.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-abortable-promise.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,WAExC,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,KAC3C,qBAAqB,CAAC,CAAC,EAAE,CAAC,CA0C5B,CAAC"}

package/dist/core/create/from-abortable-promise.mjs

@@ -1,38 +1,64 @@
 import { Optional, Result } from 'ts-data-forge';
-import '../utils/id-maker.mjs';
-import { RootObservableClass } from '../class/root-observable-class.mjs';
-
-const fromAbortablePromise = (factory) => new FromAbortablePromiseObservableClass(factory);
-class FromAbortablePromiseObservableClass extends RootObservableClass {
-  #abortController;
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  constructor(factory) {
-    super({ initialValue: Optional.none });
-    this.#abortController = new AbortController();
-    const promise = factory(this.#abortController.signal);
-    promise.then((value) => {
-      if (this.isCompleted) return;
-      this.startUpdate(Result.ok(value));
-    }).catch((error) => {
-      if (this.isCompleted) return;
-      if (error instanceof DOMException && error.name === "AbortError") {
-        return;
-      }
-      this.startUpdate(
-        Result.err(
-          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-          error
-        )
-      );
-    }).finally(() => {
-      this.complete();
+import { createRootObservable } from '../base/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const fromAbortablePromise = (
+
+factory) => {
+    const abortController = new AbortController();
+    return createRootObservable({
+        initialValue: Optional.none,
+        onComplete: () => {
+            abortController.abort();
+        },
+    }, ({ startUpdate, isCompleted, complete }) => {
+        const promise = factory(abortController.signal);
+        promise
+            .then((value) => {
+            if (isCompleted())
+                return;
+            startUpdate(Result.ok(value));
+        })
+            .catch((error) => {
+            if (isCompleted())
+                return;
+
+
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                return;
+            }
+            startUpdate(Result.err(
+
+            error));
+        })
+            .finally(() => {
+            complete();
+        });
+        return {};
     });
-  }
-  complete() {
-    this.#abortController.abort();
-    super.complete();
-  }
-}
-
-export { fromAbortablePromise };
-//# sourceMappingURL=from-abortable-promise.mjs.map
+};
+//# sourceMappingURL=from-abortable-promise.mjs.map

package/dist/core/create/from-abortable-promise.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"from-abortable-promise.mjs","sources":["../../../src/core/create/from-abortable-promise.mts"],"sourcesContent":["import { Optional, Result } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport { type FromPromiseObservable } from '../types/index.mjs';\n\n/**\n * Creates an observable from a Promise factory that receives an `AbortSignal`.\n * When the observable is completed (e.g., by `switchMap` switching to a new\n * inner observable), the `AbortController` is automatically aborted, cancelling\n * the in-flight request.\n *\n * Emits `Result.ok(value)` when the promise resolves, or `Result.err(error)`\n * when it rejects. Rejections caused by abort (`AbortError`) are silently\n * ignored and do not emit.\n *\n * @template A - The type of the resolved value\n * @template E - The type of the error (excluding AbortError)\n * @param factory - A function that receives an `AbortSignal` and returns a Promise\n * @returns An observable that emits the promise result\n *\n * @example\n * ```ts\n * const results$ = query.pipe(\n *   switchMap((q) =>\n *     fromAbortablePromise((signal) =>\n *       fetch(`/api/search?q=${q}`, { signal }).then((r) => r.json()),\n *     ),\n *   ),\n * );\n * ```\n */\nexport const fromAbortablePromise = <A, E = unknown>(\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  factory: (signal: AbortSignal) => Promise<A>,\n): FromPromiseObservable<A, E> =>\n  new FromAbortablePromiseObservableClass(factory);\n\nclass FromAbortablePromiseObservableClass<A, E = unknown>\n  extends RootObservableClass<Result<A, E>>\n  implements FromPromiseObservable<A, E>\n{\n  readonly #abortController: AbortController;\n\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  constructor(factory: (signal: AbortSignal) => Promise<A>) {\n    super({ initialValue: Optional.none });\n\n    this.#abortController = new AbortController();\n\n    const promise = factory(this.#abortController.signal);\n\n    promise\n      .then((value) => {\n        if (this.isCompleted) return;\n\n        this.startUpdate(Result.ok(value));\n      })\n      .catch((error: unknown) => {\n        if (this.isCompleted) return;\n\n        // Silently ignore AbortError — it means the observable was\n        // intentionally completed (e.g., by switchMap).\n        if (error instanceof DOMException && error.name === 'AbortError') {\n          return;\n        }\n\n        this.startUpdate(\n          Result.err(\n            // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n            error as E,\n          ),\n        );\n      })\n      .finally(() => {\n        this.complete();\n      });\n  }\n\n  override complete(): void {\n    this.#abortController.abort();\n\n    super.complete();\n  }\n}\n"],"names":[],"mappings":";;;;AA8BO,MAAM,oBAAA,GAAuB,CAElC,OAAA,KAEA,IAAI,oCAAoC,OAAO;AAEjD,MAAM,4CACI,mBAAA,CAEV;AAAA,EACW,gBAAA;AAAA;AAAA,EAGT,YAAY,OAAA,EAA8C;AACxD,IAAA,KAAA,CAAM,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,EAAM,CAAA;AAErC,IAAA,IAAA,CAAK,gBAAA,GAAmB,IAAI,eAAA,EAAgB;AAE5C,IAAA,MAAM,OAAA,GAAU,OAAA,CAAQ,IAAA,CAAK,gBAAA,CAAiB,MAAM,CAAA;AAEpD,IAAA,OAAA,CACG,IAAA,CAAK,CAAC,KAAA,KAAU;AACf,MAAA,IAAI,KAAK,WAAA,EAAa;AAEtB,MAAA,IAAA,CAAK,WAAA,CAAY,MAAA,CAAO,EAAA,CAAG,KAAK,CAAC,CAAA;AAAA,IACnC,CAAC,CAAA,CACA,KAAA,CAAM,CAAC,KAAA,KAAmB;AACzB,MAAA,IAAI,KAAK,WAAA,EAAa;AAItB,MAAA,IAAI,KAAA,YAAiB,YAAA,IAAgB,KAAA,CAAM,IAAA,KAAS,YAAA,EAAc;AAChE,QAAA;AAAA,MACF;AAEA,MAAA,IAAA,CAAK,WAAA;AAAA,QACH,MAAA,CAAO,GAAA;AAAA;AAAA,UAEL;AAAA;AACF,OACF;AAAA,IACF,CAAC,CAAA,CACA,OAAA,CAAQ,MAAM;AACb,MAAA,IAAA,CAAK,QAAA,EAAS;AAAA,IAChB,CAAC,CAAA;AAAA,EACL;AAAA,EAES,QAAA,GAAiB;AACxB,IAAA,IAAA,CAAK,iBAAiB,KAAA,EAAM;AAE5B,IAAA,KAAA,CAAM,QAAA,EAAS;AAAA,EACjB;AACF;;;;"}
+{"version":3,"file":"from-abortable-promise.mjs","sourceRoot":"","sources":["../../../src/core/create/from-abortable-promise.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;AAClC,8EAA8E;AAC9E,OAA4C,EACf,EAAE;IAC/B,MAAM,eAAe,GAAG,IAAI,eAAe,EAAE,CAAC;IAE9C,OAAO,oBAAoB,CACzB;QACE,YAAY,EAAE,QAAQ,CAAC,IAAI;QAC3B,UAAU,EAAE,GAAG,EAAE;YACf,eAAe,CAAC,KAAK,EAAE,CAAC;QAC1B,CAAC;KACF,EACD,CAAC,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,EAAE,EAAE;QACzC,MAAM,OAAO,GAAG,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;QAEhD,OAAO;aACJ,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;YACd,IAAI,WAAW,EAAE;gBAAE,OAAO;YAE1B,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;QAChC,CAAC,CAAC;aACD,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;YACxB,IAAI,WAAW,EAAE;gBAAE,OAAO;YAE1B,2DAA2D;YAC3D,gDAAgD;YAChD,IAAI,KAAK,YAAY,YAAY,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;gBACjE,OAAO;YACT,CAAC;YAED,WAAW,CACT,MAAM,CAAC,GAAG;YACR,oEAAoE;YACpE,KAAU,CACX,CACF,CAAC;QACJ,CAAC,CAAC;aACD,OAAO,CAAC,GAAG,EAAE;YACZ,QAAQ,EAAE,CAAC;QACb,CAAC,CAAC,CAAC;QAEL,OAAO,EAAE,CAAC;IACZ,CAAC,CACF,CAAC;AACJ,CAAC,CAAC"}

package/dist/core/create/from-promise.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"from-promise.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-promise.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,WAC/B,OAAO,CAAC,CAAC,CAAC,KAClB,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAA4C,CAAC"}
+{"version":3,"file":"from-promise.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-promise.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,WAC/B,OAAO,CAAC,CAAC,CAAC,KAClB,qBAAqB,CAAC,CAAC,EAAE,CAAC,CA0B1B,CAAC"}

package/dist/core/create/from-promise.mjs

@@ -1,27 +1,69 @@
 import { Optional, Result } from 'ts-data-forge';
-import '../utils/id-maker.mjs';
-import { RootObservableClass } from '../class/root-observable-class.mjs';
-
-const fromPromise = (promise) => new FromPromiseObservableClass(promise);
-class FromPromiseObservableClass extends RootObservableClass {
-  constructor(promise) {
-    super({ initialValue: Optional.none });
-    promise.then((value) => {
-      if (this.isCompleted) return;
-      this.startUpdate(Result.ok(value));
-    }).catch((error) => {
-      if (this.isCompleted) return;
-      this.startUpdate(
-        Result.err(
-          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-          error
-        )
-      );
-    }).finally(() => {
-      this.complete();
-    });
-  }
-}
+import { createRootObservable } from '../base/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-export { fromPromise };
-//# sourceMappingURL=from-promise.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const fromPromise = (promise) => createRootObservable({ initialValue: Optional.none }, ({ startUpdate, isCompleted, complete }) => {
+    promise
+        .then((value) => {
+        if (isCompleted())
+            return;
+        startUpdate(Result.ok(value));
+    })
+        .catch((error) => {
+        if (isCompleted())
+            return;
+        startUpdate(Result.err(
+
+        error));
+    })
+        .finally(() => {
+        complete();
+    });
+    return {};
+});
+//# sourceMappingURL=from-promise.mjs.map

package/dist/core/create/from-promise.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"from-promise.mjs","sources":["../../../src/core/create/from-promise.mts"],"sourcesContent":["import { Optional, Result } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport { type FromPromiseObservable } from '../types/index.mjs';\n\n/**\n * Creates an observable from a Promise.\n * Emits Result.ok when the promise resolves, or Result.err when it rejects.\n *\n * @template A - The type of the resolved value\n * @template E - The type of the error\n * @param promise - The promise to convert to observable\n * @returns An observable that emits the promise result\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  promise     [pending...]  -> resolved/rejected\n * //  data$                        Ok(value) or Err(error)\n * //\n * //  Explanation:\n * //  - fromPromise converts a Promise into an observable\n * //  - Emits a Result type: Ok(value) on success, Err(error) on failure\n * //  - Completes after emitting the result\n * //  - Useful for integrating async operations into reactive flows\n *\n * const fetchData = async (): Promise<Readonly<{ value: number }>> =>\n *   ({\n *     value: 42,\n *   }) as const;\n *\n * const data$ = fromPromise(fetchData());\n *\n * const valueHistory: Readonly<{ value: number }>[] = [];\n *\n * await new Promise<void>((resolve) => {\n *   data$.subscribe(\n *     (result) => {\n *       if (Result.isOk(result)) {\n *         valueHistory.push(result.value);\n *       }\n *     },\n *     () => {\n *       resolve();\n *     },\n *   );\n * });\n *\n * assert.deepStrictEqual(valueHistory, [{ value: 42 }]);\n * ```\n */\nexport const fromPromise = <A, E = unknown>(\n  promise: Promise<A>,\n): FromPromiseObservable<A, E> => new FromPromiseObservableClass(promise);\n\nclass FromPromiseObservableClass<A, E = unknown>\n  extends RootObservableClass<Result<A, E>>\n  implements FromPromiseObservable<A, E>\n{\n  constructor(promise: Promise<A>) {\n    super({ initialValue: Optional.none });\n\n    promise\n      .then((value) => {\n        if (this.isCompleted) return;\n\n        this.startUpdate(Result.ok(value));\n      })\n      .catch((error: unknown) => {\n        if (this.isCompleted) return;\n\n        this.startUpdate(\n          Result.err(\n            // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n            error as E,\n          ),\n        );\n      })\n      .finally(() => {\n        this.complete();\n      });\n  }\n}\n"],"names":[],"mappings":";;;;AAmDO,MAAM,WAAA,GAAc,CACzB,OAAA,KACgC,IAAI,2BAA2B,OAAO;AAExE,MAAM,mCACI,mBAAA,CAEV;AAAA,EACE,YAAY,OAAA,EAAqB;AAC/B,IAAA,KAAA,CAAM,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,EAAM,CAAA;AAErC,IAAA,OAAA,CACG,IAAA,CAAK,CAAC,KAAA,KAAU;AACf,MAAA,IAAI,KAAK,WAAA,EAAa;AAEtB,MAAA,IAAA,CAAK,WAAA,CAAY,MAAA,CAAO,EAAA,CAAG,KAAK,CAAC,CAAA;AAAA,IACnC,CAAC,CAAA,CACA,KAAA,CAAM,CAAC,KAAA,KAAmB;AACzB,MAAA,IAAI,KAAK,WAAA,EAAa;AAEtB,MAAA,IAAA,CAAK,WAAA;AAAA,QACH,MAAA,CAAO,GAAA;AAAA;AAAA,UAEL;AAAA;AACF,OACF;AAAA,IACF,CAAC,CAAA,CACA,OAAA,CAAQ,MAAM;AACb,MAAA,IAAA,CAAK,QAAA,EAAS;AAAA,IAChB,CAAC,CAAA;AAAA,EACL;AACF;;;;"}
+{"version":3,"file":"from-promise.mjs","sourceRoot":"","sources":["../../../src/core/create/from-promise.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,OAAmB,EACU,EAAE,CAC/B,oBAAoB,CAClB,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,EAC/B,CAAC,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,EAAE,EAAE;IACzC,OAAO;SACJ,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;QACd,IAAI,WAAW,EAAE;YAAE,OAAO;QAE1B,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAChC,CAAC,CAAC;SACD,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;QACxB,IAAI,WAAW,EAAE;YAAE,OAAO;QAE1B,WAAW,CACT,MAAM,CAAC,GAAG;QACR,oEAAoE;QACpE,KAAU,CACX,CACF,CAAC;IACJ,CAAC,CAAC;SACD,OAAO,CAAC,GAAG,EAAE;QACZ,QAAQ,EAAE,CAAC;IACb,CAAC,CAAC,CAAC;IAEL,OAAO,EAAE,CAAC;AACZ,CAAC,CACF,CAAC"}

package/dist/core/create/from-subscribable.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"from-subscribable.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-subscribable.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,YAAY,EAClB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,gBAC/B,YAAY,CAAC,CAAC,CAAC,KAC5B,0BAA0B,CAAC,CAAC,EAAE,CAAC,CACiB,CAAC"}
+{"version":3,"file":"from-subscribable.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-subscribable.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,YAAY,EAClB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,gBAC/B,YAAY,CAAC,CAAC,CAAC,KAC5B,0BAA0B,CAAC,CAAC,EAAE,CAAC,CAuB/B,CAAC"}

package/dist/core/create/from-subscribable.mjs

@@ -1,29 +1,73 @@
 import { Optional, Result } from 'ts-data-forge';
-import '../utils/id-maker.mjs';
-import { RootObservableClass } from '../class/root-observable-class.mjs';
-
-const fromSubscribable = (subscribable) => new FromSubscribableObservableClass(subscribable);
-class FromSubscribableObservableClass extends RootObservableClass {
-  constructor(subscribable) {
-    super({ initialValue: Optional.none });
-    subscribable.subscribe(
-      (nextValue) => {
-        this.startUpdate(Result.ok(nextValue));
-      },
-      (error) => {
-        this.startUpdate(
-          Result.err(
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            error
-          )
-        );
-      },
-      () => {
-        this.complete();
-      }
-    );
-  }
-}
-
-export { fromSubscribable };
-//# sourceMappingURL=from-subscribable.mjs.map
+import { createRootObservable } from '../base/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const fromSubscribable = (subscribable) => createRootObservable({ initialValue: Optional.none }, ({ startUpdate, complete }) => {
+    subscribable.subscribe((nextValue) => {
+        startUpdate(Result.ok(nextValue));
+    }, (error) => {
+        startUpdate(Result.err(
+
+        error));
+    }, () => {
+        complete();
+    });
+    return {};
+});
+//# sourceMappingURL=from-subscribable.mjs.map

package/dist/core/create/from-subscribable.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"from-subscribable.mjs","sources":["../../../src/core/create/from-subscribable.mts"],"sourcesContent":["import { Optional, Result } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport {\n  type FromSubscribableObservable,\n  type Subscribable,\n} from '../types/index.mjs';\n\n/**\n * Converts any subscribable object into a SynState Observable.\n * Works with objects that have a subscribe(onNext, onError, onComplete) method.\n *\n * @template A - The type of values from the subscribable\n * @template E - The type of errors from the subscribable\n * @param subscribable - An object with a subscribe method\n * @returns An observable that wraps values in Result type\n *\n * @example\n * ```ts\n * //  Explanation:\n * //  - fromSubscribable converts any subscribable object into a SynState Observable\n * //  - Works with objects that have a subscribe(onNext, onError, onComplete) method\n * //  - Wraps values in Result type for error handling\n * //  - Useful for integrating with other reactive libraries or custom subscribables\n *\n * // Example: Converting a custom subscribable\n * const customSubscribable = {\n *   subscribe: (\n *     onNext: (value: number) => void,\n *     _onError?: (error: unknown) => void,\n *     onComplete?: () => void,\n *   ) => {\n *     setTimeout(() => {\n *       onNext(1);\n *\n *       onNext(2);\n *\n *       onNext(3);\n *\n *       onComplete?.();\n *     }, 0);\n *\n *     return { unsubscribe: () => {} };\n *   },\n * } as const;\n *\n * const observable$ = fromSubscribable<number>(customSubscribable);\n *\n * const valueHistory: number[] = [];\n *\n * await new Promise<void>((resolve) => {\n *   observable$.subscribe(\n *     (result) => {\n *       if (Result.isOk(result)) {\n *         valueHistory.push(result.value);\n *       }\n *     },\n *     () => {\n *       resolve();\n *     },\n *   );\n * });\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 3]);\n * ```\n */\nexport const fromSubscribable = <A, E = unknown>(\n  subscribable: Subscribable<A>,\n): FromSubscribableObservable<A, E> =>\n  new FromSubscribableObservableClass(subscribable);\n\nclass FromSubscribableObservableClass<A, E = unknown>\n  extends RootObservableClass<Result<A, E>>\n  implements FromSubscribableObservable<A, E>\n{\n  constructor(subscribable: Subscribable<A>) {\n    super({ initialValue: Optional.none });\n\n    subscribable.subscribe(\n      (nextValue) => {\n        this.startUpdate(Result.ok(nextValue));\n      },\n      (error?: unknown) => {\n        this.startUpdate(\n          Result.err(\n            // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n            error as E,\n          ),\n        );\n      },\n      () => {\n        this.complete();\n      },\n    );\n  }\n}\n"],"names":[],"mappings":";;;;AAiEO,MAAM,gBAAA,GAAmB,CAC9B,YAAA,KAEA,IAAI,gCAAgC,YAAY;AAElD,MAAM,wCACI,mBAAA,CAEV;AAAA,EACE,YAAY,YAAA,EAA+B;AACzC,IAAA,KAAA,CAAM,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,EAAM,CAAA;AAErC,IAAA,YAAA,CAAa,SAAA;AAAA,MACX,CAAC,SAAA,KAAc;AACb,QAAA,IAAA,CAAK,WAAA,CAAY,MAAA,CAAO,EAAA,CAAG,SAAS,CAAC,CAAA;AAAA,MACvC,CAAA;AAAA,MACA,CAAC,KAAA,KAAoB;AACnB,QAAA,IAAA,CAAK,WAAA;AAAA,UACH,MAAA,CAAO,GAAA;AAAA;AAAA,YAEL;AAAA;AACF,SACF;AAAA,MACF,CAAA;AAAA,MACA,MAAM;AACJ,QAAA,IAAA,CAAK,QAAA,EAAS;AAAA,MAChB;AAAA,KACF;AAAA,EACF;AACF;;;;"}
+{"version":3,"file":"from-subscribable.mjs","sourceRoot":"","sources":["../../../src/core/create/from-subscribable.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAMzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,YAA6B,EACK,EAAE,CACpC,oBAAoB,CAClB,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,EAC/B,CAAC,EAAE,WAAW,EAAE,QAAQ,EAAE,EAAE,EAAE;IAC5B,YAAY,CAAC,SAAS,CACpB,CAAC,SAAS,EAAE,EAAE;QACZ,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;IACpC,CAAC,EACD,CAAC,KAAe,EAAE,EAAE;QAClB,WAAW,CACT,MAAM,CAAC,GAAG;QACR,oEAAoE;QACpE,KAAU,CACX,CACF,CAAC;IACJ,CAAC,EACD,GAAG,EAAE;QACH,QAAQ,EAAE,CAAC;IACb,CAAC,CACF,CAAC;IAEF,OAAO,EAAE,CAAC;AACZ,CAAC,CACF,CAAC"}

package/dist/core/create/index.mjs

@@ -1,8 +1,8 @@
-export { counter } from './counter.mjs';
-export { fromAbortablePromise } from './from-abortable-promise.mjs';
-export { fromPromise } from './from-promise.mjs';
-export { fromSubscribable } from './from-subscribable.mjs';
-export { just } from './just.mjs';
-export { source } from './source.mjs';
-export { timer } from './timer.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './counter.mjs';
+export * from './from-abortable-promise.mjs';
+export * from './from-promise.mjs';
+export * from './from-subscribable.mjs';
+export * from './just.mjs';
+export * from './source.mjs';
+export * from './timer.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/core/create/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../src/core/create/index.mts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC"}

package/dist/core/create/just.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"just.d.mts","sourceRoot":"","sources":["../../../src/core/create/just.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,SAAU,CAAC,KAAG,yBAAyB,CAAC,CAAC,CASpE,CAAC"}
+{"version":3,"file":"just.d.mts","sourceRoot":"","sources":["../../../src/core/create/just.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,SAAU,CAAC,KAAG,yBAAyB,CAAC,CAAC,CAUpE,CAAC"}

package/dist/core/create/just.mjs

@@ -1,14 +1,38 @@
 import { Optional } from 'ts-data-forge';
-import '../utils/id-maker.mjs';
-import { RootObservableClass } from '../class/root-observable-class.mjs';
-
-const just = (value) => {
-  const obs = new RootObservableClass({
-    initialValue: Optional.some(value)
-  });
-  obs.complete();
-  return obs;
-};
+import { createRootObservable } from '../base/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-export { just };
-//# sourceMappingURL=just.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const just = (value) => {
+    const obs = createRootObservable({ initialValue: Optional.some(value) }, () => ({}));
+    obs.complete();
+
+    return obs;
+};
+//# sourceMappingURL=just.mjs.map

package/dist/core/create/just.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"just.mjs","sources":["../../../src/core/create/just.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport { type InitializedRootObservable } from '../types/index.mjs';\n\n/**\n * Creates an Observable that holds a single static value and immediately\n * completes. Useful inside `switchMap` to emit a fallback value when no\n * asynchronous work is needed.\n *\n * @template A - The type of the value\n * @param value - The value to emit\n * @returns An initialized Observable that holds the value and is already completed\n *\n * @example\n * ```ts\n * const greeting$ = just('hello');\n *\n * const valueHistory: string[] = [];\n *\n * greeting$.subscribe(\n *   (value) => {\n *     valueHistory.push(value);\n *   },\n *   () => {\n *     // onComplete — called immediately since just() completes right away\n *   },\n * );\n *\n * assert.deepStrictEqual(valueHistory, ['hello']);\n *\n * assert.strictEqual(greeting$.isCompleted, true);\n * ```\n */\nexport const just = <const A,>(value: A): InitializedRootObservable<A> => {\n  const obs = new RootObservableClass<A>({\n    initialValue: Optional.some(value),\n  });\n\n  obs.complete();\n\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  return obs as InitializedRootObservable<A>;\n};\n"],"names":[],"mappings":";;;;AAiCO,MAAM,IAAA,GAAO,CAAW,KAAA,KAA2C;AACxE,EAAA,MAAM,GAAA,GAAM,IAAI,mBAAA,CAAuB;AAAA,IACrC,YAAA,EAAc,QAAA,CAAS,IAAA,CAAK,KAAK;AAAA,GAClC,CAAA;AAED,EAAA,GAAA,CAAI,QAAA,EAAS;AAGb,EAAA,OAAO,GAAA;AACT;;;;"}
+{"version":3,"file":"just.mjs","sourceRoot":"","sources":["../../../src/core/create/just.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAAW,KAAQ,EAAgC,EAAE;IACvE,MAAM,GAAG,GAAG,oBAAoB,CAC9B,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,EACtC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CACX,CAAC;IAEF,GAAG,CAAC,QAAQ,EAAE,CAAC;IAEf,oEAAoE;IACpE,OAAO,GAAmC,CAAC;AAC7C,CAAC,CAAC"}