@vielzeug/flux 1.0.8 → 2.0.0

package/dist/operators/filtering.js.map

@@ -1 +1 @@
-{"version":3,"file":"filtering.js","names":[],"sources":["../../src/operators/filtering.ts"],"sourcesContent":["import type { Flux, Operator, Scheduler, Unsubscribe } from '../types';\n\nimport { guard } from '../_safe';\nimport { DEFAULT_SCHEDULER } from '../_scheduler';\nimport { flux } from '../core';\n\n/**\n * Emit only the first `count` values, then complete.\n *\n * @example\n * interval(100).pipe(take(3)); // emits 0, 1, 2 then completes\n */\nexport function take<T>(count: number): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      if (count <= 0) {\n        observer.complete?.();\n\n        return;\n      }\n\n      let seen = 0;\n      let unsub: Unsubscribe = () => {};\n\n      unsub = source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          observer.next(v);\n          seen++;\n\n          if (seen >= count) {\n            observer.complete?.();\n            unsub();\n          }\n        },\n      });\n\n      return unsub;\n    });\n}\n\n/** Skip the first `count` values, then emit the rest. */\nexport function skip<T>(count: number): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let skipped = 0;\n\n      return source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          if (skipped < count) {\n            skipped++;\n          } else {\n            observer.next(v);\n          }\n        },\n      });\n    });\n}\n\n/**\n * Complete when either `notifier` emits its first value or an `AbortSignal` aborts.\n *\n * @example\n * source$.pipe(takeUntil(stop$));\n * source$.pipe(takeUntil(abortController.signal));\n */\nexport function takeUntil<T>(notifier: AbortSignal | Flux<unknown>): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let done = false;\n\n      const finish = (): void => {\n        if (done) return;\n\n        done = true;\n        observer.complete?.();\n        notifierUnsub();\n        sourceUnsub?.();\n      };\n\n      let notifierUnsub: () => void;\n\n      if (notifier instanceof AbortSignal) {\n        if (notifier.aborted) {\n          observer.complete?.();\n\n          return;\n        }\n\n        notifier.addEventListener('abort', finish, { once: true });\n        notifierUnsub = () => notifier.removeEventListener('abort', finish);\n      } else {\n        notifierUnsub = notifier.subscribe({ next: finish });\n      }\n\n      const sourceUnsub = source.subscribe({\n        complete() {\n          done = true;\n          notifierUnsub();\n          observer.complete?.();\n        },\n        error(err) {\n          done = true;\n          notifierUnsub();\n          observer.error?.(err);\n        },\n        next: observer.next,\n      });\n\n      return () => {\n        notifierUnsub();\n        sourceUnsub();\n      };\n    });\n}\n\n/**\n * Emit values while `predicate` is truthy. Complete when it returns `false`.\n *\n * @example\n * of(1, 2, 3, 4).pipe(takeWhile((n) => n < 3)); // emits 1, 2\n */\nexport function takeWhile<T>(predicate: (value: T) => boolean): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let unsub: Unsubscribe = () => {};\n\n      unsub = source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            if (predicate(v)) {\n              observer.next(v);\n            } else {\n              observer.complete?.();\n              unsub();\n            }\n          }, observer.error);\n        },\n      });\n\n      return unsub;\n    });\n}\n\n/**\n * Emit the last value after `ms` milliseconds of silence.\n * Resets the timer on every source emission.\n *\n * **Note:** if the source completes while a value is pending (timer not yet fired),\n * the pending value is dropped. Only the completion signal is forwarded.\n *\n * @example\n * fromEvent(input, 'input').pipe(debounce(300)); // wait 300ms after last keystroke\n */\nexport function debounce<T>(ms: number, scheduler: Scheduler = DEFAULT_SCHEDULER): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let cancelTimer: (() => void) | undefined;\n\n      const unsub = source.subscribe({\n        complete() {\n          cancelTimer?.();\n          observer.complete?.();\n        },\n        error(err) {\n          cancelTimer?.();\n          observer.error?.(err);\n        },\n        next(v) {\n          cancelTimer?.();\n          cancelTimer = scheduler.delay(() => observer.next(v), ms);\n        },\n      });\n\n      return () => {\n        cancelTimer?.();\n        unsub();\n      };\n    });\n}\n\n/**\n * Emit at most once per `ms` milliseconds. Leading edge by default.\n * Pass a custom `clock` function (default: `Date.now`) to control time in tests.\n *\n * @example\n * fromEvent(window, 'scroll').pipe(throttle(100));\n */\nexport function throttle<T>(ms: number, clock: () => number = Date.now): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let lastEmit = -Infinity;\n\n      return source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          const now = clock();\n\n          if (now - lastEmit >= ms) {\n            lastEmit = now;\n            observer.next(v);\n          }\n        },\n      });\n    });\n}\n\n/**\n * When `notifier` emits, emit the latest value from `source` (if any).\n * Useful for polling-like patterns.\n *\n * @example\n * source$.pipe(sample(interval(1000))); // emit latest value every 1s\n */\nexport function sample<T>(notifier: Flux<unknown>): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let latest: T;\n      let hasValue = false;\n\n      const sourceUnsub = source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          latest = v;\n          hasValue = true;\n        },\n      });\n\n      const notifierUnsub = notifier.subscribe({\n        next() {\n          if (hasValue) observer.next(latest);\n        },\n      });\n\n      return () => {\n        sourceUnsub();\n        notifierUnsub();\n      };\n    });\n}\n\n/** Emit only the first value, then complete. Equivalent to `take(1)`. */\nexport function first<T>(): Operator<T, T> {\n  return take(1);\n}\n\n/**\n * Emit only the last value, collected when source completes.\n *\n * @example\n * of(1, 2, 3).pipe(last()); // emits 3\n */\nexport function last<T>(): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      let latest: T;\n      let hasValue = false;\n\n      return source.subscribe({\n        complete() {\n          if (hasValue) observer.next(latest);\n\n          observer.complete?.();\n        },\n        error: observer.error,\n        next(v) {\n          latest = v;\n          hasValue = true;\n        },\n      });\n    });\n}\n"],"mappings":"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"}
+{"version":3,"file":"filtering.js","names":[],"sources":["../../src/operators/filtering.ts"],"sourcesContent":["import type { Operator, Stream, Subscription } from '../types';\n\nimport { link } from '../_link';\nimport { defaultScheduler } from '../_scheduler';\nimport { stream } from '../core';\nimport { FluxTimeoutError } from '../errors';\n\nexport type DebounceOptions = {\n  for: number;\n};\n\nexport type TimeoutOptions = {\n  after: number;\n};\n\nfunction assertDuration(milliseconds: number, name: string): void {\n  if (!Number.isFinite(milliseconds) || milliseconds < 0) {\n    throw new RangeError(`${name} must be a finite number greater than or equal to zero`);\n  }\n}\n\nexport function take<T>(count: number): Operator<T, T> {\n  if (!Number.isInteger(count) || count < 0) {\n    throw new RangeError('take count must be a non-negative integer');\n  }\n\n  return (source) =>\n    stream((sink, signal) => {\n      if (count === 0) {\n        sink.complete();\n\n        return;\n      }\n\n      let seen = 0;\n      const subscriptionRef: { current?: Subscription } = {};\n\n      subscriptionRef.current = link(\n        source,\n        {\n          complete: sink.complete,\n          error: sink.error,\n          next(value) {\n            sink.next(value);\n            seen++;\n\n            if (seen === count) {\n              sink.complete();\n              subscriptionRef.current?.unsubscribe();\n            }\n          },\n        },\n        signal,\n      );\n\n      return () => subscriptionRef.current?.unsubscribe();\n    });\n}\n\nexport function takeUntil<T>(notifier: AbortSignal | Stream<unknown>): Operator<T, T> {\n  return (source) =>\n    stream((sink, signal) => {\n      let sourceSubscription: Subscription | undefined;\n      let notifierSubscription: Subscription | undefined;\n      let removeNotifier = (): void => {};\n\n      const complete = (): void => {\n        sourceSubscription?.unsubscribe();\n        notifierSubscription?.unsubscribe();\n        sink.complete();\n      };\n\n      if (notifier instanceof AbortSignal) {\n        if (notifier.aborted) {\n          sink.complete();\n\n          return;\n        }\n\n        notifier.addEventListener('abort', complete, { once: true });\n        removeNotifier = (): void => notifier.removeEventListener('abort', complete);\n      } else {\n        notifierSubscription = link(notifier, { error: sink.error, next: complete }, signal);\n      }\n\n      if (!signal.aborted) {\n        sourceSubscription = link(\n          source,\n          {\n            complete: sink.complete,\n            error: sink.error,\n            next: sink.next,\n          },\n          signal,\n        );\n      }\n\n      return () => {\n        removeNotifier();\n        sourceSubscription?.unsubscribe();\n        notifierSubscription?.unsubscribe();\n      };\n    });\n}\n\nexport function debounce<T>(options: DebounceOptions): Operator<T, T> {\n  assertDuration(options.for, 'Debounce duration');\n\n  return (source) =>\n    stream((sink, signal) => {\n      let cancel: (() => void) | undefined;\n      let pending: T | undefined;\n      let hasPending = false;\n\n      const flush = (): void => {\n        cancel = undefined;\n\n        if (!hasPending) return;\n\n        hasPending = false;\n        sink.next(pending as T);\n      };\n\n      const subscription = link(\n        source,\n        {\n          complete() {\n            cancel?.();\n            flush();\n            sink.complete();\n          },\n          error: sink.error,\n          next(value) {\n            pending = value;\n            hasPending = true;\n            cancel?.();\n            cancel = defaultScheduler.delay(flush, options.for);\n          },\n        },\n        signal,\n      );\n\n      return () => {\n        cancel?.();\n        subscription.unsubscribe();\n      };\n    });\n}\n\nexport function timeout<T>(options: TimeoutOptions): Operator<T, T> {\n  assertDuration(options.after, 'Timeout duration');\n\n  return (source) =>\n    stream((sink, signal) => {\n      let cancel: () => void;\n\n      const start = (): void => {\n        cancel = defaultScheduler.delay(() => sink.error(new FluxTimeoutError(options.after)), options.after);\n      };\n\n      start();\n\n      const subscription = link(\n        source,\n        {\n          complete() {\n            cancel();\n            sink.complete();\n          },\n          error(reason) {\n            cancel();\n            sink.error(reason);\n          },\n          next(value) {\n            cancel();\n            start();\n            sink.next(value);\n          },\n        },\n        signal,\n      );\n\n      return () => {\n        cancel();\n        subscription.unsubscribe();\n      };\n    });\n}\n"],"mappings":";;;;;AAeA,SAAS,EAAe,GAAsB,GAAoB;CAChE,IAAI,CAAC,OAAO,SAAS,CAAY,KAAK,IAAe,GACnD,MAAU,WAAW,GAAG,EAAK,uDAAuD;AAExF;AAEA,SAAgB,EAAQ,GAA+B;CACrD,IAAI,CAAC,OAAO,UAAU,CAAK,KAAK,IAAQ,GACtC,MAAU,WAAW,2CAA2C;CAGlE,QAAQ,MACN,GAAQ,GAAM,MAAW;EACvB,IAAI,MAAU,GAAG;GACf,EAAK,SAAS;GAEd;EACF;EAEA,IAAI,IAAO,GACL,IAA8C,CAAC;EAoBrD,OAlBA,EAAgB,UAAU,EACxB,GACA;GACE,UAAU,EAAK;GACf,OAAO,EAAK;GACZ,KAAK,GAAO;IAIV,AAHA,EAAK,KAAK,CAAK,GACf,KAEI,MAAS,MACX,EAAK,SAAS,GACd,EAAgB,SAAS,YAAY;GAEzC;EACF,GACA,CACF,SAEa,EAAgB,SAAS,YAAY;CACpD,CAAC;AACL;AAEA,SAAgB,EAAa,GAAyD;CACpF,QAAQ,MACN,GAAQ,GAAM,MAAW;EACvB,IAAI,GACA,GACA,UAA6B,CAAC,GAE5B,UAAuB;GAG3B,AAFA,GAAoB,YAAY,GAChC,GAAsB,YAAY,GAClC,EAAK,SAAS;EAChB;EAEA,IAAI,aAAoB,aAAa;GACnC,IAAI,EAAS,SAAS;IACpB,EAAK,SAAS;IAEd;GACF;GAGA,AADA,EAAS,iBAAiB,SAAS,GAAU,EAAE,MAAM,GAAK,CAAC,GAC3D,UAA6B,EAAS,oBAAoB,SAAS,CAAQ;EAC7E,OACE,IAAuB,EAAK,GAAU;GAAE,OAAO,EAAK;GAAO,MAAM;EAAS,GAAG,CAAM;EAerF,OAZK,EAAO,YACV,IAAqB,EACnB,GACA;GACE,UAAU,EAAK;GACf,OAAO,EAAK;GACZ,MAAM,EAAK;EACb,GACA,CACF,UAGW;GAGX,AAFA,EAAe,GACf,GAAoB,YAAY,GAChC,GAAsB,YAAY;EACpC;CACF,CAAC;AACL;AAEA,SAAgB,EAAY,GAA0C;CAGpE,OAFA,EAAe,EAAQ,KAAK,mBAAmB,IAEvC,MACN,GAAQ,GAAM,MAAW;EACvB,IAAI,GACA,GACA,IAAa,IAEX,UAAoB;GACxB,IAAS,KAAA,GAEJ,MAEL,IAAa,IACb,EAAK,KAAK,CAAY;EACxB,GAEM,IAAe,EACnB,GACA;GACE,WAAW;IAGT,AAFA,IAAS,GACT,EAAM,GACN,EAAK,SAAS;GAChB;GACA,OAAO,EAAK;GACZ,KAAK,GAAO;IAIV,AAHA,IAAU,GACV,IAAa,IACb,IAAS,GACT,IAAS,EAAiB,MAAM,GAAO,EAAQ,GAAG;GACpD;EACF,GACA,CACF;EAEA,aAAa;GAEX,AADA,IAAS,GACT,EAAa,YAAY;EAC3B;CACF,CAAC;AACL;AAEA,SAAgB,EAAW,GAAyC;CAGlE,OAFA,EAAe,EAAQ,OAAO,kBAAkB,IAExC,MACN,GAAQ,GAAM,MAAW;EACvB,IAAI,GAEE,UAAoB;GACxB,IAAS,EAAiB,YAAY,EAAK,MAAM,IAAI,EAAiB,EAAQ,KAAK,CAAC,GAAG,EAAQ,KAAK;EACtG;EAEA,EAAM;EAEN,IAAM,IAAe,EACnB,GACA;GACE,WAAW;IAET,AADA,EAAO,GACP,EAAK,SAAS;GAChB;GACA,MAAM,GAAQ;IAEZ,AADA,EAAO,GACP,EAAK,MAAM,CAAM;GACnB;GACA,KAAK,GAAO;IAGV,AAFA,EAAO,GACP,EAAM,GACN,EAAK,KAAK,CAAK;GACjB;EACF,GACA,CACF;EAEA,aAAa;GAEX,AADA,EAAO,GACP,EAAa,YAAY;EAC3B;CACF,CAAC;AACL"}

