{"version":3,"sources":["/home/runner/work/flowp/flowp/dist/index.cjs","../src/promise/delegate.ts","../src/promise/timer.ts","../src/promise/future.ts","../src/promise/progress.ts","../src/promise/barrier.ts","../src/protocol/pipeable.ts","../src/utils/functools.ts","../src/control/semaphore.ts","../src/utils/borrow.ts","../src/control/mutex.ts","../src/control/channel.ts","../src/control/channel_hub.ts"],"names":["timeout","to"],"mappings":"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","file":"/home/runner/work/flowp/flowp/dist/index.cjs","sourcesContent":[null,"import type { Callable } from '../types'\n\n/**\n * @internal\n */\nexport type Delegated<T> = (Awaited<T> extends Callable\n  ? // @ts-expect-error ts cannot infer Awaited<T> here\n    (...args: Parameters<Awaited<T>>) => ReturnType<Awaited<T>>\n  : {\n      readonly [K in keyof Awaited<T> & string as `$${K}`]: Delegated<Awaited<T>[K]>\n    }) &\n  Promise<Awaited<T>>\n\nfunction isPromiseProtoMethods(\n  v: any\n): v is typeof Promise.prototype.then | typeof Promise.prototype.catch | typeof Promise.prototype.finally {\n  return v === Promise.prototype.then || v === Promise.prototype.catch || v === Promise.prototype.finally\n}\n\nconst raw = Symbol('get the raw untouched value')\n\n/**\n * Delegates method calls and member access to the resolved value\n *\n * @alpha not verified in production use\n * @param value - value to delegate to, must be a promise and should not be resolved with primitives\n * @returns the delegated object, access delegated properties with `${key}`\n * @example\n * ```typescript\n * const promise = Promise.resolve({ foo: { bar: 'baz' } })\n * const delegated = delegate(promise)\n * await delegated.$foo.$bar // 'baz'\n * ```\n */\nexport function delegate<T extends Promise<unknown>>(value: T): Delegated<T> {\n  // proxy on a function so the returned value is callable\n  return new Proxy(new Function() as unknown as T, {\n    get(_, key, receiver) {\n      if (key === raw) return value\n      if (typeof key === 'string' && key.startsWith('$')) {\n        return delegate(\n          value.then((v) => {\n            // FIXME: pass unit test\n            // if (typeof v !== 'object' || typeof v !== 'function') throw new Error('Cound not delegate primitives')\n            return Reflect.get(v as any, key.slice(1))\n          })\n        )\n      }\n      const prop = Reflect.get(value, key, receiver)\n      if (isPromiseProtoMethods(prop)) {\n        // wrap then methods otherwise TypeError will be thrown\n        // TypeError: Method Promise.prototype.then called on incompatible receiver function () { }\n        return (...args: unknown[]) => Reflect.apply(prop, value, args)\n      }\n      return prop\n    },\n    apply(_, thisPromise, args) {\n      return (async () => {\n        const thisArg = await thisPromise?.[raw]\n        const fn = (await value) as Callable\n        return Reflect.apply(fn, thisArg, args)\n      })()\n    },\n  }) as T & Delegated<T>\n}\n","/**\n * util.promisify only works on browser\n *\n * @public\n */\n\nexport interface SleepTimer {\n  (ms: number): Promise<void>\n  <T>(ms: number, value: T): Promise<T>\n}\n\n/**\n * **resolve** after timeout (in miliseconds), can pass in an optional resolved value\n *\n * @public\n */\nexport const sleep: SleepTimer = <T = unknown>(ms: number, value?: T) => {\n  return new Promise<T>((r) => {\n    setTimeout(() => r(value!), ms)\n  })\n}\n\n/**\n * **reject** after timeout (in miliseconds)\n *\n * By default, reject with `Error('timeout')`, but can pass in an optional rejected value\n *\n * @public\n */\nexport const timeout = (ms: number, err?: string | Error) => {\n  return new Promise((_, r) => {\n    setTimeout(() => r(err ?? new Error('timeout')), ms)\n  })\n}\n\n/**\n * **resolve** with given value immediately (aka. setImmediate)\n *\n * @public\n */\nexport const immediately = <T>(value?: T): Promise<T | undefined> => {\n  return new Promise((r) => {\n    setImmediate(() => r(value))\n  })\n}\n","const pending = Symbol('pending')\nconst fulfilled = Symbol('fulfilled')\nconst rejected = Symbol('rejected')\n\n/**\n * Future is a resolve-later Promise, you can resolve it any time after a future is created.\n *\n * @public this feature is stable and is guaranteed to not have breaking change before v1.0.0\n * @example\n *\n * ```typescript\n * const future = new Future<number>()\n * // somewhere\n * const count = await future\n * // elsewhere, and the future becomes `fullfilled`\n * future.resolve(count)\n * ```\n */\nexport class Future<T = unknown> extends Promise<T> {\n  private static _constructors: [(value: any | PromiseLike<any>) => void, (error: unknown) => void][] = []\n  protected _resolve: (value: T | PromiseLike<T>) => void\n  protected _reject: (error: unknown) => void\n  protected promiseState = pending\n  protected settledValue?: T | unknown\n\n  public static get [Symbol.species]() {\n    return Promise\n  }\n\n  public constructor() {\n    // executor is called immediately in Promise constructor\n    // https://tc39.es/ecma262/#sec-promise-executor\n    super((resolve, reject) => {\n      // since `this` is not accessible before super() finished\n      Future._constructors.push([resolve, reject])\n    })\n    ;[this._resolve, this._reject] = Future._constructors.pop()!\n  }\n\n  /**\n   * resolve the future with given value\n   *\n   * tips: the method has already bound to `this`, so you can write `emitter.on('event', future.resolve)`\n   */\n  public get resolve(): (value: T | PromiseLike<T>) => void {\n    return (value) => {\n      if (this.pending) {\n        this.promiseState = fulfilled\n        this.settledValue = value\n        this._resolve(value)\n      }\n    }\n  }\n\n  /**\n   * reject the future with given value.\n   *\n   * the method has already bound to `this`, so you can write `emitter.on('error', future.reject)`\n   */\n  public get reject(): (error?: unknown) => void {\n    return (error) => {\n      if (this.pending) {\n        this.promiseState = rejected\n        this.settledValue = error\n        // catch UnhandledRejection\n        this.catch(() => {})\n        this._reject(error)\n      }\n    }\n  }\n\n  /**\n   * check if the promise is neither fulfilled nor rejected\n   */\n  public get pending() {\n    return this.promiseState === pending\n  }\n\n  /**\n   * check if future has been fullfilled.\n   */\n  public get fulfilled() {\n    return this.promiseState === fulfilled\n  }\n\n  /**\n   * check if future has been rejected.\n   */\n  public get rejected() {\n    return this.promiseState === rejected\n  }\n\n  /**\n   * get the promise settled result, for debug purpose only.\n   */\n  public get settled() {\n    return this.settledValue\n  }\n}\n","import { Future } from './future'\n\n/**\n * @internal\n */\nexport type ProgressInspectionResult<Result, Progress> =\n  | {\n      state: 'pending'\n      progress: Progress\n    }\n  | {\n      state: 'fulfilled'\n      value: Result\n    }\n  | {\n      state: 'rejected'\n      reason: unknown\n    }\n\n/**\n * Create a promise, but with progress reporting\n *\n * @beta\n * @typeParam Result - type of the progress's fulfilled value\n * @typeParam CurrentProgress - type of current progress used in p.report or p.progress\n */\nexport class Progress<Result = unknown, CurrentProgress = unknown> extends Future<Result> {\n  /**\n   * creates a new progress object and runs the given function with the progress as parameter,\n   * returns the created progress object.\n   *\n   * the function should report progress and call `progress.resolve` / `progress.reject` once done.\n   *\n   * @example\n   * ```typescript\n   * Progress.run((progress) => {\n   *   progress.report(100)\n   *   progress.resolve('hello')\n   * }, 0)\n   * ```\n   */\n  public static run<Result = unknown, CurrentProgress = unknown>(\n    fn: (progress: Progress<Result, CurrentProgress>) => unknown,\n    initialProgress: CurrentProgress\n  ): Progress<Result, CurrentProgress> {\n    const progress = new Progress<Result, CurrentProgress>(initialProgress)\n    fn(progress)\n    return progress\n  }\n\n  private currentProgress: CurrentProgress\n  private listeners: Set<(progress: CurrentProgress) => unknown> = new Set()\n\n  /**\n   * create a promise, but with progress reporting.\n   */\n  public constructor(initialProgress: CurrentProgress) {\n    super()\n    this.currentProgress = initialProgress\n  }\n\n  /**\n   * get last reported progress (despite current progress state)\n   */\n  public get progress(): CurrentProgress {\n    return this.currentProgress\n  }\n\n  /**\n   * inspect the current progress, for debug purpose only.\n   */\n  public inspect(): ProgressInspectionResult<Result, CurrentProgress> {\n    return this.pending\n      ? {\n          state: 'pending',\n          progress: this.currentProgress,\n        }\n      : this.fulfilled\n      ? {\n          state: 'fulfilled',\n          value: this.settledValue as Result,\n        }\n      : {\n          state: 'rejected',\n          reason: this.settledValue,\n        }\n  }\n\n  /**\n   * register a listener on progress report, and use the returned function to cancel listening.\n   *\n   * listeners won't receive messages on progress rejection\n   */\n  public onProgress(listener: (progress: Readonly<CurrentProgress>) => unknown) {\n    this.listeners.add(listener)\n    return () => this.listeners.delete(listener)\n  }\n\n  /**\n   * report current progress\n   *\n   * no-op if progress has already fulfilled or rejected\n   */\n  public report(progress: CurrentProgress) {\n    if (!this.pending) return\n    this.currentProgress = progress\n    this.listeners.forEach((callback) => callback(progress))\n  }\n}\n","import { Future } from './future'\n\n/**\n * Barrier is a one-time signal that can be used in like ready states, close events etc.\n *\n * it's basically a special type of promise with no resolve value and will never reject.\n *\n * @example\n * ```\n * const serverReady = new Barrier()\n * server.on('listening', () => barrier.unlock())\n * await serverReady\n * ```\n *\n * @public\n */\nexport class Barrier implements PromiseLike<void> {\n  private future: Future<void>\n  public constructor() {\n    this.future = new Future<void>()\n  }\n  public unlock() {\n    this.future.resolve()\n  }\n  public get unlocked() {\n    return this.future.fulfilled\n  }\n  public then<TResult1 = void, TResult2 = never>(\n    onfulfilled?: (() => TResult1 | PromiseLike<TResult1>) | null | undefined,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined\n  ): PromiseLike<TResult1 | TResult2> {\n    return this.future.then(onfulfilled).catch(onrejected)\n  }\n}\n","/**\n * @internal\n */\nexport const read = Symbol('pipeable')\n\n/**\n * a pipe source should be able to write its output to a pipe target\n *\n * @public\n */\nexport interface PipeSource<T> {\n  pipe: (target: PipeTarget<T>) => void\n  unpipe: () => void\n}\n\n/**\n * a pipe target can receive data from a pipe source\n *\n * @public\n */\nexport interface PipeTarget<T, S = PipeSource<T>> {\n  [read]: (value: T, source?: S) => void\n}\n\n/**\n * @public\n */\nexport interface Pipe<TIn, TOut> extends PipeTarget<TIn>, PipeSource<TOut> {}\n\n/**\n * @public\n */\nexport class Transform<TIn, TOut> implements PipeTarget<TIn, PipeSource<TIn>>, PipeSource<TOut> {\n  public handler: (value: TIn, source?: PipeSource<TIn>) => TOut\n  private target: PipeTarget<TOut> | null = null\n\n  /**\n   * creates a pipe that transforms data from `TIn` to `TOut`\n   * @param handler - transform data in pipe\n   */\n  public constructor(handler: (value: TIn) => TOut) {\n    this.handler = handler\n  }\n\n  public pipe(target: PipeTarget<TOut>): void {\n    this.target = target\n  }\n\n  public unpipe(): void {\n    this.target = null\n  }\n\n  /**\n   * @internal\n   */\n  public [read](value: TIn, source?: PipeSource<TIn>): void {\n    this.target?.[read](this.handler(value, source), this)\n  }\n}\n\n/**\n * @public\n */\nconst to = <T>(fn: (v: T, s?: PipeSource<T>) => any): PipeTarget<T> => {\n  return { [read]: fn }\n}\n\n/**\n * @public\n */\nexport type ConsoleLevel = 'debug' | 'log' | 'warn' | 'error'\n/* c8 ignore next 3 */\nto.console = (level: ConsoleLevel = 'log') => {\n  return { [read]: console[level] }\n}\n/* c8 ignore start */\n// don't know why c8 is reporting an empty line :(\nexport { to }\n/* c8 ignore end */\n","import type { Callable } from '../types'\n\n/**\n * ensure function to be called once, and only once\n *\n * note: `this` is dropped\n * @param fn - the function to call for the first time\n * @param subsequent - the function to call after the first one\n * @returns function that will call `fn` for the first time, and then `subsequent`\n */\nexport function once<T extends Callable>(\n  fn: T & ThisType<null>,\n  subsequent?: (lastResult: ReturnType<T>, ...args: Parameters<T>) => any\n): T {\n  let called = false\n  let lastResult: ReturnType<T>\n  return ((...args: Parameters<T>) => {\n    if (!called) {\n      called = true\n      lastResult = Reflect.apply(fn, null, args)\n      return lastResult\n    }\n    if (subsequent) {\n      return Reflect.apply(subsequent, null, [lastResult, ...args])\n    }\n  }) as T\n}\n","import { once } from '../utils/functools'\nimport { Future } from '../promise'\n\n/**\n * Semaphore with async api\n * @param permits - number of permits\n * @public\n *\n * @example\n * const sem = new Semaphore(5)\n * const release = await sem.acquire()\n * // do something\n * release()\n */\nexport class Semaphore {\n  /**\n   * check if semaphore is frozen (non-undefined value), other uses are not guaranteed\n   */\n  public frozen?: Future<void>\n  private _permits: number\n  // the first {permits} items in the queue are running tasks or frozen, others are waiting\n  private queue: Future<void>[] = []\n\n  /**\n   * constructs a new Semaphore with n permits\n   * @param permits - number of permits\n   */\n  public constructor(permits?: number) {\n    this._permits = permits ?? Infinity\n  }\n\n  /**\n   * Acquire a permit, resolve when resouce is available.\n   * @returns a function to release semaphore\n   */\n  public async acquire(timeout?: number) {\n    const self = new Future<void>()\n\n    if (!Number.isFinite(timeout) || timeout === undefined) {\n      // continue\n    } else if (timeout >= 0) {\n      setTimeout(() => {\n        self.reject(new Error('timeout'))\n        this.resolveNext()\n        this.remove(self)\n      }, timeout)\n    } else {\n      throw new Error('timeout must be non-negative')\n    }\n    this.queue.push(self)\n\n    // throw if self.reject because of timeout\n    // otherwise wait frozen & self are all ready\n    if (this.queue.length > this._permits || this.frozen) {\n      if (this.frozen) await Promise.all([self, this.frozen])\n      else await self\n    }\n\n    return this.releaser(self)\n  }\n\n  /**\n   * Try to synchronosly acquire if there's remaining permits\n   * @returns a function to release the semaphore\n   * @throws Error if semaphore is drained\n   */\n  public tryAcquire() {\n    if (this.queue.length < this._permits && !this.frozen) {\n      const self = new Future<void>()\n      this.queue.push(self)\n      return this.releaser(self)\n    }\n    throw new Error(\"can't acquire semaphore\")\n  }\n\n  /**\n   * Schedule a task to run when a permit is available and automatically release after run.\n   */\n  public async schedule<T>(fn: () => T): Promise<Awaited<T>> {\n    const release = await this.acquire()\n    try {\n      const res = await fn()\n      release()\n      return res\n    } finally {\n      release()\n    }\n  }\n\n  /**\n   * Give n permits to the semaphore, will immediately start this number of waiting tasks if not frozen\n   * @param permits - number of permits\n   * @throws RangeError - if permits is less than 0\n   */\n  public grant(permits = 1) {\n    if (permits < 0) throw RangeError('permits must be positive')\n    this.resolveNext(permits)\n    this._permits += permits\n  }\n\n  /**\n   * Destroy n permits, effective until `remain` fills the n permits\n   *\n   * **note**: you may need to check if `permits > semaphore.permits`, or it will wait until granted that many permits\n   * @param permits - number of permits\n   * @throws RangeError - if permits is less than 0\n   */\n  public async revoke(permits = 1) {\n    if (permits < 0) throw new Error('permits must be positive')\n    // if n is Infinity, will wait until all running tasks are released\n    const tokens = Array.from({ length: Number.isFinite(permits) ? permits : this.queue.length })\n      .fill(0)\n      .map(() => this.acquire())\n    const release = await Promise.all(tokens)\n    if (!Number.isFinite(permits)) {\n      this._permits = 0\n    } else {\n      this._permits -= permits\n    }\n    release.forEach((r) => r())\n  }\n\n  /**\n   * Freeze this semaphore, calling `acquire` won't resolve and `tryAcquire` will throw (release can still be called).\n   *\n   * NOTE: don't call this again if {@link Semaphore.frozen}, not supported yet\n   */\n  public freeze() {\n    this.frozen = new Future<void>()\n  }\n\n  /**\n   * unfreeze this semaphore, it is synchronos and the returned value should be ignored\n   * @returns a promise that's already resolved you can add a\n   */\n  public unfreeze(): Promise<void> {\n    if (!this.frozen) return Promise.resolve()\n\n    const frozen = this.frozen\n    this.frozen = undefined\n    // this will trigger all promises\n    frozen?.resolve()\n    return frozen\n  }\n\n  /**\n   * Get the number of remaining permits\n   */\n  public get remain() {\n    return Math.max(this._permits - this.queue.length, 0)\n  }\n\n  /**\n   * Get the number of total permits currently\n   */\n  public get permits() {\n    return this._permits\n  }\n\n  /**\n   * Check if all permits are being used\n   *\n   * always return `true` if `permits = 0`\n   */\n  public get isFull() {\n    return this.queue.length >= this._permits\n  }\n\n  /**\n   * Check if no task is using the semaphore'\n   *\n   * always return `true` if `permits = 0`\n   */\n  public get isEmpty() {\n    return this.queue.length === 0 || this.permits === 0\n  }\n\n  private releaser(token: Future<void>) {\n    // return a function to release semaphore\n    // should not provide `release` on semaphore instance because the order of `release` is not guaranteed\n    return once(() => {\n      this.resolveNext()\n      this.remove(token)\n    })\n  }\n\n  /**\n   * resolves next n values in the queue.\n   *\n   * If semaphore is frozen, wait for `frozen` to resolve first.\n   * These queued items are although the first _permits_ elements in the queue, they are not resolved.\n   */\n  private async resolveNext(count = 1) {\n    for (let i = this._permits; i < this._permits + count; i++) {\n      if (this.frozen) {\n        this.frozen.then(() => this.queue.at(i)?.resolve())\n      } else {\n        this.queue.at(i)?.resolve()\n      }\n    }\n  }\n\n  private remove(token: Future<void>) {\n    const index = this.queue.indexOf(token)\n    // this is already removed, do nothing\n    /* c8 ignore start */\n    if (index === -1) return\n    /* c8 ignore end */\n\n    this.queue.splice(index, 1)\n  }\n}\n\n/**\n * transfer n permits from one semaphore to another\n * @param from - semaphore to revoke permits\n * @param to - semaphore to grant permits\n * @param tokens - number of permits, defaults to 1\n *\n * @internal\n */\nexport const transfer = async (from: Semaphore, to: Semaphore, tokens = 1) => {\n  await from.revoke(tokens)\n  to.grant(tokens)\n}\n","/**\n * create a reference to target\n * return the reference and a revoke function that will invalidate the reference\n *\n * further call will throw an type error\n *\n * TODO: currently no support for class private field - do we need a transparent proxy in this library?\n */\nexport const borrow = <T extends object>(value: T): [T, () => void] => {\n  const borrowRef = Proxy.revocable<T>(value, {})\n\n  return [borrowRef.proxy, borrowRef.revoke]\n}\n","import { borrow } from '../utils/borrow'\nimport { Semaphore } from './semaphore'\n\n/**\n * a value created by `mutex.lock()`\n *\n * calling the `guard()` or `guard.release()` will release the mutex and revoke `MutexGuard.value`\n * so that any subsequent access to the value will throw a TypeError\n *\n * @public\n */\nexport type MutexGuard<V> = V extends object\n  ? {\n      (): void\n      release: () => void\n      value: V\n    }\n  : () => void\n\n/**\n * Asynchronos style mutex lock\n *\n * @typeParam V - type of the object wrapped by the mutex, and a immutable T does not make sense\n * @public\n */\nexport class Mutex<V = void> {\n  protected _value!: V\n  private semaphore: Semaphore\n\n  /**\n   * {@link Semaphore} with capacity of 1\n   *\n   * @param value - you may optionally wrap an object with mutex\n   */\n  public constructor()\n  public constructor(value: V)\n  public constructor(value?: V) {\n    this.semaphore = new Semaphore(1)\n    if (value) this._value = value\n  }\n\n  /**\n   * acquire lock\n   *\n   * @returns `MutexGuard` - a function to release the lock, you can access wrapped value using `MutexGuard.value` before release\n   *\n   * @example\n   * ```typescript\n   * const mutex = new Mutex({ a: 1 })\n   * const { release, value } = await mutex.lock()\n   * const ref = value\n   * ref.a // => 1\n   * release()\n   * ref.a // => TypeError, temporary reference destroyed\n   * ```\n   */\n  public async lock(timeout?: number): Promise<MutexGuard<V>> {\n    return this.semaphore.acquire(timeout).then((release) => {\n      return this.createLockGuard(release)\n    })\n  }\n\n  /**\n   * synchronosly acquire lock\n   *\n   * @throws Error if failed to acquire lock\n   * @returns `MutexGuard` - a function to release the lock, you can access wrapped value using `MutexGuard.value` before release\n   *\n   * @example\n   * ```typescript\n   * const mutex = new Mutex({ a: 1 })\n   * const { release, value } = mutex.tryLock()\n   * const ref = value // value is a temporary reference which does not equal the value stores in mutex\n   * ref.a // => 1\n   * release()\n   * ref.a // => TypeError, temporary reference destroyed\n   * ```\n   */\n  public tryLock() {\n    const release = this.semaphore.tryAcquire()\n    return this.createLockGuard(release)\n  }\n\n  /**\n   * check if mutex is available, returns true if it is not locked and frozen\n   */\n  public get canLock() {\n    return this.semaphore.isEmpty && !this.semaphore.frozen\n  }\n\n  /**\n   * Schedule a task to run when mutex is not locked.\n   */\n  public schedule<T>(fn: (v: V) => T) {\n    // create a guard but keep it secret until we have acquired the lock\n    const guard = this.createLockGuard(() => {})\n    const ret = this.semaphore.schedule(async () => {\n      // @ts-expect-error for runtime undefined value == void\n      // but it's slightly different to call fn() and fn(undefined) since the latter's arguments.length is 1\n      return this._value !== undefined ? await fn(guard.value) : await fn()\n    })\n\n    return ret\n      .catch((e) => {\n        throw e\n      })\n      .finally(guard)\n  }\n\n  /**\n   * freeze the mutex lock, see {@link Semaphore.freeze}\n   */\n  public freeze() {\n    return this.semaphore.freeze()\n  }\n\n  /**\n   * unfreeze the mutex lock, see {@link Semaphore.unfreeze}\n   */\n  public unfreeze() {\n    return this.semaphore.unfreeze()\n  }\n\n  /**\n   * unfreeze the mutex lock, see {@link Semaphore.unfreeze}\n   */\n  public get frozen() {\n    return !!this.semaphore.frozen\n  }\n\n  private createLockGuard(release: () => void) {\n    if (typeof this._value === 'object' && this._value !== null) {\n      const [ref, revoke] = borrow(this._value)\n      const guard = (() => {\n        revoke()\n        release()\n      }) as MutexGuard<object>\n      guard.release = guard\n      guard.value = ref\n      return guard as MutexGuard<V>\n    }\n    return release as MutexGuard<V>\n  }\n}\n","import { Future } from '../promise'\nimport type { PipeSource, PipeTarget } from '../protocol/pipeable'\nimport { read } from '../protocol/pipeable'\nimport { Semaphore, transfer } from './semaphore'\n\n/**\n * Indicates that the buffered items in queue has reached its capacity\n *\n * @internal\n */\nclass ClosedChannelError extends Error {\n  public message = 'channel is closed'\n}\n\n/**\n * Indicates that the buffered items in queue has reached its capacity\n *\n * @internal\n */\nclass ChannelFullError extends Error {\n  public message = 'channel queue is full'\n}\n\n/**\n * Indicates that the buffered items in queue has reached its capacity\n *\n * @internal\n */\nexport interface ChannelStream<T> extends AsyncIterable<T> {\n  next: () => Promise<T>\n}\n\n/**\n * @internal\n */\nexport interface ChannelPipeOptions {\n  /**\n   * Called when `target[read]` throws e.g. pipe a closed target channel.\n   *\n   * param will be called immediately every time the read throws an error.\n   */\n  onPipeError?: (err: unknown) => any\n}\n\n/**\n *\n * Promise based multi producer single consumer channel\n *\n *\n * - buffered message queue\n *\n * - `send` / `receive` basic message passing\n *\n * - `pipe` piping to other channels (or use `pipe.to()`)\n *\n * - `stream` ES6 async iterator api\n *\n * - `freeze` temporarily block all consumers, useful if your target has limited rate of consumption like Node.js net.Socket\n *\n * @typeParam T - type of messages in queue\n * @public\n */\nexport class Channel<T> implements PipeSource<T>, PipeTarget<T> {\n  /**\n   * ```\n   * class ClosedChannelError extends Error\n   * ```\n   */\n  public static ClosedChannelError = ClosedChannelError\n  /**\n   * ```\n   * class ChannelFullError extends Error\n   * ```\n   */\n  public static ChannelFullError = ChannelFullError\n\n  private _closed = false\n  private _capacity\n  private queue: T[] = []\n  private sendSem: Semaphore\n  private recvSem: Semaphore\n  private pipeTarget: PipeTarget<T> | null = null\n  private pipeOptions?: ChannelPipeOptions\n  private paused?: Future<void>\n  /**\n   * should use sendSem to control maximum messages queued,\n   * `false` if capacity is Infinity\n   */\n  private bounded: boolean\n\n  /**\n   * create a new channel with specified capacity\n   * @typeParam T - type of messages in queue\n   * @param capacity - channel capacity, defaults to `Infinity`\n   *\n   * @throws RangeError - capacity is negative or NaN\n   */\n  public constructor(capacity = Infinity) {\n    if (capacity < 0 || Number.isNaN(capacity)) {\n      throw new RangeError('capacity cannot be negative or NaN')\n    }\n    this._capacity = capacity\n    this.bounded = Number.isFinite(capacity)\n    this.sendSem = new Semaphore(capacity)\n    this.recvSem = new Semaphore(0)\n  }\n\n  /**\n   * send a value to channel.\n   *\n   * if the channel has reached its capacity, then call to `send` will be blocked\n   *\n   * @throws -{@link Channel.ClosedChannelError} throw if channel is closed\n   */\n  public async send(value: T) {\n    if (this._closed) throw new ClosedChannelError()\n    if (!this.pipeTarget) {\n      if (this.bounded) {\n        await transfer(this.sendSem, this.recvSem, 1)\n      } else {\n        this.recvSem.grant()\n      }\n    }\n\n    this.writeValue(value)\n  }\n\n  /**\n   * retrieve a value from channel.\n   *\n   * will never resolve if {@link Channel.pipe} or is enabled;\n   * will race with {@link Channel.stream}\n   */\n  public async receive(): Promise<T> {\n    // if pipe is enabled, recvSem will not receive any token\n    if (!this.pipeTarget) {\n      await transfer(this.recvSem, this.sendSem, 1)\n    }\n    // since we already acquired 1 token fron recvSem, queue should not be empty\n    // if channel is closed, the queue should be empty\n    if (this._closed && this.queue.length === 0) throw new ClosedChannelError()\n    const value = this.queue.shift()!\n    return value\n  }\n\n  /**\n   * try to send a value synchronosly\n   *\n   * @throws -{@link Channel.ClosedChannelError} channel is closed\n   * @throws -{@link Channel.ChannelFullError} channel is full\n   */\n  public trySend(value: T) {\n    if (this._closed) throw new ClosedChannelError()\n    if (this.queue.length + 1 > this._capacity) throw new ChannelFullError()\n    this.writeValue(value)\n  }\n\n  /**\n   * send a promise to channel, after the promise is resolved, send its fullfilled value\n   */\n  public sendAsync(value: Promise<T>) {\n    return value.then((v) => this.send(v))\n  }\n\n  /**\n   * try receive one message\n   * @returns message `T` or `undefined` if no messages in the queue\n   */\n  public tryReceive() {\n    return this.queue.shift()\n  }\n\n  /**\n   * get a stream to read from the channel, internally uses {@link Channel.receive}\n   */\n  public stream(): ChannelStream<T> {\n    return {\n      next: async () => {\n        const next = await this.next()\n        if (next.done) throw new Error('Finished')\n        return next.value\n      },\n      [Symbol.asyncIterator]: () => {\n        return {\n          next: () => this.next(),\n          return: () => Promise.resolve({ value: undefined, done: true }),\n        }\n      },\n    }\n  }\n\n  /**\n   * @internal\n   */\n  public [read](value: T) {\n    // synchronos call to wait and write\n    if (this._closed) throw new ClosedChannelError()\n    if (this.bounded) {\n      transfer(this.sendSem, this.recvSem, 1).then(() => this.writeValue(value))\n    } else {\n      this.recvSem.grant()\n      this.writeValue(value)\n    }\n  }\n\n  /**\n   * pipe channel output to target\n   *\n   * there is only one target at the same time, use `ChannelHub` if you want to have multiple readers\n   */\n  public pipe(target: PipeTarget<T>, options?: ChannelPipeOptions) {\n    this.pipeTarget = target\n    this.pipeOptions = options\n    if (!this.paused) this.flushQueue()\n  }\n\n  /**\n   * unlink output with target, future input will be stored in channel's internal buffer\n   */\n  public unpipe() {\n    this.pipeTarget = null\n    this.pipeOptions = undefined\n  }\n\n  /**\n   * stop {@link Channel.stream} / {@link Channel.pipe} / {@link Channel.receive} new items until {@link Channel.resume} is called\n   *\n   * items sending to the channel will be queued despite pipe enabled\n   */\n  public pause() {\n    this.recvSem.freeze()\n    this.paused = new Future()\n  }\n\n  /**\n   * resume the channel so {@link Channel.stream} / {@link Channel.pipe} / {@link Channel.receive} can continue to handle new messages\n   */\n  public resume() {\n    this.paused?.resolve()\n    if (this.pipeTarget) {\n      this.flushQueue()\n    }\n  }\n\n  /**\n   * close the channel, future `send` will throw a {@link Channel.ClosedChannelError}\n   */\n  public close() {\n    this._closed = true\n    // since transfer from recvSem to sendSem is possibly blocking\n    // we need to grant 1 token to recvSem, after which Channel will be invalid\n    this.recvSem.grant(1)\n  }\n\n  /**\n   * check if channel has been closed\n   */\n  public get closed() {\n    return this._closed\n  }\n\n  /**\n   * Get the number of maximum items in queue\n   */\n  public get capacity() {\n    return this._capacity\n  }\n\n  /**\n   * Get the number of current queued items\n   */\n  public get size() {\n    return this.queue.length\n  }\n\n  /**\n   * **SHOULD** check `capacity` and `closed` state before calling this method.\n   *\n   * if check inside `writeValue`, there is a chance that `close` is called immediately after `send`\n   * while writeValue is `asynchronosly` called in `send` and will unexpectedly throw an error\n   */\n  private writeValue(value: T) {\n    if (this.pipeTarget && !this.paused) {\n      this.flushValue(value)\n    } else {\n      this.queue.push(value)\n    }\n  }\n\n  /**\n   * empty current queue by writing all values to pipe target\n   */\n  private flushQueue() {\n    for (const v of this.queue) {\n      this.flushValue(v)\n    }\n    this.queue = []\n  }\n\n  /**\n   * write single item to pipe target\n   */\n  private flushValue(value: T) {\n    try {\n      this.pipeTarget?.[read](value, this)\n    } catch (err) {\n      this.pipeOptions?.onPipeError?.(err)\n    }\n  }\n\n  private async next(): Promise<IteratorResult<T, undefined>> {\n    if (this._closed) {\n      const value = this.queue.shift()\n      return value === undefined ? { value: undefined, done: true } : { value, done: false }\n    }\n\n    try {\n      return { value: await this.receive(), done: false }\n    } catch (e) {\n      if (e instanceof ClosedChannelError) return { value: undefined, done: true }\n      throw e\n    }\n  }\n}\n","import { Channel } from './channel'\nimport type { PipeTarget} from '../protocol/pipeable';\nimport { read } from '../protocol/pipeable'\n\n/**\n * compose multiple channels into one\n *\n * @public\n */\nexport class ChannelHub<T = unknown> implements PipeTarget<T> {\n  /** a helper function, equivalant to ChannelHub.constructor */\n  public static from<T>(writers?: Channel<T>[], readers?: Channel<T>[]) {\n    return new ChannelHub(writers, readers)\n  }\n\n  private closed = false\n  private readers: Channel<T>[]\n  private writers: Channel<T>[]\n\n  public constructor(writers?: Channel<T>[], readers?: Channel<T>[]) {\n    this.readers = readers || []\n    this.writers = writers || []\n    if (new Set([...this.readers, ...this.writers]).size < this.writers.length + this.readers.length)\n      throw new Error('readers and writers must not have overlap')\n    this.writers.forEach((w) => w.pipe(this))\n  }\n\n  /**\n   * send a value to the hub, will be received by all readers\n   * @param T - value\n   * @throws `Channel.ClosedChannelError` - if ChannelHub is closed\n   */\n  public broadcast(value: T) {\n    if (this.closed) throw new Channel.ClosedChannelError()\n    this.readers.forEach((r) => r.send(value))\n  }\n\n  /**\n   * get a reader channel that can get messages from channel hub\n   *\n   * use {@link ChannelHub.disconnect} if you don't want to receive messages from the hub\n   * @throws `Channel.ClosedChannelError` - if ChannelHub is closed\n   */\n  public reader() {\n    if (this.closed) throw new Channel.ClosedChannelError()\n    const ch = new Channel<T>()\n    this.readers.push(ch)\n    return ch\n  }\n\n  /**\n   * get a writer channel that can send messages to channel hub\n   *\n   * use {@link ChannelHub.disconnect} if you don't want to send messages to the hub\n   * @throws `Channel.ClosedChannelError` - if ChannelHub is closed\n   */\n  public writer() {\n    if (this.closed) throw new Channel.ClosedChannelError()\n    const ch = new Channel<T>()\n    ch.pipe(this)\n    this.writers.push(ch)\n    return ch\n  }\n\n  /**\n   * diconnect a channel from the hub, could be a reader or a writer\n   *\n   * disconnected channel will NOT be closed automatically,\n   * they can still be used to send and receive messages\n   */\n  public disconnect(ch: Channel<T>) {\n    let index = this.readers.indexOf(ch)\n    if (index !== -1) {\n      this.readers.splice(index, 1)\n    }\n    index = this.writers.indexOf(ch)\n    if (index !== -1) {\n      ch.unpipe()\n      this.writers.splice(index, 1)\n    }\n  }\n\n  /**\n   * @internal\n   */\n  public [read](value: T) {\n    this.broadcast(value)\n  }\n\n  /**\n   * close the hub and all readers/writers connected to it\n   *\n   * no-op if already closed\n   */\n  public close() {\n    if (this.closed) return\n    this.closed = true\n    this.writers.forEach((ch) => ch.close())\n    this.readers.forEach((ch) => ch.close())\n  }\n}\n"]}