@dereekb/rxjs 13.0.7 → 13.2.0

package/index.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@dereekb/rxjs",
-  "version": "13.0.7",
+  "version": "13.2.0",
   "peerDependencies": {
     "rxjs": "^7.8.0",
-    "@dereekb/util": "13.0.7"
+    "@dereekb/util": "13.2.0"
   },
   "exports": {
     "./package.json": "./package.json",

package/src/lib/filter/filter.d.ts

@@ -1,55 +1,70 @@
 import { type Observable } from 'rxjs';
 /**
- * Source that provides a filter observable.
+ * Abstract base class for providing reactive filter state.
+ *
+ * Implementations expose a `filter$` observable that emits the current filter value,
+ * and optionally support initialization from an external observable.
  */
 export declare abstract class FilterSource<F = unknown> {
     /**
-     * Provided filter.
+     * Observable of the current filter value.
      */
     abstract readonly filter$: Observable<F>;
     /**
-     * (Optional) Function that allows initializing a filter source from an observable.
+     * Optionally initializes this filter source from an external observable.
      *
-     * This lets the filter set its initial value, etc.
+     * Allows setting the initial/default filter value from an upstream source,
+     * which is useful when composing filters hierarchically.
      */
     abstract initWithFilter?(filterObs: Observable<F>): void;
 }
 /**
- * Preset identifier.
+ * String identifier used to reference a named filter preset configuration.
  */
 export type FilterPresetString = string;
 /**
- * An object that contains a FilterPresetString.
+ * Object that contains a {@link FilterPresetString} reference.
  *
- * When a preset value is present, it may either be used as the sole filter variable, or act as a base that is overwritten by other values.
+ * When a preset value is present, it may either be used as the sole filter configuration
+ * or act as a base that is overridden by other filter values.
  */
 export interface FilterPresetStringRef<P extends string = string> {
     /**
-     * Preset key.
+     * Preset key identifying a named filter configuration.
      */
     preset: P;
 }
+/**
+ * Filter type that optionally includes a preset reference.
+ */
 export type FilterWithPreset<P extends string = string> = Partial<FilterPresetStringRef<P>>;
+/**
+ * Makes the preset field optional on a filter that normally includes one.
+ */
 export type FilterWithPresetOptional<F extends FilterWithPreset<P>, P extends string = string> = Partial<Pick<F, 'preset'>> & Omit<F, 'preset'>;
 /**
- * A FilterPreset with only the preset.
+ * Extracts only the preset field from a filter type, discarding all other filter properties.
  */
 export type FilterOnlyWithPresetString<F extends FilterWithPreset<P>, P extends string = string> = Pick<F, 'preset'>;
 /**
- * A FilterPreset without a preset value available.
+ * Filter type with the preset field removed, retaining only the concrete filter properties.
  */
 export type FilterWithoutPresetString<F extends FilterWithPreset<P>, P extends string = string> = Omit<F, 'preset'>;
 /**
- * A FilterSource that has a filter with a FilterPreset potentially available.
+ * A {@link FilterSource} whose filter type includes an optional preset reference.
+ *
+ * Useful for filter UIs that support both preset configurations and custom filter values.
  */
 export declare abstract class PresetFilterSource<F extends FilterWithPreset<P>, P extends string = string> extends FilterSource<F> {
 }
 /**
- * A FilterSourceConnector connects with a Source for a function.
+ * Abstract connector that wires a {@link FilterSource} into a consuming component.
+ *
+ * Implementations define how to subscribe to a filter source and apply its values.
  */
 export declare abstract class FilterSourceConnector<F = unknown> {
     /**
-     * Coonnects with the input source.
+     * Connects with the input filter source to begin receiving filter updates.
      */
     abstract connectWithSource(filterSource: FilterSource<F>): void;
 }

package/src/lib/filter/filter.map.d.ts

@@ -3,29 +3,96 @@ import { type Observable } from 'rxjs';
 import { type FilterSource, type FilterSourceConnector } from './filter';
 import { type Destroyable, type Maybe } from '@dereekb/util';
 /**
- * Used to identify a specific filter.
+ * String key used to identify a specific filter entry within a {@link FilterMap}.
  */
 export type FilterMapKey = string;
 /**
- * Class used to keep track of filters keyed by a specific string identifier.
+ * Manages a collection of reactive filters keyed by string identifiers.
+ *
+ * Multiple filter observables can be registered under the same key and their emissions are merged.
+ * Supports default filters that are used when no explicit filter is set.
+ *
+ * @example
+ * ```ts
+ * const filterMap = new FilterMap<{ active: boolean }>();
+ *
+ * // Register a filter observable under a key
+ * filterMap.addFilterObs('users', of({ active: true }));
+ *
+ * // Subscribe to the filter for that key
+ * filterMap.filterForKey('users').subscribe(f => console.log(f));
+ * // Output: { active: true }
+ * ```
  */
 export declare class FilterMap<F> implements Destroyable {
     private readonly _map;
+    /**
+     * Returns an observable of the filter value for the given key.
+     *
+     * Waits until a filter entry exists for the key, then switches to its filter stream.
+     *
+     * @param key - filter map key to observe
+     * @returns observable that emits the current filter value for the key
+     */
     filterForKey(key: FilterMapKey): Observable<F>;
+    /**
+     * Sets a default filter observable for the given key, used as a fallback when no explicit filter is set.
+     *
+     * @param key - filter map key
+     * @param obs - default filter observable or value
+     */
     addDefaultFilterObs(key: FilterMapKey, obs: Maybe<ObservableOrValue<F>>): void;
+    /**
+     * Adds a filter observable for the given key. Multiple observables can be added per key
+     * and their emissions are merged together.
+     *
+     * @param key - filter map key
+     * @param obs - filter observable to add
+     */
     addFilterObs(key: FilterMapKey, obs: Observable<F>): void;
+    /**
+     * Creates a {@link FilterMapKeyInstance} bound to the given key, providing both
+     * {@link FilterSource} and {@link FilterSourceConnector} interfaces for that key.
+     *
+     * @param key - filter map key to bind
+     * @returns instance for interacting with the filter at the given key
+     */
     makeInstance(key: FilterMapKey): FilterMapKeyInstance<F>;
+    /**
+     * Creates an observable that emits a new {@link FilterMapKeyInstance} each time the key changes.
+     *
+     * @param keyObs - observable of filter map keys
+     * @returns observable that emits instances for the current key
+     */
     instanceObsForKeyObs(keyObs: Observable<FilterMapKey>): Observable<FilterMapKeyInstance<F>>;
     private _itemForKey;
+    /**
+     * Destroys all filter items and completes the internal subject.
+     */
     destroy(): void;
 }
+/**
+ * Bound instance of a {@link FilterMap} for a specific key.
+ *
+ * Implements both {@link FilterSource} (provides filter values) and {@link FilterSourceConnector}
+ * (accepts filter sources) for a single filter map entry.
+ */
 export declare class FilterMapKeyInstance<F> implements FilterSourceConnector<F>, FilterSource<F> {
     private readonly _dbxFilterMap;
     private readonly _key;
+    /**
+     * Observable of the filter value for this instance's key.
+     */
     readonly filter$: Observable<F>;
     constructor(dbxFilterMap: FilterMap<F>, key: FilterMapKey);
     get dbxFilterMap(): FilterMap<F>;
     get key(): FilterMapKey;
+    /**
+     * Sets the default filter observable for this key.
+     */
     initWithFilter(filterObs: Observable<F>): void;
+    /**
+     * Connects a filter source, adding its filter observable to this key's merged filters.
+     */
     connectWithSource(filterSource: FilterSource<F>): void;
 }

package/src/lib/filter/filter.preset.d.ts

@@ -1,5 +1,40 @@
 import { type FilterWithoutPresetString, type FilterWithPreset } from './filter';
 import { type OperatorFunction } from 'rxjs';
+/**
+ * Function that maps a filter with a preset reference into a concrete filter configuration
+ * with the preset field removed.
+ */
 export type MapFilterWithPresetFn<F extends FilterWithPreset> = (filter: F) => FilterWithoutPresetString<F>;
+/**
+ * Creates a mapping function that resolves preset references in filters.
+ *
+ * When a filter has a `preset` value, the provided function is called to expand the preset
+ * into concrete filter values, then the `preset` field is removed from the result.
+ * Filters without a preset are passed through unchanged.
+ *
+ * @param fn - function that expands a preset into concrete filter values
+ * @returns mapping function that resolves presets and strips the preset field
+ *
+ * @example
+ * ```ts
+ * interface MyFilter extends FilterWithPreset {
+ *   active?: boolean;
+ * }
+ *
+ * const resolve = makeMapFilterWithPresetFn<MyFilter>((f) => {
+ *   if (f.preset === 'active') return { active: true };
+ *   return { active: false };
+ * });
+ *
+ * const result = resolve({ preset: 'active' });
+ * // result === { active: true }
+ * ```
+ */
 export declare function makeMapFilterWithPresetFn<F extends FilterWithPreset>(fn: MapFilterWithPresetFn<F>): MapFilterWithPresetFn<F>;
+/**
+ * RxJS operator that resolves preset references in a filter stream using the provided mapping function.
+ *
+ * @param fn - function that expands a preset into concrete filter values
+ * @returns operator that maps filter emissions, resolving any preset references
+ */
 export declare function mapFilterWithPreset<F extends FilterWithPreset>(fn: MapFilterWithPresetFn<F>): OperatorFunction<F, FilterWithoutPresetString<F>>;

package/src/lib/filter/filter.source.d.ts

@@ -2,13 +2,39 @@ import { type Observable } from 'rxjs';
 import { type FilterSource } from './filter';
 import { type MaybeObservableOrValue } from '../rxjs/getter';
 import { type Destroyable, type Maybe } from '@dereekb/util';
+/**
+ * Configuration for initializing a {@link FilterSourceInstance}.
+ */
 export interface FilterSourceInstanceConfig<F> {
+    /** Observable used to initialize the filter value, taking priority over the default. */
     readonly initWithFilter?: Maybe<Observable<F>>;
+    /** Default filter value or observable, used as a fallback when no explicit filter is set. */
     readonly defaultFilter?: MaybeObservableOrValue<F>;
+    /** Explicit filter value to set immediately. */
     readonly filter?: Maybe<F>;
 }
 /**
- * A basic FilterSource implementation.
+ * Concrete implementation of {@link FilterSource} that manages reactive filter state with
+ * support for default values, initial values, and explicit overrides.
+ *
+ * Filter priority (highest to lowest):
+ * 1. Explicit filter set via {@link setFilter}
+ * 2. Initial filter set via {@link initWithFilter}
+ * 3. Default filter set via {@link setDefaultFilter}
+ *
+ * @example
+ * ```ts
+ * const source = new FilterSourceInstance<{ active: boolean }>();
+ *
+ * // Set a default filter
+ * source.setDefaultFilter(of({ active: false }));
+ *
+ * // Override with an explicit filter
+ * source.setFilter({ active: true });
+ *
+ * // Reset back to default
+ * source.resetFilter();
+ * ```
  */
 export declare class FilterSourceInstance<F> implements FilterSource<F>, Destroyable {
     private readonly _initialFilterSub;
@@ -19,21 +45,54 @@ export declare class FilterSourceInstance<F> implements FilterSource<F>, Destroy
      */
     private readonly _initialFilter;
     private readonly _defaultFilter;
+    /**
+     * Observable of the default filter value, emitting when a default is set.
+     */
     readonly defaultFilter$: Observable<Maybe<F>>;
+    /**
+     * Observable that emits the initial filter value, preferring the init filter over the default.
+     */
     readonly initialFilter$: Observable<Maybe<F>>;
     /**
-     * filter$ uses the latest value from any filter.
+     * Observable of the active filter value, resolving to the explicit filter if set,
+     * otherwise falling back to the initial/default filter. Deduplicated by deep value equality.
      */
     readonly filter$: Observable<F>;
     constructor(config?: FilterSourceInstanceConfig<F>);
+    /**
+     * Sets an initial filter observable that takes priority over the default filter.
+     *
+     * @param filterObs - observable providing the initial filter value
+     */
     initWithFilter(filterObs: Observable<F>): void;
+    /**
+     * Sets the default filter, used as a fallback when no explicit or initial filter is active.
+     *
+     * @param filter - default filter value, observable, or undefined to clear
+     */
     setDefaultFilter(filter: MaybeObservableOrValue<F>): void;
+    /**
+     * Sets an explicit filter value that takes priority over the initial and default filters.
+     *
+     * @param filter - the filter value to set
+     */
     setFilter(filter: F): void;
     /**
      * Resets the current filter to be the default filter.
      */
     resetFilter(): void;
+    /**
+     * Controls whether changes to the initial filter automatically reset the explicit filter.
+     *
+     * When enabled, any new emission from the initial filter observable clears the explicit
+     * filter, causing `filter$` to fall back to the initial filter value.
+     *
+     * @param initialFilterTakesPriority - whether initial filter changes should reset the explicit filter
+     */
     setInitialFilterTakesPriority(initialFilterTakesPriority: boolean): void;
     protected initFilterTakesPriority(): void;
+    /**
+     * Completes all internal subjects and cleans up subscriptions.
+     */
     destroy(): void;
 }

package/src/lib/iterator/iteration.accumulator.d.ts

@@ -2,9 +2,13 @@ import { type Observable } from 'rxjs';
 import { type MapFunctionOutputPair, type Destroyable, type IndexRef, type GetterOrValue, type MapFunction, type PromiseOrValue, type Page } from '@dereekb/util';
 import { type ItemIteration, type PageItemIteration } from './iteration';
 import { type LoadingState, type MapLoadingStateValueMapFunction } from '../loading';
+/**
+ * Function that maps loaded values from their raw iteration type to the accumulator's output type.
+ */
 export type ItemAccumulatorMapFunction<O, I> = MapLoadingStateValueMapFunction<O, I>;
 /**
- * An object that accumulates and exposes values from an ItemIteration.
+ * Accumulates values from an {@link ItemIteration} into a growing collection,
+ * optionally mapping each value through a transform function.
  */
 export interface ItemAccumulator<O, I = unknown, N extends ItemIteration<I> = ItemIteration<I>> {
     /**
@@ -53,40 +57,62 @@ export type MonotypePageItemAccumulator<I, N extends PageItemIteration<I> = Page
  */
 export interface ItemAccumulatorValuePair<O, I = unknown> extends MapFunctionOutputPair<O, LoadingState<I>>, IndexRef {
 }
+/**
+ * Concrete accumulator instance with additional observables for tracking load progress
+ * and successful states.
+ */
 export interface ItemAccumulatorInstance<O, I = unknown, N extends ItemIteration<I> = ItemIteration<I>> extends ItemAccumulator<O, I, N>, Destroyable {
+    /** Emits `true` once the first load has completed. */
     readonly hasCompletedInitialLoad$: Observable<boolean>;
+    /** The most recent loading state that completed without an error. */
     readonly latestSuccessfulState$: Observable<LoadingState<I>>;
-    /**
-     * All successful page results in a single array.
-     */
+    /** All successful loading states accumulated in order. */
     readonly allSuccessfulStates$: Observable<LoadingState<I>[]>;
+    /** Count of successfully loaded pages so far. */
     readonly successfulLoadCount$: Observable<number>;
 }
 /**
- * Creates a new ItemAccumulatorInstance give the input ItemIteration and optional map function.
+ * Creates a new {@link ItemAccumulatorInstance} that collects values from an {@link ItemIteration},
+ * optionally transforming each value through a mapping function.
+ *
+ * The accumulator subscribes to the iteration's states and builds up an array of all
+ * successfully loaded items over time. Error states are excluded from accumulation.
  *
- * @param itemIteration
- * @param mapItem
- * @returns
+ * @param itemIteration - the iteration to accumulate values from
+ * @param inputMapItem - optional function to transform raw values into the desired output type
+ * @returns accumulator instance with observables for all collected items
  */
 export declare function itemAccumulator<I, N extends ItemIteration<I> = ItemIteration<I>>(itemIteration: N): ItemAccumulatorInstance<I, I, N>;
 export declare function itemAccumulator<O, I, N extends ItemIteration<I> = ItemIteration<I>>(itemIteration: N, mapItem?: ItemAccumulatorMapFunction<O, I>): ItemAccumulatorInstance<O, I, N>;
+/**
+ * Function that counts the number of meaningful results in the accumulated items array.
+ */
 export type ItemAccumulatorNextPageUntilResultsCountFunction<O> = MapFunction<O[], PromiseOrValue<number>>;
+/**
+ * Configuration for {@link itemAccumulatorNextPageUntilResultsCount}.
+ */
 export interface ItemAccumulatorNextPageUntilResultsCountConfig<O> {
+    /** The accumulator whose iteration will be advanced. */
     readonly accumulator: ItemAccumulator<O, any, PageItemIteration<any>>;
+    /** Target number of results to accumulate before stopping. */
     readonly maxResultsLimit: GetterOrValue<number>;
+    /** Function to count how many meaningful results exist in the accumulated items. */
     readonly countResultsFunction: ItemAccumulatorNextPageUntilResultsCountFunction<O>;
 }
+/**
+ * Result of {@link itemAccumulatorNextPageUntilResultsCount} containing the final page
+ * and total results count.
+ */
 export interface ItemAccumulatorNextPageUntilResultsCountResult extends Page {
     readonly resultsCount: number;
 }
 /**
- * Automatically calls next on the accumulator's page item iteration up to the target number of results. Returns the total number of items loaded.
+ * Automatically pages through an accumulator's iteration until the desired number of results
+ * is reached or no more pages are available.
  *
- * The promise will reject with an error if an error is encountered.
+ * @param config - configuration specifying the accumulator, result limit, and counting function
+ * @returns promise resolving to the final page number and total results count
  *
- * @param iteration
- * @param maxResultsLimit
- * @returns
+ * @throws Rejects if the iteration encounters an error during loading
  */
 export declare function itemAccumulatorNextPageUntilResultsCount<O>(config: ItemAccumulatorNextPageUntilResultsCountConfig<O>): Promise<ItemAccumulatorNextPageUntilResultsCountResult>;

package/src/lib/iterator/iteration.accumulator.rxjs.d.ts

@@ -2,24 +2,41 @@ import { type Observable } from 'rxjs';
 import { type PageListLoadingState } from '../loading';
 import { type ItemAccumulator, type PageItemAccumulator } from './iteration.accumulator';
 /**
- * Used for ItemAccumulators that have an array of results returned per page instead of a single item.
+ * Flattens paginated array results from an {@link ItemAccumulator} into a single growing array.
  *
- * @param accumulator
- * @returns
+ * Designed for accumulators where each page returns an array of items. Concatenates all
+ * page results into one flat array that grows as new pages are loaded.
+ *
+ * @param accumulator - accumulator whose page results are arrays to flatten
+ * @returns observable emitting the flattened array of all accumulated items
  */
 export declare function flattenAccumulatorResultItemArray<T, I = unknown>(accumulator: ItemAccumulator<T[], I>): Observable<T[]>;
 /**
- * A PageListLoadingState that captures all the values that have been loaded so far, flattens them as an array, and the current loading state of currentPageResult$.
+ * Combines a page accumulator's flattened array results with its current loading state
+ * into a single {@link PageListLoadingState} observable.
+ *
+ * The loading state reflects whether a page is currently being fetched, while the value
+ * always contains the full flattened array of all items loaded so far.
+ *
+ * @param accumulator - page accumulator whose results are arrays to flatten
+ * @returns observable of the combined loading state with all accumulated items
  */
 export declare function accumulatorFlattenPageListLoadingState<T, I = unknown>(accumulator: PageItemAccumulator<T[], I>): Observable<PageListLoadingState<T>>;
 /**
- * A PageListLoadingState that captures all the values that have been loaded so far, and the current loading state of currentPageResult$.
+ * Combines a page accumulator's collected items with its current loading state
+ * into a single {@link PageListLoadingState} observable.
+ *
+ * Unlike {@link accumulatorFlattenPageListLoadingState}, this does not flatten arrays —
+ * each accumulated value is included as-is.
+ *
+ * @param accumulator - page accumulator to observe
+ * @returns observable of the combined loading state with all accumulated items
  */
 export declare function accumulatorCurrentPageListLoadingState<V, I = unknown>(accumulator: PageItemAccumulator<V, I>): Observable<PageListLoadingState<V>>;
 /**
- * Returns the latest loaded page number from the input PageItemAccumulator.
+ * Returns the latest loaded page number from the input accumulator's underlying iteration.
  *
- * @param pageItemAccumulator
- * @returns
+ * @param pageItemAccumulator - accumulator to observe the current page from
+ * @returns observable emitting the most recently loaded page number
  */
 export declare function pageItemAccumulatorCurrentPage(pageItemAccumulator: PageItemAccumulator<any, any>): Observable<number>;

package/src/lib/iterator/iteration.d.ts

@@ -1,18 +1,26 @@
 import { type Observable } from 'rxjs';
 import { type Destroyable, type Maybe, type PageNumber } from '@dereekb/util';
 import { type LoadingState, type PageLoadingState } from '../loading';
+/**
+ * Request parameters for triggering the next load in an {@link ItemIteration}.
+ */
 export interface ItemIteratorNextRequest {
     /**
-     * The expected page to request.
-     *
-     * If provided, the page must equal the target page, otherwise the next is ignored.
+     * Target page number to load. If provided and the iterator is not on this page,
+     * the request is ignored to prevent out-of-order loading.
      */
     page?: number;
     /**
-     * Whether or not to retry loading the page.
+     * Whether to retry loading the current page after an error.
      */
     retry?: boolean;
 }
+/**
+ * Reactive iterator that loads items incrementally and exposes loading state as observables.
+ *
+ * Consumers call {@link next} to trigger loading of the next batch and observe results
+ * through the various state observables.
+ */
 export interface ItemIteration<V = unknown, L extends LoadingState<V> = LoadingState<V>> extends Destroyable {
     /**
      * Whether or not there are more items to be loaded.
@@ -48,7 +56,10 @@ export interface ItemIteration<V = unknown, L extends LoadingState<V> = LoadingS
     next(request?: ItemIteratorNextRequest): void;
 }
 /**
- * An ItemIteration that has pages.
+ * Extension of {@link ItemIteration} that supports paginated loading with page numbers.
+ *
+ * Adds page-specific operations like {@link nextPage} (promise-based) and page load limits
+ * to prevent unbounded iteration.
  */
 export interface PageItemIteration<V = unknown, L extends PageLoadingState<V> = PageLoadingState<V>> extends ItemIteration<V, L> {
     /**

package/src/lib/iterator/iteration.mapped.d.ts

@@ -3,7 +3,8 @@ import { type Destroyable } from '@dereekb/util';
 import { type Observable } from 'rxjs';
 import { type ItemIteration, type ItemIteratorNextRequest } from './iteration';
 /**
- * An object that maps loading states from one mapping to another.
+ * An {@link ItemIteration} wrapper that transforms loading state values from one type to another
+ * while preserving the iteration interface.
  */
 export interface MappedItemIteration<O, I = unknown, M extends LoadingState<O> = LoadingState<O>, L extends LoadingState<I> = LoadingState<I>, N extends ItemIteration<I, L> = ItemIteration<I, L>> extends ItemIteration<O, M> {
     /**
@@ -11,12 +12,21 @@ export interface MappedItemIteration<O, I = unknown, M extends LoadingState<O> =
      */
     readonly itemIteration: N;
 }
+/**
+ * Configuration for creating a {@link MappedItemIterationInstance}, extending the loading state
+ * mapping configuration with lifecycle options.
+ */
 export interface MappedItemIterationInstanceMapConfig<O, I, M extends LoadingState<O> = PageLoadingState<O>, L extends LoadingState<I> = PageLoadingState<I>> extends MapLoadingStateResultsConfiguration<I, O, L, M> {
     /**
-     * Whether or not to forward the destroy() call to the base itemIteration.
+     * Whether destroying the mapped instance also destroys the underlying iteration.
+     * Defaults to `true`.
      */
     forwardDestroy?: boolean;
 }
+/**
+ * Concrete instance of a mapped item iteration, exposing the transformed state observables
+ * and the underlying iterator and configuration.
+ */
 export interface MappedItemIterationInstance<O, I = unknown, M extends LoadingState<O> = LoadingState<O>, L extends LoadingState<I> = LoadingState<I>, N extends ItemIteration<I, L> = ItemIteration<I, L>> extends ItemIteration<O>, Destroyable {
     readonly itemIterator: N;
     readonly config: MappedItemIterationInstanceMapConfig<O, I, M, L>;
@@ -28,10 +38,13 @@ export interface MappedItemIterationInstance<O, I = unknown, M extends LoadingSt
     next(request?: ItemIteratorNextRequest): void;
 }
 /**
- * Creates a new MappedItemIteration instance given the input ItemIteration and config.
+ * Creates a {@link MappedItemIterationInstance} that wraps an existing iteration and transforms
+ * its loading state values through the provided mapping configuration.
+ *
+ * Control flow (next, hasNext, canLoadMore) is delegated directly to the underlying iteration.
  *
- * @param itemIteration
- * @param config
- * @returns
+ * @param itemIterator - the source iteration to wrap
+ * @param config - mapping configuration for transforming loading state values
+ * @returns mapped iteration instance with transformed state observables
  */
 export declare function mapItemIteration<O, I = unknown, M extends LoadingState<O> = LoadingState<O>, L extends LoadingState<I> = LoadingState<I>, N extends ItemIteration<I, L> = ItemIteration<I, L>>(itemIterator: N, config: MappedItemIterationInstanceMapConfig<O, I, M, L>): MappedItemIterationInstance<O, I, M, L, N>;

package/src/lib/iterator/iteration.mapped.page.d.ts

@@ -2,19 +2,22 @@ import { type PageLoadingState } from '../loading';
 import { type PageItemIteration } from './iteration';
 import { type MappedItemIteration, type MappedItemIterationInstance, type MappedItemIterationInstanceMapConfig } from './iteration.mapped';
 /**
- * MappedItemIteration for PageItemIteration
+ * {@link MappedItemIteration} specialized for {@link PageItemIteration}, preserving page-specific loading state types.
  */
 export type MappedPageItemIteration<O, I = unknown, M extends PageLoadingState<O> = PageLoadingState<O>, L extends PageLoadingState<I> = PageLoadingState<I>, N extends PageItemIteration<I, L> = PageItemIteration<I, L>> = MappedItemIteration<O, I, M, L, N>;
 /**
- * MappedItemIterationInstance extension that implements PageItemIteration.
+ * Instance of a mapped page iteration that implements both {@link MappedItemIterationInstance}
+ * and {@link PageItemIteration}, providing transformed states alongside page-specific operations.
  */
 export interface MappedPageItemIterationInstance<O, I = unknown, M extends PageLoadingState<O> = PageLoadingState<O>, L extends PageLoadingState<I> = PageLoadingState<I>, N extends PageItemIteration<I, L> = PageItemIteration<I, L>> extends MappedItemIterationInstance<O, I, M, L, N>, PageItemIteration<O, M> {
 }
 /**
- * Creates a new MappedItemIteration instance given the input ItemIteration and config.
+ * Creates a {@link MappedPageItemIterationInstance} that wraps a {@link PageItemIteration}
+ * and transforms its loading state values while preserving page-level operations
+ * (nextPage, page load limits, latestLoadedPage).
  *
- * @param itemIteration
- * @param config
- * @returns
+ * @param itemIteration - the source page iteration to wrap
+ * @param config - mapping configuration for transforming loading state values
+ * @returns mapped page iteration instance
  */
 export declare function mappedPageItemIteration<O, I = unknown, M extends PageLoadingState<O> = PageLoadingState<O>, L extends PageLoadingState<I> = PageLoadingState<I>, N extends PageItemIteration<I, L> = PageItemIteration<I, L>>(itemIteration: N, config: MappedItemIterationInstanceMapConfig<O, I, M, L>): MappedPageItemIterationInstance<O, I, M, L, N>;