package/dist/operators/transformation.cjs

@@ -1,2 +1,2 @@
-const e=require("../_dev.cjs"),t=require("../core.cjs"),n=require("../_safe.cjs"),r=require("../_numeric.cjs");function i(e){return r=>t.flux(t=>r.subscribe({complete:t.complete,error:t.error,next(r){n.guard(()=>t.next(e(r)),t.error)}}))}function a(e){return r=>t.flux(t=>r.subscribe({complete:t.complete,error:t.error,next(r){n.guard(()=>{e(r)&&t.next(r)},t.error)}}))}function o(e,r){return i=>t.flux(t=>{let a=r;return i.subscribe({complete:t.complete,error:t.error,next(r){n.guard(()=>{a=e(a,r),t.next(a)},t.error)}})})}function s(e){return r=>t.flux(t=>{let i,a=!1,o=()=>{a&&!i&&t.complete?.()},s=r.subscribe({complete(){a=!0,o()},error:t.error,next(r){n.guard(()=>{i?.(),i=e(r).subscribe({complete(){i=void 0,o()},error:t.error,next:t.next})},t.error)}});return()=>{s(),i?.()}})}function c(e){return r=>t.flux(t=>{let i=!1,a=0,o=new Set,s=()=>{i&&a===0&&t.complete?.()},c=r.subscribe({complete(){i=!0,s()},error:t.error,next(r){n.guard(()=>{a++;let n=!1,i=()=>{};i=e(r).subscribe({complete(){n=!0,a--,o.delete(i),s()},error:t.error,next:t.next}),n||o.add(i)},t.error)}});return()=>{c();for(let e of o)e()}})}function l(e,r=1/0){return i=>t.flux(t=>{let a=!1,o=[],s=!1,c;function l(){if(o.length===0){s=!1,a&&t.complete?.();return}s=!0;let r=o.shift();n.guard(()=>{c=e(r).subscribe({complete(){c=void 0,l()},error:t.error,next:t.next})},t.error)}let u=i.subscribe({complete(){a=!0,s||t.complete?.()},error:t.error,next(e){o.length<r&&(o.push(e),s||l())}});return()=>{u(),c?.(),o.length=0}})}function u(e){let r=e??Object.is;return e=>t.flux(t=>{let i=!1,a;return e.subscribe({complete:t.complete,error:t.error,next(e){n.guard(()=>{(!i||!r(a,e))&&(i=!0,a=e,t.next(e))},t.error)}})})}function d(...e){return n=>t.flux(t=>{for(let n of e)t.next(n);return n.subscribe(t)})}function f(n,i){let{clamped:a,value:o}=r.clampPositiveInt(n),{clamped:s,value:c}=r.clampPositiveInt(i??o);return a&&e.warn(`bufferCount: size must be a finite integer >= 1, got ${n} — clamped to ${o}`),i!==void 0&&s&&e.warn(`bufferCount: every must be a finite integer >= 1, got ${i} — clamped to ${c}`),e=>t.flux(t=>{let n=[],r=0;return e.subscribe({complete(){for(let e of n)e.length>0&&t.next(e);t.complete?.()},error:t.error,next(e){r%c===0&&n.push([]);for(let t of n)t.push(e);let i=0;for(;i<n.length;)n[i].length>=o?(t.next(n[i]),n.splice(i,1)):i++;r++}})})}function p(){return e=>t.flux(t=>{let n=!1,r;return e.subscribe({complete:t.complete,error:t.error,next(e){n&&t.next([r,e]),n=!0,r=e}})})}exports.bufferCount=f,exports.concatMap=l,exports.distinctUntilChanged=u,exports.filter=a,exports.flatMap=c,exports.map=i,exports.pairwise=p,exports.scan=o,exports.startWith=d,exports.switchMap=s;
+const e=require("../core.cjs"),t=require("../_link.cjs"),n=require("../_safe.cjs");function r(r){return i=>e.stream((e,a)=>t.link(i,{complete:e.complete,error:e.error,next(t){n.tryCall(()=>e.next(r(t)),e.error)}},a).unsubscribe)}function i(r){return i=>e.stream((e,a)=>t.link(i,{complete:e.complete,error:e.error,next(t){n.tryCall(()=>{r(t)&&e.next(t)},e.error)}},a).unsubscribe)}function a(r,i){return a=>e.stream((e,o)=>{let s=i;return t.link(a,{complete:e.complete,error:e.error,next(t){n.tryCall(()=>{s=r(s,t),e.next(s)},e.error)}},o).unsubscribe})}function o(r){return i=>e.stream((e,a)=>{let o=!1,s,c=()=>{o&&!s&&e.complete()},l=t.link(i,{complete(){o=!0,c()},error:e.error,next(i){s?.unsubscribe(),s=void 0,n.tryCall(()=>{let n=t.link(r(i),{complete(){s=void 0,c()},error:e.error,next:e.next},a);s=n.closed?void 0:n},e.error)}},a);return()=>{l.unsubscribe(),s?.unsubscribe()}})}function s(r){return i=>e.stream((e,a)=>{let o=!1,s=new Set,c=()=>{o&&s.size===0&&e.complete()},l=t.link(i,{complete(){o=!0,c()},error:e.error,next(i){n.tryCall(()=>{let n={};n.current=t.link(r(i),{complete(){n.current&&s.delete(n.current),c()},error:e.error,next:e.next},a),n.current.closed||s.add(n.current)},e.error)}},a);return()=>{l.unsubscribe();for(let e of s)e.unsubscribe()}})}function c(r,i){if(!Number.isInteger(i.capacity)||i.capacity<1)throw RangeError(`concatMap capacity must be a positive integer`);return a=>e.stream((e,o)=>{let s=[],c=!1,l,u={},d=()=>{if(l||s.length===0){c&&!l&&s.length===0&&e.complete();return}let i=s.shift();n.tryCall(()=>{let n=t.link(r(i),{complete(){l=void 0,d()},error:e.error,next:e.next},o);l=n.closed?void 0:n,l||d()},e.error)};return u.current=t.link(a,{complete(){c=!0,d()},error:e.error,next(t){if(s.length===i.capacity){u.current?.unsubscribe(),e.error(RangeError(`concatMap buffer capacity exceeded`));return}s.push(t),d()}},o),()=>{u.current?.unsubscribe(),l?.unsubscribe(),s.length=0}})}exports.concatMap=c,exports.filter=i,exports.map=r,exports.mergeMap=s,exports.scan=a,exports.switchMap=o;
 //# sourceMappingURL=transformation.cjs.map

