@lmvz-ds/components 0.12.5-alpha.5 → 0.13.0

package/dist/esm/aria-validation-controller-iA4YWFG-.js

@@ -1,2927 +0,0 @@
-import { B as Build } from './index-smGPjoDX.js';
-import { a6 as make$4, a7 as modify$1, a8 as get$1, a9 as update$1, aa as isInterrupted$1, ab as fail$2, ac as failureOrCause$1, ad as flipCauseOption$1, ae as map$3, af as die$1, ag as interrupt$2, ah as isDieType$1, ai as interruptors$1, aj as isInterruptedOnly$1, ak as join$1, al as interruptFiber, am as _await$1, an as inheritAll$1, ao as interruptAsFiber, N as pipe, F as flatMap$2, q as sync$1, ap as dual, j as map$4, L as make$5, aq as deferredMake, ar as Class, as as pipeArguments, v as suspend$2, at as catchAll, au as interrupt$3, av as get$2, y as none, B as some, aw as uninterruptible, ax as withFiberRuntime, K as set, U as asVoid, ay as whenEffect, az as deferredSucceed, Y as zipRight$1, aA as forEachConcurrentDiscard, aB as deferredAwait, x as succeed$1, aC as fromIterable, aD as empty, aE as splitAt, aF as isEmpty, aG as deferredUnsafeMake, X as onInterrupt, aH as fromIterable$1, aI as deferredUnsafeDone, aJ as prepend, aK as filter, aL as appendAll, aM as append, aN as deferredInterruptWith, aO as empty$1, aP as void_$1, o as fiberId, S as hasProperty, aQ as isEffect, i as identity, aR as match$1, aS as _void, aT as ignore, aU as zipWith, aV as exit, aW as sync$2, aX as provide, aY as matchCauseEffect, aZ as zipRight$3, a_ as flatMap$3, a$ as forkDaemon, b0 as interruptible, b1 as suspend$3, b2 as ensuring$2, b3 as uninterruptible$1, b4 as map$5, b5 as zip$1, b6 as forEach, s as succeed$3, A as isSome, b7 as getOrElse, b8 as dieMessage, b9 as catchAllCause, ba as uninterruptibleMask, bb as all$1, bc as fork, bd as sequential, be as acquireUseRelease, bf as forkIn, bg as size$2, bh as combineAll, bi as intoDeferred, bj as zipLeft, bk as tapErrorCause, bl as addFinalizer, bm as failCause$4, bn as flatten$2, bo as fiberIdWith, bp as interrupt$4, d as left, b as right, bq as matchCause, br as scopedWith$2, bs as unsafeGet, bt as constVoid, bu as scope, $ as gen, bv as withFiberRuntime$1, bw as make$7, bx as extend, by as close, bz as raceWith, bA as runtime, bB as tap, bC as addFinalizerExit, bD as makeSemaphore, bE as when, bF as race, bG as as, m as match$3, bH as repeat, bI as asVoid$1, T as equals, bJ as raceFirst, bK as forever, bL as of$1, bM as fail$4, bN as mapError, bO as reduce, bP as map$7, bQ as match$4, bR as splitWhere, bS as head, bT as filterMap, c as catchAll$1, bU as catchSomeCause, bV as unsafeFromArray, bW as runFork, bX as promise, bY as async } from './Effect-BhQLGXPs.js';
-import { a as unbounded$2, l as length, p as poll, E as EmptyMutableQueue, o as offer$2, b as pollUpTo, c as isEmpty$1, e as offerAll, f as bounded$2, g as capacity, h as isFailure, z as zipRight$2, s as succeed$2, j as failCause$3, m as match$2, k as all, v as void_$2, n as die$2, q as map$6, r as make$6, t as isDone, w as succeed$4, _ as _await$2, x as failCause$5, y as fail$3, A as zip$2, B as isSuccess } from './MutableQueue-CNlEFklh.js';
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-const make$3 = make$4;
-/**
- * @since 2.0.0
- * @category getters
- */
-const get = get$1;
-/**
- * @since 2.0.0
- * @category utils
- */
-const modify = modify$1;
-/**
- * @since 2.0.0
- * @category utils
- */
-const update = update$1;
-
-/**
- * Creates a `Fail` cause from an expected error.
- *
- * **Details**
- *
- * This function constructs a `Cause` carrying an error of type `E`. It's used
- * when you want to represent a known or anticipated failure in your effectful
- * computations.
- *
- * @see {@link isFailure} Check if a `Cause` contains a failure
- *
- * @since 2.0.0
- * @category Constructors
- */
-const fail$1 = fail$2;
-/**
- * Creates a `Die` cause from an unexpected error.
- *
- * **Details**
- *
- * This function wraps an unhandled or unknown defect (like a runtime crash)
- * into a `Cause`. It's useful for capturing unforeseen issues in a structured
- * way.
- *
- * @see {@link isDie} Check if a `Cause` contains a defect
- *
- * @since 2.0.0
- * @category Constructors
- */
-const die = die$1;
-/**
- * Creates an `Interrupt` cause from a `FiberId`.
- *
- * **Details**
- *
- * This function represents a fiber that has been interrupted. It stores the
- * identifier of the interrupted fiber, enabling precise tracking of concurrent
- * cancellations.
- *
- * @see {@link isInterrupted} Check if a `Cause` contains an interruption
- *
- * @since 2.0.0
- * @category Constructors
- */
-const interrupt$1 = interrupt$2;
-/**
- * Checks if a `Cause` is a `Die` type.
- *
- * @see {@link die} Create a new `Die` cause
- *
- * @since 2.0.0
- * @category Guards
- */
-const isDieType = isDieType$1;
-/**
- * Checks if a `Cause` contains an interruption.
- *
- * **Details**
- *
- * This function returns `true` if the `Cause` includes any fiber interruptions.
- *
- * @since 2.0.0
- * @category Getters
- */
-const isInterrupted = isInterrupted$1;
-/**
- * Checks if a `Cause` contains only interruptions.
- *
- * **Details**
- *
- * This function returns `true` if the `Cause` has been interrupted but does not
- * contain any other failures, such as `Fail` or `Die`. It's helpful for
- * verifying purely "cancellation" scenarios.
- *
- * @since 2.0.0
- * @category Getters
- */
-const isInterruptedOnly = isInterruptedOnly$1;
-/**
- * Collects all `FiberId`s responsible for interrupting a fiber.
- *
- * **Details**
- *
- * This function returns a set of IDs indicating which fibers caused
- * interruptions within this `Cause`. It's useful for debugging concurrency
- * issues or tracing cancellations.
- *
- * @since 2.0.0
- * @category Getters
- */
-const interruptors = interruptors$1;
-/**
- * Splits a `Cause` into either its first `Fail` error or the rest of the cause
- * (which might only contain `Die` or `Interrupt`).
- *
- * **Details**
- *
- * This function either returns the checked error (`E`) or the remaining
- * `Cause<never>` with defects/interruptions. It helps you decide if there's a
- * recoverable path or if only unhandled issues remain.
- *
- * @since 2.0.0
- * @category Getters
- */
-const failureOrCause = failureOrCause$1;
-/**
- * Strips out failures with an error of `None` from a `Cause<Option<E>>`.
- *
- * **Details**
- *
- * This function turns a `Cause<Option<E>>` into an `Option<Cause<E>>`. If the
- * cause only contains failures of `None`, it becomes `None`; otherwise, it
- * returns a `Cause` of the remaining errors. It's helpful when working with
- * optional errors and filtering out certain error paths.
- *
- * @since 2.0.0
- * @category Getters
- */
-const flipCauseOption = flipCauseOption$1;
-/**
- * Transforms the errors in a `Cause` using a user-provided function.
- *
- * **Details**
- *
- * This function applies `f` to each `Fail` error while leaving defects (`Die`)
- * and interruptions untouched. It's useful for changing or simplifying error
- * types in your effectful workflows.
- *
- * @see {@link as} Replace errors with a single constant
- *
- * @since 2.0.0
- * @category Mapping
- */
-const map$2 = map$3;
-
-const _await = _await$1;
-/**
- * Inherits values from all `FiberRef` instances into current fiber. This
- * will resume immediately.
- *
- * @since 2.0.0
- * @category destructors
- */
-const inheritAll = inheritAll$1;
-/**
- * Interrupts the fiber from whichever fiber is calling this method. If the
- * fiber has already exited, the returned effect will resume immediately.
- * Otherwise, the effect will resume when the fiber exits.
- *
- * @since 2.0.0
- * @category interruption
- */
-const interrupt = interruptFiber;
-/**
- * Interrupts the fiber as if interrupted from the specified fiber. If the
- * fiber has already exited, the returned effect will resume immediately.
- * Otherwise, the effect will resume when the fiber exits.
- *
- * @since 2.0.0
- * @category interruption
- */
-const interruptAs = interruptAsFiber;
-/**
- * Joins the fiber, which suspends the joining fiber until the result of the
- * fiber has been determined. Attempting to join a fiber that has erred will
- * result in a catchable error. Joining an interrupted fiber will result in an
- * "inner interruption" of this fiber, unlike interruption triggered by
- * another fiber, "inner interruption" can be caught and recovered.
- *
- * @since 2.0.0
- * @category destructors
- */
-const join = join$1;
-
-/** @internal */
-const EnqueueSymbolKey = "effect/QueueEnqueue";
-/** @internal */
-const EnqueueTypeId = /*#__PURE__*/Symbol.for(EnqueueSymbolKey);
-/** @internal */
-const DequeueSymbolKey = "effect/QueueDequeue";
-/** @internal */
-const DequeueTypeId = /*#__PURE__*/Symbol.for(DequeueSymbolKey);
-/** @internal */
-const QueueStrategySymbolKey = "effect/QueueStrategy";
-/** @internal */
-const QueueStrategyTypeId = /*#__PURE__*/Symbol.for(QueueStrategySymbolKey);
-/** @internal */
-const BackingQueueSymbolKey = "effect/BackingQueue";
-/** @internal */
-const BackingQueueTypeId = /*#__PURE__*/Symbol.for(BackingQueueSymbolKey);
-const queueStrategyVariance = {
-  /* c8 ignore next */
-  _A: _ => _
-};
-const backingQueueVariance = {
-  /* c8 ignore next */
-  _A: _ => _
-};
-/** @internal */
-const enqueueVariance = {
-  /* c8 ignore next */
-  _In: _ => _
-};
-/** @internal */
-const dequeueVariance = {
-  /* c8 ignore next */
-  _Out: _ => _
-};
-/** @internal */
-class QueueImpl extends Class {
-  queue;
-  takers;
-  shutdownHook;
-  shutdownFlag;
-  strategy;
-  [EnqueueTypeId] = enqueueVariance;
-  [DequeueTypeId] = dequeueVariance;
-  constructor(/** @internal */
-  queue, /** @internal */
-  takers, /** @internal */
-  shutdownHook, /** @internal */
-  shutdownFlag, /** @internal */
-  strategy) {
-    super();
-    this.queue = queue;
-    this.takers = takers;
-    this.shutdownHook = shutdownHook;
-    this.shutdownFlag = shutdownFlag;
-    this.strategy = strategy;
-  }
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-  commit() {
-    return this.take;
-  }
-  capacity() {
-    return this.queue.capacity();
-  }
-  get size() {
-    return suspend$2(() => catchAll(this.unsafeSize(), () => interrupt$3));
-  }
-  unsafeSize() {
-    if (get$2(this.shutdownFlag)) {
-      return none();
-    }
-    return some(this.queue.length() - length(this.takers) + this.strategy.surplusSize());
-  }
-  get isEmpty() {
-    return map$4(this.size, size => size <= 0);
-  }
-  get isFull() {
-    return map$4(this.size, size => size >= this.capacity());
-  }
-  get shutdown() {
-    return uninterruptible(withFiberRuntime(state => {
-      pipe(this.shutdownFlag, set(true));
-      return pipe(forEachConcurrentDiscard(unsafePollAll(this.takers), d => deferredInterruptWith(d, state.id()), false, false), zipRight$1(this.strategy.shutdown), whenEffect(deferredSucceed(this.shutdownHook, void 0)), asVoid);
-    }));
-  }
-  get isShutdown() {
-    return sync$1(() => get$2(this.shutdownFlag));
-  }
-  get awaitShutdown() {
-    return deferredAwait(this.shutdownHook);
-  }
-  isActive() {
-    return !get$2(this.shutdownFlag);
-  }
-  unsafeOffer(value) {
-    if (get$2(this.shutdownFlag)) {
-      return false;
-    }
-    let noRemaining;
-    if (this.queue.length() === 0) {
-      const taker = pipe(this.takers, poll(EmptyMutableQueue));
-      if (taker !== EmptyMutableQueue) {
-        unsafeCompleteDeferred(taker, value);
-        noRemaining = true;
-      } else {
-        noRemaining = false;
-      }
-    } else {
-      noRemaining = false;
-    }
-    if (noRemaining) {
-      return true;
-    }
-    // Not enough takers, offer to the queue
-    const succeeded = this.queue.offer(value);
-    unsafeCompleteTakers(this.strategy, this.queue, this.takers);
-    return succeeded;
-  }
-  offer(value) {
-    return suspend$2(() => {
-      if (get$2(this.shutdownFlag)) {
-        return interrupt$3;
-      }
-      let noRemaining;
-      if (this.queue.length() === 0) {
-        const taker = pipe(this.takers, poll(EmptyMutableQueue));
-        if (taker !== EmptyMutableQueue) {
-          unsafeCompleteDeferred(taker, value);
-          noRemaining = true;
-        } else {
-          noRemaining = false;
-        }
-      } else {
-        noRemaining = false;
-      }
-      if (noRemaining) {
-        return succeed$1(true);
-      }
-      // Not enough takers, offer to the queue
-      const succeeded = this.queue.offer(value);
-      unsafeCompleteTakers(this.strategy, this.queue, this.takers);
-      return succeeded ? succeed$1(true) : this.strategy.handleSurplus([value], this.queue, this.takers, this.shutdownFlag);
-    });
-  }
-  offerAll(iterable) {
-    return suspend$2(() => {
-      if (get$2(this.shutdownFlag)) {
-        return interrupt$3;
-      }
-      const values = fromIterable(iterable);
-      const pTakers = this.queue.length() === 0 ? fromIterable(unsafePollN(this.takers, values.length)) : empty;
-      const [forTakers, remaining] = pipe(values, splitAt(pTakers.length));
-      for (let i = 0; i < pTakers.length; i++) {
-        const taker = pTakers[i];
-        const item = forTakers[i];
-        unsafeCompleteDeferred(taker, item);
-      }
-      if (remaining.length === 0) {
-        return succeed$1(true);
-      }
-      // Not enough takers, offer to the queue
-      const surplus = this.queue.offerAll(remaining);
-      unsafeCompleteTakers(this.strategy, this.queue, this.takers);
-      return isEmpty(surplus) ? succeed$1(true) : this.strategy.handleSurplus(surplus, this.queue, this.takers, this.shutdownFlag);
-    });
-  }
-  get take() {
-    return withFiberRuntime(state => {
-      if (get$2(this.shutdownFlag)) {
-        return interrupt$3;
-      }
-      const item = this.queue.poll(EmptyMutableQueue);
-      if (item !== EmptyMutableQueue) {
-        this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
-        return succeed$1(item);
-      } else {
-        // Add the deferred to takers, then:
-        // - Try to take again in case a value was added since
-        // - Wait for the deferred to be completed
-        // - Clean up resources in case of interruption
-        const deferred = deferredUnsafeMake(state.id());
-        return pipe(suspend$2(() => {
-          pipe(this.takers, offer$2(deferred));
-          unsafeCompleteTakers(this.strategy, this.queue, this.takers);
-          return get$2(this.shutdownFlag) ? interrupt$3 : deferredAwait(deferred);
-        }), onInterrupt(() => {
-          return sync$1(() => unsafeRemove(this.takers, deferred));
-        }));
-      }
-    });
-  }
-  get takeAll() {
-    return suspend$2(() => {
-      return get$2(this.shutdownFlag) ? interrupt$3 : sync$1(() => {
-        const values = this.queue.pollUpTo(Number.POSITIVE_INFINITY);
-        this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
-        return fromIterable$1(values);
-      });
-    });
-  }
-  takeUpTo(max) {
-    return suspend$2(() => get$2(this.shutdownFlag) ? interrupt$3 : sync$1(() => {
-      const values = this.queue.pollUpTo(max);
-      this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
-      return fromIterable$1(values);
-    }));
-  }
-  takeBetween(min, max) {
-    return suspend$2(() => takeRemainderLoop(this, min, max, empty$1()));
-  }
-}
-/** @internal */
-const takeRemainderLoop = (self, min, max, acc) => {
-  if (max < min) {
-    return succeed$1(acc);
-  }
-  return pipe(takeUpTo(self, max), flatMap$2(bs => {
-    const remaining = min - bs.length;
-    if (remaining === 1) {
-      return pipe(take$1(self), map$4(b => pipe(acc, appendAll(bs), append(b))));
-    }
-    if (remaining > 1) {
-      return pipe(take$1(self), flatMap$2(b => takeRemainderLoop(self, remaining - 1, max - bs.length - 1, pipe(acc, appendAll(bs), append(b)))));
-    }
-    return succeed$1(pipe(acc, appendAll(bs)));
-  }));
-};
-/** @internal */
-const bounded$1 = requestedCapacity => pipe(sync$1(() => bounded$2(requestedCapacity)), flatMap$2(queue => make$2(backingQueueFromMutableQueue(queue), backPressureStrategy())));
-/** @internal */
-const unbounded$1 = () => pipe(sync$1(() => unbounded$2()), flatMap$2(queue => make$2(backingQueueFromMutableQueue(queue), droppingStrategy())));
-/** @internal */
-const unsafeMake = (queue, takers, shutdownHook, shutdownFlag, strategy) => {
-  return new QueueImpl(queue, takers, shutdownHook, shutdownFlag, strategy);
-};
-/** @internal */
-const make$2 = (queue, strategy) => pipe(deferredMake(), map$4(deferred => unsafeMake(queue, unbounded$2(), deferred, make$5(false), strategy)));
-/** @internal */
-class BackingQueueFromMutableQueue {
-  mutable;
-  [BackingQueueTypeId] = backingQueueVariance;
-  constructor(mutable) {
-    this.mutable = mutable;
-  }
-  poll(def) {
-    return poll(this.mutable, def);
-  }
-  pollUpTo(limit) {
-    return pollUpTo(this.mutable, limit);
-  }
-  offerAll(elements) {
-    return offerAll(this.mutable, elements);
-  }
-  offer(element) {
-    return offer$2(this.mutable, element);
-  }
-  capacity() {
-    return capacity(this.mutable);
-  }
-  length() {
-    return length(this.mutable);
-  }
-}
-/** @internal */
-const backingQueueFromMutableQueue = mutable => new BackingQueueFromMutableQueue(mutable);
-/** @internal */
-const size$1 = self => self.size;
-/** @internal */
-const isShutdown$1 = self => self.isShutdown;
-/** @internal */
-const shutdown$1 = self => self.shutdown;
-/** @internal */
-const offer$1 = /*#__PURE__*/dual(2, (self, value) => self.offer(value));
-/** @internal */
-const take$1 = self => self.take;
-/** @internal */
-const takeUpTo = /*#__PURE__*/dual(2, (self, max) => self.takeUpTo(max));
-/** @internal */
-const takeBetween$1 = /*#__PURE__*/dual(3, (self, min, max) => self.takeBetween(min, max));
-// -----------------------------------------------------------------------------
-// Strategy
-// -----------------------------------------------------------------------------
-/** @internal */
-const backPressureStrategy = () => new BackPressureStrategy();
-/** @internal */
-const droppingStrategy = () => new DroppingStrategy();
-/** @internal */
-class BackPressureStrategy {
-  [QueueStrategyTypeId] = queueStrategyVariance;
-  putters = /*#__PURE__*/unbounded$2();
-  surplusSize() {
-    return length(this.putters);
-  }
-  onCompleteTakersWithEmptyQueue(takers) {
-    while (!isEmpty$1(this.putters) && !isEmpty$1(takers)) {
-      const taker = poll(takers, void 0);
-      const putter = poll(this.putters, void 0);
-      if (putter[2]) {
-        unsafeCompleteDeferred(putter[1], true);
-      }
-      unsafeCompleteDeferred(taker, putter[0]);
-    }
-  }
-  get shutdown() {
-    return pipe(fiberId, flatMap$2(fiberId => pipe(sync$1(() => unsafePollAll(this.putters)), flatMap$2(putters => forEachConcurrentDiscard(putters, ([_, deferred, isLastItem]) => isLastItem ? pipe(deferredInterruptWith(deferred, fiberId), asVoid) : void_$1, false, false)))));
-  }
-  handleSurplus(iterable, queue, takers, isShutdown) {
-    return withFiberRuntime(state => {
-      const deferred = deferredUnsafeMake(state.id());
-      return pipe(suspend$2(() => {
-        this.unsafeOffer(iterable, deferred);
-        this.unsafeOnQueueEmptySpace(queue, takers);
-        unsafeCompleteTakers(this, queue, takers);
-        return get$2(isShutdown) ? interrupt$3 : deferredAwait(deferred);
-      }), onInterrupt(() => sync$1(() => this.unsafeRemove(deferred))));
-    });
-  }
-  unsafeOnQueueEmptySpace(queue, takers) {
-    let keepPolling = true;
-    while (keepPolling && (queue.capacity() === Number.POSITIVE_INFINITY || queue.length() < queue.capacity())) {
-      const putter = pipe(this.putters, poll(EmptyMutableQueue));
-      if (putter === EmptyMutableQueue) {
-        keepPolling = false;
-      } else {
-        const offered = queue.offer(putter[0]);
-        if (offered && putter[2]) {
-          unsafeCompleteDeferred(putter[1], true);
-        } else if (!offered) {
-          unsafeOfferAll(this.putters, pipe(unsafePollAll(this.putters), prepend(putter)));
-        }
-        unsafeCompleteTakers(this, queue, takers);
-      }
-    }
-  }
-  unsafeOffer(iterable, deferred) {
-    const stuff = fromIterable(iterable);
-    for (let i = 0; i < stuff.length; i++) {
-      const value = stuff[i];
-      if (i === stuff.length - 1) {
-        pipe(this.putters, offer$2([value, deferred, true]));
-      } else {
-        pipe(this.putters, offer$2([value, deferred, false]));
-      }
-    }
-  }
-  unsafeRemove(deferred) {
-    unsafeOfferAll(this.putters, pipe(unsafePollAll(this.putters), filter(([, _]) => _ !== deferred)));
-  }
-}
-/** @internal */
-class DroppingStrategy {
-  [QueueStrategyTypeId] = queueStrategyVariance;
-  surplusSize() {
-    return 0;
-  }
-  get shutdown() {
-    return void_$1;
-  }
-  onCompleteTakersWithEmptyQueue() {}
-  handleSurplus(_iterable, _queue, _takers, _isShutdown) {
-    return succeed$1(false);
-  }
-  unsafeOnQueueEmptySpace(_queue, _takers) {
-    //
-  }
-}
-/** @internal */
-const unsafeCompleteDeferred = (deferred, a) => {
-  return deferredUnsafeDone(deferred, succeed$1(a));
-};
-/** @internal */
-const unsafeOfferAll = (queue, as) => {
-  return pipe(queue, offerAll(as));
-};
-/** @internal */
-const unsafePollAll = queue => {
-  return pipe(queue, pollUpTo(Number.POSITIVE_INFINITY));
-};
-/** @internal */
-const unsafePollN = (queue, max) => {
-  return pipe(queue, pollUpTo(max));
-};
-/** @internal */
-const unsafeRemove = (queue, a) => {
-  unsafeOfferAll(queue, pipe(unsafePollAll(queue), filter(b => a !== b)));
-};
-/** @internal */
-const unsafeCompleteTakers = (strategy, queue, takers) => {
-  // Check both a taker and an item are in the queue, starting with the taker
-  let keepPolling = true;
-  while (keepPolling && queue.length() !== 0) {
-    const taker = pipe(takers, poll(EmptyMutableQueue));
-    if (taker !== EmptyMutableQueue) {
-      const element = queue.poll(EmptyMutableQueue);
-      if (element !== EmptyMutableQueue) {
-        unsafeCompleteDeferred(taker, element);
-        strategy.unsafeOnQueueEmptySpace(queue, takers);
-      } else {
-        unsafeOfferAll(takers, pipe(unsafePollAll(takers), prepend(taker)));
-      }
-      keepPolling = true;
-    } else {
-      keepPolling = false;
-    }
-  }
-  if (keepPolling && queue.length() === 0 && !isEmpty$1(takers)) {
-    strategy.onCompleteTakersWithEmptyQueue(takers);
-  }
-};
-
-/**
- * Makes a new bounded `Queue`. When the capacity of the queue is reached, any
- * additional calls to `offer` will be suspended until there is more room in
- * the queue.
- *
- * **Note**: When possible use only power of 2 capacities; this will provide
- * better performance by utilising an optimised version of the underlying
- * `RingBuffer`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const bounded = bounded$1;
-/**
- * Creates a new unbounded `Queue`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const unbounded = unbounded$1;
-/**
- * Retrieves the size of the queue, which is equal to the number of elements
- * in the queue. This may be negative if fibers are suspended waiting for
- * elements to be added to the queue.
- *
- * @since 2.0.0
- * @category getters
- */
-const size = size$1;
-/**
- * Returns `true` if `shutdown` has been called, otherwise returns `false`.
- *
- * @since 2.0.0
- * @category getters
- */
-const isShutdown = isShutdown$1;
-/**
- * Interrupts any fibers that are suspended on `offer` or `take`. Future calls
- * to `offer*` and `take*` will be interrupted immediately.
- *
- * @since 2.0.0
- * @category utils
- */
-const shutdown = shutdown$1;
-/**
- * Places one value in the queue.
- *
- * @since 2.0.0
- * @category utils
- */
-const offer = offer$1;
-/**
- * Takes the oldest value in the queue. If the queue is empty, this will return
- * a computation that resumes when an item has been added to the queue.
- *
- * @since 2.0.0
- * @category utils
- */
-const take = take$1;
-/**
- * Takes a number of elements from the queue between the specified minimum and
- * maximum. If there are fewer than the minimum number of elements available,
- * suspends until at least the minimum number of elements have been collected.
- *
- * @since 2.0.0
- * @category utils
- */
-const takeBetween = takeBetween$1;
-
-/** @internal */
-const OP_CONTINUE = "Continue";
-/** @internal */
-const OP_CLOSE = "Close";
-/** @internal */
-const OP_YIELD = "Yield";
-
-/** @internal */
-const ChildExecutorDecisionSymbolKey = "effect/ChannelChildExecutorDecision";
-/** @internal */
-const ChildExecutorDecisionTypeId = /*#__PURE__*/Symbol.for(ChildExecutorDecisionSymbolKey);
-/** @internal */
-const proto$7 = {
-  [ChildExecutorDecisionTypeId]: ChildExecutorDecisionTypeId
-};
-/** @internal */
-const Continue = _ => {
-  const op = Object.create(proto$7);
-  op._tag = OP_CONTINUE;
-  return op;
-};
-
-/** @internal */
-const OP_CONTINUATION_K = "ContinuationK";
-/** @internal */
-const OP_CONTINUATION_FINALIZER = "ContinuationFinalizer";
-
-/** @internal */
-const ContinuationTypeId = /*#__PURE__*/Symbol.for("effect/ChannelContinuation");
-const continuationVariance = {
-  /* c8 ignore next */
-  _Env: _ => _,
-  /* c8 ignore next */
-  _InErr: _ => _,
-  /* c8 ignore next */
-  _InElem: _ => _,
-  /* c8 ignore next */
-  _InDone: _ => _,
-  /* c8 ignore next */
-  _OutErr: _ => _,
-  /* c8 ignore next */
-  _OutDone: _ => _,
-  /* c8 ignore next */
-  _OutErr2: _ => _,
-  /* c8 ignore next */
-  _OutElem: _ => _,
-  /* c8 ignore next */
-  _OutDone2: _ => _
-};
-/** @internal */
-class ContinuationKImpl {
-  onSuccess;
-  onHalt;
-  _tag = OP_CONTINUATION_K;
-  [ContinuationTypeId] = continuationVariance;
-  constructor(onSuccess, onHalt) {
-    this.onSuccess = onSuccess;
-    this.onHalt = onHalt;
-  }
-  onExit(exit) {
-    return isFailure(exit) ? this.onHalt(exit.cause) : this.onSuccess(exit.value);
-  }
-}
-/** @internal */
-class ContinuationFinalizerImpl {
-  finalizer;
-  _tag = OP_CONTINUATION_FINALIZER;
-  [ContinuationTypeId] = continuationVariance;
-  constructor(finalizer) {
-    this.finalizer = finalizer;
-  }
-}
-
-/** @internal */
-const OP_PULL_AFTER_NEXT = "PullAfterNext";
-/** @internal */
-const OP_PULL_AFTER_ALL_ENQUEUED = "PullAfterAllEnqueued";
-
-/** @internal */
-const UpstreamPullStrategySymbolKey = "effect/ChannelUpstreamPullStrategy";
-/** @internal */
-const UpstreamPullStrategyTypeId = /*#__PURE__*/Symbol.for(UpstreamPullStrategySymbolKey);
-const upstreamPullStrategyVariance = {
-  /* c8 ignore next */
-  _A: _ => _
-};
-/** @internal */
-const proto$6 = {
-  [UpstreamPullStrategyTypeId]: upstreamPullStrategyVariance
-};
-/** @internal */
-const PullAfterNext = emitSeparator => {
-  const op = Object.create(proto$6);
-  op._tag = OP_PULL_AFTER_NEXT;
-  op.emitSeparator = emitSeparator;
-  return op;
-};
-
-/** @internal */
-const OP_BRACKET_OUT = "BracketOut";
-/** @internal */
-const OP_BRIDGE = "Bridge";
-/** @internal */
-const OP_CONCAT_ALL = "ConcatAll";
-/** @internal */
-const OP_EMIT$2 = "Emit";
-/** @internal */
-const OP_ENSURING = "Ensuring";
-/** @internal */
-const OP_FAIL = "Fail";
-/** @internal */
-const OP_FOLD = "Fold";
-/** @internal */
-const OP_FROM_EFFECT$1 = "FromEffect";
-/** @internal */
-const OP_PIPE_TO = "PipeTo";
-/** @internal */
-const OP_PROVIDE = "Provide";
-/** @internal */
-const OP_READ$1 = "Read";
-/** @internal */
-const OP_SUCCEED = "Succeed";
-/** @internal */
-const OP_SUCCEED_NOW = "SucceedNow";
-/** @internal */
-const OP_SUSPEND = "Suspend";
-
-/** @internal */
-const ChannelSymbolKey = "effect/Channel";
-/** @internal */
-const ChannelTypeId = /*#__PURE__*/Symbol.for(ChannelSymbolKey);
-const channelVariance = {
-  /* c8 ignore next */
-  _Env: _ => _,
-  /* c8 ignore next */
-  _InErr: _ => _,
-  /* c8 ignore next */
-  _InElem: _ => _,
-  /* c8 ignore next */
-  _InDone: _ => _,
-  /* c8 ignore next */
-  _OutErr: _ => _,
-  /* c8 ignore next */
-  _OutElem: _ => _,
-  /* c8 ignore next */
-  _OutDone: _ => _
-};
-/** @internal */
-const proto$5 = {
-  [ChannelTypeId]: channelVariance,
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-/** @internal */
-const isChannel = u => hasProperty(u, ChannelTypeId) || isEffect(u);
-/** @internal */
-const acquireReleaseOut = /*#__PURE__*/dual(2, (self, release) => {
-  const op = Object.create(proto$5);
-  op._tag = OP_BRACKET_OUT;
-  op.acquire = () => self;
-  op.finalizer = release;
-  return op;
-});
-/** @internal */
-const concatAllWith = (channels, f, g) => {
-  const op = Object.create(proto$5);
-  op._tag = OP_CONCAT_ALL;
-  op.combineInners = f;
-  op.combineAll = g;
-  op.onPull = () => PullAfterNext(none());
-  op.onEmit = () => Continue;
-  op.value = () => channels;
-  op.k = identity;
-  return op;
-};
-/** @internal */
-const concatMapWith = /*#__PURE__*/dual(4, (self, f, g, h) => {
-  const op = Object.create(proto$5);
-  op._tag = OP_CONCAT_ALL;
-  op.combineInners = g;
-  op.combineAll = h;
-  op.onPull = () => PullAfterNext(none());
-  op.onEmit = () => Continue;
-  op.value = () => self;
-  op.k = f;
-  return op;
-});
-/** @internal */
-const embedInput = /*#__PURE__*/dual(2, (self, input) => {
-  const op = Object.create(proto$5);
-  op._tag = OP_BRIDGE;
-  op.input = input;
-  op.channel = self;
-  return op;
-});
-/** @internal */
-const ensuringWith = /*#__PURE__*/dual(2, (self, finalizer) => {
-  const op = Object.create(proto$5);
-  op._tag = OP_ENSURING;
-  op.channel = self;
-  op.finalizer = finalizer;
-  return op;
-});
-/** @internal */
-const fail = error => failCause$2(fail$1(error));
-/** @internal */
-const failCause$2 = cause => failCauseSync(() => cause);
-/** @internal */
-const failCauseSync = evaluate => {
-  const op = Object.create(proto$5);
-  op._tag = OP_FAIL;
-  op.error = evaluate;
-  return op;
-};
-/** @internal */
-const flatMap$1 = /*#__PURE__*/dual(2, (self, f) => {
-  const op = Object.create(proto$5);
-  op._tag = OP_FOLD;
-  op.channel = self;
-  op.k = new ContinuationKImpl(f, failCause$2);
-  return op;
-});
-/** @internal */
-const fromEffect$3 = effect => {
-  const op = Object.create(proto$5);
-  op._tag = OP_FROM_EFFECT$1;
-  op.effect = () => effect;
-  return op;
-};
-/** @internal */
-const pipeTo = /*#__PURE__*/dual(2, (self, that) => {
-  const op = Object.create(proto$5);
-  op._tag = OP_PIPE_TO;
-  op.left = () => self;
-  op.right = () => that;
-  return op;
-});
-/** @internal */
-const readWith = options => readWithCause({
-  onInput: options.onInput,
-  onFailure: cause => match$1(failureOrCause(cause), {
-    onLeft: options.onFailure,
-    onRight: failCause$2
-  }),
-  onDone: options.onDone
-});
-/** @internal */
-const readWithCause = options => {
-  const op = Object.create(proto$5);
-  op._tag = OP_READ$1;
-  op.more = options.onInput;
-  op.done = new ContinuationKImpl(options.onDone, options.onFailure);
-  return op;
-};
-/** @internal */
-const succeed = value => sync(() => value);
-/** @internal */
-const succeedNow = result => {
-  const op = Object.create(proto$5);
-  op._tag = OP_SUCCEED_NOW;
-  op.terminal = result;
-  return op;
-};
-/** @internal */
-const suspend$1 = evaluate => {
-  const op = Object.create(proto$5);
-  op._tag = OP_SUSPEND;
-  op.channel = evaluate;
-  return op;
-};
-const sync = evaluate => {
-  const op = Object.create(proto$5);
-  op._tag = OP_SUCCEED;
-  op.evaluate = evaluate;
-  return op;
-};
-const void_ = /*#__PURE__*/succeedNow(void 0);
-/** @internal */
-const write = out => {
-  const op = Object.create(proto$5);
-  op._tag = OP_EMIT$2;
-  op.out = out;
-  return op;
-};
-
-/** @internal */
-const OP_DONE$1 = "Done";
-/** @internal */
-const OP_EMIT$1 = "Emit";
-/** @internal */
-const OP_FROM_EFFECT = "FromEffect";
-/** @internal */
-const OP_READ = "Read";
-
-/** @internal */
-const ChannelStateTypeId = /*#__PURE__*/Symbol.for("effect/ChannelState");
-const channelStateVariance = {
-  /* c8 ignore next */
-  _E: _ => _,
-  /* c8 ignore next */
-  _R: _ => _
-};
-/** @internal */
-const proto$4 = {
-  [ChannelStateTypeId]: channelStateVariance
-};
-/** @internal */
-const Done = () => {
-  const op = Object.create(proto$4);
-  op._tag = OP_DONE$1;
-  return op;
-};
-/** @internal */
-const Emit$1 = () => {
-  const op = Object.create(proto$4);
-  op._tag = OP_EMIT$1;
-  return op;
-};
-/** @internal */
-const fromEffect$2 = effect => {
-  const op = Object.create(proto$4);
-  op._tag = OP_FROM_EFFECT;
-  op.effect = effect;
-  return op;
-};
-/** @internal */
-const Read = (upstream, onEffect, onEmit, onDone) => {
-  const op = Object.create(proto$4);
-  op._tag = OP_READ;
-  op.upstream = upstream;
-  op.onEffect = onEffect;
-  op.onEmit = onEmit;
-  op.onDone = onDone;
-  return op;
-};
-/** @internal */
-const isFromEffect = self => self._tag === OP_FROM_EFFECT;
-/** @internal */
-const effect = self => isFromEffect(self) ? self.effect : _void;
-/** @internal */
-const effectOrUndefinedIgnored = self => isFromEffect(self) ? ignore(self.effect) : undefined;
-
-/** @internal */
-const OP_PULL_FROM_CHILD = "PullFromChild";
-/** @internal */
-const OP_PULL_FROM_UPSTREAM = "PullFromUpstream";
-/** @internal */
-const OP_DRAIN_CHILD_EXECUTORS = "DrainChildExecutors";
-/** @internal */
-const OP_EMIT = "Emit";
-/**
- * Execute the `childExecutor` and on each emitted value, decide what to do by
- * `onEmit`.
- *
- * @internal
- */
-class PullFromChild {
-  childExecutor;
-  parentSubexecutor;
-  onEmit;
-  _tag = OP_PULL_FROM_CHILD;
-  constructor(childExecutor, parentSubexecutor, onEmit) {
-    this.childExecutor = childExecutor;
-    this.parentSubexecutor = parentSubexecutor;
-    this.onEmit = onEmit;
-  }
-  close(exit$1) {
-    const fin1 = this.childExecutor.close(exit$1);
-    const fin2 = this.parentSubexecutor.close(exit$1);
-    if (fin1 !== undefined && fin2 !== undefined) {
-      return zipWith(exit(fin1), exit(fin2), (exit1, exit2) => pipe(exit1, zipRight$2(exit2)));
-    } else if (fin1 !== undefined) {
-      return fin1;
-    } else if (fin2 !== undefined) {
-      return fin2;
-    } else {
-      return undefined;
-    }
-  }
-  enqueuePullFromChild(_child) {
-    return this;
-  }
-}
-/**
- * Execute `upstreamExecutor` and for each emitted element, spawn a child
- * channel and continue with processing it by `PullFromChild`.
- *
- * @internal
- */
-class PullFromUpstream {
-  upstreamExecutor;
-  createChild;
-  lastDone;
-  activeChildExecutors;
-  combineChildResults;
-  combineWithChildResult;
-  onPull;
-  onEmit;
-  _tag = OP_PULL_FROM_UPSTREAM;
-  constructor(upstreamExecutor, createChild, lastDone, activeChildExecutors, combineChildResults, combineWithChildResult, onPull, onEmit) {
-    this.upstreamExecutor = upstreamExecutor;
-    this.createChild = createChild;
-    this.lastDone = lastDone;
-    this.activeChildExecutors = activeChildExecutors;
-    this.combineChildResults = combineChildResults;
-    this.combineWithChildResult = combineWithChildResult;
-    this.onPull = onPull;
-    this.onEmit = onEmit;
-  }
-  close(exit$1) {
-    const fin1 = this.upstreamExecutor.close(exit$1);
-    const fins = [...this.activeChildExecutors.map(child => child !== undefined ? child.childExecutor.close(exit$1) : undefined), fin1];
-    const result = fins.reduce((acc, next) => {
-      if (acc !== undefined && next !== undefined) {
-        return zipWith(acc, exit(next), (exit1, exit2) => zipRight$2(exit1, exit2));
-      } else if (acc !== undefined) {
-        return acc;
-      } else if (next !== undefined) {
-        return exit(next);
-      } else {
-        return undefined;
-      }
-    }, undefined);
-    return result === undefined ? result : result;
-  }
-  enqueuePullFromChild(child) {
-    return new PullFromUpstream(this.upstreamExecutor, this.createChild, this.lastDone, [...this.activeChildExecutors, child], this.combineChildResults, this.combineWithChildResult, this.onPull, this.onEmit);
-  }
-}
-/**
- * Transformed from `PullFromUpstream` when upstream has finished but there
- * are still active child executors.
- *
- * @internal
- */
-class DrainChildExecutors {
-  upstreamExecutor;
-  lastDone;
-  activeChildExecutors;
-  upstreamDone;
-  combineChildResults;
-  combineWithChildResult;
-  onPull;
-  _tag = OP_DRAIN_CHILD_EXECUTORS;
-  constructor(upstreamExecutor, lastDone, activeChildExecutors, upstreamDone, combineChildResults, combineWithChildResult, onPull) {
-    this.upstreamExecutor = upstreamExecutor;
-    this.lastDone = lastDone;
-    this.activeChildExecutors = activeChildExecutors;
-    this.upstreamDone = upstreamDone;
-    this.combineChildResults = combineChildResults;
-    this.combineWithChildResult = combineWithChildResult;
-    this.onPull = onPull;
-  }
-  close(exit$1) {
-    const fin1 = this.upstreamExecutor.close(exit$1);
-    const fins = [...this.activeChildExecutors.map(child => child !== undefined ? child.childExecutor.close(exit$1) : undefined), fin1];
-    const result = fins.reduce((acc, next) => {
-      if (acc !== undefined && next !== undefined) {
-        return zipWith(acc, exit(next), (exit1, exit2) => zipRight$2(exit1, exit2));
-      } else if (acc !== undefined) {
-        return acc;
-      } else if (next !== undefined) {
-        return exit(next);
-      } else {
-        return undefined;
-      }
-    }, undefined);
-    return result === undefined ? result : result;
-  }
-  enqueuePullFromChild(child) {
-    return new DrainChildExecutors(this.upstreamExecutor, this.lastDone, [...this.activeChildExecutors, child], this.upstreamDone, this.combineChildResults, this.combineWithChildResult, this.onPull);
-  }
-}
-/** @internal */
-class Emit {
-  value;
-  next;
-  _tag = OP_EMIT;
-  constructor(value, next) {
-    this.value = value;
-    this.next = next;
-  }
-  close(exit) {
-    const result = this.next.close(exit);
-    return result === undefined ? result : result;
-  }
-  enqueuePullFromChild(_child) {
-    return this;
-  }
-}
-
-/** @internal */
-const OP_PULLED = "Pulled";
-/** @internal */
-const OP_NO_UPSTREAM = "NoUpstream";
-
-/** @internal */
-const UpstreamPullRequestSymbolKey = "effect/ChannelUpstreamPullRequest";
-/** @internal */
-const UpstreamPullRequestTypeId = /*#__PURE__*/Symbol.for(UpstreamPullRequestSymbolKey);
-const upstreamPullRequestVariance = {
-  /* c8 ignore next */
-  _A: _ => _
-};
-/** @internal */
-const proto$3 = {
-  [UpstreamPullRequestTypeId]: upstreamPullRequestVariance
-};
-/** @internal */
-const Pulled = value => {
-  const op = Object.create(proto$3);
-  op._tag = OP_PULLED;
-  op.value = value;
-  return op;
-};
-/** @internal */
-const NoUpstream = activeDownstreamCount => {
-  const op = Object.create(proto$3);
-  op._tag = OP_NO_UPSTREAM;
-  op.activeDownstreamCount = activeDownstreamCount;
-  return op;
-};
-
-/** @internal */
-class ChannelExecutor {
-  _activeSubexecutor = undefined;
-  _cancelled = undefined;
-  _closeLastSubstream = undefined;
-  _currentChannel;
-  _done = undefined;
-  _doneStack = [];
-  _emitted = undefined;
-  _executeCloseLastSubstream;
-  _input = undefined;
-  _inProgressFinalizer = undefined;
-  _providedEnv;
-  constructor(initialChannel, providedEnv, executeCloseLastSubstream) {
-    this._currentChannel = initialChannel;
-    this._executeCloseLastSubstream = executeCloseLastSubstream;
-    this._providedEnv = providedEnv;
-  }
-  run() {
-    let result = undefined;
-    while (result === undefined) {
-      if (this._cancelled !== undefined) {
-        result = this.processCancellation();
-      } else if (this._activeSubexecutor !== undefined) {
-        result = this.runSubexecutor();
-      } else {
-        try {
-          if (this._currentChannel === undefined) {
-            result = Done();
-          } else {
-            if (isEffect(this._currentChannel)) {
-              this._currentChannel = fromEffect$3(this._currentChannel);
-            }
-            switch (this._currentChannel._tag) {
-              case OP_BRACKET_OUT:
-                {
-                  result = this.runBracketOut(this._currentChannel);
-                  break;
-                }
-              case OP_BRIDGE:
-                {
-                  const bridgeInput = this._currentChannel.input;
-                  // PipeTo(left, Bridge(queue, channel))
-                  // In a fiber: repeatedly run left and push its outputs to the queue
-                  // Add a finalizer to interrupt the fiber and close the executor
-                  this._currentChannel = this._currentChannel.channel;
-                  if (this._input !== undefined) {
-                    const inputExecutor = this._input;
-                    this._input = undefined;
-                    const drainer = () => flatMap$3(bridgeInput.awaitRead(), () => suspend$3(() => {
-                      const state = inputExecutor.run();
-                      switch (state._tag) {
-                        case OP_DONE$1:
-                          {
-                            return match$2(inputExecutor.getDone(), {
-                              onFailure: cause => bridgeInput.error(cause),
-                              onSuccess: value => bridgeInput.done(value)
-                            });
-                          }
-                        case OP_EMIT$1:
-                          {
-                            return flatMap$3(bridgeInput.emit(inputExecutor.getEmit()), () => drainer());
-                          }
-                        case OP_FROM_EFFECT:
-                          {
-                            return matchCauseEffect(state.effect, {
-                              onFailure: cause => bridgeInput.error(cause),
-                              onSuccess: () => drainer()
-                            });
-                          }
-                        case OP_READ:
-                          {
-                            return readUpstream(state, () => drainer(), cause => bridgeInput.error(cause));
-                          }
-                      }
-                    }));
-                    result = fromEffect$2(flatMap$3(forkDaemon(interruptible(drainer())), fiber => sync$2(() => this.addFinalizer(exit => flatMap$3(interrupt(fiber), () => suspend$3(() => {
-                      const effect = this.restorePipe(exit, inputExecutor);
-                      return effect !== undefined ? effect : _void;
-                    }))))));
-                  }
-                  break;
-                }
-              case OP_CONCAT_ALL:
-                {
-                  const executor = new ChannelExecutor(this._currentChannel.value(), this._providedEnv, effect => sync$2(() => {
-                    const prevLastClose = this._closeLastSubstream === undefined ? _void : this._closeLastSubstream;
-                    this._closeLastSubstream = pipe(prevLastClose, zipRight$3(effect));
-                  }));
-                  executor._input = this._input;
-                  const channel = this._currentChannel;
-                  this._activeSubexecutor = new PullFromUpstream(executor, value => channel.k(value), undefined, [], (x, y) => channel.combineInners(x, y), (x, y) => channel.combineAll(x, y), request => channel.onPull(request), value => channel.onEmit(value));
-                  this._closeLastSubstream = undefined;
-                  this._currentChannel = undefined;
-                  break;
-                }
-              case OP_EMIT$2:
-                {
-                  this._emitted = this._currentChannel.out;
-                  this._currentChannel = this._activeSubexecutor !== undefined ? undefined : void_;
-                  result = Emit$1();
-                  break;
-                }
-              case OP_ENSURING:
-                {
-                  this.runEnsuring(this._currentChannel);
-                  break;
-                }
-              case OP_FAIL:
-                {
-                  result = this.doneHalt(this._currentChannel.error());
-                  break;
-                }
-              case OP_FOLD:
-                {
-                  this._doneStack.push(this._currentChannel.k);
-                  this._currentChannel = this._currentChannel.channel;
-                  break;
-                }
-              case OP_FROM_EFFECT$1:
-                {
-                  const effect = this._providedEnv === undefined ? this._currentChannel.effect() : pipe(this._currentChannel.effect(), provide(this._providedEnv));
-                  result = fromEffect$2(matchCauseEffect(effect, {
-                    onFailure: cause => {
-                      const state = this.doneHalt(cause);
-                      return state !== undefined && isFromEffect(state) ? state.effect : _void;
-                    },
-                    onSuccess: value => {
-                      const state = this.doneSucceed(value);
-                      return state !== undefined && isFromEffect(state) ? state.effect : _void;
-                    }
-                  }));
-                  break;
-                }
-              case OP_PIPE_TO:
-                {
-                  const previousInput = this._input;
-                  const leftExec = new ChannelExecutor(this._currentChannel.left(), this._providedEnv, effect => this._executeCloseLastSubstream(effect));
-                  leftExec._input = previousInput;
-                  this._input = leftExec;
-                  this.addFinalizer(exit => {
-                    const effect = this.restorePipe(exit, previousInput);
-                    return effect !== undefined ? effect : _void;
-                  });
-                  this._currentChannel = this._currentChannel.right();
-                  break;
-                }
-              case OP_PROVIDE:
-                {
-                  const previousEnv = this._providedEnv;
-                  this._providedEnv = this._currentChannel.context();
-                  this._currentChannel = this._currentChannel.inner;
-                  this.addFinalizer(() => sync$2(() => {
-                    this._providedEnv = previousEnv;
-                  }));
-                  break;
-                }
-              case OP_READ$1:
-                {
-                  const read = this._currentChannel;
-                  result = Read(this._input, identity, emitted => {
-                    try {
-                      this._currentChannel = read.more(emitted);
-                    } catch (error) {
-                      this._currentChannel = read.done.onExit(die$2(error));
-                    }
-                    return undefined;
-                  }, exit => {
-                    const onExit = exit => {
-                      return read.done.onExit(exit);
-                    };
-                    this._currentChannel = onExit(exit);
-                    return undefined;
-                  });
-                  break;
-                }
-              case OP_SUCCEED:
-                {
-                  result = this.doneSucceed(this._currentChannel.evaluate());
-                  break;
-                }
-              case OP_SUCCEED_NOW:
-                {
-                  result = this.doneSucceed(this._currentChannel.terminal);
-                  break;
-                }
-              case OP_SUSPEND:
-                {
-                  this._currentChannel = this._currentChannel.channel();
-                  break;
-                }
-            }
-          }
-        } catch (error) {
-          this._currentChannel = failCause$2(die(error));
-        }
-      }
-    }
-    return result;
-  }
-  getDone() {
-    return this._done;
-  }
-  getEmit() {
-    return this._emitted;
-  }
-  cancelWith(exit) {
-    this._cancelled = exit;
-  }
-  clearInProgressFinalizer() {
-    this._inProgressFinalizer = undefined;
-  }
-  storeInProgressFinalizer(finalizer) {
-    this._inProgressFinalizer = finalizer;
-  }
-  popAllFinalizers(exit) {
-    const finalizers = [];
-    let next = this._doneStack.pop();
-    while (next) {
-      if (next._tag === "ContinuationFinalizer") {
-        finalizers.push(next.finalizer);
-      }
-      next = this._doneStack.pop();
-    }
-    const effect = finalizers.length === 0 ? _void : runFinalizers(finalizers, exit);
-    this.storeInProgressFinalizer(effect);
-    return effect;
-  }
-  popNextFinalizers() {
-    const builder = [];
-    while (this._doneStack.length !== 0) {
-      const cont = this._doneStack[this._doneStack.length - 1];
-      if (cont._tag === OP_CONTINUATION_K) {
-        return builder;
-      }
-      builder.push(cont);
-      this._doneStack.pop();
-    }
-    return builder;
-  }
-  restorePipe(exit, prev) {
-    const currInput = this._input;
-    this._input = prev;
-    if (currInput !== undefined) {
-      const effect = currInput.close(exit);
-      return effect;
-    }
-    return _void;
-  }
-  close(exit$1) {
-    let runInProgressFinalizers = undefined;
-    const finalizer = this._inProgressFinalizer;
-    if (finalizer !== undefined) {
-      runInProgressFinalizers = pipe(finalizer, ensuring$2(sync$2(() => this.clearInProgressFinalizer())));
-    }
-    let closeSelf = undefined;
-    const selfFinalizers = this.popAllFinalizers(exit$1);
-    if (selfFinalizers !== undefined) {
-      closeSelf = pipe(selfFinalizers, ensuring$2(sync$2(() => this.clearInProgressFinalizer())));
-    }
-    const closeSubexecutors = this._activeSubexecutor === undefined ? undefined : this._activeSubexecutor.close(exit$1);
-    if (closeSubexecutors === undefined && runInProgressFinalizers === undefined && closeSelf === undefined) {
-      return undefined;
-    }
-    return pipe(exit(ifNotNull(closeSubexecutors)), zip$1(exit(ifNotNull(runInProgressFinalizers))), zip$1(exit(ifNotNull(closeSelf))), map$5(([[exit1, exit2], exit3]) => pipe(exit1, zipRight$2(exit2), zipRight$2(exit3))), uninterruptible$1,
-    // TODO: remove
-    flatMap$3(exit => suspend$3(() => exit)));
-  }
-  doneSucceed(value) {
-    if (this._doneStack.length === 0) {
-      this._done = succeed$2(value);
-      this._currentChannel = undefined;
-      return Done();
-    }
-    const head = this._doneStack[this._doneStack.length - 1];
-    if (head._tag === OP_CONTINUATION_K) {
-      this._doneStack.pop();
-      this._currentChannel = head.onSuccess(value);
-      return undefined;
-    }
-    const finalizers = this.popNextFinalizers();
-    if (this._doneStack.length === 0) {
-      this._doneStack = finalizers.reverse();
-      this._done = succeed$2(value);
-      this._currentChannel = undefined;
-      return Done();
-    }
-    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), succeed$2(value));
-    this.storeInProgressFinalizer(finalizerEffect);
-    const effect = pipe(finalizerEffect, ensuring$2(sync$2(() => this.clearInProgressFinalizer())), uninterruptible$1, flatMap$3(() => sync$2(() => this.doneSucceed(value))));
-    return fromEffect$2(effect);
-  }
-  doneHalt(cause) {
-    if (this._doneStack.length === 0) {
-      this._done = failCause$3(cause);
-      this._currentChannel = undefined;
-      return Done();
-    }
-    const head = this._doneStack[this._doneStack.length - 1];
-    if (head._tag === OP_CONTINUATION_K) {
-      this._doneStack.pop();
-      try {
-        this._currentChannel = head.onHalt(cause);
-      } catch (error) {
-        this._currentChannel = failCause$2(die(error));
-      }
-      return undefined;
-    }
-    const finalizers = this.popNextFinalizers();
-    if (this._doneStack.length === 0) {
-      this._doneStack = finalizers.reverse();
-      this._done = failCause$3(cause);
-      this._currentChannel = undefined;
-      return Done();
-    }
-    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), failCause$3(cause));
-    this.storeInProgressFinalizer(finalizerEffect);
-    const effect = pipe(finalizerEffect, ensuring$2(sync$2(() => this.clearInProgressFinalizer())), uninterruptible$1, flatMap$3(() => sync$2(() => this.doneHalt(cause))));
-    return fromEffect$2(effect);
-  }
-  processCancellation() {
-    this._currentChannel = undefined;
-    this._done = this._cancelled;
-    this._cancelled = undefined;
-    return Done();
-  }
-  runBracketOut(bracketOut) {
-    const effect = uninterruptible$1(matchCauseEffect(this.provide(bracketOut.acquire()), {
-      onFailure: cause => sync$2(() => {
-        this._currentChannel = failCause$2(cause);
-      }),
-      onSuccess: out => sync$2(() => {
-        this.addFinalizer(exit => this.provide(bracketOut.finalizer(out, exit)));
-        this._currentChannel = write(out);
-      })
-    }));
-    return fromEffect$2(effect);
-  }
-  provide(effect) {
-    if (this._providedEnv === undefined) {
-      return effect;
-    }
-    return pipe(effect, provide(this._providedEnv));
-  }
-  runEnsuring(ensuring) {
-    this.addFinalizer(ensuring.finalizer);
-    this._currentChannel = ensuring.channel;
-  }
-  addFinalizer(f) {
-    this._doneStack.push(new ContinuationFinalizerImpl(f));
-  }
-  runSubexecutor() {
-    const subexecutor = this._activeSubexecutor;
-    switch (subexecutor._tag) {
-      case OP_PULL_FROM_CHILD:
-        {
-          return this.pullFromChild(subexecutor.childExecutor, subexecutor.parentSubexecutor, subexecutor.onEmit, subexecutor);
-        }
-      case OP_PULL_FROM_UPSTREAM:
-        {
-          return this.pullFromUpstream(subexecutor);
-        }
-      case OP_DRAIN_CHILD_EXECUTORS:
-        {
-          return this.drainChildExecutors(subexecutor);
-        }
-      case OP_EMIT:
-        {
-          this._emitted = subexecutor.value;
-          this._activeSubexecutor = subexecutor.next;
-          return Emit$1();
-        }
-    }
-  }
-  replaceSubexecutor(nextSubExec) {
-    this._currentChannel = undefined;
-    this._activeSubexecutor = nextSubExec;
-  }
-  finishWithExit(exit) {
-    const state = match$2(exit, {
-      onFailure: cause => this.doneHalt(cause),
-      onSuccess: value => this.doneSucceed(value)
-    });
-    this._activeSubexecutor = undefined;
-    return state === undefined ? _void : effect(state);
-  }
-  finishSubexecutorWithCloseEffect(subexecutorDone, ...closeFuncs) {
-    this.addFinalizer(() => pipe(closeFuncs, forEach(closeFunc => pipe(sync$2(() => closeFunc(subexecutorDone)), flatMap$3(closeEffect => closeEffect !== undefined ? closeEffect : _void)), {
-      discard: true
-    })));
-    const state = pipe(subexecutorDone, match$2({
-      onFailure: cause => this.doneHalt(cause),
-      onSuccess: value => this.doneSucceed(value)
-    }));
-    this._activeSubexecutor = undefined;
-    return state;
-  }
-  applyUpstreamPullStrategy(upstreamFinished, queue, strategy) {
-    switch (strategy._tag) {
-      case OP_PULL_AFTER_NEXT:
-        {
-          const shouldPrepend = !upstreamFinished || queue.some(subexecutor => subexecutor !== undefined);
-          return [strategy.emitSeparator, shouldPrepend ? [undefined, ...queue] : queue];
-        }
-      case OP_PULL_AFTER_ALL_ENQUEUED:
-        {
-          const shouldEnqueue = !upstreamFinished || queue.some(subexecutor => subexecutor !== undefined);
-          return [strategy.emitSeparator, shouldEnqueue ? [...queue, undefined] : queue];
-        }
-    }
-  }
-  pullFromChild(childExecutor, parentSubexecutor, onEmitted, subexecutor) {
-    return Read(childExecutor, identity, emitted => {
-      const childExecutorDecision = onEmitted(emitted);
-      switch (childExecutorDecision._tag) {
-        case OP_CONTINUE:
-          {
-            break;
-          }
-        case OP_CLOSE:
-          {
-            this.finishWithDoneValue(childExecutor, parentSubexecutor, childExecutorDecision.value);
-            break;
-          }
-        case OP_YIELD:
-          {
-            const modifiedParent = parentSubexecutor.enqueuePullFromChild(subexecutor);
-            this.replaceSubexecutor(modifiedParent);
-            break;
-          }
-      }
-      this._activeSubexecutor = new Emit(emitted, this._activeSubexecutor);
-      return undefined;
-    }, match$2({
-      onFailure: cause => {
-        const state = this.handleSubexecutorFailure(childExecutor, parentSubexecutor, cause);
-        return state === undefined ? undefined : effectOrUndefinedIgnored(state);
-      },
-      onSuccess: doneValue => {
-        this.finishWithDoneValue(childExecutor, parentSubexecutor, doneValue);
-        return undefined;
-      }
-    }));
-  }
-  finishWithDoneValue(childExecutor, parentSubexecutor, doneValue) {
-    const subexecutor = parentSubexecutor;
-    switch (subexecutor._tag) {
-      case OP_PULL_FROM_UPSTREAM:
-        {
-          const modifiedParent = new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone !== undefined ? subexecutor.combineChildResults(subexecutor.lastDone, doneValue) : doneValue, subexecutor.activeChildExecutors, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit);
-          this._closeLastSubstream = childExecutor.close(succeed$2(doneValue));
-          this.replaceSubexecutor(modifiedParent);
-          break;
-        }
-      case OP_DRAIN_CHILD_EXECUTORS:
-        {
-          const modifiedParent = new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone !== undefined ? subexecutor.combineChildResults(subexecutor.lastDone, doneValue) : doneValue, subexecutor.activeChildExecutors, subexecutor.upstreamDone, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull);
-          this._closeLastSubstream = childExecutor.close(succeed$2(doneValue));
-          this.replaceSubexecutor(modifiedParent);
-          break;
-        }
-    }
-  }
-  handleSubexecutorFailure(childExecutor, parentSubexecutor, cause) {
-    return this.finishSubexecutorWithCloseEffect(failCause$3(cause), exit => parentSubexecutor.close(exit), exit => childExecutor.close(exit));
-  }
-  pullFromUpstream(subexecutor) {
-    if (subexecutor.activeChildExecutors.length === 0) {
-      return this.performPullFromUpstream(subexecutor);
-    }
-    const activeChild = subexecutor.activeChildExecutors[0];
-    const parentSubexecutor = new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone, subexecutor.activeChildExecutors.slice(1), subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit);
-    if (activeChild === undefined) {
-      return this.performPullFromUpstream(parentSubexecutor);
-    }
-    this.replaceSubexecutor(new PullFromChild(activeChild.childExecutor, parentSubexecutor, activeChild.onEmit));
-    return undefined;
-  }
-  performPullFromUpstream(subexecutor) {
-    return Read(subexecutor.upstreamExecutor, effect => {
-      const closeLastSubstream = this._closeLastSubstream === undefined ? _void : this._closeLastSubstream;
-      this._closeLastSubstream = undefined;
-      return pipe(this._executeCloseLastSubstream(closeLastSubstream), zipRight$3(effect));
-    }, emitted => {
-      if (this._closeLastSubstream !== undefined) {
-        const closeLastSubstream = this._closeLastSubstream;
-        this._closeLastSubstream = undefined;
-        return pipe(this._executeCloseLastSubstream(closeLastSubstream), map$5(() => {
-          const childExecutor = new ChannelExecutor(subexecutor.createChild(emitted), this._providedEnv, this._executeCloseLastSubstream);
-          childExecutor._input = this._input;
-          const [emitSeparator, updatedChildExecutors] = this.applyUpstreamPullStrategy(false, subexecutor.activeChildExecutors, subexecutor.onPull(Pulled(emitted)));
-          this._activeSubexecutor = new PullFromChild(childExecutor, new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone, updatedChildExecutors, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit), subexecutor.onEmit);
-          if (isSome(emitSeparator)) {
-            this._activeSubexecutor = new Emit(emitSeparator.value, this._activeSubexecutor);
-          }
-          return undefined;
-        }));
-      }
-      const childExecutor = new ChannelExecutor(subexecutor.createChild(emitted), this._providedEnv, this._executeCloseLastSubstream);
-      childExecutor._input = this._input;
-      const [emitSeparator, updatedChildExecutors] = this.applyUpstreamPullStrategy(false, subexecutor.activeChildExecutors, subexecutor.onPull(Pulled(emitted)));
-      this._activeSubexecutor = new PullFromChild(childExecutor, new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone, updatedChildExecutors, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit), subexecutor.onEmit);
-      if (isSome(emitSeparator)) {
-        this._activeSubexecutor = new Emit(emitSeparator.value, this._activeSubexecutor);
-      }
-      return undefined;
-    }, exit => {
-      if (subexecutor.activeChildExecutors.some(subexecutor => subexecutor !== undefined)) {
-        const drain = new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone, [undefined, ...subexecutor.activeChildExecutors], subexecutor.upstreamExecutor.getDone(), subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull);
-        if (this._closeLastSubstream !== undefined) {
-          const closeLastSubstream = this._closeLastSubstream;
-          this._closeLastSubstream = undefined;
-          return pipe(this._executeCloseLastSubstream(closeLastSubstream), map$5(() => this.replaceSubexecutor(drain)));
-        }
-        this.replaceSubexecutor(drain);
-        return undefined;
-      }
-      const closeLastSubstream = this._closeLastSubstream;
-      const state = this.finishSubexecutorWithCloseEffect(pipe(exit, map$6(a => subexecutor.combineWithChildResult(subexecutor.lastDone, a))), () => closeLastSubstream, exit => subexecutor.upstreamExecutor.close(exit));
-      return state === undefined ? undefined :
-      // NOTE: assuming finalizers cannot fail
-      effectOrUndefinedIgnored(state);
-    });
-  }
-  drainChildExecutors(subexecutor) {
-    if (subexecutor.activeChildExecutors.length === 0) {
-      const lastClose = this._closeLastSubstream;
-      if (lastClose !== undefined) {
-        this.addFinalizer(() => succeed$3(lastClose));
-      }
-      return this.finishSubexecutorWithCloseEffect(subexecutor.upstreamDone, () => lastClose, exit => subexecutor.upstreamExecutor.close(exit));
-    }
-    const activeChild = subexecutor.activeChildExecutors[0];
-    const rest = subexecutor.activeChildExecutors.slice(1);
-    if (activeChild === undefined) {
-      const [emitSeparator, remainingExecutors] = this.applyUpstreamPullStrategy(true, rest, subexecutor.onPull(NoUpstream(rest.reduce((n, curr) => curr !== undefined ? n + 1 : n, 0))));
-      this.replaceSubexecutor(new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone, remainingExecutors, subexecutor.upstreamDone, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull));
-      if (isSome(emitSeparator)) {
-        this._emitted = emitSeparator.value;
-        return Emit$1();
-      }
-      return undefined;
-    }
-    const parentSubexecutor = new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone, rest, subexecutor.upstreamDone, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull);
-    this.replaceSubexecutor(new PullFromChild(activeChild.childExecutor, parentSubexecutor, activeChild.onEmit));
-    return undefined;
-  }
-}
-const ifNotNull = effect => effect !== undefined ? effect : _void;
-const runFinalizers = (finalizers, exit$1) => {
-  return pipe(forEach(finalizers, fin => exit(fin(exit$1))), map$5(exits => pipe(all(exits), getOrElse(() => void_$2))), flatMap$3(exit => suspend$3(() => exit)));
-};
-/**
- * @internal
- */
-const readUpstream = (r, onSuccess, onFailure) => {
-  const readStack = [r];
-  const read = () => {
-    const current = readStack.pop();
-    if (current === undefined || current.upstream === undefined) {
-      return dieMessage("Unexpected end of input for channel execution");
-    }
-    const state = current.upstream.run();
-    switch (state._tag) {
-      case OP_EMIT$1:
-        {
-          const emitEffect = current.onEmit(current.upstream.getEmit());
-          if (readStack.length === 0) {
-            if (emitEffect === undefined) {
-              return suspend$3(onSuccess);
-            }
-            return pipe(emitEffect, matchCauseEffect({
-              onFailure,
-              onSuccess
-            }));
-          }
-          if (emitEffect === undefined) {
-            return suspend$3(() => read());
-          }
-          return pipe(emitEffect, matchCauseEffect({
-            onFailure,
-            onSuccess: () => read()
-          }));
-        }
-      case OP_DONE$1:
-        {
-          const doneEffect = current.onDone(current.upstream.getDone());
-          if (readStack.length === 0) {
-            if (doneEffect === undefined) {
-              return suspend$3(onSuccess);
-            }
-            return pipe(doneEffect, matchCauseEffect({
-              onFailure,
-              onSuccess
-            }));
-          }
-          if (doneEffect === undefined) {
-            return suspend$3(() => read());
-          }
-          return pipe(doneEffect, matchCauseEffect({
-            onFailure,
-            onSuccess: () => read()
-          }));
-        }
-      case OP_FROM_EFFECT:
-        {
-          readStack.push(current);
-          return pipe(current.onEffect(state.effect), catchAllCause(cause => suspend$3(() => {
-            const doneEffect = current.onDone(failCause$3(cause));
-            return doneEffect === undefined ? _void : doneEffect;
-          })), matchCauseEffect({
-            onFailure,
-            onSuccess: () => read()
-          }));
-        }
-      case OP_READ:
-        {
-          readStack.push(current);
-          readStack.push(state);
-          return suspend$3(() => read());
-        }
-    }
-  };
-  return read();
-};
-/** @internal */
-const runIn = /*#__PURE__*/dual(2, (self, scope) => {
-  const run = (channelDeferred, scopeDeferred, scope) => acquireUseRelease(sync$2(() => new ChannelExecutor(self, void 0, identity)), exec => suspend$3(() => runScopedInterpret(exec.run(), exec).pipe(intoDeferred(channelDeferred), zipRight$3(_await$2(channelDeferred)), zipLeft(_await$2(scopeDeferred)))), (exec, exit) => {
-    const finalize = exec.close(exit);
-    if (finalize === undefined) {
-      return _void;
-    }
-    return tapErrorCause(finalize, cause => addFinalizer(scope, failCause$4(cause)));
-  });
-  return uninterruptibleMask(restore => all$1([fork(scope, sequential), make$6(), make$6()]).pipe(flatMap$3(([child, channelDeferred, scopeDeferred]) => restore(run(channelDeferred, scopeDeferred, child)).pipe(forkIn(scope), flatMap$3(fiber => scope.addFinalizer(exit => {
-    const interruptors$1 = isFailure(exit) ? interruptors(exit.cause) : undefined;
-    return isDone(channelDeferred).pipe(flatMap$3(isDone => isDone ? succeed$4(scopeDeferred, void 0).pipe(zipRight$3(_await(fiber)), zipRight$3(inheritAll(fiber))) : succeed$4(scopeDeferred, void 0).pipe(zipRight$3(interruptors$1 && size$2(interruptors$1) > 0 ? interruptAs(fiber, combineAll(interruptors$1)) : interrupt(fiber)), zipRight$3(inheritAll(fiber)))));
-  }).pipe(zipRight$3(restore(_await$2(channelDeferred)))))))));
-});
-/** @internal */
-const runScopedInterpret = (channelState, exec) => {
-  const op = channelState;
-  switch (op._tag) {
-    case OP_FROM_EFFECT:
-      {
-        return pipe(op.effect, flatMap$3(() => runScopedInterpret(exec.run(), exec)));
-      }
-    case OP_EMIT$1:
-      {
-        // Can't really happen because Out <:< Nothing. So just skip ahead.
-        return runScopedInterpret(exec.run(), exec);
-      }
-    case OP_DONE$1:
-      {
-        return suspend$3(() => exec.getDone());
-      }
-    case OP_READ:
-      {
-        return readUpstream(op, () => runScopedInterpret(exec.run(), exec), failCause$4);
-      }
-  }
-};
-
-/** @internal */
-const OP_DONE = "Done";
-/** @internal */
-const OP_AWAIT = "Await";
-
-/** @internal */
-const MergeDecisionSymbolKey = "effect/ChannelMergeDecision";
-/** @internal */
-const MergeDecisionTypeId = /*#__PURE__*/Symbol.for(MergeDecisionSymbolKey);
-/** @internal */
-const proto$2 = {
-  [MergeDecisionTypeId]: {
-    _R: _ => _,
-    _E0: _ => _,
-    _Z0: _ => _,
-    _E: _ => _,
-    _Z: _ => _
-  }
-};
-/** @internal */
-const Await = f => {
-  const op = Object.create(proto$2);
-  op._tag = OP_AWAIT;
-  op.f = f;
-  return op;
-};
-
-/** @internal */
-const OP_BOTH_RUNNING = "BothRunning";
-/** @internal */
-const OP_LEFT_DONE = "LeftDone";
-/** @internal */
-const OP_RIGHT_DONE = "RightDone";
-
-/** @internal */
-const MergeStateSymbolKey = "effect/ChannelMergeState";
-/** @internal */
-const MergeStateTypeId = /*#__PURE__*/Symbol.for(MergeStateSymbolKey);
-/** @internal */
-const proto$1 = {
-  [MergeStateTypeId]: MergeStateTypeId
-};
-/** @internal */
-const BothRunning = (left, right) => {
-  const op = Object.create(proto$1);
-  op._tag = OP_BOTH_RUNNING;
-  op.left = left;
-  op.right = right;
-  return op;
-};
-/** @internal */
-const LeftDone = f => {
-  const op = Object.create(proto$1);
-  op._tag = OP_LEFT_DONE;
-  op.f = f;
-  return op;
-};
-/** @internal */
-const RightDone = f => {
-  const op = Object.create(proto$1);
-  op._tag = OP_RIGHT_DONE;
-  op.f = f;
-  return op;
-};
-
-/** @internal */
-const OP_BACK_PRESSURE = "BackPressure";
-/** @internal */
-const OP_BUFFER_SLIDING = "BufferSliding";
-
-/** @internal */
-const MergeStrategySymbolKey = "effect/ChannelMergeStrategy";
-/** @internal */
-const MergeStrategyTypeId = /*#__PURE__*/Symbol.for(MergeStrategySymbolKey);
-/** @internal */
-const proto = {
-  [MergeStrategyTypeId]: MergeStrategyTypeId
-};
-/** @internal */
-const BackPressure = _ => {
-  const op = Object.create(proto);
-  op._tag = OP_BACK_PRESSURE;
-  return op;
-};
-/** @internal */
-const BufferSliding = _ => {
-  const op = Object.create(proto);
-  op._tag = OP_BUFFER_SLIDING;
-  return op;
-};
-/** @internal */
-const match = /*#__PURE__*/dual(2, (self, {
-  onBackPressure,
-  onBufferSliding
-}) => {
-  switch (self._tag) {
-    case OP_BACK_PRESSURE:
-      {
-        return onBackPressure();
-      }
-    case OP_BUFFER_SLIDING:
-      {
-        return onBufferSliding();
-      }
-  }
-});
-
-/** @internal */
-const OP_STATE_EMPTY = "Empty";
-/** @internal */
-const OP_STATE_EMIT = "Emit";
-/** @internal */
-const OP_STATE_ERROR = "Error";
-/** @internal */
-const OP_STATE_DONE = "Done";
-/** @internal */
-const stateEmpty = notifyProducer => ({
-  _tag: OP_STATE_EMPTY,
-  notifyProducer
-});
-/** @internal */
-const stateEmit = notifyConsumers => ({
-  _tag: OP_STATE_EMIT,
-  notifyConsumers
-});
-/** @internal */
-const stateError = cause => ({
-  _tag: OP_STATE_ERROR,
-  cause
-});
-/** @internal */
-const stateDone = done => ({
-  _tag: OP_STATE_DONE,
-  done
-});
-/** @internal */
-class SingleProducerAsyncInputImpl {
-  ref;
-  constructor(ref) {
-    this.ref = ref;
-  }
-  awaitRead() {
-    return flatten$2(modify(this.ref, state => state._tag === OP_STATE_EMPTY ? [_await$2(state.notifyProducer), state] : [_void, state]));
-  }
-  get close() {
-    return fiberIdWith(fiberId => this.error(interrupt$1(fiberId)));
-  }
-  done(value) {
-    return flatten$2(modify(this.ref, state => {
-      switch (state._tag) {
-        case OP_STATE_EMPTY:
-          {
-            return [_await$2(state.notifyProducer), state];
-          }
-        case OP_STATE_EMIT:
-          {
-            return [forEach(state.notifyConsumers, deferred => succeed$4(deferred, left(value)), {
-              discard: true
-            }), stateDone(value)];
-          }
-        case OP_STATE_ERROR:
-          {
-            return [interrupt$4, state];
-          }
-        case OP_STATE_DONE:
-          {
-            return [interrupt$4, state];
-          }
-      }
-    }));
-  }
-  emit(element) {
-    return flatMap$3(make$6(), deferred => flatten$2(modify(this.ref, state => {
-      switch (state._tag) {
-        case OP_STATE_EMPTY:
-          {
-            return [_await$2(state.notifyProducer), state];
-          }
-        case OP_STATE_EMIT:
-          {
-            const notifyConsumer = state.notifyConsumers[0];
-            const notifyConsumers = state.notifyConsumers.slice(1);
-            if (notifyConsumer !== undefined) {
-              return [succeed$4(notifyConsumer, right(element)), notifyConsumers.length === 0 ? stateEmpty(deferred) : stateEmit(notifyConsumers)];
-            }
-            throw new Error("Bug: Channel.SingleProducerAsyncInput.emit - Queue was empty! please report an issue at https://github.com/Effect-TS/effect/issues");
-          }
-        case OP_STATE_ERROR:
-          {
-            return [interrupt$4, state];
-          }
-        case OP_STATE_DONE:
-          {
-            return [interrupt$4, state];
-          }
-      }
-    })));
-  }
-  error(cause) {
-    return flatten$2(modify(this.ref, state => {
-      switch (state._tag) {
-        case OP_STATE_EMPTY:
-          {
-            return [_await$2(state.notifyProducer), state];
-          }
-        case OP_STATE_EMIT:
-          {
-            return [forEach(state.notifyConsumers, deferred => failCause$5(deferred, cause), {
-              discard: true
-            }), stateError(cause)];
-          }
-        case OP_STATE_ERROR:
-          {
-            return [interrupt$4, state];
-          }
-        case OP_STATE_DONE:
-          {
-            return [interrupt$4, state];
-          }
-      }
-    }));
-  }
-  get take() {
-    return this.takeWith(cause => failCause$3(map$2(cause, left)), elem => succeed$2(elem), done => fail$3(right(done)));
-  }
-  takeWith(onError, onElement, onDone) {
-    return flatMap$3(make$6(), deferred => flatten$2(modify(this.ref, state => {
-      switch (state._tag) {
-        case OP_STATE_EMPTY:
-          {
-            return [zipRight$3(succeed$4(state.notifyProducer, void 0), matchCause(_await$2(deferred), {
-              onFailure: onError,
-              onSuccess: match$1({
-                onLeft: onDone,
-                onRight: onElement
-              })
-            })), stateEmit([deferred])];
-          }
-        case OP_STATE_EMIT:
-          {
-            return [matchCause(_await$2(deferred), {
-              onFailure: onError,
-              onSuccess: match$1({
-                onLeft: onDone,
-                onRight: onElement
-              })
-            }), stateEmit([...state.notifyConsumers, deferred])];
-          }
-        case OP_STATE_ERROR:
-          {
-            return [succeed$3(onError(state.cause)), state];
-          }
-        case OP_STATE_DONE:
-          {
-            return [succeed$3(onDone(state.done)), state];
-          }
-      }
-    })));
-  }
-}
-/** @internal */
-const make$1 = () => pipe(make$6(), flatMap$3(deferred => make$3(stateEmpty(deferred))), map$5(ref => new SingleProducerAsyncInputImpl(ref)));
-
-/** @internal */
-const concatMap = /*#__PURE__*/dual(2, (self, f) => concatMapWith(self, f, () => void 0, () => void 0));
-/** @internal */
-const drain$1 = self => {
-  const drainer = readWithCause({
-    onInput: () => drainer,
-    onFailure: failCause$2,
-    onDone: succeed
-  });
-  return pipeTo(self, drainer);
-};
-/** @internal */
-const ensuring$1 = /*#__PURE__*/dual(2, (self, finalizer) => ensuringWith(self, () => finalizer));
-/** @internal */
-const flatten$1 = self => flatMap$1(self, identity);
-/** @internal */
-const fromInput = input => unwrap(input.takeWith(failCause$2, elem => flatMap$1(write(elem), () => fromInput(input)), succeed));
-/** @internal */
-const identityChannel = () => readWith({
-  onInput: input => flatMap$1(write(input), () => identityChannel()),
-  onFailure: fail,
-  onDone: succeedNow
-});
-/** @internal */
-const map$1 = /*#__PURE__*/dual(2, (self, f) => flatMap$1(self, a => sync(() => f(a))));
-/** @internal */
-const mapOut = /*#__PURE__*/dual(2, (self, f) => {
-  const reader = readWith({
-    onInput: outElem => flatMap$1(write(f(outElem)), () => reader),
-    onFailure: fail,
-    onDone: succeedNow
-  });
-  return pipeTo(self, reader);
-});
-/** @internal */
-const mapOutEffectPar = /*#__PURE__*/dual(3, (self, f, n) => unwrapScopedWith$1(scope => gen(function* () {
-  const input = yield* make$1();
-  const queueReader = fromInput(input);
-  const queue = yield* bounded(n);
-  yield* addFinalizer(scope, shutdown(queue));
-  const errorSignal = yield* make$6();
-  const withPermits = n === Number.POSITIVE_INFINITY ? _ => identity : (yield* makeSemaphore(n)).withPermits;
-  const pull = yield* queueReader.pipe(pipeTo(self), toPullIn(scope));
-  yield* pull.pipe(matchCauseEffect({
-    onFailure: cause => offer(queue, failCause$4(cause)),
-    onSuccess: match$1({
-      onLeft: outDone => zipRight$3(interruptible(withPermits(n)(_void)), asVoid$1(offer(queue, succeed$3(left(outDone))))),
-      onRight: outElem => gen(function* () {
-        const deferred = yield* make$6();
-        const latch = yield* make$6();
-        yield* offer(queue, map$5(_await$2(deferred), right));
-        yield* succeed$4(latch, void 0).pipe(zipRight$3(uninterruptibleMask(restore => exit(restore(_await$2(errorSignal))).pipe(raceFirst(exit(restore(f(outElem)))), flatMap$3(identity))).pipe(tapErrorCause(cause => failCause$5(errorSignal, cause)), intoDeferred(deferred))), withPermits(1), forkIn(scope));
-        yield* _await$2(latch);
-      })
-    })
-  }), forever, interruptible, forkIn(scope));
-  const consumer = unwrap(matchCause(flatten$2(take(queue)), {
-    onFailure: failCause$2,
-    onSuccess: match$1({
-      onLeft: succeedNow,
-      onRight: outElem => flatMap$1(write(outElem), () => consumer)
-    })
-  }));
-  return embedInput(consumer, input);
-})));
-/** @internal */
-const mergeAll = options => {
-  return channels => mergeAllWith(options)(channels, constVoid);
-};
-/** @internal */
-const mergeAllWith = ({
-  bufferSize = 16,
-  concurrency,
-  mergeStrategy = BackPressure()
-}) => (channels, f) => unwrapScopedWith$1(scope => gen(function* () {
-  const concurrencyN = concurrency === "unbounded" ? Number.MAX_SAFE_INTEGER : concurrency;
-  const input = yield* make$1();
-  const queueReader = fromInput(input);
-  const queue = yield* bounded(bufferSize);
-  yield* addFinalizer(scope, shutdown(queue));
-  const cancelers = yield* unbounded();
-  yield* addFinalizer(scope, shutdown(cancelers));
-  const lastDone = yield* make$3(none());
-  const errorSignal = yield* make$6();
-  const withPermits = (yield* makeSemaphore(concurrencyN)).withPermits;
-  const pull = yield* toPullIn(pipeTo(queueReader, channels), scope);
-  function evaluatePull(pull) {
-    return pull.pipe(flatMap$3(match$1({
-      onLeft: done => succeed$3(some(done)),
-      onRight: outElem => as(offer(queue, succeed$3(right(outElem))), none())
-    })), repeat({
-      until: _ => isSome(_)
-    }), flatMap$3(outDone => update(lastDone, match$3({
-      onNone: () => some(outDone.value),
-      onSome: lastDone => some(f(lastDone, outDone.value))
-    }))), catchAllCause(cause => isInterrupted(cause) ? failCause$4(cause) : offer(queue, failCause$4(cause)).pipe(zipRight$3(succeed$4(errorSignal, void 0)), asVoid$1)));
-  }
-  yield* pull.pipe(matchCauseEffect({
-    onFailure: cause => offer(queue, failCause$4(cause)).pipe(zipRight$3(succeed$3(false))),
-    onSuccess: match$1({
-      onLeft: outDone => raceWith(interruptible(_await$2(errorSignal)), interruptible(withPermits(concurrencyN)(_void)), {
-        onSelfDone: (_, permitAcquisition) => as(interrupt(permitAcquisition), false),
-        onOtherDone: (_, failureAwait) => zipRight$3(interrupt(failureAwait), get(lastDone).pipe(flatMap$3(match$3({
-          onNone: () => offer(queue, succeed$3(left(outDone))),
-          onSome: lastDone => offer(queue, succeed$3(left(f(lastDone, outDone))))
-        })), as(false)))
-      }),
-      onRight: channel => match(mergeStrategy, {
-        onBackPressure: () => gen(function* () {
-          const latch = yield* make$6();
-          const raceEffects = scopedWith$2(scope => toPullIn(pipeTo(queueReader, channel), scope).pipe(flatMap$3(pull => race(exit(evaluatePull(pull)), exit(interruptible(_await$2(errorSignal))))), flatMap$3(identity)));
-          yield* succeed$4(latch, void 0).pipe(zipRight$3(raceEffects), withPermits(1), forkIn(scope));
-          yield* _await$2(latch);
-          const errored = yield* isDone(errorSignal);
-          return !errored;
-        }),
-        onBufferSliding: () => gen(function* () {
-          const canceler = yield* make$6();
-          const latch = yield* make$6();
-          const size$1 = yield* size(cancelers);
-          yield* take(cancelers).pipe(flatMap$3(canceler => succeed$4(canceler, void 0)), when(() => size$1 >= concurrencyN));
-          yield* offer(cancelers, canceler);
-          const raceEffects = scopedWith$2(scope => toPullIn(pipeTo(queueReader, channel), scope).pipe(flatMap$3(pull => exit(evaluatePull(pull)).pipe(race(exit(interruptible(_await$2(errorSignal)))), race(exit(interruptible(_await$2(canceler)))))), flatMap$3(identity)));
-          yield* succeed$4(latch, void 0).pipe(zipRight$3(raceEffects), withPermits(1), forkIn(scope));
-          yield* _await$2(latch);
-          const errored = yield* isDone(errorSignal);
-          return !errored;
-        })
-      })
-    })
-  }), repeat({
-    while: _ => _
-  }), forkIn(scope));
-  const consumer = pipe(take(queue), flatten$2, matchCause({
-    onFailure: failCause$2,
-    onSuccess: match$1({
-      onLeft: succeedNow,
-      onRight: outElem => flatMap$1(write(outElem), () => consumer)
-    })
-  }), unwrap);
-  return embedInput(consumer, input);
-}));
-/** @internal */
-const mergeMap = /*#__PURE__*/dual(3, (self, f, options) => mergeAll(options)(mapOut(self, f)));
-/** @internal */
-const mergeWith = /*#__PURE__*/dual(2, (self, options) => {
-  function merge(scope) {
-    return gen(function* () {
-      const input = yield* make$1();
-      const queueReader = fromInput(input);
-      const pullL = yield* toPullIn(pipeTo(queueReader, self), scope);
-      const pullR = yield* toPullIn(pipeTo(queueReader, options.other), scope);
-      function handleSide(exit, fiber, pull) {
-        return (done, both, single) => {
-          function onDecision(decision) {
-            const op = decision;
-            if (op._tag === OP_DONE) {
-              return succeed$3(fromEffect$3(zipRight$3(interrupt(fiber), op.effect)));
-            }
-            return map$5(_await(fiber), match$2({
-              onFailure: cause => fromEffect$3(op.f(failCause$3(cause))),
-              onSuccess: match$1({
-                onLeft: done => fromEffect$3(op.f(succeed$2(done))),
-                onRight: elem => zipRight(write(elem), go(single(op.f)))
-              })
-            }));
-          }
-          return match$2(exit, {
-            onFailure: cause => onDecision(done(failCause$3(cause))),
-            onSuccess: match$1({
-              onLeft: z => onDecision(done(succeed$2(z))),
-              onRight: elem => succeed$3(flatMap$1(write(elem), () => flatMap$1(fromEffect$3(forkIn(interruptible(pull), scope)), leftFiber => go(both(leftFiber, fiber)))))
-            })
-          });
-        };
-      }
-      function go(state) {
-        switch (state._tag) {
-          case OP_BOTH_RUNNING:
-            {
-              const leftJoin = interruptible(join(state.left));
-              const rightJoin = interruptible(join(state.right));
-              return unwrap(raceWith(leftJoin, rightJoin, {
-                onSelfDone: (leftExit, rf) => zipRight$3(interrupt(rf), handleSide(leftExit, state.right, pullL)(options.onSelfDone, BothRunning, f => LeftDone(f))),
-                onOtherDone: (rightExit, lf) => zipRight$3(interrupt(lf), handleSide(rightExit, state.left, pullR)(options.onOtherDone, (left, right) => BothRunning(right, left), f => RightDone(f)))
-              }));
-            }
-          case OP_LEFT_DONE:
-            {
-              return unwrap(map$5(exit(pullR), match$2({
-                onFailure: cause => fromEffect$3(state.f(failCause$3(cause))),
-                onSuccess: match$1({
-                  onLeft: done => fromEffect$3(state.f(succeed$2(done))),
-                  onRight: elem => flatMap$1(write(elem), () => go(LeftDone(state.f)))
-                })
-              })));
-            }
-          case OP_RIGHT_DONE:
-            {
-              return unwrap(map$5(exit(pullL), match$2({
-                onFailure: cause => fromEffect$3(state.f(failCause$3(cause))),
-                onSuccess: match$1({
-                  onLeft: done => fromEffect$3(state.f(succeed$2(done))),
-                  onRight: elem => flatMap$1(write(elem), () => go(RightDone(state.f)))
-                })
-              })));
-            }
-        }
-      }
-      return fromEffect$3(withFiberRuntime$1(parent => {
-        const inherit = withFiberRuntime$1(state => {
-          state.transferChildren(parent.scope());
-          return _void;
-        });
-        const leftFiber = interruptible(pullL).pipe(ensuring$2(inherit), forkIn(scope));
-        const rightFiber = interruptible(pullR).pipe(ensuring$2(inherit), forkIn(scope));
-        return zipWith(leftFiber, rightFiber, (left, right) => BothRunning(left, right));
-      })).pipe(flatMap$1(go), embedInput(input));
-    });
-  }
-  return unwrapScopedWith$1(merge);
-});
-/** @internal */
-const pipeToOrFail = /*#__PURE__*/dual(2, (self, that) => suspend$1(() => {
-  let channelException = undefined;
-  const reader = readWith({
-    onInput: outElem => flatMap$1(write(outElem), () => reader),
-    onFailure: outErr => {
-      channelException = ChannelException(outErr);
-      return failCause$2(die(channelException));
-    },
-    onDone: succeedNow
-  });
-  const writer = readWithCause({
-    onInput: outElem => pipe(write(outElem), flatMap$1(() => writer)),
-    onFailure: cause => isDieType(cause) && isChannelException(cause.defect) && equals(cause.defect, channelException) ? fail(cause.defect.error) : failCause$2(cause),
-    onDone: succeedNow
-  });
-  return pipeTo(pipeTo(pipeTo(self, reader), that), writer);
-}));
-/** @internal */
-const run$1 = self => scopedWith$2(scope => runIn(self, scope));
-/** @internal */
-const runDrain$2 = self => run$1(drain$1(self));
-/** @internal */
-const scoped = effect => unwrap(uninterruptibleMask(restore => map$5(make$7(), scope => acquireReleaseOut(tapErrorCause(restore(extend(effect, scope)), cause => close(scope, failCause$3(cause))), (_, exit) => close(scope, exit)))));
-/** @internal */
-const scopedWith$1 = f => unwrapScoped(map$5(scope, scope => flatMap$1(fromEffect$3(f(scope)), write)));
-/** @internal */
-const toPullIn = /*#__PURE__*/dual(2, (self, scope) => zip$1(sync$2(() => new ChannelExecutor(self, void 0, identity)), runtime()).pipe(tap(([executor, runtime]) => addFinalizerExit(scope, exit => {
-  const finalizer = executor.close(exit);
-  return finalizer !== undefined ? provide(finalizer, runtime) : _void;
-})), uninterruptible$1, map$5(([executor]) => suspend$3(() => interpretToPull(executor.run(), executor)))));
-/** @internal */
-const interpretToPull = (channelState, exec) => {
-  const state = channelState;
-  switch (state._tag) {
-    case OP_DONE$1:
-      {
-        return match$2(exec.getDone(), {
-          onFailure: failCause$4,
-          onSuccess: done => succeed$3(left(done))
-        });
-      }
-    case OP_EMIT$1:
-      {
-        return succeed$3(right(exec.getEmit()));
-      }
-    case OP_FROM_EFFECT:
-      {
-        return pipe(state.effect, flatMap$3(() => interpretToPull(exec.run(), exec)));
-      }
-    case OP_READ:
-      {
-        return readUpstream(state, () => interpretToPull(exec.run(), exec), cause => failCause$4(cause));
-      }
-  }
-};
-/** @internal */
-const unwrap = channel => flatten$1(fromEffect$3(channel));
-/** @internal */
-const unwrapScoped = self => concatAllWith(scoped(self), (d, _) => d, (d, _) => d);
-/** @internal */
-const unwrapScopedWith$1 = f => concatAllWith(scopedWith$1(f), (d, _) => d, (d, _) => d);
-/** @internal */
-const writeChunk = outs => writeChunkWriter(0, outs.length, outs);
-/** @internal */
-const writeChunkWriter = (idx, len, chunk) => {
-  return idx === len ? void_ : pipe(write(pipe(chunk, unsafeGet(idx))), flatMap$1(() => writeChunkWriter(idx + 1, len, chunk)));
-};
-/** @internal */
-const zip = /*#__PURE__*/dual(args => isChannel(args[1]), (self, that, options) => options?.concurrent ? mergeWith(self, {
-  other: that,
-  onSelfDone: exit1 => Await(exit2 => suspend$3(() => zip$2(exit1, exit2))),
-  onOtherDone: exit2 => Await(exit1 => suspend$3(() => zip$2(exit1, exit2)))
-}) : flatMap$1(self, a => map$1(that, b => [a, b])));
-/** @internal */
-const zipRight = /*#__PURE__*/dual(args => isChannel(args[1]), (self, that, options) => options?.concurrent ? map$1(zip(self, that, {
-  concurrent: true
-}), tuple => tuple[1]) : flatMap$1(self, () => that));
-/** @internal */
-const ChannelExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Channel/ChannelException");
-/** @internal */
-const ChannelException = error => ({
-  _tag: "ChannelException",
-  [ChannelExceptionTypeId]: ChannelExceptionTypeId,
-  error
-});
-/** @internal */
-const isChannelException = u => hasProperty(u, ChannelExceptionTypeId);
-
-/** @internal */
-const SinkTypeId = /*#__PURE__*/Symbol.for("effect/Sink");
-const sinkVariance = {
-  /* c8 ignore next */
-  _A: _ => _,
-  /* c8 ignore next */
-  _In: _ => _,
-  /* c8 ignore next */
-  _L: _ => _,
-  /* c8 ignore next */
-  _E: _ => _,
-  /* c8 ignore next */
-  _R: _ => _
-};
-/** @internal */
-class SinkImpl {
-  channel;
-  [SinkTypeId] = sinkVariance;
-  constructor(channel) {
-    this.channel = channel;
-  }
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-}
-/** @internal */
-const drain = /*#__PURE__*/new SinkImpl(/*#__PURE__*/drain$1(/*#__PURE__*/identityChannel()));
-/** @internal */
-const fromEffect$1 = effect => new SinkImpl(fromEffect$3(effect));
-/** @internal */
-const toChannel$1 = self => isEffect(self) ? toChannel$1(fromEffect$1(self)) : self.channel;
-
-/** @internal */
-const TakeSymbolKey = "effect/Take";
-/** @internal */
-const TakeTypeId = /*#__PURE__*/Symbol.for(TakeSymbolKey);
-const takeVariance = {
-  /* c8 ignore next */
-  _A: _ => _,
-  /* c8 ignore next */
-  _E: _ => _
-};
-/** @internal */
-class TakeImpl {
-  exit;
-  [TakeTypeId] = takeVariance;
-  constructor(exit) {
-    this.exit = exit;
-  }
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-}
-/** @internal */
-const chunk = chunk => new TakeImpl(succeed$2(chunk));
-/** @internal */
-const end$1 = /*#__PURE__*/new TakeImpl(/*#__PURE__*/fail$3(/*#__PURE__*/none()));
-/** @internal */
-const failCause$1 = cause => new TakeImpl(failCause$3(pipe(cause, map$2(some))));
-/** @internal */
-const of = value => new TakeImpl(succeed$2(of$1(value)));
-
-/** @internal */
-const end = () => fail$4(none());
-/** @internal */
-const failCause = cause => mapError(failCause$4(cause), some);
-
-/** @internal */
-const StreamSymbolKey = "effect/Stream";
-/** @internal */
-const StreamTypeId = /*#__PURE__*/Symbol.for(StreamSymbolKey);
-/** @internal */
-const streamVariance = {
-  _R: _ => _,
-  _E: _ => _,
-  _A: _ => _
-};
-/** @internal */
-class StreamImpl {
-  channel;
-  [StreamTypeId] = streamVariance;
-  constructor(channel) {
-    this.channel = channel;
-  }
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-}
-/** @internal */
-const isStream = u => hasProperty(u, StreamTypeId) || isEffect(u);
-/** @internal */
-const DefaultChunkSize = 4096;
-/** @internal */
-const ensuring = /*#__PURE__*/dual(2, (self, finalizer) => new StreamImpl(pipe(toChannel(self), ensuring$1(finalizer))));
-/** @internal */
-const flatMap = /*#__PURE__*/dual(args => isStream(args[0]), (self, f, options) => {
-  const bufferSize = options?.bufferSize ?? 16;
-  if (options?.switch) {
-    return matchConcurrency(options?.concurrency, () => flatMapParSwitchBuffer(self, 1, bufferSize, f), n => flatMapParSwitchBuffer(self, n, bufferSize, f));
-  }
-  return matchConcurrency(options?.concurrency, () => new StreamImpl(concatMap(toChannel(self), as => pipe(as, map$7(a => toChannel(f(a))), reduce(void_, (left, right) => pipe(left, zipRight(right)))))), _ => new StreamImpl(pipe(toChannel(self), concatMap(writeChunk), mergeMap(out => toChannel(f(out)), options))));
-});
-/** @internal */
-const matchConcurrency = (concurrency, sequential, bounded) => {
-  switch (concurrency) {
-    case undefined:
-      return sequential();
-    case "unbounded":
-      return bounded(Number.MAX_SAFE_INTEGER);
-    default:
-      return concurrency > 1 ? bounded(concurrency) : sequential();
-  }
-};
-const flatMapParSwitchBuffer = /*#__PURE__*/dual(4, (self, n, bufferSize, f) => new StreamImpl(pipe(toChannel(self), concatMap(writeChunk), mergeMap(out => toChannel(f(out)), {
-  concurrency: n,
-  mergeStrategy: BufferSliding(),
-  bufferSize
-}))));
-/** @internal */
-const flatten = /*#__PURE__*/dual(args => isStream(args[0]), (self, options) => flatMap(self, identity, options));
-/** @internal */
-const flattenChunks = self => {
-  const flatten = readWithCause({
-    onInput: chunks => flatMap$1(writeChunk(chunks), () => flatten),
-    onFailure: failCause$2,
-    onDone: () => void_
-  });
-  return new StreamImpl(pipe(toChannel(self), pipeTo(flatten)));
-};
-/** @internal */
-const flattenExitOption = self => {
-  const processChunk = (chunk, cont) => {
-    const [toEmit, rest] = pipe(chunk, splitWhere(exit => !isSuccess(exit)));
-    const next = pipe(head(rest), match$3({
-      onNone: () => cont,
-      onSome: match$2({
-        onFailure: cause => match$3(flipCauseOption(cause), {
-          onNone: () => void_,
-          onSome: failCause$2
-        }),
-        onSuccess: () => void_
-      })
-    }));
-    return pipe(write(pipe(toEmit, filterMap(exit => isSuccess(exit) ? some(exit.value) : none()))), flatMap$1(() => next));
-  };
-  const process = readWithCause({
-    onInput: chunk => processChunk(chunk, process),
-    onFailure: cause => failCause$2(cause),
-    onDone: () => void_
-  });
-  return new StreamImpl(pipe(toChannel(self), pipeTo(process)));
-};
-/** @internal */
-const flattenTake = self => flattenChunks(flattenExitOption(pipe(self, map(take => take.exit))));
-/** @internal */
-const toChannel = stream => {
-  if ("channel" in stream) {
-    return stream.channel;
-  } else if (isEffect(stream)) {
-    return toChannel(fromEffect(stream));
-  } else {
-    throw new TypeError(`Expected a Stream.`);
-  }
-};
-/** @internal */
-const fromEffect = effect => pipe(effect, mapError(some), fromEffectOption);
-/** @internal */
-const fromEffectOption = effect => new StreamImpl(unwrap(match$4(effect, {
-  onFailure: match$3({
-    onNone: () => void_,
-    onSome: fail
-  }),
-  onSuccess: a => write(of$1(a))
-})));
-/** @internal */
-const fromQueue$1 = (queue, options) => pipe(takeBetween(queue, 1, options?.maxChunkSize ?? DefaultChunkSize), catchAllCause(cause => pipe(isShutdown(queue), flatMap$3(isShutdown => isShutdown && isInterrupted(cause) ? end() : failCause(cause)))), repeatEffectChunkOption, options?.shutdown ? ensuring(shutdown(queue)) : identity);
-/** @internal */
-const map = /*#__PURE__*/dual(2, (self, f) => new StreamImpl(pipe(toChannel(self), mapOut(map$7(f)))));
-/** @internal */
-const mapEffectSequential = /*#__PURE__*/dual(2, (self, f) => {
-  const loop = iterator => {
-    const next = iterator.next();
-    if (next.done) {
-      return readWithCause({
-        onInput: elem => loop(elem[Symbol.iterator]()),
-        onFailure: failCause$2,
-        onDone: succeed
-      });
-    } else {
-      const value = next.value;
-      return unwrap(map$5(f(value), a2 => flatMap$1(write(of$1(a2)), () => loop(iterator))));
-    }
-  };
-  return new StreamImpl(pipe(toChannel(self), pipeTo(suspend$1(() => loop(empty$1()[Symbol.iterator]())))));
-});
-/** @internal */
-const mapEffectPar = /*#__PURE__*/dual(3, (self, n, f) => new StreamImpl(pipe(toChannel(self), concatMap(writeChunk), mapOutEffectPar(f, n), mapOut(of$1))));
-/** @internal */
-const repeatEffectChunkOption = effect => unfoldChunkEffect(effect, effect => pipe(map$5(effect, chunk => some([chunk, effect])), catchAll$1(match$3({
-  onNone: () => succeed$3(none()),
-  onSome: fail$4
-}))));
-/** @internal */
-const run = /*#__PURE__*/dual(2, (self, sink) => toChannel(self).pipe(pipeToOrFail(toChannel$1(sink)), runDrain$2));
-/** @internal */
-const runDrain$1 = self => run(self, drain);
-/** @internal */
-const scopedWith = f => new StreamImpl(scopedWith$1(scope => f(scope).pipe(map$5(of$1))));
-/** @internal */
-const suspend = stream => new StreamImpl(suspend$1(() => toChannel(stream())));
-/** @internal */
-const unfoldChunkEffect = (s, f) => suspend(() => {
-  const loop = s => unwrap(map$5(f(s), match$3({
-    onNone: () => void_,
-    onSome: ([chunk, s]) => flatMap$1(write(chunk), () => loop(s))
-  })));
-  return new StreamImpl(loop(s));
-});
-/** @internal */
-const unwrapScopedWith = f => flatten(scopedWith(scope => f(scope)));
-
-/** @internal */
-const GroupBySymbolKey = "effect/GroupBy";
-/** @internal */
-const GroupByTypeId = /*#__PURE__*/Symbol.for(GroupBySymbolKey);
-const groupByVariance = {
-  /* c8 ignore next */
-  _R: _ => _,
-  /* c8 ignore next */
-  _E: _ => _,
-  /* c8 ignore next */
-  _K: _ => _,
-  /* c8 ignore next */
-  _V: _ => _
-};
-/** @internal */
-const isGroupBy = u => hasProperty(u, GroupByTypeId);
-/** @internal */
-const evaluate = /*#__PURE__*/dual(args => isGroupBy(args[0]), (self, f, options) => flatMap(self.grouped, ([key, queue]) => f(key, flattenTake(fromQueue$1(queue, {
-  shutdown: true
-}))), {
-  concurrency: "unbounded",
-  bufferSize: options?.bufferSize ?? 16
-}));
-/** @internal */
-const make = grouped => ({
-  [GroupByTypeId]: groupByVariance,
-  pipe() {
-    return pipeArguments(this, arguments);
-  },
-  grouped
-});
-/** @internal */
-const mapEffectOptions = /*#__PURE__*/dual(args => typeof args[0] !== "function", (self, f, options) => {
-  if (options?.key) {
-    return evaluate(groupByKey(self, options.key, {
-      bufferSize: options.bufferSize
-    }), (_, s) => mapEffectSequential(s, f));
-  }
-  return matchConcurrency(options?.concurrency, () => mapEffectSequential(self, f), n => options?.unordered ? flatMap(self, a => fromEffect(f(a)), {
-    concurrency: n
-  }) : mapEffectPar(self, n, f));
-});
-/** @internal */
-const groupByKey = /*#__PURE__*/dual(args => typeof args[0] !== "function", (self, f, options) => {
-  const loop = (map, outerQueue) => readWithCause({
-    onInput: input => flatMap$1(fromEffect$3(forEach(groupByIterable(input, f), ([key, values]) => {
-      const innerQueue = map.get(key);
-      if (innerQueue === undefined) {
-        return pipe(bounded(options?.bufferSize ?? 16), flatMap$3(innerQueue => pipe(sync$2(() => {
-          map.set(key, innerQueue);
-        }), zipRight$3(offer(outerQueue, of([key, innerQueue]))), zipRight$3(pipe(offer(innerQueue, chunk(values)), catchSomeCause(cause => isInterruptedOnly(cause) ? some(_void) : none()))))));
-      }
-      return catchSomeCause(offer(innerQueue, chunk(values)), cause => isInterruptedOnly(cause) ? some(_void) : none());
-    }, {
-      discard: true
-    })), () => loop(map, outerQueue)),
-    onFailure: cause => fromEffect$3(offer(outerQueue, failCause$1(cause))),
-    onDone: () => fromEffect$3(pipe(forEach(map.entries(), ([_, innerQueue]) => pipe(offer(innerQueue, end$1), catchSomeCause(cause => isInterruptedOnly(cause) ? some(_void) : none())), {
-      discard: true
-    }), zipRight$3(offer(outerQueue, end$1))))
-  });
-  return make(unwrapScopedWith(scope => gen(function* () {
-    const map = new Map();
-    const queue = yield* unbounded();
-    yield* addFinalizer(scope, shutdown(queue));
-    return yield* toChannel(self).pipe(pipeTo(loop(map, queue)), drain$1, runIn(scope), forkIn(scope), as(flattenTake(fromQueue$1(queue, {
-      shutdown: true
-    }))));
-  })));
-});
-/**
- * A variant of `groupBy` that retains the insertion order of keys.
- *
- * @internal
- */
-const groupByIterable = /*#__PURE__*/dual(2, (iterable, f) => {
-  const builder = [];
-  const iterator = iterable[Symbol.iterator]();
-  const map = new Map();
-  let next;
-  while ((next = iterator.next()) && !next.done) {
-    const value = next.value;
-    const key = f(value);
-    if (map.has(key)) {
-      const innerBuilder = map.get(key);
-      innerBuilder.push(value);
-    } else {
-      const innerBuilder = [value];
-      builder.push([key, innerBuilder]);
-      map.set(key, innerBuilder);
-    }
-  }
-  return unsafeFromArray(builder.map(tuple => [tuple[0], unsafeFromArray(tuple[1])]));
-});
-
-/**
- * Creates a stream from a queue of values
- *
- * **Options**
- *
- * - `maxChunkSize`: The maximum number of queued elements to put in one chunk in the stream
- * - `shutdown`: If `true`, the queue will be shutdown after the stream is evaluated (defaults to `false`)
- *
- * @since 2.0.0
- * @category constructors
- */
-const fromQueue = fromQueue$1;
-/**
- * Maps over elements of the stream with the specified effectful function.
- *
- * @example
- * ```ts
- * import { Effect, Random, Stream } from "effect"
- *
- * const stream = Stream.make(10, 20, 30).pipe(
- *   Stream.mapEffect((n) => Random.nextIntBetween(0, n))
- * )
- *
- * Effect.runPromise(Stream.runCollect(stream)).then(console.log)
- * // Example Output: { _id: 'Chunk', values: [ 7, 19, 8 ] }
- * ```
- *
- * @since 2.0.0
- * @category mapping
- */
-const mapEffect = mapEffectOptions;
-/**
- * Runs the stream only for its effects. The emitted elements are discarded.
- *
- * @since 2.0.0
- * @category destructors
- */
-const runDrain = runDrain$1;
-
-class ReactiveControllerHost {
-    controllers = new Set();
-    addController(controller) {
-        this.controllers.add(controller);
-    }
-    removeController(controller) {
-        this.controllers.delete(controller);
-    }
-    get activeControllers() {
-        return Array.from(this.controllers).filter(controller => !controller.disabled);
-    }
-    connectedCallback() {
-        if (!this.controllers.size) {
-            console.warn('ReactiveControllerHost connected with no controllers registered.', this);
-        }
-        this.activeControllers.forEach(controller => controller.hostConnected?.());
-    }
-    disconnectedCallback() {
-        this.activeControllers.forEach(controller => controller.hostDisconnected?.());
-    }
-    componentWillLoad() {
-        this.activeControllers.forEach(controller => controller.hostWillLoad?.());
-    }
-    componentDidLoad() {
-        this.activeControllers.forEach(controller => controller.hostDidLoad?.());
-    }
-    componentWillRender() {
-        this.activeControllers.forEach(controller => controller.hostWillRender?.());
-    }
-    componentDidRender() {
-        this.activeControllers.forEach(controller => controller.hostDidRender?.());
-    }
-    componentWillUpdate() {
-        this.activeControllers.forEach(controller => controller.hostWillUpdate?.());
-    }
-    componentDidUpdate() {
-        this.activeControllers.forEach(controller => controller.hostDidUpdate?.());
-    }
-}
-
-class AriaValidationController {
-    host;
-    config;
-    static get globalValidationEnabled() {
-        return Build.isDev;
-    }
-    static axe = this.globalValidationEnabled ? import('./axe-cRQ9Ux1I.js').then(function (n) { return n.a; }) : null;
-    static axeQueue = null;
-    static axeStreamFiber = null;
-    visibilityObserver;
-    elementQueued = false;
-    elementValidated = false;
-    knownValidationErrors = [];
-    get disabled() {
-        return true;
-    }
-    constructor(host, config) {
-        this.host = host;
-        this.config = config;
-        AriaValidationController.initializeAxeStream();
-    }
-    static initializeAxeStream() {
-        if (!this.globalValidationEnabled)
-            return;
-        if (this.axeStreamFiber)
-            return;
-        const program = gen(function* () {
-            const queue = (AriaValidationController.axeQueue = yield* bounded(100));
-            const axeLib = yield* promise(() => AriaValidationController.axe);
-            if (!axeLib) {
-                console.error('Axe library not available, ARIA validation will not run.');
-                return;
-            }
-            const stream = fromQueue(queue).pipe(mapEffect(({ context, onComplete }) => async(resume => {
-                axeLib.run(context, {}, (error, results) => {
-                    onComplete(error, results);
-                    resume(_void);
-                });
-            })));
-            yield* runDrain(stream);
-        });
-        this.axeStreamFiber = runFork(program);
-    }
-    hostDidLoad() {
-        if (this.elementQueued || this.elementValidated)
-            return;
-        if (!this.host.el.checkVisibility()) {
-            this.observeVisibilityOnce();
-            return;
-        }
-        this.enqueueValidation();
-    }
-    hostDidUpdate() {
-        this.checkLazyValidation();
-    }
-    hostDisconnected() {
-        this.discardVisibilityObserver();
-    }
-    observeVisibilityOnce() {
-        this.visibilityObserver = new IntersectionObserver(entries => {
-            for (const entry of entries) {
-                if (entry.target !== this.host.el)
-                    continue;
-                if (!entry.isIntersecting)
-                    continue;
-                this.checkLazyValidation();
-                this.discardVisibilityObserver();
-            }
-        }, {
-            root: this.host.el.parentElement,
-            rootMargin: '0px',
-            threshold: 0.01,
-        });
-        this.visibilityObserver.observe(this.host.el);
-    }
-    checkLazyValidation() {
-        if (!this.config?.reValidateOnPropChanges && (this.elementQueued || this.elementValidated))
-            return;
-        this.enqueueValidation();
-    }
-    enqueueValidation() {
-        return;
-    }
-    discardVisibilityObserver() {
-        if (!this.visibilityObserver)
-            return;
-        this.visibilityObserver.disconnect();
-        this.visibilityObserver = undefined;
-    }
-}
-
-export { AriaValidationController as A, ReactiveControllerHost as R };