synstate 0.1.2 → 1.0.0

package/src/core/predefined/operators/unwrap-result-err.mts

@@ -1,7 +1,47 @@
 import { Result } from 'ts-data-forge';
+import { map } from '../../operators/index.mjs';
 import { type KeepInitialValueOperator } from '../../types/index.mjs';
-import { map } from './map.mjs';
 
+/**
+ * Unwraps the error value from a `Result`, converting `Err(error)` to `error` and `Ok` to `undefined`.
+ *
+ * @template R - The Result type from the source
+ * @returns An operator that unwraps the Err side of Result emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  result$     Ok(1)      Err("fail")   Ok(2)
+ * //  unwrapped$  undefined  "fail"        undefined
+ * //
+ * //  Explanation:
+ * //  - unwrapResultErr converts Err(error) to error, and Ok to undefined
+ * //  - Useful for extracting error values from Result streams
+ *
+ * const result$ = source<Result<number, string>>();
+ *
+ * const unwrapped$ = result$.pipe(unwrapResultErr());
+ *
+ * const valueHistory: (string | undefined)[] = [];
+ *
+ * unwrapped$.subscribe((v) => {
+ *   valueHistory.push(v);
+ * });
+ *
+ * result$.next(Result.ok(1));
+ *
+ * assert.deepStrictEqual(valueHistory, [undefined]);
+ *
+ * result$.next(Result.err('fail'));
+ *
+ * assert.deepStrictEqual(valueHistory, [undefined, 'fail']);
+ *
+ * result$.next(Result.ok(2));
+ *
+ * assert.deepStrictEqual(valueHistory, [undefined, 'fail', undefined]);
+ * ```
+ */
 export const unwrapResultErr = <
   R extends UnknownResult,
 >(): KeepInitialValueOperator<R, Result.UnwrapErr<R> | undefined> =>

package/src/core/predefined/operators/unwrap-result-ok.mts

@@ -1,7 +1,47 @@
 import { Result } from 'ts-data-forge';
+import { map } from '../../operators/index.mjs';
 import { type KeepInitialValueOperator } from '../../types/index.mjs';
-import { map } from './map.mjs';
 
+/**
+ * Unwraps the success value from a `Result`, converting `Ok(value)` to `value` and `Err` to `undefined`.
+ *
+ * @template R - The Result type from the source
+ * @returns An operator that unwraps the Ok side of Result emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  result$     Ok(42)    Err("e")    Ok(7)
+ * //  unwrapped$  42        undefined   7
+ * //
+ * //  Explanation:
+ * //  - unwrapResultOk converts Ok(value) to value, and Err to undefined
+ * //  - Useful for extracting success values from Result streams
+ *
+ * const result$ = source<Result<number, string>>();
+ *
+ * const unwrapped$ = result$.pipe(unwrapResultOk());
+ *
+ * const valueHistory: (number | undefined)[] = [];
+ *
+ * unwrapped$.subscribe((v) => {
+ *   valueHistory.push(v);
+ * });
+ *
+ * result$.next(Result.ok(42));
+ *
+ * assert.deepStrictEqual(valueHistory, [42]);
+ *
+ * result$.next(Result.err('e'));
+ *
+ * assert.deepStrictEqual(valueHistory, [42, undefined]);
+ *
+ * result$.next(Result.ok(7));
+ *
+ * assert.deepStrictEqual(valueHistory, [42, undefined, 7]);
+ * ```
+ */
 export const unwrapResultOk = <
   R extends UnknownResult,
 >(): KeepInitialValueOperator<R, Result.UnwrapOk<R> | undefined> =>

package/src/core/types/id.mts

@@ -2,4 +2,4 @@ export type ObservableId = Brand<symbol, 'observable-id'>;
 
 export type SubscriberId = Brand<symbol, 'subscriber-id'>;
 
-export type UpdaterSymbol = Brand<symbol, 'updater-symbol'>;
+export type UpdateToken = Brand<symbol, 'update-token'>;

package/src/core/types/index.mts

@@ -2,4 +2,5 @@ export * from './id.mjs';
 export * from './observable-family.mjs';
 export * from './observable-kind.mjs';
 export * from './observable.mjs';
+export * from './timer.mjs';
 export * from './types.mjs';

package/src/core/types/observable-family.mts

@@ -23,16 +23,6 @@ export type SourceObservable<A> = Readonly<{
 }> &
   RootObservable<A>;
 