package/dist/operators/transformation.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"transformation.cjs","names":[],"sources":["../../src/operators/transformation.ts"],"sourcesContent":["import type { Flux, Operator, Unsubscribe } from '../types';\n\nimport { warn } from '../_dev';\nimport { clampPositiveInt } from '../_numeric';\nimport { guard } from '../_safe';\nimport { flux } from '../core';\n\n/** Transform each emitted value through `fn`. */\nexport function map<A, B>(fn: (value: A) => B): Operator<A, B> {\n  return (source) =>\n    flux<B>((observer) =>\n      source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          guard(() => observer.next(fn(v)), observer.error);\n        },\n      }),\n    );\n}\n\n/** Emit only values for which `predicate` returns `true`. */\nexport function filter<T>(predicate: (value: T) => boolean): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) =>\n      source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            if (predicate(v)) observer.next(v);\n          }, observer.error);\n        },\n      }),\n    );\n}\n\n/**\n * Accumulate state with a reducer. Emits the accumulated value after each source emission.\n *\n * @example\n * of(1, 2, 3).pipe(scan((acc, n) => acc + n, 0)); // emits 1, 3, 6\n */\nexport function scan<T, A>(reducer: (acc: A, value: T) => A, seed: A): Operator<T, A> {\n  return (source) =>\n    flux<A>((observer) => {\n      let acc = seed;\n\n      return source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            acc = reducer(acc, v);\n            observer.next(acc);\n          }, observer.error);\n        },\n      });\n    });\n}\n\n/**\n * Map each source value to an inner `Flux`, cancelling the previous inner on each new emission.\n * Useful for search-as-you-type, navigation, etc.\n */\nexport function switchMap<A, B>(fn: (value: A) => Flux<B>): Operator<A, B> {\n  return (source) =>\n    flux<B>((observer) => {\n      let innerUnsub: Unsubscribe | undefined;\n      let outerDone = false;\n\n      const checkDone = (): void => {\n        if (outerDone && !innerUnsub) observer.complete?.();\n      };\n\n      const outerUnsub = source.subscribe({\n        complete() {\n          outerDone = true;\n          checkDone();\n        },\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            innerUnsub?.();\n            innerUnsub = fn(v).subscribe({\n              complete() {\n                innerUnsub = undefined;\n                checkDone();\n              },\n              error: observer.error,\n              next: observer.next,\n            });\n          }, observer.error);\n        },\n      });\n\n      return () => {\n        outerUnsub();\n        innerUnsub?.();\n      };\n    });\n}\n\n/**\n * Map each source value to an inner `Flux`, merging all inner streams concurrently.\n * All inner subscriptions run simultaneously.\n */\nexport function flatMap<A, B>(fn: (value: A) => Flux<B>): Operator<A, B> {\n  return (source) =>\n    flux<B>((observer) => {\n      let outerDone = false;\n      let activeInner = 0;\n      const innerUnsubs = new Set<Unsubscribe>();\n\n      const checkDone = (): void => {\n        if (outerDone && activeInner === 0) observer.complete?.();\n      };\n\n      const outerUnsub = source.subscribe({\n        complete() {\n          outerDone = true;\n          checkDone();\n        },\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            activeInner++;\n\n            let syncDone = false;\n            // Init to NOOP to avoid TDZ if complete fires synchronously during subscribe().\n            let unsub: Unsubscribe = () => {};\n\n            const sub = fn(v).subscribe({\n              complete() {\n                syncDone = true;\n                activeInner--;\n                innerUnsubs.delete(unsub);\n                checkDone();\n              },\n              error: observer.error,\n              next: observer.next,\n            });\n\n            unsub = sub;\n\n            if (!syncDone) innerUnsubs.add(unsub);\n          }, observer.error);\n        },\n      });\n\n      return () => {\n        outerUnsub();\n        for (const u of innerUnsubs) u();\n      };\n    });\n}\n\n/**\n * Map each source value to an inner `Flux`, subscribing to each one only after\n * the previous inner completes (sequential, queued).\n * Pass `maxBuffer` to cap queued items; excess items are dropped silently.\n */\nexport function concatMap<A, B>(fn: (value: A) => Flux<B>, maxBuffer = Infinity): Operator<A, B> {\n  return (source) =>\n    flux<B>((observer) => {\n      let outerDone = false;\n      const queue: A[] = [];\n      let processing = false;\n      let currentUnsub: Unsubscribe | undefined;\n\n      function processNext(): void {\n        if (queue.length === 0) {\n          processing = false;\n\n          if (outerDone) observer.complete?.();\n\n          return;\n        }\n\n        processing = true;\n\n        const item = queue.shift()!;\n\n        guard(() => {\n          currentUnsub = fn(item).subscribe({\n            complete() {\n              currentUnsub = undefined;\n\n              processNext();\n            },\n            error: observer.error,\n            next: observer.next,\n          });\n        }, observer.error);\n      }\n\n      const outerUnsub = source.subscribe({\n        complete() {\n          outerDone = true;\n\n          if (!processing) observer.complete?.();\n        },\n        error: observer.error,\n        next(v) {\n          if (queue.length < maxBuffer) {\n            queue.push(v);\n\n            if (!processing) processNext();\n          }\n        },\n      });\n\n      return () => {\n        outerUnsub();\n        currentUnsub?.();\n        queue.length = 0;\n      };\n    });\n}\n\n/**\n * Suppress consecutive duplicate values.\n * Uses `Object.is` by default; provide a custom `comparator` for deep equality.\n *\n * @example\n * of(1, 1, 2, 2, 3).pipe(distinctUntilChanged()); // emits 1, 2, 3\n */\nexport function distinctUntilChanged<T>(comparator?: (a: T, b: T) => boolean): Operator<T, T> {\n  const eq = comparator ?? Object.is;\n\n  return (source) =>\n    flux<T>((observer) => {\n      let hasPrev = false;\n      let prev: T;\n\n      return source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            if (!hasPrev || !eq(prev, v)) {\n              hasPrev = true;\n              prev = v;\n              observer.next(v);\n            }\n          }, observer.error);\n        },\n      });\n    });\n}\n\n/**\n * Prepend one or more static values before the source's first emission.\n *\n * @example\n * of(2, 3).pipe(startWith(0, 1)).subscribe(console.log); // 0, 1, 2, 3\n */\nexport function startWith<T>(...values: T[]): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      for (const v of values) observer.next(v);\n\n      return source.subscribe(observer);\n    });\n}\n\n/**\n * Collect source emissions into fixed-size arrays, emitting each batch when full.\n * A partial batch at the end of the source is flushed on completion.\n *\n * @param size - Number of emissions per batch.\n * @param every - Start a new batch every `every` emissions (default: `size`, non-overlapping).\n *\n * @example\n * of(1, 2, 3, 4, 5, 6).pipe(bufferCount(2)).subscribe(console.log);\n * // [1, 2], [3, 4], [5, 6]\n */\nexport function bufferCount<T>(size: number, every?: number): Operator<T, T[]> {\n  const { clamped: sizeClamped, value: safeSize } = clampPositiveInt(size);\n  const { clamped: everyClamped, value: step } = clampPositiveInt(every ?? safeSize);\n\n  if (sizeClamped) {\n    warn(`bufferCount: size must be a finite integer >= 1, got ${size} — clamped to ${safeSize}`);\n  }\n\n  if (every !== undefined && everyClamped) {\n    warn(`bufferCount: every must be a finite integer >= 1, got ${every} — clamped to ${step}`);\n  }\n\n  return (source) =>\n    flux<T[]>((observer) => {\n      const buffers: T[][] = [];\n      let count = 0;\n\n      return source.subscribe({\n        complete() {\n          for (const buf of buffers) {\n            if (buf.length > 0) observer.next(buf);\n          }\n\n          observer.complete?.();\n        },\n        error: observer.error,\n        next(v) {\n          if (count % step === 0) buffers.push([]);\n\n          for (const buf of buffers) buf.push(v);\n\n          let i = 0;\n\n          while (i < buffers.length) {\n            if (buffers[i]!.length >= safeSize) {\n              observer.next(buffers[i]!);\n              buffers.splice(i, 1);\n            } else {\n              i++;\n            }\n          }\n\n          count++;\n        },\n      });\n    });\n}\n\n/**\n * Emit the previous and current value as a `[prev, curr]` tuple.\n * No emission occurs until the second source value arrives.\n *\n * @example\n * of(1, 2, 3).pipe(pairwise()).subscribe(console.log); // [1, 2], [2, 3]\n */\nexport function pairwise<T>(): Operator<T, [T, T]> {\n  return (source) =>\n    flux<[T, T]>((observer) => {\n      let hasPrev = false;\n      let prev: T;\n\n      return source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          if (hasPrev) observer.next([prev, v]);\n\n          hasPrev = true;\n          prev = v;\n        },\n      });\n    });\n}\n"],"mappings":"+GAQA,SAAgB,EAAU,EAAqC,CAC7D,MAAQ,IACN,EAAA,KAAS,GACP,EAAO,UAAU,CACf,SAAU,EAAS,SACnB,MAAO,EAAS,MAChB,KAAK,EAAG,CACN,EAAA,UAAY,EAAS,KAAK,EAAG,CAAC,CAAC,EAAG,EAAS,KAAK,CAClD,CACF,CAAC,CACH,CACJ,CAGA,SAAgB,EAAU,EAAkD,CAC1E,MAAQ,IACN,EAAA,KAAS,GACP,EAAO,UAAU,CACf,SAAU,EAAS,SACnB,MAAO,EAAS,MAChB,KAAK,EAAG,CACN,EAAA,UAAY,CACN,EAAU,CAAC,GAAG,EAAS,KAAK,CAAC,CACnC,EAAG,EAAS,KAAK,CACnB,CACF,CAAC,CACH,CACJ,CAQA,SAAgB,EAAW,EAAkC,EAAyB,CACpF,MAAQ,IACN,EAAA,KAAS,GAAa,CACpB,IAAI,EAAM,EAEV,OAAO,EAAO,UAAU,CACtB,SAAU,EAAS,SACnB,MAAO,EAAS,MAChB,KAAK,EAAG,CACN,EAAA,UAAY,CACV,EAAM,EAAQ,EAAK,CAAC,EACpB,EAAS,KAAK,CAAG,CACnB,EAAG,EAAS,KAAK,CACnB,CACF,CAAC,CACH,CAAC,CACL,CAMA,SAAgB,EAAgB,EAA2C,CACzE,MAAQ,IACN,EAAA,KAAS,GAAa,CACpB,IAAI,EACA,EAAY,GAEV,MAAwB,CACxB,GAAa,CAAC,GAAY,EAAS,WAAW,CACpD,EAEM,EAAa,EAAO,UAAU,CAClC,UAAW,CACT,EAAY,GACZ,EAAU,CACZ,EACA,MAAO,EAAS,MAChB,KAAK,EAAG,CACN,EAAA,UAAY,CACV,IAAa,EACb,EAAa,EAAG,CAAC,CAAC,CAAC,UAAU,CAC3B,UAAW,CACT,EAAa,IAAA,GACb,EAAU,CACZ,EACA,MAAO,EAAS,MAChB,KAAM,EAAS,IACjB,CAAC,CACH,EAAG,EAAS,KAAK,CACnB,CACF,CAAC,EAED,UAAa,CACX,EAAW,EACX,IAAa,CACf,CACF,CAAC,CACL,CAMA,SAAgB,EAAc,EAA2C,CACvE,MAAQ,IACN,EAAA,KAAS,GAAa,CACpB,IAAI,EAAY,GACZ,EAAc,EACZ,EAAc,IAAI,IAElB,MAAwB,CACxB,GAAa,IAAgB,GAAG,EAAS,WAAW,CAC1D,EAEM,EAAa,EAAO,UAAU,CAClC,UAAW,CACT,EAAY,GACZ,EAAU,CACZ,EACA,MAAO,EAAS,MAChB,KAAK,EAAG,CACN,EAAA,UAAY,CACV,IAEA,IAAI,EAAW,GAEX,MAA2B,CAAC,EAahC,EAXY,EAAG,CAAC,CAAC,CAAC,UAAU,CAC1B,UAAW,CACT,EAAW,GACX,IACA,EAAY,OAAO,CAAK,EACxB,EAAU,CACZ,EACA,MAAO,EAAS,MAChB,KAAM,EAAS,IACjB,CAEQ,EAEH,GAAU,EAAY,IAAI,CAAK,CACtC,EAAG,EAAS,KAAK,CACnB,CACF,CAAC,EAED,UAAa,CACX,EAAW,EACX,IAAK,IAAM,KAAK,EAAa,EAAE,CACjC,CACF,CAAC,CACL,CAOA,SAAgB,EAAgB,EAA2B,EAAY,IAA0B,CAC/F,MAAQ,IACN,EAAA,KAAS,GAAa,CACpB,IAAI,EAAY,GACV,EAAa,CAAC,EAChB,EAAa,GACb,EAEJ,SAAS,GAAoB,CAC3B,GAAI,EAAM,SAAW,EAAG,CACtB,EAAa,GAET,GAAW,EAAS,WAAW,EAEnC,MACF,CAEA,EAAa,GAEb,IAAM,EAAO,EAAM,MAAM,EAEzB,EAAA,UAAY,CACV,EAAe,EAAG,CAAI,CAAC,CAAC,UAAU,CAChC,UAAW,CACT,EAAe,IAAA,GAEf,EAAY,CACd,EACA,MAAO,EAAS,MAChB,KAAM,EAAS,IACjB,CAAC,CACH,EAAG,EAAS,KAAK,CACnB,CAEA,IAAM,EAAa,EAAO,UAAU,CAClC,UAAW,CACT,EAAY,GAEP,GAAY,EAAS,WAAW,CACvC,EACA,MAAO,EAAS,MAChB,KAAK,EAAG,CACF,EAAM,OAAS,IACjB,EAAM,KAAK,CAAC,EAEP,GAAY,EAAY,EAEjC,CACF,CAAC,EAED,UAAa,CACX,EAAW,EACX,IAAe,EACf,EAAM,OAAS,CACjB,CACF,CAAC,CACL,CASA,SAAgB,EAAwB,EAAsD,CAC5F,IAAM,EAAK,GAAc,OAAO,GAEhC,MAAQ,IACN,EAAA,KAAS,GAAa,CACpB,IAAI,EAAU,GACV,EAEJ,OAAO,EAAO,UAAU,CACtB,SAAU,EAAS,SACnB,MAAO,EAAS,MAChB,KAAK,EAAG,CACN,EAAA,UAAY,EACN,CAAC,GAAW,CAAC,EAAG,EAAM,CAAC,KACzB,EAAU,GACV,EAAO,EACP,EAAS,KAAK,CAAC,EAEnB,EAAG,EAAS,KAAK,CACnB,CACF,CAAC,CACH,CAAC,CACL,CAQA,SAAgB,EAAa,GAAG,EAA6B,CAC3D,MAAQ,IACN,EAAA,KAAS,GAAa,CACpB,IAAK,IAAM,KAAK,EAAQ,EAAS,KAAK,CAAC,EAEvC,OAAO,EAAO,UAAU,CAAQ,CAClC,CAAC,CACL,CAaA,SAAgB,EAAe,EAAc,EAAkC,CAC7E,GAAM,CAAE,QAAS,EAAa,MAAO,GAAa,EAAA,iBAAiB,CAAI,EACjE,CAAE,QAAS,EAAc,MAAO,GAAS,EAAA,iBAAiB,GAAS,CAAQ,EAUjF,OARI,GACF,EAAA,KAAK,wDAAwD,EAAK,gBAAgB,GAAU,EAG1F,IAAU,IAAA,IAAa,GACzB,EAAA,KAAK,yDAAyD,EAAM,gBAAgB,GAAM,EAGpF,GACN,EAAA,KAAW,GAAa,CACtB,IAAM,EAAiB,CAAC,EACpB,EAAQ,EAEZ,OAAO,EAAO,UAAU,CACtB,UAAW,CACT,IAAK,IAAM,KAAO,EACZ,EAAI,OAAS,GAAG,EAAS,KAAK,CAAG,EAGvC,EAAS,WAAW,CACtB,EACA,MAAO,EAAS,MAChB,KAAK,EAAG,CACF,EAAQ,IAAS,GAAG,EAAQ,KAAK,CAAC,CAAC,EAEvC,IAAK,IAAM,KAAO,EAAS,EAAI,KAAK,CAAC,EAErC,IAAI,EAAI,EAER,KAAO,EAAI,EAAQ,QACb,EAAQ,EAAE,CAAE,QAAU,GACxB,EAAS,KAAK,EAAQ,EAAG,EACzB,EAAQ,OAAO,EAAG,CAAC,GAEnB,IAIJ,GACF,CACF,CAAC,CACH,CAAC,CACL,CASA,SAAgB,GAAmC,CACjD,MAAQ,IACN,EAAA,KAAc,GAAa,CACzB,IAAI,EAAU,GACV,EAEJ,OAAO,EAAO,UAAU,CACtB,SAAU,EAAS,SACnB,MAAO,EAAS,MAChB,KAAK,EAAG,CACF,GAAS,EAAS,KAAK,CAAC,EAAM,CAAC,CAAC,EAEpC,EAAU,GACV,EAAO,CACT,CACF,CAAC,CACH,CAAC,CACL"}
+{"version":3,"file":"transformation.cjs","names":[],"sources":["../../src/operators/transformation.ts"],"sourcesContent":["import type { Operator, Stream, Subscription } from '../types';\n\nimport { link } from '../_link';\nimport { tryCall } from '../_safe';\nimport { stream } from '../core';\n\nexport type ConcatMapOptions = {\n  capacity: number;\n};\n\nexport function map<A, B>(project: (value: A) => B): Operator<A, B> {\n  return (source) =>\n    stream(\n      (sink, signal) =>\n        link(\n          source,\n          {\n            complete: sink.complete,\n            error: sink.error,\n            next(value) {\n              tryCall(() => sink.next(project(value)), sink.error);\n            },\n          },\n          signal,\n        ).unsubscribe,\n    );\n}\n\nexport function filter<T>(predicate: (value: T) => boolean): Operator<T, T> {\n  return (source) =>\n    stream(\n      (sink, signal) =>\n        link(\n          source,\n          {\n            complete: sink.complete,\n            error: sink.error,\n            next(value) {\n              tryCall(() => {\n                if (predicate(value)) sink.next(value);\n              }, sink.error);\n            },\n          },\n          signal,\n        ).unsubscribe,\n    );\n}\n\nexport function scan<T, A>(reducer: (state: A, value: T) => A, initial: A): Operator<T, A> {\n  return (source) =>\n    stream((sink, signal) => {\n      let state = initial;\n\n      return link(\n        source,\n        {\n          complete: sink.complete,\n          error: sink.error,\n          next(value) {\n            tryCall(() => {\n              state = reducer(state, value);\n              sink.next(state);\n            }, sink.error);\n          },\n        },\n        signal,\n      ).unsubscribe;\n    });\n}\n\nexport function switchMap<A, B>(project: (value: A) => Stream<B>): Operator<A, B> {\n  return (source) =>\n    stream((sink, signal) => {\n      let outerComplete = false;\n      let inner: Subscription | undefined;\n\n      const finish = (): void => {\n        if (outerComplete && !inner) sink.complete();\n      };\n\n      const outer = link(\n        source,\n        {\n          complete() {\n            outerComplete = true;\n            finish();\n          },\n          error: sink.error,\n          next(value) {\n            inner?.unsubscribe();\n            inner = undefined;\n\n            tryCall(() => {\n              const subscription = link(\n                project(value),\n                {\n                  complete() {\n                    inner = undefined;\n                    finish();\n                  },\n                  error: sink.error,\n                  next: sink.next,\n                },\n                signal,\n              );\n\n              inner = subscription.closed ? undefined : subscription;\n            }, sink.error);\n          },\n        },\n        signal,\n      );\n\n      return () => {\n        outer.unsubscribe();\n        inner?.unsubscribe();\n      };\n    });\n}\n\nexport function mergeMap<A, B>(project: (value: A) => Stream<B>): Operator<A, B> {\n  return (source) =>\n    stream((sink, signal) => {\n      let outerComplete = false;\n      const inners = new Set<Subscription>();\n\n      const finish = (): void => {\n        if (outerComplete && inners.size === 0) sink.complete();\n      };\n\n      const outer = link(\n        source,\n        {\n          complete() {\n            outerComplete = true;\n            finish();\n          },\n          error: sink.error,\n          next(value) {\n            tryCall(() => {\n              const innerRef: { current?: Subscription } = {};\n\n              innerRef.current = link(\n                project(value),\n                {\n                  complete() {\n                    if (innerRef.current) inners.delete(innerRef.current);\n\n                    finish();\n                  },\n                  error: sink.error,\n                  next: sink.next,\n                },\n                signal,\n              );\n\n              if (!innerRef.current.closed) inners.add(innerRef.current);\n            }, sink.error);\n          },\n        },\n        signal,\n      );\n\n      return () => {\n        outer.unsubscribe();\n        for (const inner of inners) inner.unsubscribe();\n      };\n    });\n}\n\nexport function concatMap<A, B>(project: (value: A) => Stream<B>, options: ConcatMapOptions): Operator<A, B> {\n  if (!Number.isInteger(options.capacity) || options.capacity < 1) {\n    throw new RangeError('concatMap capacity must be a positive integer');\n  }\n\n  return (source) =>\n    stream((sink, signal) => {\n      const queue: A[] = [];\n      let outerComplete = false;\n      let inner: Subscription | undefined;\n      const outerRef: { current?: Subscription } = {};\n\n      const next = (): void => {\n        if (inner || queue.length === 0) {\n          if (outerComplete && !inner && queue.length === 0) sink.complete();\n\n          return;\n        }\n\n        const value = queue.shift()!;\n\n        tryCall(() => {\n          const subscription = link(\n            project(value),\n            {\n              complete() {\n                inner = undefined;\n                next();\n              },\n              error: sink.error,\n              next: sink.next,\n            },\n            signal,\n          );\n\n          inner = subscription.closed ? undefined : subscription;\n\n          if (!inner) next();\n        }, sink.error);\n      };\n\n      outerRef.current = link(\n        source,\n        {\n          complete() {\n            outerComplete = true;\n            next();\n          },\n          error: sink.error,\n          next(value) {\n            if (queue.length === options.capacity) {\n              outerRef.current?.unsubscribe();\n              sink.error(new RangeError('concatMap buffer capacity exceeded'));\n\n              return;\n            }\n\n            queue.push(value);\n            next();\n          },\n        },\n        signal,\n      );\n\n      return () => {\n        outerRef.current?.unsubscribe();\n        inner?.unsubscribe();\n        queue.length = 0;\n      };\n    });\n}\n"],"mappings":"mFAUA,SAAgB,EAAU,EAA0C,CAClE,MAAQ,IACN,EAAA,QACG,EAAM,IACL,EAAA,KACE,EACA,CACE,SAAU,EAAK,SACf,MAAO,EAAK,MACZ,KAAK,EAAO,CACV,EAAA,YAAc,EAAK,KAAK,EAAQ,CAAK,CAAC,EAAG,EAAK,KAAK,CACrD,CACF,EACA,CACF,CAAC,CAAC,WACN,CACJ,CAEA,SAAgB,EAAU,EAAkD,CAC1E,MAAQ,IACN,EAAA,QACG,EAAM,IACL,EAAA,KACE,EACA,CACE,SAAU,EAAK,SACf,MAAO,EAAK,MACZ,KAAK,EAAO,CACV,EAAA,YAAc,CACR,EAAU,CAAK,GAAG,EAAK,KAAK,CAAK,CACvC,EAAG,EAAK,KAAK,CACf,CACF,EACA,CACF,CAAC,CAAC,WACN,CACJ,CAEA,SAAgB,EAAW,EAAoC,EAA4B,CACzF,MAAQ,IACN,EAAA,QAAQ,EAAM,IAAW,CACvB,IAAI,EAAQ,EAEZ,OAAO,EAAA,KACL,EACA,CACE,SAAU,EAAK,SACf,MAAO,EAAK,MACZ,KAAK,EAAO,CACV,EAAA,YAAc,CACZ,EAAQ,EAAQ,EAAO,CAAK,EAC5B,EAAK,KAAK,CAAK,CACjB,EAAG,EAAK,KAAK,CACf,CACF,EACA,CACF,CAAC,CAAC,WACJ,CAAC,CACL,CAEA,SAAgB,EAAgB,EAAkD,CAChF,MAAQ,IACN,EAAA,QAAQ,EAAM,IAAW,CACvB,IAAI,EAAgB,GAChB,EAEE,MAAqB,CACrB,GAAiB,CAAC,GAAO,EAAK,SAAS,CAC7C,EAEM,EAAQ,EAAA,KACZ,EACA,CACE,UAAW,CACT,EAAgB,GAChB,EAAO,CACT,EACA,MAAO,EAAK,MACZ,KAAK,EAAO,CACV,GAAO,YAAY,EACnB,EAAQ,IAAA,GAER,EAAA,YAAc,CACZ,IAAM,EAAe,EAAA,KACnB,EAAQ,CAAK,EACb,CACE,UAAW,CACT,EAAQ,IAAA,GACR,EAAO,CACT,EACA,MAAO,EAAK,MACZ,KAAM,EAAK,IACb,EACA,CACF,EAEA,EAAQ,EAAa,OAAS,IAAA,GAAY,CAC5C,EAAG,EAAK,KAAK,CACf,CACF,EACA,CACF,EAEA,UAAa,CACX,EAAM,YAAY,EAClB,GAAO,YAAY,CACrB,CACF,CAAC,CACL,CAEA,SAAgB,EAAe,EAAkD,CAC/E,MAAQ,IACN,EAAA,QAAQ,EAAM,IAAW,CACvB,IAAI,EAAgB,GACd,EAAS,IAAI,IAEb,MAAqB,CACrB,GAAiB,EAAO,OAAS,GAAG,EAAK,SAAS,CACxD,EAEM,EAAQ,EAAA,KACZ,EACA,CACE,UAAW,CACT,EAAgB,GAChB,EAAO,CACT,EACA,MAAO,EAAK,MACZ,KAAK,EAAO,CACV,EAAA,YAAc,CACZ,IAAM,EAAuC,CAAC,EAE9C,EAAS,QAAU,EAAA,KACjB,EAAQ,CAAK,EACb,CACE,UAAW,CACL,EAAS,SAAS,EAAO,OAAO,EAAS,OAAO,EAEpD,EAAO,CACT,EACA,MAAO,EAAK,MACZ,KAAM,EAAK,IACb,EACA,CACF,EAEK,EAAS,QAAQ,QAAQ,EAAO,IAAI,EAAS,OAAO,CAC3D,EAAG,EAAK,KAAK,CACf,CACF,EACA,CACF,EAEA,UAAa,CACX,EAAM,YAAY,EAClB,IAAK,IAAM,KAAS,EAAQ,EAAM,YAAY,CAChD,CACF,CAAC,CACL,CAEA,SAAgB,EAAgB,EAAkC,EAA2C,CAC3G,GAAI,CAAC,OAAO,UAAU,EAAQ,QAAQ,GAAK,EAAQ,SAAW,EAC5D,MAAU,WAAW,+CAA+C,EAGtE,MAAQ,IACN,EAAA,QAAQ,EAAM,IAAW,CACvB,IAAM,EAAa,CAAC,EAChB,EAAgB,GAChB,EACE,EAAuC,CAAC,EAExC,MAAmB,CACvB,GAAI,GAAS,EAAM,SAAW,EAAG,CAC3B,GAAiB,CAAC,GAAS,EAAM,SAAW,GAAG,EAAK,SAAS,EAEjE,MACF,CAEA,IAAM,EAAQ,EAAM,MAAM,EAE1B,EAAA,YAAc,CACZ,IAAM,EAAe,EAAA,KACnB,EAAQ,CAAK,EACb,CACE,UAAW,CACT,EAAQ,IAAA,GACR,EAAK,CACP,EACA,MAAO,EAAK,MACZ,KAAM,EAAK,IACb,EACA,CACF,EAEA,EAAQ,EAAa,OAAS,IAAA,GAAY,EAErC,GAAO,EAAK,CACnB,EAAG,EAAK,KAAK,CACf,EAyBA,MAvBA,GAAS,QAAU,EAAA,KACjB,EACA,CACE,UAAW,CACT,EAAgB,GAChB,EAAK,CACP,EACA,MAAO,EAAK,MACZ,KAAK,EAAO,CACV,GAAI,EAAM,SAAW,EAAQ,SAAU,CACrC,EAAS,SAAS,YAAY,EAC9B,EAAK,MAAU,WAAW,oCAAoC,CAAC,EAE/D,MACF,CAEA,EAAM,KAAK,CAAK,EAChB,EAAK,CACP,CACF,EACA,CACF,MAEa,CACX,EAAS,SAAS,YAAY,EAC9B,GAAO,YAAY,EACnB,EAAM,OAAS,CACjB,CACF,CAAC,CACL"}

