@lmvz-ds/components 0.12.5 → 0.13.1

package/dist/cjs/aria-validation-controller-B3hMkau3.js

@@ -1,2930 +0,0 @@
-'use strict';
-
-var index = require('./index-9ZJx0550.js');
-var Effect = require('./Effect-CNhHt4Xb.js');
-var MutableQueue = require('./MutableQueue-Bk9tBfaK.js');
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-const make$3 = Effect.make$1;
-/**
- * @since 2.0.0
- * @category getters
- */
-const get = Effect.get$1;
-/**
- * @since 2.0.0
- * @category utils
- */
-const modify = Effect.modify;
-/**
- * @since 2.0.0
- * @category utils
- */
-const update = Effect.update;
-
-/**
- * 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 = Effect.fail;
-/**
- * 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 = Effect.die;
-/**
- * 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 = Effect.interrupt;
-/**
- * Checks if a `Cause` is a `Die` type.
- *
- * @see {@link die} Create a new `Die` cause
- *
- * @since 2.0.0
- * @category Guards
- */
-const isDieType = Effect.isDieType;
-/**
- * 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 = Effect.isInterrupted;
-/**
- * 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 = Effect.isInterruptedOnly;
-/**
- * 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 = Effect.interruptors;
-/**
- * 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 = Effect.failureOrCause;
-/**
- * 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 = Effect.flipCauseOption;
-/**
- * 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 = Effect.map$1;
-
-const _await = Effect._await;
-/**
- * Inherits values from all `FiberRef` instances into current fiber. This
- * will resume immediately.
- *
- * @since 2.0.0
- * @category destructors
- */
-const inheritAll = Effect.inheritAll;
-/**
- * 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 = Effect.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 = Effect.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 = Effect.join;
-
-/** @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 Effect.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 Effect.pipeArguments(this, arguments);
-  }
-  commit() {
-    return this.take;
-  }
-  capacity() {
-    return this.queue.capacity();
-  }
-  get size() {
-    return Effect.suspend(() => Effect.catchAll$1(this.unsafeSize(), () => Effect.interrupt$1));
-  }
-  unsafeSize() {
-    if (Effect.get$2(this.shutdownFlag)) {
-      return Effect.none();
-    }
-    return Effect.some(this.queue.length() - MutableQueue.length(this.takers) + this.strategy.surplusSize());
-  }
-  get isEmpty() {
-    return Effect.map(this.size, size => size <= 0);
-  }
-  get isFull() {
-    return Effect.map(this.size, size => size >= this.capacity());
-  }
-  get shutdown() {
-    return Effect.uninterruptible(Effect.withFiberRuntime(state => {
-      Effect.pipe(this.shutdownFlag, Effect.set$1(true));
-      return Effect.pipe(Effect.forEachConcurrentDiscard(unsafePollAll(this.takers), d => Effect.deferredInterruptWith(d, state.id()), false, false), Effect.zipRight(this.strategy.shutdown), Effect.whenEffect(Effect.deferredSucceed(this.shutdownHook, void 0)), Effect.asVoid);
-    }));
-  }
-  get isShutdown() {
-    return Effect.sync(() => Effect.get$2(this.shutdownFlag));
-  }
-  get awaitShutdown() {
-    return Effect.deferredAwait(this.shutdownHook);
-  }
-  isActive() {
-    return !Effect.get$2(this.shutdownFlag);
-  }
-  unsafeOffer(value) {
-    if (Effect.get$2(this.shutdownFlag)) {
-      return false;
-    }
-    let noRemaining;
-    if (this.queue.length() === 0) {
-      const taker = Effect.pipe(this.takers, MutableQueue.poll(MutableQueue.EmptyMutableQueue));
-      if (taker !== MutableQueue.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 Effect.suspend(() => {
-      if (Effect.get$2(this.shutdownFlag)) {
-        return Effect.interrupt$1;
-      }
-      let noRemaining;
-      if (this.queue.length() === 0) {
-        const taker = Effect.pipe(this.takers, MutableQueue.poll(MutableQueue.EmptyMutableQueue));
-        if (taker !== MutableQueue.EmptyMutableQueue) {
-          unsafeCompleteDeferred(taker, value);
-          noRemaining = true;
-        } else {
-          noRemaining = false;
-        }
-      } else {
-        noRemaining = false;
-      }
-      if (noRemaining) {
-        return Effect.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 ? Effect.succeed$1(true) : this.strategy.handleSurplus([value], this.queue, this.takers, this.shutdownFlag);
-    });
-  }
-  offerAll(iterable) {
-    return Effect.suspend(() => {
-      if (Effect.get$2(this.shutdownFlag)) {
-        return Effect.interrupt$1;
-      }
-      const values = Effect.fromIterable(iterable);
-      const pTakers = this.queue.length() === 0 ? Effect.fromIterable(unsafePollN(this.takers, values.length)) : Effect.empty$1;
-      const [forTakers, remaining] = Effect.pipe(values, Effect.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 Effect.succeed$1(true);
-      }
-      // Not enough takers, offer to the queue
-      const surplus = this.queue.offerAll(remaining);
-      unsafeCompleteTakers(this.strategy, this.queue, this.takers);
-      return Effect.isEmpty(surplus) ? Effect.succeed$1(true) : this.strategy.handleSurplus(surplus, this.queue, this.takers, this.shutdownFlag);
-    });
-  }
-  get take() {
-    return Effect.withFiberRuntime(state => {
-      if (Effect.get$2(this.shutdownFlag)) {
-        return Effect.interrupt$1;
-      }
-      const item = this.queue.poll(MutableQueue.EmptyMutableQueue);
-      if (item !== MutableQueue.EmptyMutableQueue) {
-        this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
-        return Effect.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 = Effect.deferredUnsafeMake(state.id());
-        return Effect.pipe(Effect.suspend(() => {
-          Effect.pipe(this.takers, MutableQueue.offer(deferred));
-          unsafeCompleteTakers(this.strategy, this.queue, this.takers);
-          return Effect.get$2(this.shutdownFlag) ? Effect.interrupt$1 : Effect.deferredAwait(deferred);
-        }), Effect.onInterrupt(() => {
-          return Effect.sync(() => unsafeRemove(this.takers, deferred));
-        }));
-      }
-    });
-  }
-  get takeAll() {
-    return Effect.suspend(() => {
-      return Effect.get$2(this.shutdownFlag) ? Effect.interrupt$1 : Effect.sync(() => {
-        const values = this.queue.pollUpTo(Number.POSITIVE_INFINITY);
-        this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
-        return Effect.fromIterable$1(values);
-      });
-    });
-  }
-  takeUpTo(max) {
-    return Effect.suspend(() => Effect.get$2(this.shutdownFlag) ? Effect.interrupt$1 : Effect.sync(() => {
-      const values = this.queue.pollUpTo(max);
-      this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
-      return Effect.fromIterable$1(values);
-    }));
-  }
-  takeBetween(min, max) {
-    return Effect.suspend(() => takeRemainderLoop(this, min, max, Effect.empty$2()));
-  }
-}
-/** @internal */
-const takeRemainderLoop = (self, min, max, acc) => {
-  if (max < min) {
-    return Effect.succeed$1(acc);
-  }
-  return Effect.pipe(takeUpTo(self, max), Effect.flatMap(bs => {
-    const remaining = min - bs.length;
-    if (remaining === 1) {
-      return Effect.pipe(take$1(self), Effect.map(b => Effect.pipe(acc, Effect.appendAll(bs), Effect.append(b))));
-    }
-    if (remaining > 1) {
-      return Effect.pipe(take$1(self), Effect.flatMap(b => takeRemainderLoop(self, remaining - 1, max - bs.length - 1, Effect.pipe(acc, Effect.appendAll(bs), Effect.append(b)))));
-    }
-    return Effect.succeed$1(Effect.pipe(acc, Effect.appendAll(bs)));
-  }));
-};
-/** @internal */
-const bounded$1 = requestedCapacity => Effect.pipe(Effect.sync(() => MutableQueue.bounded(requestedCapacity)), Effect.flatMap(queue => make$2(backingQueueFromMutableQueue(queue), backPressureStrategy())));
-/** @internal */
-const unbounded$1 = () => Effect.pipe(Effect.sync(() => MutableQueue.unbounded()), Effect.flatMap(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) => Effect.pipe(Effect.deferredMake(), Effect.map(deferred => unsafeMake(queue, MutableQueue.unbounded(), deferred, Effect.make(false), strategy)));
-/** @internal */
-class BackingQueueFromMutableQueue {
-  mutable;
-  [BackingQueueTypeId] = backingQueueVariance;
-  constructor(mutable) {
-    this.mutable = mutable;
-  }
-  poll(def) {
-    return MutableQueue.poll(this.mutable, def);
-  }
-  pollUpTo(limit) {
-    return MutableQueue.pollUpTo(this.mutable, limit);
-  }
-  offerAll(elements) {
-    return MutableQueue.offerAll(this.mutable, elements);
-  }
-  offer(element) {
-    return MutableQueue.offer(this.mutable, element);
-  }
-  capacity() {
-    return MutableQueue.capacity(this.mutable);
-  }
-  length() {
-    return MutableQueue.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__*/Effect.dual(2, (self, value) => self.offer(value));
-/** @internal */
-const take$1 = self => self.take;
-/** @internal */
-const takeUpTo = /*#__PURE__*/Effect.dual(2, (self, max) => self.takeUpTo(max));
-/** @internal */
-const takeBetween$1 = /*#__PURE__*/Effect.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__*/MutableQueue.unbounded();
-  surplusSize() {
-    return MutableQueue.length(this.putters);
-  }
-  onCompleteTakersWithEmptyQueue(takers) {
-    while (!MutableQueue.isEmpty(this.putters) && !MutableQueue.isEmpty(takers)) {
-      const taker = MutableQueue.poll(takers, void 0);
-      const putter = MutableQueue.poll(this.putters, void 0);
-      if (putter[2]) {
-        unsafeCompleteDeferred(putter[1], true);
-      }
-      unsafeCompleteDeferred(taker, putter[0]);
-    }
-  }
-  get shutdown() {
-    return Effect.pipe(Effect.fiberId, Effect.flatMap(fiberId => Effect.pipe(Effect.sync(() => unsafePollAll(this.putters)), Effect.flatMap(putters => Effect.forEachConcurrentDiscard(putters, ([_, deferred, isLastItem]) => isLastItem ? Effect.pipe(Effect.deferredInterruptWith(deferred, fiberId), Effect.asVoid) : Effect.void_, false, false)))));
-  }
-  handleSurplus(iterable, queue, takers, isShutdown) {
-    return Effect.withFiberRuntime(state => {
-      const deferred = Effect.deferredUnsafeMake(state.id());
-      return Effect.pipe(Effect.suspend(() => {
-        this.unsafeOffer(iterable, deferred);
-        this.unsafeOnQueueEmptySpace(queue, takers);
-        unsafeCompleteTakers(this, queue, takers);
-        return Effect.get$2(isShutdown) ? Effect.interrupt$1 : Effect.deferredAwait(deferred);
-      }), Effect.onInterrupt(() => Effect.sync(() => this.unsafeRemove(deferred))));
-    });
-  }
-  unsafeOnQueueEmptySpace(queue, takers) {
-    let keepPolling = true;
-    while (keepPolling && (queue.capacity() === Number.POSITIVE_INFINITY || queue.length() < queue.capacity())) {
-      const putter = Effect.pipe(this.putters, MutableQueue.poll(MutableQueue.EmptyMutableQueue));
-      if (putter === MutableQueue.EmptyMutableQueue) {
-        keepPolling = false;
-      } else {
-        const offered = queue.offer(putter[0]);
-        if (offered && putter[2]) {
-          unsafeCompleteDeferred(putter[1], true);
-        } else if (!offered) {
-          unsafeOfferAll(this.putters, Effect.pipe(unsafePollAll(this.putters), Effect.prepend(putter)));
-        }
-        unsafeCompleteTakers(this, queue, takers);
-      }
-    }
-  }
-  unsafeOffer(iterable, deferred) {
-    const stuff = Effect.fromIterable(iterable);
-    for (let i = 0; i < stuff.length; i++) {
-      const value = stuff[i];
-      if (i === stuff.length - 1) {
-        Effect.pipe(this.putters, MutableQueue.offer([value, deferred, true]));
-      } else {
-        Effect.pipe(this.putters, MutableQueue.offer([value, deferred, false]));
-      }
-    }
-  }
-  unsafeRemove(deferred) {
-    unsafeOfferAll(this.putters, Effect.pipe(unsafePollAll(this.putters), Effect.filter(([, _]) => _ !== deferred)));
-  }
-}
-/** @internal */
-class DroppingStrategy {
-  [QueueStrategyTypeId] = queueStrategyVariance;
-  surplusSize() {
-    return 0;
-  }
-  get shutdown() {
-    return Effect.void_;
-  }
-  onCompleteTakersWithEmptyQueue() {}
-  handleSurplus(_iterable, _queue, _takers, _isShutdown) {
-    return Effect.succeed$1(false);
-  }
-  unsafeOnQueueEmptySpace(_queue, _takers) {
-    //
-  }
-}
-/** @internal */
-const unsafeCompleteDeferred = (deferred, a) => {
-  return Effect.deferredUnsafeDone(deferred, Effect.succeed$1(a));
-};
-/** @internal */
-const unsafeOfferAll = (queue, as) => {
-  return Effect.pipe(queue, MutableQueue.offerAll(as));
-};
-/** @internal */
-const unsafePollAll = queue => {
-  return Effect.pipe(queue, MutableQueue.pollUpTo(Number.POSITIVE_INFINITY));
-};
-/** @internal */
-const unsafePollN = (queue, max) => {
-  return Effect.pipe(queue, MutableQueue.pollUpTo(max));
-};
-/** @internal */
-const unsafeRemove = (queue, a) => {
-  unsafeOfferAll(queue, Effect.pipe(unsafePollAll(queue), Effect.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 = Effect.pipe(takers, MutableQueue.poll(MutableQueue.EmptyMutableQueue));
-    if (taker !== MutableQueue.EmptyMutableQueue) {
-      const element = queue.poll(MutableQueue.EmptyMutableQueue);
-      if (element !== MutableQueue.EmptyMutableQueue) {
-        unsafeCompleteDeferred(taker, element);
-        strategy.unsafeOnQueueEmptySpace(queue, takers);
-      } else {
-        unsafeOfferAll(takers, Effect.pipe(unsafePollAll(takers), Effect.prepend(taker)));
-      }
-      keepPolling = true;
-    } else {
-      keepPolling = false;
-    }
-  }
-  if (keepPolling && queue.length() === 0 && !MutableQueue.isEmpty(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 MutableQueue.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 Effect.pipeArguments(this, arguments);
-  }
-};
-/** @internal */
-const isChannel = u => Effect.hasProperty(u, ChannelTypeId) || Effect.isEffect(u);
-/** @internal */
-const acquireReleaseOut = /*#__PURE__*/Effect.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(Effect.none());
-  op.onEmit = () => Continue;
-  op.value = () => channels;
-  op.k = Effect.identity;
-  return op;
-};
-/** @internal */
-const concatMapWith = /*#__PURE__*/Effect.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(Effect.none());
-  op.onEmit = () => Continue;
-  op.value = () => self;
-  op.k = f;
-  return op;
-});
-/** @internal */
-const embedInput = /*#__PURE__*/Effect.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__*/Effect.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__*/Effect.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__*/Effect.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 => Effect.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 : Effect._void;
-/** @internal */
-const effectOrUndefinedIgnored = self => isFromEffect(self) ? Effect.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) {
-    const fin1 = this.childExecutor.close(exit);
-    const fin2 = this.parentSubexecutor.close(exit);
-    if (fin1 !== undefined && fin2 !== undefined) {
-      return Effect.zipWith(Effect.exit$1(fin1), Effect.exit$1(fin2), (exit1, exit2) => Effect.pipe(exit1, MutableQueue.zipRight(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) {
-    const fin1 = this.upstreamExecutor.close(exit);
-    const fins = [...this.activeChildExecutors.map(child => child !== undefined ? child.childExecutor.close(exit) : undefined), fin1];
-    const result = fins.reduce((acc, next) => {
-      if (acc !== undefined && next !== undefined) {
-        return Effect.zipWith(acc, Effect.exit$1(next), (exit1, exit2) => MutableQueue.zipRight(exit1, exit2));
-      } else if (acc !== undefined) {
-        return acc;
-      } else if (next !== undefined) {
-        return Effect.exit$1(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) {
-    const fin1 = this.upstreamExecutor.close(exit);
-    const fins = [...this.activeChildExecutors.map(child => child !== undefined ? child.childExecutor.close(exit) : undefined), fin1];
-    const result = fins.reduce((acc, next) => {
-      if (acc !== undefined && next !== undefined) {
-        return Effect.zipWith(acc, Effect.exit$1(next), (exit1, exit2) => MutableQueue.zipRight(exit1, exit2));
-      } else if (acc !== undefined) {
-        return acc;
-      } else if (next !== undefined) {
-        return Effect.exit$1(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 (Effect.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 = () => Effect.flatMap$1(bridgeInput.awaitRead(), () => Effect.suspend$1(() => {
-                      const state = inputExecutor.run();
-                      switch (state._tag) {
-                        case OP_DONE$1:
-                          {
-                            return MutableQueue.match(inputExecutor.getDone(), {
-                              onFailure: cause => bridgeInput.error(cause),
-                              onSuccess: value => bridgeInput.done(value)
-                            });
-                          }
-                        case OP_EMIT$1:
-                          {
-                            return Effect.flatMap$1(bridgeInput.emit(inputExecutor.getEmit()), () => drainer());
-                          }
-                        case OP_FROM_EFFECT:
-                          {
-                            return Effect.matchCauseEffect(state.effect, {
-                              onFailure: cause => bridgeInput.error(cause),
-                              onSuccess: () => drainer()
-                            });
-                          }
-                        case OP_READ:
-                          {
-                            return readUpstream(state, () => drainer(), cause => bridgeInput.error(cause));
-                          }
-                      }
-                    }));
-                    result = fromEffect$2(Effect.flatMap$1(Effect.forkDaemon(Effect.interruptible(drainer())), fiber => Effect.sync$1(() => this.addFinalizer(exit => Effect.flatMap$1(interrupt(fiber), () => Effect.suspend$1(() => {
-                      const effect = this.restorePipe(exit, inputExecutor);
-                      return effect !== undefined ? effect : Effect._void;
-                    }))))));
-                  }
-                  break;
-                }
-              case OP_CONCAT_ALL:
-                {
-                  const executor = new ChannelExecutor(this._currentChannel.value(), this._providedEnv, effect => Effect.sync$1(() => {
-                    const prevLastClose = this._closeLastSubstream === undefined ? Effect._void : this._closeLastSubstream;
-                    this._closeLastSubstream = Effect.pipe(prevLastClose, Effect.zipRight$1(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() : Effect.pipe(this._currentChannel.effect(), Effect.provide(this._providedEnv));
-                  result = fromEffect$2(Effect.matchCauseEffect(effect, {
-                    onFailure: cause => {
-                      const state = this.doneHalt(cause);
-                      return state !== undefined && isFromEffect(state) ? state.effect : Effect._void;
-                    },
-                    onSuccess: value => {
-                      const state = this.doneSucceed(value);
-                      return state !== undefined && isFromEffect(state) ? state.effect : 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 : 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(() => Effect.sync$1(() => {
-                    this._providedEnv = previousEnv;
-                  }));
-                  break;
-                }
-              case OP_READ$1:
-                {
-                  const read = this._currentChannel;
-                  result = Read(this._input, Effect.identity, emitted => {
-                    try {
-                      this._currentChannel = read.more(emitted);
-                    } catch (error) {
-                      this._currentChannel = read.done.onExit(MutableQueue.die(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 ? Effect._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 Effect._void;
-  }
-  close(exit) {
-    let runInProgressFinalizers = undefined;
-    const finalizer = this._inProgressFinalizer;
-    if (finalizer !== undefined) {
-      runInProgressFinalizers = Effect.pipe(finalizer, Effect.ensuring(Effect.sync$1(() => this.clearInProgressFinalizer())));
-    }
-    let closeSelf = undefined;
-    const selfFinalizers = this.popAllFinalizers(exit);
-    if (selfFinalizers !== undefined) {
-      closeSelf = Effect.pipe(selfFinalizers, Effect.ensuring(Effect.sync$1(() => this.clearInProgressFinalizer())));
-    }
-    const closeSubexecutors = this._activeSubexecutor === undefined ? undefined : this._activeSubexecutor.close(exit);
-    if (closeSubexecutors === undefined && runInProgressFinalizers === undefined && closeSelf === undefined) {
-      return undefined;
-    }
-    return Effect.pipe(Effect.exit$1(ifNotNull(closeSubexecutors)), Effect.zip(Effect.exit$1(ifNotNull(runInProgressFinalizers))), Effect.zip(Effect.exit$1(ifNotNull(closeSelf))), Effect.map$2(([[exit1, exit2], exit3]) => Effect.pipe(exit1, MutableQueue.zipRight(exit2), MutableQueue.zipRight(exit3))), Effect.uninterruptible$1,
-    // TODO: remove
-    Effect.flatMap$1(exit => Effect.suspend$1(() => exit)));
-  }
-  doneSucceed(value) {
-    if (this._doneStack.length === 0) {
-      this._done = MutableQueue.succeed(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 = MutableQueue.succeed(value);
-      this._currentChannel = undefined;
-      return Done();
-    }
-    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), MutableQueue.succeed(value));
-    this.storeInProgressFinalizer(finalizerEffect);
-    const effect = Effect.pipe(finalizerEffect, Effect.ensuring(Effect.sync$1(() => this.clearInProgressFinalizer())), Effect.uninterruptible$1, Effect.flatMap$1(() => Effect.sync$1(() => this.doneSucceed(value))));
-    return fromEffect$2(effect);
-  }
-  doneHalt(cause) {
-    if (this._doneStack.length === 0) {
-      this._done = MutableQueue.failCause(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 = MutableQueue.failCause(cause);
-      this._currentChannel = undefined;
-      return Done();
-    }
-    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), MutableQueue.failCause(cause));
-    this.storeInProgressFinalizer(finalizerEffect);
-    const effect = Effect.pipe(finalizerEffect, Effect.ensuring(Effect.sync$1(() => this.clearInProgressFinalizer())), Effect.uninterruptible$1, Effect.flatMap$1(() => Effect.sync$1(() => this.doneHalt(cause))));
-    return fromEffect$2(effect);
-  }
-  processCancellation() {
-    this._currentChannel = undefined;
-    this._done = this._cancelled;
-    this._cancelled = undefined;
-    return Done();
-  }
-  runBracketOut(bracketOut) {
-    const effect = Effect.uninterruptible$1(Effect.matchCauseEffect(this.provide(bracketOut.acquire()), {
-      onFailure: cause => Effect.sync$1(() => {
-        this._currentChannel = failCause$2(cause);
-      }),
-      onSuccess: out => Effect.sync$1(() => {
-        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 Effect.pipe(effect, 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 = MutableQueue.match(exit, {
-      onFailure: cause => this.doneHalt(cause),
-      onSuccess: value => this.doneSucceed(value)
-    });
-    this._activeSubexecutor = undefined;
-    return state === undefined ? Effect._void : effect(state);
-  }
-  finishSubexecutorWithCloseEffect(subexecutorDone, ...closeFuncs) {
-    this.addFinalizer(() => Effect.pipe(closeFuncs, Effect.forEach(closeFunc => Effect.pipe(Effect.sync$1(() => closeFunc(subexecutorDone)), Effect.flatMap$1(closeEffect => closeEffect !== undefined ? closeEffect : Effect._void)), {
-      discard: true
-    })));
-    const state = Effect.pipe(subexecutorDone, MutableQueue.match({
-      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, Effect.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;
-    }, MutableQueue.match({
-      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(MutableQueue.succeed(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(MutableQueue.succeed(doneValue));
-          this.replaceSubexecutor(modifiedParent);
-          break;
-        }
-    }
-  }
-  handleSubexecutorFailure(childExecutor, parentSubexecutor, cause) {
-    return this.finishSubexecutorWithCloseEffect(MutableQueue.failCause(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 ? Effect._void : this._closeLastSubstream;
-      this._closeLastSubstream = undefined;
-      return Effect.pipe(this._executeCloseLastSubstream(closeLastSubstream), Effect.zipRight$1(effect));
-    }, emitted => {
-      if (this._closeLastSubstream !== undefined) {
-        const closeLastSubstream = this._closeLastSubstream;
-        this._closeLastSubstream = undefined;
-        return Effect.pipe(this._executeCloseLastSubstream(closeLastSubstream), Effect.map$2(() => {
-          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 (Effect.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 (Effect.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 Effect.pipe(this._executeCloseLastSubstream(closeLastSubstream), Effect.map$2(() => this.replaceSubexecutor(drain)));
-        }
-        this.replaceSubexecutor(drain);
-        return undefined;
-      }
-      const closeLastSubstream = this._closeLastSubstream;
-      const state = this.finishSubexecutorWithCloseEffect(Effect.pipe(exit, MutableQueue.map(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(() => Effect.succeed(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 (Effect.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 : Effect._void;
-const runFinalizers = (finalizers, exit) => {
-  return Effect.pipe(Effect.forEach(finalizers, fin => Effect.exit$1(fin(exit))), Effect.map$2(exits => Effect.pipe(MutableQueue.all(exits), Effect.getOrElse(() => MutableQueue.void_))), Effect.flatMap$1(exit => Effect.suspend$1(() => exit)));
-};
-/**
- * @internal
- */
-const readUpstream = (r, onSuccess, onFailure) => {
-  const readStack = [r];
-  const read = () => {
-    const current = readStack.pop();
-    if (current === undefined || current.upstream === undefined) {
-      return Effect.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 Effect.suspend$1(onSuccess);
-            }
-            return Effect.pipe(emitEffect, Effect.matchCauseEffect({
-              onFailure,
-              onSuccess
-            }));
-          }
-          if (emitEffect === undefined) {
-            return Effect.suspend$1(() => read());
-          }
-          return Effect.pipe(emitEffect, Effect.matchCauseEffect({
-            onFailure,
-            onSuccess: () => read()
-          }));
-        }
-      case OP_DONE$1:
-        {
-          const doneEffect = current.onDone(current.upstream.getDone());
-          if (readStack.length === 0) {
-            if (doneEffect === undefined) {
-              return Effect.suspend$1(onSuccess);
-            }
-            return Effect.pipe(doneEffect, Effect.matchCauseEffect({
-              onFailure,
-              onSuccess
-            }));
-          }
-          if (doneEffect === undefined) {
-            return Effect.suspend$1(() => read());
-          }
-          return Effect.pipe(doneEffect, Effect.matchCauseEffect({
-            onFailure,
-            onSuccess: () => read()
-          }));
-        }
-      case OP_FROM_EFFECT:
-        {
-          readStack.push(current);
-          return Effect.pipe(current.onEffect(state.effect), Effect.catchAllCause(cause => Effect.suspend$1(() => {
-            const doneEffect = current.onDone(MutableQueue.failCause(cause));
-            return doneEffect === undefined ? Effect._void : doneEffect;
-          })), Effect.matchCauseEffect({
-            onFailure,
-            onSuccess: () => read()
-          }));
-        }
-      case OP_READ:
-        {
-          readStack.push(current);
-          readStack.push(state);
-          return Effect.suspend$1(() => read());
-        }
-    }
-  };
-  return read();
-};
-/** @internal */
-const runIn = /*#__PURE__*/Effect.dual(2, (self, scope) => {
-  const run = (channelDeferred, scopeDeferred, scope) => Effect.acquireUseRelease(Effect.sync$1(() => new ChannelExecutor(self, void 0, Effect.identity)), exec => Effect.suspend$1(() => runScopedInterpret(exec.run(), exec).pipe(Effect.intoDeferred(channelDeferred), Effect.zipRight$1(MutableQueue._await(channelDeferred)), Effect.zipLeft(MutableQueue._await(scopeDeferred)))), (exec, exit) => {
-    const finalize = exec.close(exit);
-    if (finalize === undefined) {
-      return Effect._void;
-    }
-    return Effect.tapErrorCause(finalize, cause => Effect.addFinalizer(scope, Effect.failCause(cause)));
-  });
-  return Effect.uninterruptibleMask(restore => Effect.all$1([Effect.fork(scope, Effect.sequential), MutableQueue.make(), MutableQueue.make()]).pipe(Effect.flatMap$1(([child, channelDeferred, scopeDeferred]) => restore(run(channelDeferred, scopeDeferred, child)).pipe(Effect.forkIn(scope), Effect.flatMap$1(fiber => scope.addFinalizer(exit => {
-    const interruptors$1 = MutableQueue.isFailure(exit) ? interruptors(exit.cause) : undefined;
-    return MutableQueue.isDone(channelDeferred).pipe(Effect.flatMap$1(isDone => isDone ? MutableQueue.succeed$1(scopeDeferred, void 0).pipe(Effect.zipRight$1(_await(fiber)), Effect.zipRight$1(inheritAll(fiber))) : MutableQueue.succeed$1(scopeDeferred, void 0).pipe(Effect.zipRight$1(interruptors$1 && Effect.size$1(interruptors$1) > 0 ? interruptAs(fiber, Effect.combineAll(interruptors$1)) : interrupt(fiber)), Effect.zipRight$1(inheritAll(fiber)))));
-  }).pipe(Effect.zipRight$1(restore(MutableQueue._await(channelDeferred)))))))));
-});
-/** @internal */
-const runScopedInterpret = (channelState, exec) => {
-  const op = channelState;
-  switch (op._tag) {
-    case OP_FROM_EFFECT:
-      {
-        return Effect.pipe(op.effect, Effect.flatMap$1(() => 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 Effect.suspend$1(() => exec.getDone());
-      }
-    case OP_READ:
-      {
-        return readUpstream(op, () => runScopedInterpret(exec.run(), exec), Effect.failCause);
-      }
-  }
-};
-
-/** @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__*/Effect.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 Effect.flatten(modify(this.ref, state => state._tag === OP_STATE_EMPTY ? [MutableQueue._await(state.notifyProducer), state] : [Effect._void, state]));
-  }
-  get close() {
-    return Effect.fiberIdWith(fiberId => this.error(interrupt$1(fiberId)));
-  }
-  done(value) {
-    return Effect.flatten(modify(this.ref, state => {
-      switch (state._tag) {
-        case OP_STATE_EMPTY:
-          {
-            return [MutableQueue._await(state.notifyProducer), state];
-          }
-        case OP_STATE_EMIT:
-          {
-            return [Effect.forEach(state.notifyConsumers, deferred => MutableQueue.succeed$1(deferred, Effect.left(value)), {
-              discard: true
-            }), stateDone(value)];
-          }
-        case OP_STATE_ERROR:
-          {
-            return [Effect.interrupt$2, state];
-          }
-        case OP_STATE_DONE:
-          {
-            return [Effect.interrupt$2, state];
-          }
-      }
-    }));
-  }
-  emit(element) {
-    return Effect.flatMap$1(MutableQueue.make(), deferred => Effect.flatten(modify(this.ref, state => {
-      switch (state._tag) {
-        case OP_STATE_EMPTY:
-          {
-            return [MutableQueue._await(state.notifyProducer), state];
-          }
-        case OP_STATE_EMIT:
-          {
-            const notifyConsumer = state.notifyConsumers[0];
-            const notifyConsumers = state.notifyConsumers.slice(1);
-            if (notifyConsumer !== undefined) {
-              return [MutableQueue.succeed$1(notifyConsumer, Effect.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 [Effect.interrupt$2, state];
-          }
-        case OP_STATE_DONE:
-          {
-            return [Effect.interrupt$2, state];
-          }
-      }
-    })));
-  }
-  error(cause) {
-    return Effect.flatten(modify(this.ref, state => {
-      switch (state._tag) {
-        case OP_STATE_EMPTY:
-          {
-            return [MutableQueue._await(state.notifyProducer), state];
-          }
-        case OP_STATE_EMIT:
-          {
-            return [Effect.forEach(state.notifyConsumers, deferred => MutableQueue.failCause$1(deferred, cause), {
-              discard: true
-            }), stateError(cause)];
-          }
-        case OP_STATE_ERROR:
-          {
-            return [Effect.interrupt$2, state];
-          }
-        case OP_STATE_DONE:
-          {
-            return [Effect.interrupt$2, state];
-          }
-      }
-    }));
-  }
-  get take() {
-    return this.takeWith(cause => MutableQueue.failCause(map$2(cause, Effect.left)), elem => MutableQueue.succeed(elem), done => MutableQueue.fail(Effect.right(done)));
-  }
-  takeWith(onError, onElement, onDone) {
-    return Effect.flatMap$1(MutableQueue.make(), deferred => Effect.flatten(modify(this.ref, state => {
-      switch (state._tag) {
-        case OP_STATE_EMPTY:
-          {
-            return [Effect.zipRight$1(MutableQueue.succeed$1(state.notifyProducer, void 0), Effect.matchCause(MutableQueue._await(deferred), {
-              onFailure: onError,
-              onSuccess: Effect.match$1({
-                onLeft: onDone,
-                onRight: onElement
-              })
-            })), stateEmit([deferred])];
-          }
-        case OP_STATE_EMIT:
-          {
-            return [Effect.matchCause(MutableQueue._await(deferred), {
-              onFailure: onError,
-              onSuccess: Effect.match$1({
-                onLeft: onDone,
-                onRight: onElement
-              })
-            }), stateEmit([...state.notifyConsumers, deferred])];
-          }
-        case OP_STATE_ERROR:
-          {
-            return [Effect.succeed(onError(state.cause)), state];
-          }
-        case OP_STATE_DONE:
-          {
-            return [Effect.succeed(onDone(state.done)), state];
-          }
-      }
-    })));
-  }
-}
-/** @internal */
-const make$1 = () => Effect.pipe(MutableQueue.make(), Effect.flatMap$1(deferred => make$3(stateEmpty(deferred))), Effect.map$2(ref => new SingleProducerAsyncInputImpl(ref)));
-
-/** @internal */
-const concatMap = /*#__PURE__*/Effect.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__*/Effect.dual(2, (self, finalizer) => ensuringWith(self, () => finalizer));
-/** @internal */
-const flatten$1 = self => flatMap$1(self, Effect.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__*/Effect.dual(2, (self, f) => flatMap$1(self, a => sync(() => f(a))));
-/** @internal */
-const mapOut = /*#__PURE__*/Effect.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__*/Effect.dual(3, (self, f, n) => unwrapScopedWith$1(scope => Effect.gen(function* () {
-  const input = yield* make$1();
-  const queueReader = fromInput(input);
-  const queue = yield* bounded(n);
-  yield* Effect.addFinalizer(scope, shutdown(queue));
-  const errorSignal = yield* MutableQueue.make();
-  const withPermits = n === Number.POSITIVE_INFINITY ? _ => Effect.identity : (yield* Effect.makeSemaphore(n)).withPermits;
-  const pull = yield* queueReader.pipe(pipeTo(self), toPullIn(scope));
-  yield* pull.pipe(Effect.matchCauseEffect({
-    onFailure: cause => offer(queue, Effect.failCause(cause)),
-    onSuccess: Effect.match$1({
-      onLeft: outDone => Effect.zipRight$1(Effect.interruptible(withPermits(n)(Effect._void)), Effect.asVoid$1(offer(queue, Effect.succeed(Effect.left(outDone))))),
-      onRight: outElem => Effect.gen(function* () {
-        const deferred = yield* MutableQueue.make();
-        const latch = yield* MutableQueue.make();
-        yield* offer(queue, Effect.map$2(MutableQueue._await(deferred), Effect.right));
-        yield* MutableQueue.succeed$1(latch, void 0).pipe(Effect.zipRight$1(Effect.uninterruptibleMask(restore => Effect.exit$1(restore(MutableQueue._await(errorSignal))).pipe(Effect.raceFirst(Effect.exit$1(restore(f(outElem)))), Effect.flatMap$1(Effect.identity))).pipe(Effect.tapErrorCause(cause => MutableQueue.failCause$1(errorSignal, cause)), Effect.intoDeferred(deferred))), withPermits(1), Effect.forkIn(scope));
-        yield* MutableQueue._await(latch);
-      })
-    })
-  }), Effect.forever, Effect.interruptible, Effect.forkIn(scope));
-  const consumer = unwrap(Effect.matchCause(Effect.flatten(take(queue)), {
-    onFailure: failCause$2,
-    onSuccess: Effect.match$1({
-      onLeft: succeedNow,
-      onRight: outElem => flatMap$1(write(outElem), () => consumer)
-    })
-  }));
-  return embedInput(consumer, input);
-})));
-/** @internal */
-const mergeAll = options => {
-  return channels => mergeAllWith(options)(channels, Effect.constVoid);
-};
-/** @internal */
-const mergeAllWith = ({
-  bufferSize = 16,
-  concurrency,
-  mergeStrategy = BackPressure()
-}) => (channels, f) => unwrapScopedWith$1(scope => Effect.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* Effect.addFinalizer(scope, shutdown(queue));
-  const cancelers = yield* unbounded();
-  yield* Effect.addFinalizer(scope, shutdown(cancelers));
-  const lastDone = yield* make$3(Effect.none());
-  const errorSignal = yield* MutableQueue.make();
-  const withPermits = (yield* Effect.makeSemaphore(concurrencyN)).withPermits;
-  const pull = yield* toPullIn(pipeTo(queueReader, channels), scope);
-  function evaluatePull(pull) {
-    return pull.pipe(Effect.flatMap$1(Effect.match$1({
-      onLeft: done => Effect.succeed(Effect.some(done)),
-      onRight: outElem => Effect.as(offer(queue, Effect.succeed(Effect.right(outElem))), Effect.none())
-    })), Effect.repeat({
-      until: _ => Effect.isSome(_)
-    }), Effect.flatMap$1(outDone => update(lastDone, Effect.match({
-      onNone: () => Effect.some(outDone.value),
-      onSome: lastDone => Effect.some(f(lastDone, outDone.value))
-    }))), Effect.catchAllCause(cause => isInterrupted(cause) ? Effect.failCause(cause) : offer(queue, Effect.failCause(cause)).pipe(Effect.zipRight$1(MutableQueue.succeed$1(errorSignal, void 0)), Effect.asVoid$1)));
-  }
-  yield* pull.pipe(Effect.matchCauseEffect({
-    onFailure: cause => offer(queue, Effect.failCause(cause)).pipe(Effect.zipRight$1(Effect.succeed(false))),
-    onSuccess: Effect.match$1({
-      onLeft: outDone => Effect.raceWith(Effect.interruptible(MutableQueue._await(errorSignal)), Effect.interruptible(withPermits(concurrencyN)(Effect._void)), {
-        onSelfDone: (_, permitAcquisition) => Effect.as(interrupt(permitAcquisition), false),
-        onOtherDone: (_, failureAwait) => Effect.zipRight$1(interrupt(failureAwait), get(lastDone).pipe(Effect.flatMap$1(Effect.match({
-          onNone: () => offer(queue, Effect.succeed(Effect.left(outDone))),
-          onSome: lastDone => offer(queue, Effect.succeed(Effect.left(f(lastDone, outDone))))
-        })), Effect.as(false)))
-      }),
-      onRight: channel => match(mergeStrategy, {
-        onBackPressure: () => Effect.gen(function* () {
-          const latch = yield* MutableQueue.make();
-          const raceEffects = Effect.scopedWith(scope => toPullIn(pipeTo(queueReader, channel), scope).pipe(Effect.flatMap$1(pull => Effect.race(Effect.exit$1(evaluatePull(pull)), Effect.exit$1(Effect.interruptible(MutableQueue._await(errorSignal))))), Effect.flatMap$1(Effect.identity)));
-          yield* MutableQueue.succeed$1(latch, void 0).pipe(Effect.zipRight$1(raceEffects), withPermits(1), Effect.forkIn(scope));
-          yield* MutableQueue._await(latch);
-          const errored = yield* MutableQueue.isDone(errorSignal);
-          return !errored;
-        }),
-        onBufferSliding: () => Effect.gen(function* () {
-          const canceler = yield* MutableQueue.make();
-          const latch = yield* MutableQueue.make();
-          const size$1 = yield* size(cancelers);
-          yield* take(cancelers).pipe(Effect.flatMap$1(canceler => MutableQueue.succeed$1(canceler, void 0)), Effect.when$1(() => size$1 >= concurrencyN));
-          yield* offer(cancelers, canceler);
-          const raceEffects = Effect.scopedWith(scope => toPullIn(pipeTo(queueReader, channel), scope).pipe(Effect.flatMap$1(pull => Effect.exit$1(evaluatePull(pull)).pipe(Effect.race(Effect.exit$1(Effect.interruptible(MutableQueue._await(errorSignal)))), Effect.race(Effect.exit$1(Effect.interruptible(MutableQueue._await(canceler)))))), Effect.flatMap$1(Effect.identity)));
-          yield* MutableQueue.succeed$1(latch, void 0).pipe(Effect.zipRight$1(raceEffects), withPermits(1), Effect.forkIn(scope));
-          yield* MutableQueue._await(latch);
-          const errored = yield* MutableQueue.isDone(errorSignal);
-          return !errored;
-        })
-      })
-    })
-  }), Effect.repeat({
-    while: _ => _
-  }), Effect.forkIn(scope));
-  const consumer = Effect.pipe(take(queue), Effect.flatten, Effect.matchCause({
-    onFailure: failCause$2,
-    onSuccess: Effect.match$1({
-      onLeft: succeedNow,
-      onRight: outElem => flatMap$1(write(outElem), () => consumer)
-    })
-  }), unwrap);
-  return embedInput(consumer, input);
-}));
-/** @internal */
-const mergeMap = /*#__PURE__*/Effect.dual(3, (self, f, options) => mergeAll(options)(mapOut(self, f)));
-/** @internal */
-const mergeWith = /*#__PURE__*/Effect.dual(2, (self, options) => {
-  function merge(scope) {
-    return Effect.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 Effect.succeed(fromEffect$3(Effect.zipRight$1(interrupt(fiber), op.effect)));
-            }
-            return Effect.map$2(_await(fiber), MutableQueue.match({
-              onFailure: cause => fromEffect$3(op.f(MutableQueue.failCause(cause))),
-              onSuccess: Effect.match$1({
-                onLeft: done => fromEffect$3(op.f(MutableQueue.succeed(done))),
-                onRight: elem => zipRight(write(elem), go(single(op.f)))
-              })
-            }));
-          }
-          return MutableQueue.match(exit, {
-            onFailure: cause => onDecision(done(MutableQueue.failCause(cause))),
-            onSuccess: Effect.match$1({
-              onLeft: z => onDecision(done(MutableQueue.succeed(z))),
-              onRight: elem => Effect.succeed(flatMap$1(write(elem), () => flatMap$1(fromEffect$3(Effect.forkIn(Effect.interruptible(pull), scope)), leftFiber => go(both(leftFiber, fiber)))))
-            })
-          });
-        };
-      }
-      function go(state) {
-        switch (state._tag) {
-          case OP_BOTH_RUNNING:
-            {
-              const leftJoin = Effect.interruptible(join(state.left));
-              const rightJoin = Effect.interruptible(join(state.right));
-              return unwrap(Effect.raceWith(leftJoin, rightJoin, {
-                onSelfDone: (leftExit, rf) => Effect.zipRight$1(interrupt(rf), handleSide(leftExit, state.right, pullL)(options.onSelfDone, BothRunning, f => LeftDone(f))),
-                onOtherDone: (rightExit, lf) => Effect.zipRight$1(interrupt(lf), handleSide(rightExit, state.left, pullR)(options.onOtherDone, (left, right) => BothRunning(right, left), f => RightDone(f)))
-              }));
-            }
-          case OP_LEFT_DONE:
-            {
-              return unwrap(Effect.map$2(Effect.exit$1(pullR), MutableQueue.match({
-                onFailure: cause => fromEffect$3(state.f(MutableQueue.failCause(cause))),
-                onSuccess: Effect.match$1({
-                  onLeft: done => fromEffect$3(state.f(MutableQueue.succeed(done))),
-                  onRight: elem => flatMap$1(write(elem), () => go(LeftDone(state.f)))
-                })
-              })));
-            }
-          case OP_RIGHT_DONE:
-            {
-              return unwrap(Effect.map$2(Effect.exit$1(pullL), MutableQueue.match({
-                onFailure: cause => fromEffect$3(state.f(MutableQueue.failCause(cause))),
-                onSuccess: Effect.match$1({
-                  onLeft: done => fromEffect$3(state.f(MutableQueue.succeed(done))),
-                  onRight: elem => flatMap$1(write(elem), () => go(RightDone(state.f)))
-                })
-              })));
-            }
-        }
-      }
-      return fromEffect$3(Effect.withFiberRuntime$1(parent => {
-        const inherit = Effect.withFiberRuntime$1(state => {
-          state.transferChildren(parent.scope());
-          return Effect._void;
-        });
-        const leftFiber = Effect.interruptible(pullL).pipe(Effect.ensuring(inherit), Effect.forkIn(scope));
-        const rightFiber = Effect.interruptible(pullR).pipe(Effect.ensuring(inherit), Effect.forkIn(scope));
-        return Effect.zipWith(leftFiber, rightFiber, (left, right) => BothRunning(left, right));
-      })).pipe(flatMap$1(go), embedInput(input));
-    });
-  }
-  return unwrapScopedWith$1(merge);
-});
-/** @internal */
-const pipeToOrFail = /*#__PURE__*/Effect.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 => Effect.pipe(write(outElem), flatMap$1(() => writer)),
-    onFailure: cause => isDieType(cause) && isChannelException(cause.defect) && Effect.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 => Effect.scopedWith(scope => runIn(self, scope));
-/** @internal */
-const runDrain$2 = self => run$1(drain$1(self));
-/** @internal */
-const scoped = effect => unwrap(Effect.uninterruptibleMask(restore => Effect.map$2(Effect.make$2(), scope => acquireReleaseOut(Effect.tapErrorCause(restore(Effect.extend(effect, scope)), cause => Effect.close(scope, MutableQueue.failCause(cause))), (_, exit) => Effect.close(scope, exit)))));
-/** @internal */
-const scopedWith$1 = f => unwrapScoped(Effect.map$2(Effect.scope, scope => flatMap$1(fromEffect$3(f(scope)), write)));
-/** @internal */
-const toPullIn = /*#__PURE__*/Effect.dual(2, (self, scope) => Effect.zip(Effect.sync$1(() => new ChannelExecutor(self, void 0, Effect.identity)), Effect.runtime()).pipe(Effect.tap(([executor, runtime]) => Effect.addFinalizerExit(scope, exit => {
-  const finalizer = executor.close(exit);
-  return finalizer !== undefined ? Effect.provide(finalizer, runtime) : Effect._void;
-})), Effect.uninterruptible$1, Effect.map$2(([executor]) => Effect.suspend$1(() => interpretToPull(executor.run(), executor)))));
-/** @internal */
-const interpretToPull = (channelState, exec) => {
-  const state = channelState;
-  switch (state._tag) {
-    case OP_DONE$1:
-      {
-        return MutableQueue.match(exec.getDone(), {
-          onFailure: Effect.failCause,
-          onSuccess: done => Effect.succeed(Effect.left(done))
-        });
-      }
-    case OP_EMIT$1:
-      {
-        return Effect.succeed(Effect.right(exec.getEmit()));
-      }
-    case OP_FROM_EFFECT:
-      {
-        return Effect.pipe(state.effect, Effect.flatMap$1(() => interpretToPull(exec.run(), exec)));
-      }
-    case OP_READ:
-      {
-        return readUpstream(state, () => interpretToPull(exec.run(), exec), cause => Effect.failCause(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_ : Effect.pipe(write(Effect.pipe(chunk, Effect.unsafeGet(idx))), flatMap$1(() => writeChunkWriter(idx + 1, len, chunk)));
-};
-/** @internal */
-const zip = /*#__PURE__*/Effect.dual(args => isChannel(args[1]), (self, that, options) => options?.concurrent ? mergeWith(self, {
-  other: that,
-  onSelfDone: exit1 => Await(exit2 => Effect.suspend$1(() => MutableQueue.zip(exit1, exit2))),
-  onOtherDone: exit2 => Await(exit1 => Effect.suspend$1(() => MutableQueue.zip(exit1, exit2)))
-}) : flatMap$1(self, a => map$1(that, b => [a, b])));
-/** @internal */
-const zipRight = /*#__PURE__*/Effect.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 => Effect.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 Effect.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 => Effect.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 Effect.pipeArguments(this, arguments);
-  }
-}
-/** @internal */
-const chunk = chunk => new TakeImpl(MutableQueue.succeed(chunk));
-/** @internal */
-const end$1 = /*#__PURE__*/new TakeImpl(/*#__PURE__*/MutableQueue.fail(/*#__PURE__*/Effect.none()));
-/** @internal */
-const failCause$1 = cause => new TakeImpl(MutableQueue.failCause(Effect.pipe(cause, map$2(Effect.some))));
-/** @internal */
-const of = value => new TakeImpl(MutableQueue.succeed(Effect.of(value)));
-
-/** @internal */
-const end = () => Effect.fail$1(Effect.none());
-/** @internal */
-const failCause = cause => Effect.mapError(Effect.failCause(cause), Effect.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 Effect.pipeArguments(this, arguments);
-  }
-}
-/** @internal */
-const isStream = u => Effect.hasProperty(u, StreamTypeId) || Effect.isEffect(u);
-/** @internal */
-const DefaultChunkSize = 4096;
-/** @internal */
-const ensuring = /*#__PURE__*/Effect.dual(2, (self, finalizer) => new StreamImpl(Effect.pipe(toChannel(self), ensuring$1(finalizer))));
-/** @internal */
-const flatMap = /*#__PURE__*/Effect.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 => Effect.pipe(as, Effect.map$3(a => toChannel(f(a))), Effect.reduce(void_, (left, right) => Effect.pipe(left, zipRight(right)))))), _ => new StreamImpl(Effect.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__*/Effect.dual(4, (self, n, bufferSize, f) => new StreamImpl(Effect.pipe(toChannel(self), concatMap(writeChunk), mergeMap(out => toChannel(f(out)), {
-  concurrency: n,
-  mergeStrategy: BufferSliding(),
-  bufferSize
-}))));
-/** @internal */
-const flatten = /*#__PURE__*/Effect.dual(args => isStream(args[0]), (self, options) => flatMap(self, Effect.identity, options));
-/** @internal */
-const flattenChunks = self => {
-  const flatten = readWithCause({
-    onInput: chunks => flatMap$1(writeChunk(chunks), () => flatten),
-    onFailure: failCause$2,
-    onDone: () => void_
-  });
-  return new StreamImpl(Effect.pipe(toChannel(self), pipeTo(flatten)));
-};
-/** @internal */
-const flattenExitOption = self => {
-  const processChunk = (chunk, cont) => {
-    const [toEmit, rest] = Effect.pipe(chunk, Effect.splitWhere(exit => !MutableQueue.isSuccess(exit)));
-    const next = Effect.pipe(Effect.head(rest), Effect.match({
-      onNone: () => cont,
-      onSome: MutableQueue.match({
-        onFailure: cause => Effect.match(flipCauseOption(cause), {
-          onNone: () => void_,
-          onSome: failCause$2
-        }),
-        onSuccess: () => void_
-      })
-    }));
-    return Effect.pipe(write(Effect.pipe(toEmit, Effect.filterMap(exit => MutableQueue.isSuccess(exit) ? Effect.some(exit.value) : Effect.none()))), flatMap$1(() => next));
-  };
-  const process = readWithCause({
-    onInput: chunk => processChunk(chunk, process),
-    onFailure: cause => failCause$2(cause),
-    onDone: () => void_
-  });
-  return new StreamImpl(Effect.pipe(toChannel(self), pipeTo(process)));
-};
-/** @internal */
-const flattenTake = self => flattenChunks(flattenExitOption(Effect.pipe(self, map(take => take.exit))));
-/** @internal */
-const toChannel = stream => {
-  if ("channel" in stream) {
-    return stream.channel;
-  } else if (Effect.isEffect(stream)) {
-    return toChannel(fromEffect(stream));
-  } else {
-    throw new TypeError(`Expected a Stream.`);
-  }
-};
-/** @internal */
-const fromEffect = effect => Effect.pipe(effect, Effect.mapError(Effect.some), fromEffectOption);
-/** @internal */
-const fromEffectOption = effect => new StreamImpl(unwrap(Effect.match$2(effect, {
-  onFailure: Effect.match({
-    onNone: () => void_,
-    onSome: fail
-  }),
-  onSuccess: a => write(Effect.of(a))
-})));
-/** @internal */
-const fromQueue$1 = (queue, options) => Effect.pipe(takeBetween(queue, 1, options?.maxChunkSize ?? DefaultChunkSize), Effect.catchAllCause(cause => Effect.pipe(isShutdown(queue), Effect.flatMap$1(isShutdown => isShutdown && isInterrupted(cause) ? end() : failCause(cause)))), repeatEffectChunkOption, options?.shutdown ? ensuring(shutdown(queue)) : Effect.identity);
-/** @internal */
-const map = /*#__PURE__*/Effect.dual(2, (self, f) => new StreamImpl(Effect.pipe(toChannel(self), mapOut(Effect.map$3(f)))));
-/** @internal */
-const mapEffectSequential = /*#__PURE__*/Effect.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(Effect.map$2(f(value), a2 => flatMap$1(write(Effect.of(a2)), () => loop(iterator))));
-    }
-  };
-  return new StreamImpl(Effect.pipe(toChannel(self), pipeTo(suspend$1(() => loop(Effect.empty$2()[Symbol.iterator]())))));
-});
-/** @internal */
-const mapEffectPar = /*#__PURE__*/Effect.dual(3, (self, n, f) => new StreamImpl(Effect.pipe(toChannel(self), concatMap(writeChunk), mapOutEffectPar(f, n), mapOut(Effect.of))));
-/** @internal */
-const repeatEffectChunkOption = effect => unfoldChunkEffect(effect, effect => Effect.pipe(Effect.map$2(effect, chunk => Effect.some([chunk, effect])), Effect.catchAll(Effect.match({
-  onNone: () => Effect.succeed(Effect.none()),
-  onSome: Effect.fail$1
-}))));
-/** @internal */
-const run = /*#__PURE__*/Effect.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(Effect.map$2(Effect.of))));
-/** @internal */
-const suspend = stream => new StreamImpl(suspend$1(() => toChannel(stream())));
-/** @internal */
-const unfoldChunkEffect = (s, f) => suspend(() => {
-  const loop = s => unwrap(Effect.map$2(f(s), Effect.match({
-    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 => Effect.hasProperty(u, GroupByTypeId);
-/** @internal */
-const evaluate = /*#__PURE__*/Effect.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 Effect.pipeArguments(this, arguments);
-  },
-  grouped
-});
-/** @internal */
-const mapEffectOptions = /*#__PURE__*/Effect.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__*/Effect.dual(args => typeof args[0] !== "function", (self, f, options) => {
-  const loop = (map, outerQueue) => readWithCause({
-    onInput: input => flatMap$1(fromEffect$3(Effect.forEach(groupByIterable(input, f), ([key, values]) => {
-      const innerQueue = map.get(key);
-      if (innerQueue === undefined) {
-        return Effect.pipe(bounded(options?.bufferSize ?? 16), Effect.flatMap$1(innerQueue => Effect.pipe(Effect.sync$1(() => {
-          map.set(key, innerQueue);
-        }), Effect.zipRight$1(offer(outerQueue, of([key, innerQueue]))), Effect.zipRight$1(Effect.pipe(offer(innerQueue, chunk(values)), Effect.catchSomeCause(cause => isInterruptedOnly(cause) ? Effect.some(Effect._void) : Effect.none()))))));
-      }
-      return Effect.catchSomeCause(offer(innerQueue, chunk(values)), cause => isInterruptedOnly(cause) ? Effect.some(Effect._void) : Effect.none());
-    }, {
-      discard: true
-    })), () => loop(map, outerQueue)),
-    onFailure: cause => fromEffect$3(offer(outerQueue, failCause$1(cause))),
-    onDone: () => fromEffect$3(Effect.pipe(Effect.forEach(map.entries(), ([_, innerQueue]) => Effect.pipe(offer(innerQueue, end$1), Effect.catchSomeCause(cause => isInterruptedOnly(cause) ? Effect.some(Effect._void) : Effect.none())), {
-      discard: true
-    }), Effect.zipRight$1(offer(outerQueue, end$1))))
-  });
-  return make(unwrapScopedWith(scope => Effect.gen(function* () {
-    const map = new Map();
-    const queue = yield* unbounded();
-    yield* Effect.addFinalizer(scope, shutdown(queue));
-    return yield* toChannel(self).pipe(pipeTo(loop(map, queue)), drain$1, runIn(scope), Effect.forkIn(scope), Effect.as(flattenTake(fromQueue$1(queue, {
-      shutdown: true
-    }))));
-  })));
-});
-/**
- * A variant of `groupBy` that retains the insertion order of keys.
- *
- * @internal
- */
-const groupByIterable = /*#__PURE__*/Effect.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 Effect.unsafeFromArray(builder.map(tuple => [tuple[0], Effect.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 index.Build.isDev;
-    }
-    static axe = this.globalValidationEnabled ? Promise.resolve().then(function () { return require('./axe-BNqwbBGU.js'); }).then(function (n) { return n.axe; }) : 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 = Effect.gen(function* () {
-            const queue = (AriaValidationController.axeQueue = yield* bounded(100));
-            const axeLib = yield* Effect.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 }) => Effect.async(resume => {
-                axeLib.run(context, {}, (error, results) => {
-                    onComplete(error, results);
-                    resume(Effect._void);
-                });
-            })));
-            yield* runDrain(stream);
-        });
-        this.axeStreamFiber = Effect.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;
-    }
-}
-
-exports.AriaValidationController = AriaValidationController;
-exports.ReactiveControllerHost = ReactiveControllerHost;