@lmvz-ds/components 0.11.4

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

@@ -0,0 +1,2929 @@
+'use strict';
+
+var index = require('./index-9ZJx0550.js');
+var Effect = require('./Effect-BIlTHtLK.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$1;
+/**
+ * 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$1;
+/**
+ * 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$2));
+  }
+  unsafeSize() {
+    if (Effect.get$2(this.shutdownFlag)) {
+      return Effect.none();
+    }
+    return Effect.some(this.queue.length() - Effect.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, Effect.poll(Effect.EmptyMutableQueue));
+      if (taker !== Effect.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$2;
+      }
+      let noRemaining;
+      if (this.queue.length() === 0) {
+        const taker = Effect.pipe(this.takers, Effect.poll(Effect.EmptyMutableQueue));
+        if (taker !== Effect.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$2;
+      }
+      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$2;
+      }
+      const item = this.queue.poll(Effect.EmptyMutableQueue);
+      if (item !== Effect.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, Effect.offer(deferred));
+          unsafeCompleteTakers(this.strategy, this.queue, this.takers);
+          return Effect.get$2(this.shutdownFlag) ? Effect.interrupt$2 : 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$2 : 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$2 : 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(() => Effect.bounded(requestedCapacity)), Effect.flatMap(queue => make$2(backingQueueFromMutableQueue(queue), backPressureStrategy())));
+/** @internal */
+const unbounded$1 = () => Effect.pipe(Effect.sync(() => Effect.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, Effect.unbounded(), deferred, Effect.make(false), strategy)));
+/** @internal */
+class BackingQueueFromMutableQueue {
+  mutable;
+  [BackingQueueTypeId] = backingQueueVariance;
+  constructor(mutable) {
+    this.mutable = mutable;
+  }
+  poll(def) {
+    return Effect.poll(this.mutable, def);
+  }
+  pollUpTo(limit) {
+    return Effect.pollUpTo(this.mutable, limit);
+  }
+  offerAll(elements) {
+    return Effect.offerAll(this.mutable, elements);
+  }
+  offer(element) {
+    return Effect.offer(this.mutable, element);
+  }
+  capacity() {
+    return Effect.capacity(this.mutable);
+  }
+  length() {
+    return Effect.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__*/Effect.unbounded();
+  surplusSize() {
+    return Effect.length(this.putters);
+  }
+  onCompleteTakersWithEmptyQueue(takers) {
+    while (!Effect.isEmpty$1(this.putters) && !Effect.isEmpty$1(takers)) {
+      const taker = Effect.poll(takers, void 0);
+      const putter = Effect.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$2 : 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, Effect.poll(Effect.EmptyMutableQueue));
+      if (putter === Effect.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, Effect.offer([value, deferred, true]));
+      } else {
+        Effect.pipe(this.putters, Effect.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, Effect.offerAll(as));
+};
+/** @internal */
+const unsafePollAll = queue => {
+  return Effect.pipe(queue, Effect.pollUpTo(Number.POSITIVE_INFINITY));
+};
+/** @internal */
+const unsafePollN = (queue, max) => {
+  return Effect.pipe(queue, Effect.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, Effect.poll(Effect.EmptyMutableQueue));
+    if (taker !== Effect.EmptyMutableQueue) {
+      const element = queue.poll(Effect.EmptyMutableQueue);
+      if (element !== Effect.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 && !Effect.isEmpty$1(takers)) {
+    strategy.onCompleteTakersWithEmptyQueue(takers);
+  }
+};
+
+/**
+ * Makes a new bounded `Queue`. When the capacity of the queue is reached, any
+ * additional calls to `offer` will be suspended until there is more room in
+ * the queue.
+ *
+ * **Note**: When possible use only power of 2 capacities; this will provide
+ * better performance by utilising an optimised version of the underlying
+ * `RingBuffer`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const bounded = bounded$1;
+/**
+ * Creates a new unbounded `Queue`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unbounded = unbounded$1;
+/**
+ * Retrieves the size of the queue, which is equal to the number of elements
+ * in the queue. This may be negative if fibers are suspended waiting for
+ * elements to be added to the queue.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const size = size$1;
+/**
+ * Returns `true` if `shutdown` has been called, otherwise returns `false`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isShutdown = isShutdown$1;
+/**
+ * Interrupts any fibers that are suspended on `offer` or `take`. Future calls
+ * to `offer*` and `take*` will be interrupted immediately.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const shutdown = shutdown$1;
+/**
+ * Places one value in the queue.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const offer = offer$1;
+/**
+ * Takes the oldest value in the queue. If the queue is empty, this will return
+ * a computation that resumes when an item has been added to the queue.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const take = take$1;
+/**
+ * Takes a number of elements from the queue between the specified minimum and
+ * maximum. If there are fewer than the minimum number of elements available,
+ * suspends until at least the minimum number of elements have been collected.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const takeBetween = takeBetween$1;
+
+/** @internal */
+const OP_CONTINUE = "Continue";
+/** @internal */
+const OP_CLOSE = "Close";
+/** @internal */
+const OP_YIELD = "Yield";
+
+/** @internal */
+const ChildExecutorDecisionSymbolKey = "effect/ChannelChildExecutorDecision";
+/** @internal */
+const ChildExecutorDecisionTypeId = /*#__PURE__*/Symbol.for(ChildExecutorDecisionSymbolKey);
+/** @internal */
+const proto$7 = {
+  [ChildExecutorDecisionTypeId]: ChildExecutorDecisionTypeId
+};
+/** @internal */
+const Continue = _ => {
+  const op = Object.create(proto$7);
+  op._tag = OP_CONTINUE;
+  return op;
+};
+
+/** @internal */
+const OP_CONTINUATION_K = "ContinuationK";
+/** @internal */
+const OP_CONTINUATION_FINALIZER = "ContinuationFinalizer";
+
+/** @internal */
+const ContinuationTypeId = /*#__PURE__*/Symbol.for("effect/ChannelContinuation");
+const continuationVariance = {
+  /* c8 ignore next */
+  _Env: _ => _,
+  /* c8 ignore next */
+  _InErr: _ => _,
+  /* c8 ignore next */
+  _InElem: _ => _,
+  /* c8 ignore next */
+  _InDone: _ => _,
+  /* c8 ignore next */
+  _OutErr: _ => _,
+  /* c8 ignore next */
+  _OutDone: _ => _,
+  /* c8 ignore next */
+  _OutErr2: _ => _,
+  /* c8 ignore next */
+  _OutElem: _ => _,
+  /* c8 ignore next */
+  _OutDone2: _ => _
+};
+/** @internal */
+class ContinuationKImpl {
+  onSuccess;
+  onHalt;
+  _tag = OP_CONTINUATION_K;
+  [ContinuationTypeId] = continuationVariance;
+  constructor(onSuccess, onHalt) {
+    this.onSuccess = onSuccess;
+    this.onHalt = onHalt;
+  }
+  onExit(exit) {
+    return Effect.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, Effect.zipRight$1(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) => Effect.zipRight$1(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) => Effect.zipRight$1(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 Effect.match$2(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$2(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(Effect.die$1(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, Effect.zipRight$1(exit2), Effect.zipRight$1(exit3))), Effect.uninterruptible$1,
+    // TODO: remove
+    Effect.flatMap$1(exit => Effect.suspend$1(() => exit)));
+  }
+  doneSucceed(value) {
+    if (this._doneStack.length === 0) {
+      this._done = Effect.succeed$2(value);
+      this._currentChannel = undefined;
+      return Done();
+    }
+    const head = this._doneStack[this._doneStack.length - 1];
+    if (head._tag === OP_CONTINUATION_K) {
+      this._doneStack.pop();
+      this._currentChannel = head.onSuccess(value);
+      return undefined;
+    }
+    const finalizers = this.popNextFinalizers();
+    if (this._doneStack.length === 0) {
+      this._doneStack = finalizers.reverse();
+      this._done = Effect.succeed$2(value);
+      this._currentChannel = undefined;
+      return Done();
+    }
+    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), Effect.succeed$2(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 = Effect.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 = Effect.failCause(cause);
+      this._currentChannel = undefined;
+      return Done();
+    }
+    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), Effect.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 = Effect.match$2(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, Effect.match$2({
+      onFailure: cause => this.doneHalt(cause),
+      onSuccess: value => this.doneSucceed(value)
+    }));
+    this._activeSubexecutor = undefined;
+    return state;
+  }
+  applyUpstreamPullStrategy(upstreamFinished, queue, strategy) {
+    switch (strategy._tag) {
+      case OP_PULL_AFTER_NEXT:
+        {
+          const shouldPrepend = !upstreamFinished || queue.some(subexecutor => subexecutor !== undefined);
+          return [strategy.emitSeparator, shouldPrepend ? [undefined, ...queue] : queue];
+        }
+      case OP_PULL_AFTER_ALL_ENQUEUED:
+        {
+          const shouldEnqueue = !upstreamFinished || queue.some(subexecutor => subexecutor !== undefined);
+          return [strategy.emitSeparator, shouldEnqueue ? [...queue, undefined] : queue];
+        }
+    }
+  }
+  pullFromChild(childExecutor, parentSubexecutor, onEmitted, subexecutor) {
+    return Read(childExecutor, 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;
+    }, Effect.match$2({
+      onFailure: cause => {
+        const state = this.handleSubexecutorFailure(childExecutor, parentSubexecutor, cause);
+        return state === undefined ? undefined : effectOrUndefinedIgnored(state);
+      },
+      onSuccess: doneValue => {
+        this.finishWithDoneValue(childExecutor, parentSubexecutor, doneValue);
+        return undefined;
+      }
+    }));
+  }
+  finishWithDoneValue(childExecutor, parentSubexecutor, doneValue) {
+    const subexecutor = parentSubexecutor;
+    switch (subexecutor._tag) {
+      case OP_PULL_FROM_UPSTREAM:
+        {
+          const modifiedParent = new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone !== undefined ? subexecutor.combineChildResults(subexecutor.lastDone, doneValue) : doneValue, subexecutor.activeChildExecutors, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit);
+          this._closeLastSubstream = childExecutor.close(Effect.succeed$2(doneValue));
+          this.replaceSubexecutor(modifiedParent);
+          break;
+        }
+      case OP_DRAIN_CHILD_EXECUTORS:
+        {
+          const modifiedParent = new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone !== undefined ? subexecutor.combineChildResults(subexecutor.lastDone, doneValue) : doneValue, subexecutor.activeChildExecutors, subexecutor.upstreamDone, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull);
+          this._closeLastSubstream = childExecutor.close(Effect.succeed$2(doneValue));
+          this.replaceSubexecutor(modifiedParent);
+          break;
+        }
+    }
+  }
+  handleSubexecutorFailure(childExecutor, parentSubexecutor, cause) {
+    return this.finishSubexecutorWithCloseEffect(Effect.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$2(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, Effect.map$3(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(Effect.all$1(exits), Effect.getOrElse(() => Effect.void_$1))), 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(Effect.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$2(Effect._await(channelDeferred)), Effect.zipLeft(Effect._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$1(cause)));
+  });
+  return Effect.uninterruptibleMask(restore => Effect.all$2([Effect.fork(scope, Effect.sequential), Effect.make$2(), Effect.make$2()]).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 = Effect.isFailure(exit) ? interruptors(exit.cause) : undefined;
+    return Effect.isDone(channelDeferred).pipe(Effect.flatMap$1(isDone => isDone ? Effect.succeed$3(scopeDeferred, void 0).pipe(Effect.zipRight$2(_await(fiber)), Effect.zipRight$2(inheritAll(fiber))) : Effect.succeed$3(scopeDeferred, void 0).pipe(Effect.zipRight$2(interruptors$1 && Effect.size$1(interruptors$1) > 0 ? interruptAs(fiber, Effect.combineAll(interruptors$1)) : interrupt(fiber)), Effect.zipRight$2(inheritAll(fiber)))));
+  }).pipe(Effect.zipRight$2(restore(Effect._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$1);
+      }
+  }
+};
+
+/** @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 ? [Effect._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 [Effect._await(state.notifyProducer), state];
+          }
+        case OP_STATE_EMIT:
+          {
+            return [Effect.forEach(state.notifyConsumers, deferred => Effect.succeed$3(deferred, Effect.left(value)), {
+              discard: true
+            }), stateDone(value)];
+          }
+        case OP_STATE_ERROR:
+          {
+            return [Effect.interrupt$3, state];
+          }
+        case OP_STATE_DONE:
+          {
+            return [Effect.interrupt$3, state];
+          }
+      }
+    }));
+  }
+  emit(element) {
+    return Effect.flatMap$1(Effect.make$2(), deferred => Effect.flatten(modify(this.ref, state => {
+      switch (state._tag) {
+        case OP_STATE_EMPTY:
+          {
+            return [Effect._await(state.notifyProducer), state];
+          }
+        case OP_STATE_EMIT:
+          {
+            const notifyConsumer = state.notifyConsumers[0];
+            const notifyConsumers = state.notifyConsumers.slice(1);
+            if (notifyConsumer !== undefined) {
+              return [Effect.succeed$3(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$3, state];
+          }
+        case OP_STATE_DONE:
+          {
+            return [Effect.interrupt$3, state];
+          }
+      }
+    })));
+  }
+  error(cause) {
+    return Effect.flatten(modify(this.ref, state => {
+      switch (state._tag) {
+        case OP_STATE_EMPTY:
+          {
+            return [Effect._await(state.notifyProducer), state];
+          }
+        case OP_STATE_EMIT:
+          {
+            return [Effect.forEach(state.notifyConsumers, deferred => Effect.failCause$2(deferred, cause), {
+              discard: true
+            }), stateError(cause)];
+          }
+        case OP_STATE_ERROR:
+          {
+            return [Effect.interrupt$3, state];
+          }
+        case OP_STATE_DONE:
+          {
+            return [Effect.interrupt$3, state];
+          }
+      }
+    }));
+  }
+  get take() {
+    return this.takeWith(cause => Effect.failCause(map$2(cause, Effect.left)), elem => Effect.succeed$2(elem), done => Effect.fail$1(Effect.right(done)));
+  }
+  takeWith(onError, onElement, onDone) {
+    return Effect.flatMap$1(Effect.make$2(), deferred => Effect.flatten(modify(this.ref, state => {
+      switch (state._tag) {
+        case OP_STATE_EMPTY:
+          {
+            return [Effect.zipRight$2(Effect.succeed$3(state.notifyProducer, void 0), Effect.matchCause(Effect._await(deferred), {
+              onFailure: onError,
+              onSuccess: Effect.match$1({
+                onLeft: onDone,
+                onRight: onElement
+              })
+            })), stateEmit([deferred])];
+          }
+        case OP_STATE_EMIT:
+          {
+            return [Effect.matchCause(Effect._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(Effect.make$2(), 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* Effect.make$2();
+  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$1(cause)),
+    onSuccess: Effect.match$1({
+      onLeft: outDone => Effect.zipRight$2(Effect.interruptible(withPermits(n)(Effect._void)), Effect.asVoid$1(offer(queue, Effect.succeed(Effect.left(outDone))))),
+      onRight: outElem => Effect.gen(function* () {
+        const deferred = yield* Effect.make$2();
+        const latch = yield* Effect.make$2();
+        yield* offer(queue, Effect.map$2(Effect._await(deferred), Effect.right));
+        yield* Effect.succeed$3(latch, void 0).pipe(Effect.zipRight$2(Effect.uninterruptibleMask(restore => Effect.exit$1(restore(Effect._await(errorSignal))).pipe(Effect.raceFirst(Effect.exit$1(restore(f(outElem)))), Effect.flatMap$1(Effect.identity))).pipe(Effect.tapErrorCause(cause => Effect.failCause$2(errorSignal, cause)), Effect.intoDeferred(deferred))), withPermits(1), Effect.forkIn(scope));
+        yield* Effect._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* Effect.make$2();
+  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$1(cause) : offer(queue, Effect.failCause$1(cause)).pipe(Effect.zipRight$2(Effect.succeed$3(errorSignal, void 0)), Effect.asVoid$1)));
+  }
+  yield* pull.pipe(Effect.matchCauseEffect({
+    onFailure: cause => offer(queue, Effect.failCause$1(cause)).pipe(Effect.zipRight$2(Effect.succeed(false))),
+    onSuccess: Effect.match$1({
+      onLeft: outDone => Effect.raceWith(Effect.interruptible(Effect._await(errorSignal)), Effect.interruptible(withPermits(concurrencyN)(Effect._void)), {
+        onSelfDone: (_, permitAcquisition) => Effect.as(interrupt(permitAcquisition), false),
+        onOtherDone: (_, failureAwait) => Effect.zipRight$2(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* Effect.make$2();
+          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(Effect._await(errorSignal))))), Effect.flatMap$1(Effect.identity)));
+          yield* Effect.succeed$3(latch, void 0).pipe(Effect.zipRight$2(raceEffects), withPermits(1), Effect.forkIn(scope));
+          yield* Effect._await(latch);
+          const errored = yield* Effect.isDone(errorSignal);
+          return !errored;
+        }),
+        onBufferSliding: () => Effect.gen(function* () {
+          const canceler = yield* Effect.make$2();
+          const latch = yield* Effect.make$2();
+          const size$1 = yield* size(cancelers);
+          yield* take(cancelers).pipe(Effect.flatMap$1(canceler => Effect.succeed$3(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(Effect._await(errorSignal)))), Effect.race(Effect.exit$1(Effect.interruptible(Effect._await(canceler)))))), Effect.flatMap$1(Effect.identity)));
+          yield* Effect.succeed$3(latch, void 0).pipe(Effect.zipRight$2(raceEffects), withPermits(1), Effect.forkIn(scope));
+          yield* Effect._await(latch);
+          const errored = yield* Effect.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$2(interrupt(fiber), op.effect)));
+            }
+            return Effect.map$2(_await(fiber), Effect.match$2({
+              onFailure: cause => fromEffect$3(op.f(Effect.failCause(cause))),
+              onSuccess: Effect.match$1({
+                onLeft: done => fromEffect$3(op.f(Effect.succeed$2(done))),
+                onRight: elem => zipRight(write(elem), go(single(op.f)))
+              })
+            }));
+          }
+          return Effect.match$2(exit, {
+            onFailure: cause => onDecision(done(Effect.failCause(cause))),
+            onSuccess: Effect.match$1({
+              onLeft: z => onDecision(done(Effect.succeed$2(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$2(interrupt(rf), handleSide(leftExit, state.right, pullL)(options.onSelfDone, BothRunning, f => LeftDone(f))),
+                onOtherDone: (rightExit, lf) => Effect.zipRight$2(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), Effect.match$2({
+                onFailure: cause => fromEffect$3(state.f(Effect.failCause(cause))),
+                onSuccess: Effect.match$1({
+                  onLeft: done => fromEffect$3(state.f(Effect.succeed$2(done))),
+                  onRight: elem => flatMap$1(write(elem), () => go(LeftDone(state.f)))
+                })
+              })));
+            }
+          case OP_RIGHT_DONE:
+            {
+              return unwrap(Effect.map$2(Effect.exit$1(pullL), Effect.match$2({
+                onFailure: cause => fromEffect$3(state.f(Effect.failCause(cause))),
+                onSuccess: Effect.match$1({
+                  onLeft: done => fromEffect$3(state.f(Effect.succeed$2(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$3(), scope => acquireReleaseOut(Effect.tapErrorCause(restore(Effect.extend(effect, scope)), cause => Effect.close(scope, Effect.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 Effect.match$2(exec.getDone(), {
+          onFailure: Effect.failCause$1,
+          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$1(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(() => Effect.zip$1(exit1, exit2))),
+  onOtherDone: exit2 => Await(exit1 => Effect.suspend$1(() => Effect.zip$1(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(Effect.succeed$2(chunk));
+/** @internal */
+const end$1 = /*#__PURE__*/new TakeImpl(/*#__PURE__*/Effect.fail$1(/*#__PURE__*/Effect.none()));
+/** @internal */
+const failCause$1 = cause => new TakeImpl(Effect.failCause(Effect.pipe(cause, map$2(Effect.some))));
+/** @internal */
+const of = value => new TakeImpl(Effect.succeed$2(Effect.of(value)));
+
+/** @internal */
+const end = () => Effect.fail$2(Effect.none());
+/** @internal */
+const failCause = cause => Effect.mapError(Effect.failCause$1(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$4(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 => !Effect.isSuccess(exit)));
+    const next = Effect.pipe(Effect.head(rest), Effect.match({
+      onNone: () => cont,
+      onSome: Effect.match$2({
+        onFailure: cause => Effect.match(flipCauseOption(cause), {
+          onNone: () => void_,
+          onSome: failCause$2
+        }),
+        onSuccess: () => void_
+      })
+    }));
+    return Effect.pipe(write(Effect.pipe(toEmit, Effect.filterMap(exit => Effect.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$3(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$4(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$2
+}))));
+/** @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$2(offer(outerQueue, of([key, innerQueue]))), Effect.zipRight$2(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$2(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;