package/dist/operators/transformation.d.ts

@@ -1,64 +1,11 @@
-import type { Flux, Operator } from '../types';
-/** Transform each emitted value through `fn`. */
-export declare function map<A, B>(fn: (value: A) => B): Operator<A, B>;
-/** Emit only values for which `predicate` returns `true`. */
+import type { Operator, Stream } from '../types';
+export type ConcatMapOptions = {
+    capacity: number;
+};
+export declare function map<A, B>(project: (value: A) => B): Operator<A, B>;
 export declare function filter<T>(predicate: (value: T) => boolean): Operator<T, T>;
-/**
- * Accumulate state with a reducer. Emits the accumulated value after each source emission.
- *
- * @example
- * of(1, 2, 3).pipe(scan((acc, n) => acc + n, 0)); // emits 1, 3, 6
- */
-export declare function scan<T, A>(reducer: (acc: A, value: T) => A, seed: A): Operator<T, A>;
-/**
- * Map each source value to an inner `Flux`, cancelling the previous inner on each new emission.
- * Useful for search-as-you-type, navigation, etc.
- */
-export declare function switchMap<A, B>(fn: (value: A) => Flux<B>): Operator<A, B>;
-/**
- * Map each source value to an inner `Flux`, merging all inner streams concurrently.
- * All inner subscriptions run simultaneously.
- */
-export declare function flatMap<A, B>(fn: (value: A) => Flux<B>): Operator<A, B>;
-/**
- * Map each source value to an inner `Flux`, subscribing to each one only after
- * the previous inner completes (sequential, queued).
- * Pass `maxBuffer` to cap queued items; excess items are dropped silently.
- */
-export declare function concatMap<A, B>(fn: (value: A) => Flux<B>, maxBuffer?: number): Operator<A, B>;
-/**
- * Suppress consecutive duplicate values.
- * Uses `Object.is` by default; provide a custom `comparator` for deep equality.
- *
- * @example
- * of(1, 1, 2, 2, 3).pipe(distinctUntilChanged()); // emits 1, 2, 3
- */
-export declare function distinctUntilChanged<T>(comparator?: (a: T, b: T) => boolean): Operator<T, T>;
-/**
- * Prepend one or more static values before the source's first emission.
- *
- * @example
- * of(2, 3).pipe(startWith(0, 1)).subscribe(console.log); // 0, 1, 2, 3
- */
-export declare function startWith<T>(...values: T[]): Operator<T, T>;
-/**
- * Collect source emissions into fixed-size arrays, emitting each batch when full.
- * A partial batch at the end of the source is flushed on completion.
- *
- * @param size - Number of emissions per batch.
- * @param every - Start a new batch every `every` emissions (default: `size`, non-overlapping).
- *
- * @example
- * of(1, 2, 3, 4, 5, 6).pipe(bufferCount(2)).subscribe(console.log);
- * // [1, 2], [3, 4], [5, 6]
- */
-export declare function bufferCount<T>(size: number, every?: number): Operator<T, T[]>;
-/**
- * Emit the previous and current value as a `[prev, curr]` tuple.
- * No emission occurs until the second source value arrives.
- *
- * @example
- * of(1, 2, 3).pipe(pairwise()).subscribe(console.log); // [1, 2], [2, 3]
- */
-export declare function pairwise<T>(): Operator<T, [T, T]>;
+export declare function scan<T, A>(reducer: (state: A, value: T) => A, initial: A): Operator<T, A>;
+export declare function switchMap<A, B>(project: (value: A) => Stream<B>): Operator<A, B>;
+export declare function mergeMap<A, B>(project: (value: A) => Stream<B>): Operator<A, B>;
+export declare function concatMap<A, B>(project: (value: A) => Stream<B>, options: ConcatMapOptions): Operator<A, B>;
 //# sourceMappingURL=transformation.d.ts.map