-export type OfObservable<A> = Readonly<{
-  emit: () => OfObservable<A>;
-}> &
-  RootObservable<A>;
-
-export type FromArrayObservable<A> = Readonly<{
-  emit: () => FromArrayObservable<A>;
-}> &
-  RootObservable<A>;
-
 export type FromPromiseObservable<A, E = unknown> = RootObservable<
   Result<A, E>
 >;
@@ -41,13 +31,13 @@ export type FromSubscribableObservable<A, E = unknown> = RootObservable<
   Result<A, E>
 >;
 
-export type IntervalObservable = Readonly<{
-  start: () => IntervalObservable;
+export type CounterObservable = Readonly<{
+  start: () => void;
 }> &
   RootObservable<SafeUint>;
 
 export type TimerObservable = Readonly<{
-  start: () => TimerObservable;
+  start: () => void;
 }> &
   RootObservable<0>;
 
@@ -77,7 +67,7 @@ namespace SynStateInternals {
     ? true
     : false;
 
-  /** Evaluates True | false as true instead of boolean */
+  /** Evaluates true | false as true instead of boolean */
   type LogicalValue<B extends boolean> = readonly [B] extends readonly [true]
     ? true
     : readonly [B] extends readonly [false]
@@ -184,10 +174,7 @@ export type MergeObservableRefined<
   OS extends NonEmptyArray<Observable<unknown>>,
 > = SynStateInternals.MergeObservableRefinedImpl<OS>;
 
-export type MapWithIndexOperatorObservable<A, B> = SyncChildObservable<
-  B,
-  readonly [A]
->;
+export type MapOperatorObservable<A, B> = SyncChildObservable<B, readonly [A]>;
 
 export type PairwiseOperatorObservable<A> = SyncChildObservable<
   readonly [A, A],
@@ -231,19 +218,16 @@ export type SkipIfNoChangeOperatorObservable<A> = SyncChildObservable<
   readonly [A]
 >;
 
-export type ThrottleTimeOperatorObservable<A> = SyncChildObservable<
+export type ThrottleOperatorObservable<A> = SyncChildObservable<
   A,
   readonly [A]
 >;
 
 // AsyncChildObservable
 
-export type AuditTimeOperatorObservable<A> = AsyncChildObservable<
-  A,
-  readonly [A]
->;
+export type AuditOperatorObservable<A> = AsyncChildObservable<A, readonly [A]>;
 
-export type DebounceTimeOperatorObservable<A> = AsyncChildObservable<
+export type DebounceOperatorObservable<A> = AsyncChildObservable<
   A,
   readonly [A]
 >;

package/src/core/types/observable.mts

@@ -1,5 +1,5 @@
 import { expectType, type Optional } from 'ts-data-forge';
-import { type ObservableId, type UpdaterSymbol } from './id.mjs';
+import { type ObservableId, type UpdateToken } from './id.mjs';
 import { type ObservableKind } from './observable-kind.mjs';
 import { type NonEmptyUnknownList, type Subscription } from './types.mjs';
 
@@ -28,12 +28,12 @@ type CreateObservableType<A, Kind extends ObservableKind> = Readonly<{
   // state
   getSnapshot: () => Optional<A>;
   isCompleted: boolean;
-  updaterSymbol: UpdaterSymbol;
+  updateToken: UpdateToken;
   hasSubscriber: boolean;
   hasChild: boolean;
   hasActiveChild: () => boolean;
 
-  tryUpdate: (updaterSymbol: UpdaterSymbol) => void;
+  tryUpdate: (updateToken: UpdateToken) => void;
   tryComplete: () => void;
   complete: () => void;
   subscribe: (onNext: (v: A) => void, onComplete?: () => void) => Subscription;

package/src/core/types/timer.mts

@@ -0,0 +1,2 @@
+// Timer types for Node.js/Browser compatibility
+export type TimerId = ReturnType<typeof setTimeout>;

package/src/core/utils/id-maker.mts

@@ -1,7 +1,7 @@
 import {
   type ObservableId,
   type SubscriberId,
-  type UpdaterSymbol,
+  type UpdateToken,
 } from '../types/index.mjs';
 
 function* idMaker<T extends symbol>(): Generator<T, T, T> {
@@ -19,7 +19,7 @@ const observableIdMaker = idMaker<ObservableId>();
 
 const subscriberIdMaker = idMaker<SubscriberId>();
 
-const updaterSymbolMaker = idMaker<UpdaterSymbol>();
+const updateTokenMaker = idMaker<UpdateToken>();
 
 export const issueObservableId = (): ObservableId =>
   observableIdMaker.next().value;
@@ -27,5 +27,5 @@ export const issueObservableId = (): ObservableId =>
 export const issueSubscriberId = (): SubscriberId =>
   subscriberIdMaker.next().value;
 
-export const issueUpdaterSymbol = (): UpdaterSymbol =>
-  updaterSymbolMaker.next().value;
+export const issueUpdateToken = (): UpdateToken =>
+  updateTokenMaker.next().value;

package/src/globals.d.mts

@@ -1,4 +1 @@
 /// <reference types="ts-type-forge" />
-
-// Timer types for Node.js/Browser compatibility
-type TimerId = ReturnType<typeof setTimeout>;

package/src/utils/collect-to-array.mts

@@ -0,0 +1,17 @@
+import { type Observable } from '../core/index.mjs';
+
+export const collectToArray = <A,>(
+  observable: Observable<A>,
+): Promise<readonly A[]> =>
+  new Promise<readonly A[]>((resolve) => {
+    const mut_buffer: A[] = [];
+
+    observable.subscribe(
+      (value) => {
+        mut_buffer.push(value);
+      },
+      () => {
+        resolve(mut_buffer);
+      },
+    );
+  });

package/src/utils/create-boolean-state.mts

@@ -0,0 +1,68 @@
+import { type InitializedObservable } from '../core/index.mjs';
+import { createState } from './create-state.mjs';
+
+/**
+ * Creates a reactive boolean state with convenient methods for boolean operations.
+ * Extends `createState` with boolean-specific helpers like `toggle`, `setTrue`, and `setFalse`.
+ *
+ * @param initialState - The initial boolean value
+ * @returns A 2-element tuple: `[state, { setTrue, setFalse, toggle, setState, updateState, resetState, getSnapshot, initialState }]`
+ *
+ * @example
+ * ```ts
+ * import type * as React from 'react';
+ * import { createBooleanState } from 'synstate';
+ * import { useObservableValue } from 'synstate-react-hooks';
+ *
+ *     // Menu drawer open/close state.
+ *     // setTrue and setFalse can be passed directly as callbacks
+ *     // — no need to create wrapper functions like `() => setState(true)`.
+ *     const [menuOpen$, { setTrue: openMenu, setFalse: closeMenu }] =
+ *       createBooleanState(false);
+ *
+ *     const SampleComponent = (): React.JSX.Element => (
+ *       <MenuDrawer
+ *         open={useObservableValue(menuOpen$)}
+ *         onClose={closeMenu}
+ *         onOpen={openMenu}
+ *       />
+ *     );
+ * ```
+ */
+
+export const createBooleanState = (
+  initialState: boolean,
+): readonly [
+  state: InitializedObservable<boolean>,
+  Readonly<{
+    setTrue: () => void;
+    setFalse: () => void;
+    setState: (next: boolean) => boolean;
+    toggle: () => boolean;
+    updateState: (updateFn: (prev: boolean) => boolean) => boolean;
+    resetState: () => boolean;
+    getSnapshot: () => boolean;
+    initialState: boolean;
+  }>,
+] => {
+  const [state, setState, { updateState, resetState, getSnapshot }] =
+    createState(initialState);
+
+  return [
+    state,
+    {
+      setTrue: () => {
+        setState(true);
+      },
+      setFalse: () => {
+        setState(false);
+      },
+      toggle: () => updateState((s) => !s),
+      setState,
+      updateState,
+      resetState,
+      getSnapshot,
+      initialState,
+    },
+  ] as const;
+};

package/src/utils/create-event-emitter.mts

@@ -51,19 +51,19 @@ export const createEventEmitter = (): readonly [
  * ```ts
  * const [message$, emitMessage] = createValueEmitter<string>();
  *
- * const mut_history: string[] = [];
+ * const messageHistory: string[] = [];
  *
  * message$.subscribe((msg) => {
- *   mut_history.push(msg);
+ *   messageHistory.push(msg);
  * });
  *
  * emitMessage('Hello'); // logs: Hello
  *
- * assert.deepStrictEqual(mut_history, ['Hello']);
+ * assert.deepStrictEqual(messageHistory, ['Hello']);
  *
  * emitMessage('World');
  *
- * assert.deepStrictEqual(mut_history, ['Hello', 'World']);
+ * assert.deepStrictEqual(messageHistory, ['Hello', 'World']);
  * ```
  */
 export const createValueEmitter = <A,>(): readonly [

package/src/utils/create-reducer.mts

@@ -8,7 +8,7 @@ import { source, type InitializedObservable } from '../core/index.mjs';
  * @template A - The type of actions
  * @param reducer - A pure function that takes current state and action, returns new state
  * @param initialState - The initial value of the state
- * @returns An object containing the state observable, dispatch function, and snapshot getter
+ * @returns A 3-element tuple: `[state, dispatch, { getSnapshot, initialState }]`
  *
  * @example
  * ```ts
@@ -24,23 +24,23 @@ import { source, type InitializedObservable } from '../core/index.mjs';
  *   0,
  * );
  *
- * const mut_history: number[] = [];
+ * const stateHistory: number[] = [];
  *
  * state.subscribe((value: number) => {
- *   mut_history.push(value);
+ *   stateHistory.push(value);
  * });
  *
- * assert.deepStrictEqual(mut_history, [0]);
+ * assert.deepStrictEqual(stateHistory, [0]);
  *
  * dispatch({ type: 'increment' }); // logs: 1
  *
- * assert.deepStrictEqual(mut_history, [0, 1]);
+ * assert.deepStrictEqual(stateHistory, [0, 1]);
  *
  * dispatch({ type: 'increment' });
  *
  * dispatch({ type: 'decrement' });
  *
- * assert.deepStrictEqual(mut_history, [0, 1, 2, 1]);
+ * assert.deepStrictEqual(stateHistory, [0, 1, 2, 1]);
  * ```
  */
 export const createReducer = <S, A>(
@@ -49,7 +49,10 @@ export const createReducer = <S, A>(
 ): readonly [
   state: InitializedObservable<S>,
   dispatch: (action: A) => S,
-  getSnapshot: () => S,
+  Readonly<{
+    getSnapshot: () => S;
+    initialState: S;
+  }>,
 ] => {
   const state = source<S>(initialState);
 
@@ -63,5 +66,5 @@ export const createReducer = <S, A>(
 
   const getSnapshot = (): S => state.getSnapshot().value;
 
-  return [state, dispatch, getSnapshot] as const;
+  return [state, dispatch, { getSnapshot, initialState }] as const;
 };

package/src/utils/create-state.mts

@@ -28,31 +28,31 @@ const reducer = <S,>(state: S, action: Action<S>): S => {
  *
  * @template S - The type of the state
  * @param initialState - The initial value of the state
- * @returns An object containing the state observable and methods to manipulate it
+ * @returns A 3-element tuple: `[state, setState, { updateState, resetState, getSnapshot, initialState }]`
  *
  * @example
  * ```ts
  * const [state, setState, { updateState, resetState }] = createState(0);
  *
- * const mut_history: number[] = [];
+ * const stateHistory: number[] = [];
  *
  * state.subscribe((value: number) => {
- *   mut_history.push(value);
+ *   stateHistory.push(value);
  * });
  *
- * assert.deepStrictEqual(mut_history, [0]);
+ * assert.deepStrictEqual(stateHistory, [0]);
  *
  * setState(10); // logs: 10
  *
- * assert.deepStrictEqual(mut_history, [0, 10]);
+ * assert.deepStrictEqual(stateHistory, [0, 10]);
  *
  * updateState((prev: number) => prev + 1); // logs: 11
  *
- * assert.deepStrictEqual(mut_history, [0, 10, 11]);
+ * assert.deepStrictEqual(stateHistory, [0, 10, 11]);
  *
  * resetState(); // logs: 0
  *
- * assert.deepStrictEqual(mut_history, [0, 10, 11, 0]);
+ * assert.deepStrictEqual(stateHistory, [0, 10, 11, 0]);
  * ```
  */
 export const createState = <S,>(
@@ -64,9 +64,10 @@ export const createState = <S,>(
     updateState: (updateFn: (prev: S) => S) => S;
     resetState: () => S;
     getSnapshot: () => S;
+    initialState: S;
   }>,
 ] => {
-  const [state, dispatch, getSnapshot] = createReducer<S, Action<S>>(
+  const [state, dispatch, { getSnapshot }] = createReducer<S, Action<S>>(
     reducer,
     initialState,
   );
@@ -86,73 +87,7 @@ export const createState = <S,>(
       updateState,
       resetState,
       getSnapshot,
-    },
-  ] as const;
-};
-
-/**
- * Creates a reactive boolean state with convenient methods for boolean operations.
- * Extends `createState` with boolean-specific helpers like `toggle`, `setTrue`, and `setFalse`.
- *
- * @param initialState - The initial boolean value
- * @returns An object with the state observable and boolean-specific methods
- *
- * @example
- * ```ts
- * const [state, { setTrue, toggle }] = createBooleanState(false);
- *
- * const mut_history: boolean[] = [];
- *
- * state.subscribe((value: boolean) => {
- *   mut_history.push(value);
- * });
- *
- * assert.deepStrictEqual(mut_history, [false]);
- *
- * setTrue(); // logs: true
- *
- * assert.deepStrictEqual(mut_history, [false, true]);
- *
- * toggle(); // logs: false
- *
- * assert.deepStrictEqual(mut_history, [false, true, false]);
- *
- * toggle(); // logs: true
- *
- * assert.deepStrictEqual(mut_history, [false, true, false, true]);
- * ```
- */
-export const createBooleanState = (
-  initialState: boolean,
-): readonly [
-  state: InitializedObservable<boolean>,
-  Readonly<{
-    setTrue: () => void;
-    setFalse: () => void;
-    setState: (next: boolean) => boolean;
-    toggle: () => boolean;
-    updateState: (updateFn: (prev: boolean) => boolean) => boolean;
-    resetState: () => boolean;
-    getSnapshot: () => boolean;
-  }>,
-] => {
-  const [state, setState, { updateState, resetState, getSnapshot }] =
-    createState(initialState);
-
-  return [
-    state,
-    {
-      setTrue: () => {
-        setState(true);
-      },
-      setFalse: () => {
-        setState(false);
-      },
-      toggle: () => updateState((s) => !s),
-      setState,
-      updateState,
-      resetState,
-      getSnapshot,
+      initialState,
     },
   ] as const;
 };

package/src/utils/index.mts

@@ -1,3 +1,5 @@
+export * from './collect-to-array.mjs';
+export * from './create-boolean-state.mjs';
 export * from './create-event-emitter.mjs';
 export * from './create-reducer.mjs';
 export * from './create-state.mjs';

package/dist/core/create/from-array.d.mts

@@ -1,39 +0,0 @@
-import { type FromArrayObservable } from '../types/index.mjs';
-/**
- * Creates an observable that emits all values from an array sequentially, then completes.
- *
- * @template A - The type of array elements
- * @param values - The array of values to emit
- * @param startManually - If true, waits for manual start (default: false)
- * @returns An observable that emits array values
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  nums$     1     2     3     | (completes)
- * //
- * //  Explanation:
- * //  - fromArray creates an observable from an array
- * //  - Emits all values synchronously, then completes
- *
- * const nums$ = fromArray([1, 2, 3]);
- *
- * const mut_history: number[] = [];
- *
- * await new Promise<void>((resolve) => {
- *   nums$.subscribe(
- *     (x) => {
- *       mut_history.push(x);
- *     },
- *     () => {
- *       resolve();
- *     },
- *   );
- * });
- *
- * assert.deepStrictEqual(mut_history, [1, 2, 3]);
- * ```
- */
-export declare const fromArray: <A>(values: readonly A[], startManually?: boolean) => FromArrayObservable<A>;
-//# sourceMappingURL=from-array.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"from-array.d.mts","sourceRoot":"","sources":["../../../src/core/create/from-array.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EACzB,QAAQ,SAAS,CAAC,EAAE,EACpB,gBAAe,OAAe,KAC7B,mBAAmB,CAAC,CAAC,CACgC,CAAC"}

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

@@ -1,65 +0,0 @@
-import { Optional } from 'ts-data-forge';
-import '../utils/id-maker.mjs';
-import { RootObservableClass } from '../class/root-observable-class.mjs';
-
-/**
- * Creates an observable that emits all values from an array sequentially, then completes.
- *
- * @template A - The type of array elements
- * @param values - The array of values to emit
- * @param startManually - If true, waits for manual start (default: false)
- * @returns An observable that emits array values
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  nums$     1     2     3     | (completes)
- * //
- * //  Explanation:
- * //  - fromArray creates an observable from an array
- * //  - Emits all values synchronously, then completes
- *
- * const nums$ = fromArray([1, 2, 3]);
- *
- * const mut_history: number[] = [];
- *
- * await new Promise<void>((resolve) => {
- *   nums$.subscribe(
- *     (x) => {
- *       mut_history.push(x);
- *     },
- *     () => {
- *       resolve();
- *     },
- *   );
- * });
- *
- * assert.deepStrictEqual(mut_history, [1, 2, 3]);
- * ```
- */
-const fromArray = (values, startManually = false) => new FromArrayObservableClass(values, startManually);
-class FromArrayObservableClass extends RootObservableClass {
-    #values;
-    constructor(values, startManually = false) {
-        super({ initialValue: Optional.none });
-        this.#values = values;
-        if (!startManually) {
-            setTimeout(() => {
-                this.emit();
-            }, 0);
-        }
-    }
-    emit() {
-        if (this.isCompleted)
-            return this;
-        for (const v of this.#values) {
-            this.startUpdate(v);
-        }
-        this.complete();
-        return this;
-    }
-}
-
-export { fromArray };
-//# sourceMappingURL=from-array.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"from-array.mjs","sources":["../../../src/core/create/from-array.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCG;AACI,MAAM,SAAS,GAAG,CACvB,MAAoB,EACpB,aAAA,GAAyB,KAAK,KAE9B,IAAI,wBAAwB,CAAI,MAAM,EAAE,aAAa;AAEvD,MAAM,wBACJ,SAAQ,mBAAsB,CAAA;AAGrB,IAAA,OAAO;IAEhB,WAAA,CAAY,MAAoB,EAAE,aAAA,GAAyB,KAAK,EAAA;QAC9D,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,IAAI,CAAC,OAAO,GAAG,MAAM;QAErB,IAAI,CAAC,aAAa,EAAE;YAClB,UAAU,CAAC,MAAK;gBACd,IAAI,CAAC,IAAI,EAAE;YACb,CAAC,EAAE,CAAC,CAAC;QACP;IACF;IAEA,IAAI,GAAA;QACF,IAAI,IAAI,CAAC,WAAW;AAAE,YAAA,OAAO,IAAI;AAEjC,QAAA,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE;AAC5B,YAAA,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QACrB;QAEA,IAAI,CAAC,QAAQ,EAAE;AAEf,QAAA,OAAO,IAAI;IACb;AACD;;;;"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"interval.d.mts","sourceRoot":"","sources":["../../../src/core/create/interval.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,QAAQ,GACnB,cAAc,MAAM,EACpB,gBAAgB,OAAO,KACtB,kBACuD,CAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"interval.mjs","sources":["../../../src/core/create/interval.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CG;AACI,MAAM,QAAQ,GAAG,CACtB,YAAoB,EACpB,aAAuB,KAEvB,IAAI,uBAAuB,CAAC,YAAY,EAAE,aAAa;AAEzD,MAAM,uBACJ,SAAQ,mBAA6B,CAAA;AAG5B,IAAA,aAAa;AACtB,IAAA,YAAY;AACZ,IAAA,aAAa;AACb,IAAA,YAAY;AACZ,IAAA,cAAc;IAEd,WAAA,CAAY,YAAoB,EAAE,aAAuB,EAAA;QACvD,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,IAAI,CAAC,aAAa,GAAG,YAAY;AAEjC,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,CAAC,CAAC;AAEjC,QAAA,IAAI,CAAC,aAAa,GAAG,SAAS;AAE9B,QAAA,IAAI,CAAC,YAAY,GAAG,SAAS;AAE7B,QAAA,IAAI,CAAC,cAAc,GAAG,KAAK;AAE3B,QAAA,IAAI,aAAa,KAAK,IAAI,EAAE;YAC1B,IAAI,CAAC,KAAK,EAAE;QACd;IACF;IAEA,KAAK,GAAA;AACH,QAAA,IAAI,IAAI,CAAC,cAAc,EAAE;AACvB,YAAA,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC;AAElC,YAAA,OAAO,IAAI;QACb;AAEA,QAAA,IAAI,CAAC,cAAc,GAAG,IAAI;AAE1B,QAAA,IAAI,IAAI,CAAC,WAAW,EAAE;AACpB,YAAA,OAAO,CAAC,IAAI,CAAC,2CAA2C,CAAC;AAEzD,YAAA,OAAO,IAAI;QACb;;AAGA,QAAA,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,MAAK;AACnC,YAAA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC;QACrC,CAAC,EAAE,CAAC,CAAC;AAEL,QAAA,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC,MAAK;AACnC,YAAA,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,YAAY,CAAC;AAEtD,YAAA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC;AACrC,QAAA,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC;AAEtB,QAAA,OAAO,IAAI;IACb;IAEA,WAAW,GAAA;AACT,QAAA,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;AACvE,YAAA,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC;AAEjC,YAAA,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC;QAClC;IACF;IAES,QAAQ,GAAA;QACf,IAAI,CAAC,WAAW,EAAE;QAElB,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}