package/dist/operators/transformation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformation.d.ts","sourceRoot":"","sources":["../../src/operators/transformation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAe,MAAM,UAAU,CAAC;AAO5D,iDAAiD;AACjD,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAW7D;AAED,6DAA6D;AAC7D,wBAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAa1E;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAgBpF;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAoCzE;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAgDvE;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,SAAS,SAAW,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAwD/F;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAsB5F;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,CAAC,EAAE,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAO3D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CA8C7E;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAiBjD"}
+{"version":3,"file":"transformation.d.ts","sourceRoot":"","sources":["../../src/operators/transformation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAgB,MAAM,UAAU,CAAC;AAM/D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAgBlE;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAkB1E;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAoBzF;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAgDhF;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAgD/E;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,gBAAgB,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAsE3G"}

package/dist/operators/transformation.js

@@ -1,185 +1,134 @@
-import { warn as e } from "../_dev.js";
-import { flux as t } from "../core.js";
-import { guard as n } from "../_safe.js";
-import { clampPositiveInt as r } from "../_numeric.js";
+import { stream as e } from "../core.js";
+import { link as t } from "../_link.js";
+import { tryCall as n } from "../_safe.js";
 //#region src/operators/transformation.ts
-function i(e) {
-	return (r) => t((t) => r.subscribe({
-		complete: t.complete,
-		error: t.error,
-		next(r) {
-			n(() => t.next(e(r)), t.error);
+function r(r) {
+	return (i) => e((e, a) => t(i, {
+		complete: e.complete,
+		error: e.error,
+		next(t) {
+			n(() => e.next(r(t)), e.error);
 		}
-	}));
+	}, a).unsubscribe);
 }
-function a(e) {
-	return (r) => t((t) => r.subscribe({
-		complete: t.complete,
-		error: t.error,
-		next(r) {
+function i(r) {
+	return (i) => e((e, a) => t(i, {
+		complete: e.complete,
+		error: e.error,
+		next(t) {
 			n(() => {
-				e(r) && t.next(r);
-			}, t.error);
+				r(t) && e.next(t);
+			}, e.error);
 		}
-	}));
+	}, a).unsubscribe);
 }
-function o(e, r) {
-	return (i) => t((t) => {
-		let a = r;
-		return i.subscribe({
-			complete: t.complete,
-			error: t.error,
-			next(r) {
+function a(r, i) {
+	return (a) => e((e, o) => {
+		let s = i;
+		return t(a, {
+			complete: e.complete,
+			error: e.error,
+			next(t) {
 				n(() => {
-					a = e(a, r), t.next(a);
-				}, t.error);
+					s = r(s, t), e.next(s);
+				}, e.error);
 			}
-		});
+		}, o).unsubscribe;
 	});
 }
-function s(e) {
-	return (r) => t((t) => {
-		let i, a = !1, o = () => {
-			a && !i && t.complete?.();
-		}, s = r.subscribe({
+function o(r) {
+	return (i) => e((e, a) => {
+		let o = !1, s, c = () => {
+			o && !s && e.complete();
+		}, l = t(i, {
 			complete() {
-				a = !0, o();
+				o = !0, c();
 			},
-			error: t.error,
-			next(r) {
-				n(() => {
-					i?.(), i = e(r).subscribe({
+			error: e.error,
+			next(i) {
+				s?.unsubscribe(), s = void 0, n(() => {
+					let n = t(r(i), {
 						complete() {
-							i = void 0, o();
+							s = void 0, c();
 						},
-						error: t.error,
-						next: t.next
-					});
-				}, t.error);
+						error: e.error,
+						next: e.next
+					}, a);
+					s = n.closed ? void 0 : n;
+				}, e.error);
 			}
-		});
+		}, a);
 		return () => {
-			s(), i?.();
+			l.unsubscribe(), s?.unsubscribe();
 		};
 	});
 }
-function c(e) {
-	return (r) => t((t) => {
-		let i = !1, a = 0, o = /* @__PURE__ */ new Set(), s = () => {
-			i && a === 0 && t.complete?.();
-		}, c = r.subscribe({
+function s(r) {
+	return (i) => e((e, a) => {
+		let o = !1, s = /* @__PURE__ */ new Set(), c = () => {
+			o && s.size === 0 && e.complete();
+		}, l = t(i, {
 			complete() {
-				i = !0, s();
+				o = !0, c();
 			},
-			error: t.error,
-			next(r) {
+			error: e.error,
+			next(i) {
 				n(() => {
-					a++;
-					let n = !1, i = () => {};
-					i = e(r).subscribe({
+					let n = {};
+					n.current = t(r(i), {
 						complete() {
-							n = !0, a--, o.delete(i), s();
+							n.current && s.delete(n.current), c();
 						},
-						error: t.error,
-						next: t.next
-					}), n || o.add(i);
-				}, t.error);
+						error: e.error,
+						next: e.next
+					}, a), n.current.closed || s.add(n.current);
+				}, e.error);
 			}
-		});
+		}, a);
 		return () => {
-			c();
-			for (let e of o) e();
+			l.unsubscribe();
+			for (let e of s) e.unsubscribe();
 		};
 	});
 }
-function l(e, r = Infinity) {
-	return (i) => t((t) => {
-		let a = !1, o = [], s = !1, c;
-		function l() {
-			if (o.length === 0) {
-				s = !1, a && t.complete?.();
+function c(r, i) {
+	if (!Number.isInteger(i.capacity) || i.capacity < 1) throw RangeError("concatMap capacity must be a positive integer");
+	return (a) => e((e, o) => {
+		let s = [], c = !1, l, u = {}, d = () => {
+			if (l || s.length === 0) {
+				c && !l && s.length === 0 && e.complete();
 				return;
 			}
-			s = !0;
-			let r = o.shift();
+			let i = s.shift();
 			n(() => {
-				c = e(r).subscribe({
+				let n = t(r(i), {
 					complete() {
-						c = void 0, l();
+						l = void 0, d();
 					},
-					error: t.error,
-					next: t.next
-				});
-			}, t.error);
-		}
-		let u = i.subscribe({
-			complete() {
-				a = !0, s || t.complete?.();
-			},
-			error: t.error,
-			next(e) {
-				o.length < r && (o.push(e), s || l());
-			}
-		});
-		return () => {
-			u(), c?.(), o.length = 0;
+					error: e.error,
+					next: e.next
+				}, o);
+				l = n.closed ? void 0 : n, l || d();
+			}, e.error);
 		};
-	});
-}
-function u(e) {
-	let r = e ?? Object.is;
-	return (e) => t((t) => {
-		let i = !1, a;
-		return e.subscribe({
-			complete: t.complete,
-			error: t.error,
-			next(e) {
-				n(() => {
-					(!i || !r(a, e)) && (i = !0, a = e, t.next(e));
-				}, t.error);
-			}
-		});
-	});
-}
-function d(...e) {
-	return (n) => t((t) => {
-		for (let n of e) t.next(n);
-		return n.subscribe(t);
-	});
-}
-function f(n, i) {
-	let { clamped: a, value: o } = r(n), { clamped: s, value: c } = r(i ?? o);
-	return a && e(`bufferCount: size must be a finite integer >= 1, got ${n} — clamped to ${o}`), i !== void 0 && s && e(`bufferCount: every must be a finite integer >= 1, got ${i} — clamped to ${c}`), (e) => t((t) => {
-		let n = [], r = 0;
-		return e.subscribe({
+		return u.current = t(a, {
 			complete() {
-				for (let e of n) e.length > 0 && t.next(e);
-				t.complete?.();
+				c = !0, d();
 			},
-			error: t.error,
-			next(e) {
-				r % c === 0 && n.push([]);
-				for (let t of n) t.push(e);
-				let i = 0;
-				for (; i < n.length;) n[i].length >= o ? (t.next(n[i]), n.splice(i, 1)) : i++;
-				r++;
+			error: e.error,
+			next(t) {
+				if (s.length === i.capacity) {
+					u.current?.unsubscribe(), e.error(/* @__PURE__ */ RangeError("concatMap buffer capacity exceeded"));
+					return;
+				}
+				s.push(t), d();
 			}
-		});
-	});
-}
-function p() {
-	return (e) => t((t) => {
-		let n = !1, r;
-		return e.subscribe({
-			complete: t.complete,
-			error: t.error,
-			next(e) {
-				n && t.next([r, e]), n = !0, r = e;
-			}
-		});
+		}, o), () => {
+			u.current?.unsubscribe(), l?.unsubscribe(), s.length = 0;
+		};
 	});
 }
 //#endregion
-export { f as bufferCount, l as concatMap, u as distinctUntilChanged, a as filter, c as flatMap, i as map, p as pairwise, o as scan, d as startWith, s as switchMap };
+export { c as concatMap, i as filter, r as map, s as mergeMap, a as scan, o as switchMap };
 
 //# sourceMappingURL=transformation.js.map

package/dist/operators/transformation.js.map

@@ -1 +1 @@
-{"version":3,"file":"transformation.js","names":[],"sources":["../../src/operators/transformation.ts"],"sourcesContent":["import type { Flux, Operator, Unsubscribe } from '../types';\n\nimport { warn } from '../_dev';\nimport { clampPositiveInt } from '../_numeric';\nimport { guard } from '../_safe';\nimport { flux } from '../core';\n\n/** Transform each emitted value through `fn`. */\nexport function map<A, B>(fn: (value: A) => B): Operator<A, B> {\n  return (source) =>\n    flux<B>((observer) =>\n      source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          guard(() => observer.next(fn(v)), observer.error);\n        },\n      }),\n    );\n}\n\n/** Emit only values for which `predicate` returns `true`. */\nexport function filter<T>(predicate: (value: T) => boolean): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) =>\n      source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            if (predicate(v)) observer.next(v);\n          }, observer.error);\n        },\n      }),\n    );\n}\n\n/**\n * Accumulate state with a reducer. Emits the accumulated value after each source emission.\n *\n * @example\n * of(1, 2, 3).pipe(scan((acc, n) => acc + n, 0)); // emits 1, 3, 6\n */\nexport function scan<T, A>(reducer: (acc: A, value: T) => A, seed: A): Operator<T, A> {\n  return (source) =>\n    flux<A>((observer) => {\n      let acc = seed;\n\n      return source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            acc = reducer(acc, v);\n            observer.next(acc);\n          }, observer.error);\n        },\n      });\n    });\n}\n\n/**\n * Map each source value to an inner `Flux`, cancelling the previous inner on each new emission.\n * Useful for search-as-you-type, navigation, etc.\n */\nexport function switchMap<A, B>(fn: (value: A) => Flux<B>): Operator<A, B> {\n  return (source) =>\n    flux<B>((observer) => {\n      let innerUnsub: Unsubscribe | undefined;\n      let outerDone = false;\n\n      const checkDone = (): void => {\n        if (outerDone && !innerUnsub) observer.complete?.();\n      };\n\n      const outerUnsub = source.subscribe({\n        complete() {\n          outerDone = true;\n          checkDone();\n        },\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            innerUnsub?.();\n            innerUnsub = fn(v).subscribe({\n              complete() {\n                innerUnsub = undefined;\n                checkDone();\n              },\n              error: observer.error,\n              next: observer.next,\n            });\n          }, observer.error);\n        },\n      });\n\n      return () => {\n        outerUnsub();\n        innerUnsub?.();\n      };\n    });\n}\n\n/**\n * Map each source value to an inner `Flux`, merging all inner streams concurrently.\n * All inner subscriptions run simultaneously.\n */\nexport function flatMap<A, B>(fn: (value: A) => Flux<B>): Operator<A, B> {\n  return (source) =>\n    flux<B>((observer) => {\n      let outerDone = false;\n      let activeInner = 0;\n      const innerUnsubs = new Set<Unsubscribe>();\n\n      const checkDone = (): void => {\n        if (outerDone && activeInner === 0) observer.complete?.();\n      };\n\n      const outerUnsub = source.subscribe({\n        complete() {\n          outerDone = true;\n          checkDone();\n        },\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            activeInner++;\n\n            let syncDone = false;\n            // Init to NOOP to avoid TDZ if complete fires synchronously during subscribe().\n            let unsub: Unsubscribe = () => {};\n\n            const sub = fn(v).subscribe({\n              complete() {\n                syncDone = true;\n                activeInner--;\n                innerUnsubs.delete(unsub);\n                checkDone();\n              },\n              error: observer.error,\n              next: observer.next,\n            });\n\n            unsub = sub;\n\n            if (!syncDone) innerUnsubs.add(unsub);\n          }, observer.error);\n        },\n      });\n\n      return () => {\n        outerUnsub();\n        for (const u of innerUnsubs) u();\n      };\n    });\n}\n\n/**\n * Map each source value to an inner `Flux`, subscribing to each one only after\n * the previous inner completes (sequential, queued).\n * Pass `maxBuffer` to cap queued items; excess items are dropped silently.\n */\nexport function concatMap<A, B>(fn: (value: A) => Flux<B>, maxBuffer = Infinity): Operator<A, B> {\n  return (source) =>\n    flux<B>((observer) => {\n      let outerDone = false;\n      const queue: A[] = [];\n      let processing = false;\n      let currentUnsub: Unsubscribe | undefined;\n\n      function processNext(): void {\n        if (queue.length === 0) {\n          processing = false;\n\n          if (outerDone) observer.complete?.();\n\n          return;\n        }\n\n        processing = true;\n\n        const item = queue.shift()!;\n\n        guard(() => {\n          currentUnsub = fn(item).subscribe({\n            complete() {\n              currentUnsub = undefined;\n\n              processNext();\n            },\n            error: observer.error,\n            next: observer.next,\n          });\n        }, observer.error);\n      }\n\n      const outerUnsub = source.subscribe({\n        complete() {\n          outerDone = true;\n\n          if (!processing) observer.complete?.();\n        },\n        error: observer.error,\n        next(v) {\n          if (queue.length < maxBuffer) {\n            queue.push(v);\n\n            if (!processing) processNext();\n          }\n        },\n      });\n\n      return () => {\n        outerUnsub();\n        currentUnsub?.();\n        queue.length = 0;\n      };\n    });\n}\n\n/**\n * Suppress consecutive duplicate values.\n * Uses `Object.is` by default; provide a custom `comparator` for deep equality.\n *\n * @example\n * of(1, 1, 2, 2, 3).pipe(distinctUntilChanged()); // emits 1, 2, 3\n */\nexport function distinctUntilChanged<T>(comparator?: (a: T, b: T) => boolean): Operator<T, T> {\n  const eq = comparator ?? Object.is;\n\n  return (source) =>\n    flux<T>((observer) => {\n      let hasPrev = false;\n      let prev: T;\n\n      return source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          guard(() => {\n            if (!hasPrev || !eq(prev, v)) {\n              hasPrev = true;\n              prev = v;\n              observer.next(v);\n            }\n          }, observer.error);\n        },\n      });\n    });\n}\n\n/**\n * Prepend one or more static values before the source's first emission.\n *\n * @example\n * of(2, 3).pipe(startWith(0, 1)).subscribe(console.log); // 0, 1, 2, 3\n */\nexport function startWith<T>(...values: T[]): Operator<T, T> {\n  return (source) =>\n    flux<T>((observer) => {\n      for (const v of values) observer.next(v);\n\n      return source.subscribe(observer);\n    });\n}\n\n/**\n * Collect source emissions into fixed-size arrays, emitting each batch when full.\n * A partial batch at the end of the source is flushed on completion.\n *\n * @param size - Number of emissions per batch.\n * @param every - Start a new batch every `every` emissions (default: `size`, non-overlapping).\n *\n * @example\n * of(1, 2, 3, 4, 5, 6).pipe(bufferCount(2)).subscribe(console.log);\n * // [1, 2], [3, 4], [5, 6]\n */\nexport function bufferCount<T>(size: number, every?: number): Operator<T, T[]> {\n  const { clamped: sizeClamped, value: safeSize } = clampPositiveInt(size);\n  const { clamped: everyClamped, value: step } = clampPositiveInt(every ?? safeSize);\n\n  if (sizeClamped) {\n    warn(`bufferCount: size must be a finite integer >= 1, got ${size} — clamped to ${safeSize}`);\n  }\n\n  if (every !== undefined && everyClamped) {\n    warn(`bufferCount: every must be a finite integer >= 1, got ${every} — clamped to ${step}`);\n  }\n\n  return (source) =>\n    flux<T[]>((observer) => {\n      const buffers: T[][] = [];\n      let count = 0;\n\n      return source.subscribe({\n        complete() {\n          for (const buf of buffers) {\n            if (buf.length > 0) observer.next(buf);\n          }\n\n          observer.complete?.();\n        },\n        error: observer.error,\n        next(v) {\n          if (count % step === 0) buffers.push([]);\n\n          for (const buf of buffers) buf.push(v);\n\n          let i = 0;\n\n          while (i < buffers.length) {\n            if (buffers[i]!.length >= safeSize) {\n              observer.next(buffers[i]!);\n              buffers.splice(i, 1);\n            } else {\n              i++;\n            }\n          }\n\n          count++;\n        },\n      });\n    });\n}\n\n/**\n * Emit the previous and current value as a `[prev, curr]` tuple.\n * No emission occurs until the second source value arrives.\n *\n * @example\n * of(1, 2, 3).pipe(pairwise()).subscribe(console.log); // [1, 2], [2, 3]\n */\nexport function pairwise<T>(): Operator<T, [T, T]> {\n  return (source) =>\n    flux<[T, T]>((observer) => {\n      let hasPrev = false;\n      let prev: T;\n\n      return source.subscribe({\n        complete: observer.complete,\n        error: observer.error,\n        next(v) {\n          if (hasPrev) observer.next([prev, v]);\n\n          hasPrev = true;\n          prev = v;\n        },\n      });\n    });\n}\n"],"mappings":"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"}
+{"version":3,"file":"transformation.js","names":[],"sources":["../../src/operators/transformation.ts"],"sourcesContent":["import type { Operator, Stream, Subscription } from '../types';\n\nimport { link } from '../_link';\nimport { tryCall } from '../_safe';\nimport { stream } from '../core';\n\nexport type ConcatMapOptions = {\n  capacity: number;\n};\n\nexport function map<A, B>(project: (value: A) => B): Operator<A, B> {\n  return (source) =>\n    stream(\n      (sink, signal) =>\n        link(\n          source,\n          {\n            complete: sink.complete,\n            error: sink.error,\n            next(value) {\n              tryCall(() => sink.next(project(value)), sink.error);\n            },\n          },\n          signal,\n        ).unsubscribe,\n    );\n}\n\nexport function filter<T>(predicate: (value: T) => boolean): Operator<T, T> {\n  return (source) =>\n    stream(\n      (sink, signal) =>\n        link(\n          source,\n          {\n            complete: sink.complete,\n            error: sink.error,\n            next(value) {\n              tryCall(() => {\n                if (predicate(value)) sink.next(value);\n              }, sink.error);\n            },\n          },\n          signal,\n        ).unsubscribe,\n    );\n}\n\nexport function scan<T, A>(reducer: (state: A, value: T) => A, initial: A): Operator<T, A> {\n  return (source) =>\n    stream((sink, signal) => {\n      let state = initial;\n\n      return link(\n        source,\n        {\n          complete: sink.complete,\n          error: sink.error,\n          next(value) {\n            tryCall(() => {\n              state = reducer(state, value);\n              sink.next(state);\n            }, sink.error);\n          },\n        },\n        signal,\n      ).unsubscribe;\n    });\n}\n\nexport function switchMap<A, B>(project: (value: A) => Stream<B>): Operator<A, B> {\n  return (source) =>\n    stream((sink, signal) => {\n      let outerComplete = false;\n      let inner: Subscription | undefined;\n\n      const finish = (): void => {\n        if (outerComplete && !inner) sink.complete();\n      };\n\n      const outer = link(\n        source,\n        {\n          complete() {\n            outerComplete = true;\n            finish();\n          },\n          error: sink.error,\n          next(value) {\n            inner?.unsubscribe();\n            inner = undefined;\n\n            tryCall(() => {\n              const subscription = link(\n                project(value),\n                {\n                  complete() {\n                    inner = undefined;\n                    finish();\n                  },\n                  error: sink.error,\n                  next: sink.next,\n                },\n                signal,\n              );\n\n              inner = subscription.closed ? undefined : subscription;\n            }, sink.error);\n          },\n        },\n        signal,\n      );\n\n      return () => {\n        outer.unsubscribe();\n        inner?.unsubscribe();\n      };\n    });\n}\n\nexport function mergeMap<A, B>(project: (value: A) => Stream<B>): Operator<A, B> {\n  return (source) =>\n    stream((sink, signal) => {\n      let outerComplete = false;\n      const inners = new Set<Subscription>();\n\n      const finish = (): void => {\n        if (outerComplete && inners.size === 0) sink.complete();\n      };\n\n      const outer = link(\n        source,\n        {\n          complete() {\n            outerComplete = true;\n            finish();\n          },\n          error: sink.error,\n          next(value) {\n            tryCall(() => {\n              const innerRef: { current?: Subscription } = {};\n\n              innerRef.current = link(\n                project(value),\n                {\n                  complete() {\n                    if (innerRef.current) inners.delete(innerRef.current);\n\n                    finish();\n                  },\n                  error: sink.error,\n                  next: sink.next,\n                },\n                signal,\n              );\n\n              if (!innerRef.current.closed) inners.add(innerRef.current);\n            }, sink.error);\n          },\n        },\n        signal,\n      );\n\n      return () => {\n        outer.unsubscribe();\n        for (const inner of inners) inner.unsubscribe();\n      };\n    });\n}\n\nexport function concatMap<A, B>(project: (value: A) => Stream<B>, options: ConcatMapOptions): Operator<A, B> {\n  if (!Number.isInteger(options.capacity) || options.capacity < 1) {\n    throw new RangeError('concatMap capacity must be a positive integer');\n  }\n\n  return (source) =>\n    stream((sink, signal) => {\n      const queue: A[] = [];\n      let outerComplete = false;\n      let inner: Subscription | undefined;\n      const outerRef: { current?: Subscription } = {};\n\n      const next = (): void => {\n        if (inner || queue.length === 0) {\n          if (outerComplete && !inner && queue.length === 0) sink.complete();\n\n          return;\n        }\n\n        const value = queue.shift()!;\n\n        tryCall(() => {\n          const subscription = link(\n            project(value),\n            {\n              complete() {\n                inner = undefined;\n                next();\n              },\n              error: sink.error,\n              next: sink.next,\n            },\n            signal,\n          );\n\n          inner = subscription.closed ? undefined : subscription;\n\n          if (!inner) next();\n        }, sink.error);\n      };\n\n      outerRef.current = link(\n        source,\n        {\n          complete() {\n            outerComplete = true;\n            next();\n          },\n          error: sink.error,\n          next(value) {\n            if (queue.length === options.capacity) {\n              outerRef.current?.unsubscribe();\n              sink.error(new RangeError('concatMap buffer capacity exceeded'));\n\n              return;\n            }\n\n            queue.push(value);\n            next();\n          },\n        },\n        signal,\n      );\n\n      return () => {\n        outerRef.current?.unsubscribe();\n        inner?.unsubscribe();\n        queue.length = 0;\n      };\n    });\n}\n"],"mappings":"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"}

package/dist/operators/utility.cjs

@@ -1,2 +1,2 @@
-const e=require("../_dev.cjs"),t=require("../core.cjs"),n=require("../_scheduler.cjs"),r=require("../errors.cjs"),i=require("../_safe.cjs"),a=require("../_numeric.cjs");function o(e,n){let r=new Set,i=[],a,o=!1,s,c=!1;return t.flux(t=>{if(c){t.error?.(s);return}for(let e of i)t.next(e);if(o){t.complete?.();return}let l={complete:t.complete,error:t.error,next:t.next};return r.add(l),r.size===1&&(a=e.subscribe({complete(){o=!0;for(let e of[...r])e.complete?.();r.clear()},error(e){c=!0,s=e;for(let t of[...r])t.error?.(e);r.clear()},next(e){n>0&&(i.length>=n&&i.shift(),i.push(e));for(let t of[...r])t.next(e)}})),()=>{r.delete(l),r.size===0&&(a?.(),a=void 0)}})}function s(){return e=>o(e,0)}function c(t=1){let{clamped:n,value:r}=a.clampPositiveInt(t);return n&&e.warn(`shareReplay: bufferSize must be a finite integer >= 1, got ${t} — clamped to ${r}`),e=>o(e,r)}function l(e){return n=>t.flux(t=>n.subscribe({complete:t.complete,error:t.error,next(n){i.guard(()=>{e(n),t.next(n)},t.error)}}))}function u(e,r=n.DEFAULT_SCHEDULER){return n=>t.flux(t=>{let i=[],a=n.subscribe({complete(){i.push(r.delay(()=>t.complete?.(),e))},error:t.error,next(n){i.push(r.delay(()=>t.next(n),e))}});return()=>{a();for(let e of i)e()}})}function d(e,i=n.DEFAULT_SCHEDULER){return n=>t.flux(t=>{let a,o=()=>{a=i.delay(()=>{t.error?.(new r.FluxTimeoutError(e))},e)};o();let s=n.subscribe({complete(){a(),t.complete?.()},error(e){a(),t.error?.(e)},next(e){a(),o(),t.next(e)}});return()=>{a(),s()}})}function f(e){return n=>t.flux(t=>{let r,a=n.subscribe({complete:t.complete,error(n){i.guard(()=>{r=e(n).subscribe({complete:t.complete,error:t.error,next:t.next})},t.error)},next:t.next});return()=>{a(),r?.()}})}function p(e,r,a=n.DEFAULT_SCHEDULER){return n=>t.flux(t=>{let o=0,s,c;function l(){s=n.subscribe({complete:t.complete,error(n){if(o<e){let e=o++;r===void 0?l():i.guard(()=>{let t=typeof r==`function`?r(e):r;c=a.delay(l,Math.max(0,t))},t.error)}else t.error?.(n)},next:t.next})}return l(),()=>{c?.(),s?.()}})}function m(n){return r=>t.flux(t=>{let i=!1,a=()=>{if(!i){i=!0;try{n()}catch(t){e.error(`finalize: cleanup callback threw`,t)}}},o=r.subscribe({complete(){a(),t.complete?.()},error(e){a(),t.error?.(e)},next:t.next});return()=>{a(),o()}})}function h(e){return e.reason??new DOMException(`Aborted`,`AbortError`)}function g(e,t){return new Promise((n,r)=>{if(t?.aborted){r(h(t));return}let i,a=()=>{},o=()=>{a(),r(h(t))};t?.addEventListener(`abort`,o,{once:!0}),a=e.subscribe({complete(){t?.removeEventListener(`abort`,o),n(i)},error(e){t?.removeEventListener(`abort`,o),r(e)},next(e){i=e}})})}function _(e,t){return new Promise((n,r)=>{let i=[];if(t?.aborted){n(i);return}let a=()=>{},o=()=>{a(),n(i)};t?.addEventListener(`abort`,o,{once:!0}),a=e.subscribe({complete(){t?.removeEventListener(`abort`,o),n(i)},error(e){t?.removeEventListener(`abort`,o),r(e)},next(e){i.push(e)}})})}function v(...e){return t=>e.reduce((e,t)=>t(e),t)}exports.catchError=f,exports.delay=u,exports.finalize=m,exports.flow=v,exports.retry=p,exports.share=s,exports.shareReplay=c,exports.tap=l,exports.timeout=d,exports.toArray=_,exports.toPromise=g;
+const e=require("../core.cjs"),t=require("../_link.cjs"),n=require("../_safe.cjs"),r=require("../_scheduler.cjs");function i(){return new DOMException(`Stream consumption aborted`,`AbortError`)}function a(i){if(!Number.isInteger(i.attempts)||i.attempts<0)throw RangeError(`retry attempts must be a non-negative integer`);return a=>e.stream((e,o)=>{let s=0,c,l,u=()=>{if(o.aborted)return;let d=t.link(a,{complete:e.complete,error(t){if(s===i.attempts){e.error(t);return}let a=s++,c;if(n.tryCall(()=>{c=typeof i.delay==`function`?i.delay(a):i.delay},e.error),!o.aborted){if(c!==void 0&&(!Number.isFinite(c)||c<0)){e.error(RangeError(`retry delay must be a finite number greater than or equal to zero`));return}c===void 0||c===0?queueMicrotask(u):l=r.defaultScheduler.delay(u,c)}},next:e.next},o);d.closed||(c=d)};return u(),()=>{l?.(),c?.unsubscribe()}})}function o(e,n){return new Promise((r,a)=>{let o=new AbortController,s=()=>{o.abort(),a(i())};if(n?.signal?.aborted){s();return}n?.signal?.addEventListener(`abort`,s,{once:!0}),t.link(e,{error(e){n?.signal?.removeEventListener(`abort`,s),a(e)},next(e){n?.signal?.removeEventListener(`abort`,s),o.abort(),r(e)}},o.signal)})}function s(e,n){return new Promise((r,a)=>{let o=()=>a(i()),s;if(n?.signal?.aborted){o();return}n?.signal?.addEventListener(`abort`,o,{once:!0}),t.link(e,{complete(){n?.signal?.removeEventListener(`abort`,o),r(s)},error(e){n?.signal?.removeEventListener(`abort`,o),a(e)},next(e){s=e}},n?.signal??new AbortController().signal)})}function c(e,n){if(!Number.isInteger(n.maxItems)||n.maxItems<0)throw RangeError(`toArray maxItems must be a non-negative integer`);return new Promise((r,a)=>{let o=new AbortController,s=[],c=()=>{o.abort(),a(i())};if(n.signal?.aborted){c();return}n.signal?.addEventListener(`abort`,c,{once:!0}),t.link(e,{complete(){n.signal?.removeEventListener(`abort`,c),r(s)},error(e){n.signal?.removeEventListener(`abort`,c),a(e)},next(e){if(s.length===n.maxItems){n.signal?.removeEventListener(`abort`,c),o.abort(),a(RangeError(`toArray maxItems exceeded`));return}s.push(e)}},o.signal)})}exports.first=o,exports.last=s,exports.retry=a,exports.toArray=c;
 //# sourceMappingURL=utility.cjs.map