@lmvz-ds/components 0.14.1 → 0.16.0

package/dist/cjs/{index-QRnWYctw.js → index-ww_DCXU7.js}

@@ -1,27 +1,29 @@
 'use strict';
 
-var Effect = require('./Effect-CpZhfb0D.js');
+var icons = require('./icons-BOM23oli.js');
+require('./assets-XY-cBmal.js');
+require('./index-B1Puzu82.js');
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-const make$3 = Effect.make$1;
+const make$3 = icons.make;
 /**
  * @since 2.0.0
  * @category getters
  */
-const get = Effect.get$1;
+const get = icons.get;
 /**
  * @since 2.0.0
  * @category utils
  */
-const modify = Effect.modify;
+const modify = icons.modify;
 /**
  * @since 2.0.0
  * @category utils
  */
-const update = Effect.update;
+const update = icons.update;
 
 /**
  * Creates a `Fail` cause from an expected error.
@@ -37,7 +39,7 @@ const update = Effect.update;
  * @since 2.0.0
  * @category Constructors
  */
-const fail$1 = Effect.fail$1;
+const fail$1 = icons.fail;
 /**
  * Creates a `Die` cause from an unexpected error.
  *
@@ -52,7 +54,7 @@ const fail$1 = Effect.fail$1;
  * @since 2.0.0
  * @category Constructors
  */
-const die = Effect.die;
+const die = icons.die;
 /**
  * Creates an `Interrupt` cause from a `FiberId`.
  *
@@ -67,7 +69,7 @@ const die = Effect.die;
  * @since 2.0.0
  * @category Constructors
  */
-const interrupt$1 = Effect.interrupt$1;
+const interrupt$1 = icons.interrupt;
 /**
  * Checks if a `Cause` is a `Die` type.
  *
@@ -76,7 +78,7 @@ const interrupt$1 = Effect.interrupt$1;
  * @since 2.0.0
  * @category Guards
  */
-const isDieType = Effect.isDieType;
+const isDieType = icons.isDieType;
 /**
  * Checks if a `Cause` contains an interruption.
  *
@@ -87,7 +89,7 @@ const isDieType = Effect.isDieType;
  * @since 2.0.0
  * @category Getters
  */
-const isInterrupted = Effect.isInterrupted;
+const isInterrupted = icons.isInterrupted;
 /**
  * Checks if a `Cause` contains only interruptions.
  *
@@ -100,7 +102,7 @@ const isInterrupted = Effect.isInterrupted;
  * @since 2.0.0
  * @category Getters
  */
-const isInterruptedOnly = Effect.isInterruptedOnly;
+const isInterruptedOnly = icons.isInterruptedOnly;
 /**
  * Collects all `FiberId`s responsible for interrupting a fiber.
  *
@@ -113,7 +115,7 @@ const isInterruptedOnly = Effect.isInterruptedOnly;
  * @since 2.0.0
  * @category Getters
  */
-const interruptors = Effect.interruptors;
+const interruptors = icons.interruptors;
 /**
  * Splits a `Cause` into either its first `Fail` error or the rest of the cause
  * (which might only contain `Die` or `Interrupt`).
@@ -127,7 +129,7 @@ const interruptors = Effect.interruptors;
  * @since 2.0.0
  * @category Getters
  */
-const failureOrCause = Effect.failureOrCause;
+const failureOrCause = icons.failureOrCause;
 /**
  * Strips out failures with an error of `None` from a `Cause<Option<E>>`.
  *
@@ -141,7 +143,7 @@ const failureOrCause = Effect.failureOrCause;
  * @since 2.0.0
  * @category Getters
  */
-const flipCauseOption = Effect.flipCauseOption;
+const flipCauseOption = icons.flipCauseOption;
 /**
  * Transforms the errors in a `Cause` using a user-provided function.
  *
@@ -156,9 +158,9 @@ const flipCauseOption = Effect.flipCauseOption;
  * @since 2.0.0
  * @category Mapping
  */
-const map$2 = Effect.map$1;
+const map$2 = icons.map;
 
-const _await = Effect._await$1;
+const _await = icons._await;
 /**
  * Inherits values from all `FiberRef` instances into current fiber. This
  * will resume immediately.
@@ -166,7 +168,7 @@ const _await = Effect._await$1;
  * @since 2.0.0
  * @category destructors
  */
-const inheritAll = Effect.inheritAll;
+const inheritAll = icons.inheritAll;
 /**
  * Interrupts the fiber from whichever fiber is calling this method. If the
  * fiber has already exited, the returned effect will resume immediately.
@@ -175,7 +177,7 @@ const inheritAll = Effect.inheritAll;
  * @since 2.0.0
  * @category interruption
  */
-const interrupt = Effect.interruptFiber;
+const interrupt = icons.interruptFiber;
 /**
  * Interrupts the fiber as if interrupted from the specified fiber. If the
  * fiber has already exited, the returned effect will resume immediately.
@@ -184,7 +186,7 @@ const interrupt = Effect.interruptFiber;
  * @since 2.0.0
  * @category interruption
  */
-const interruptAs = Effect.interruptAsFiber;
+const interruptAs = icons.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
@@ -195,7 +197,7 @@ const interruptAs = Effect.interruptAsFiber;
  * @since 2.0.0
  * @category destructors
  */
-const join = Effect.join;
+const join = icons.join;
 
 /** @internal */
 const EnqueueSymbolKey = "effect/QueueEnqueue";
@@ -232,7 +234,7 @@ const dequeueVariance = {
   _Out: _ => _
 };
 /** @internal */
-class QueueImpl extends Effect.Class {
+class QueueImpl extends icons.Class {
   queue;
   takers;
   shutdownHook;
@@ -254,7 +256,7 @@ class QueueImpl extends Effect.Class {
     this.strategy = strategy;
   }
   pipe() {
-    return Effect.pipeArguments(this, arguments);
+    return icons.pipeArguments(this, arguments);
   }
   commit() {
     return this.take;
@@ -263,43 +265,43 @@ class QueueImpl extends Effect.Class {
     return this.queue.capacity();
   }
   get size() {
-    return Effect.suspend(() => Effect.catchAll$1(this.unsafeSize(), () => Effect.interrupt$2));
+    return icons.suspend(() => icons.catchAll$1(this.unsafeSize(), () => icons.interrupt$1));
   }
   unsafeSize() {
-    if (Effect.get$2(this.shutdownFlag)) {
-      return Effect.none();
+    if (icons.get$1(this.shutdownFlag)) {
+      return icons.none();
     }
-    return Effect.some(this.queue.length() - Effect.length(this.takers) + this.strategy.surplusSize());
+    return icons.some(this.queue.length() - icons.length(this.takers) + this.strategy.surplusSize());
   }
   get isEmpty() {
-    return Effect.map(this.size, size => size <= 0);
+    return icons.map$1(this.size, size => size <= 0);
   }
   get isFull() {
-    return Effect.map(this.size, size => size >= this.capacity());
+    return icons.map$1(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);
+    return icons.uninterruptible(icons.withFiberRuntime(state => {
+      icons.pipe(this.shutdownFlag, icons.set(true));
+      return icons.pipe(icons.forEachConcurrentDiscard(unsafePollAll(this.takers), d => icons.deferredInterruptWith(d, state.id()), false, false), icons.zipRight(this.strategy.shutdown), icons.whenEffect(icons.deferredSucceed(this.shutdownHook, void 0)), icons.asVoid);
     }));
   }
   get isShutdown() {
-    return Effect.sync(() => Effect.get$2(this.shutdownFlag));
+    return icons.sync(() => icons.get$1(this.shutdownFlag));
   }
   get awaitShutdown() {
-    return Effect.deferredAwait(this.shutdownHook);
+    return icons.deferredAwait(this.shutdownHook);
   }
   isActive() {
-    return !Effect.get$2(this.shutdownFlag);
+    return !icons.get$1(this.shutdownFlag);
   }
   unsafeOffer(value) {
-    if (Effect.get$2(this.shutdownFlag)) {
+    if (icons.get$1(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) {
+      const taker = icons.pipe(this.takers, icons.poll(icons.EmptyMutableQueue));
+      if (taker !== icons.EmptyMutableQueue) {
         unsafeCompleteDeferred(taker, value);
         noRemaining = true;
       } else {
@@ -317,14 +319,14 @@ class QueueImpl extends Effect.Class {
     return succeeded;
   }
   offer(value) {
-    return Effect.suspend(() => {
-      if (Effect.get$2(this.shutdownFlag)) {
-        return Effect.interrupt$2;
+    return icons.suspend(() => {
+      if (icons.get$1(this.shutdownFlag)) {
+        return icons.interrupt$1;
       }
       let noRemaining;
       if (this.queue.length() === 0) {
-        const taker = Effect.pipe(this.takers, Effect.poll(Effect.EmptyMutableQueue));
-        if (taker !== Effect.EmptyMutableQueue) {
+        const taker = icons.pipe(this.takers, icons.poll(icons.EmptyMutableQueue));
+        if (taker !== icons.EmptyMutableQueue) {
           unsafeCompleteDeferred(taker, value);
           noRemaining = true;
         } else {
@@ -334,107 +336,107 @@ class QueueImpl extends Effect.Class {
         noRemaining = false;
       }
       if (noRemaining) {
-        return Effect.succeed$1(true);
+        return icons.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);
+      return succeeded ? icons.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;
+    return icons.suspend(() => {
+      if (icons.get$1(this.shutdownFlag)) {
+        return icons.interrupt$1;
       }
-      const values = Effect.fromIterable(iterable);
-      const pTakers = this.queue.length() === 0 ? Effect.fromIterable(unsafePollN(this.takers, values.length)) : Effect.empty$1;
-      const [forTakers, remaining] = Effect.pipe(values, Effect.splitAt(pTakers.length));
+      const values = icons.fromIterable(iterable);
+      const pTakers = this.queue.length() === 0 ? icons.fromIterable(unsafePollN(this.takers, values.length)) : icons.empty;
+      const [forTakers, remaining] = icons.pipe(values, icons.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);
+        return icons.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);
+      return icons.isEmpty(surplus) ? icons.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;
+    return icons.withFiberRuntime(state => {
+      if (icons.get$1(this.shutdownFlag)) {
+        return icons.interrupt$1;
       }
-      const item = this.queue.poll(Effect.EmptyMutableQueue);
-      if (item !== Effect.EmptyMutableQueue) {
+      const item = this.queue.poll(icons.EmptyMutableQueue);
+      if (item !== icons.EmptyMutableQueue) {
         this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
-        return Effect.succeed$1(item);
+        return icons.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));
+        const deferred = icons.deferredUnsafeMake(state.id());
+        return icons.pipe(icons.suspend(() => {
+          icons.pipe(this.takers, icons.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));
+          return icons.get$1(this.shutdownFlag) ? icons.interrupt$1 : icons.deferredAwait(deferred);
+        }), icons.onInterrupt(() => {
+          return icons.sync(() => unsafeRemove(this.takers, deferred));
         }));
       }
     });
   }
   get takeAll() {
-    return Effect.suspend(() => {
-      return Effect.get$2(this.shutdownFlag) ? Effect.interrupt$2 : Effect.sync(() => {
+    return icons.suspend(() => {
+      return icons.get$1(this.shutdownFlag) ? icons.interrupt$1 : icons.sync(() => {
         const values = this.queue.pollUpTo(Number.POSITIVE_INFINITY);
         this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
-        return Effect.fromIterable$1(values);
+        return icons.fromIterable$1(values);
       });
     });
   }
   takeUpTo(max) {
-    return Effect.suspend(() => Effect.get$2(this.shutdownFlag) ? Effect.interrupt$2 : Effect.sync(() => {
+    return icons.suspend(() => icons.get$1(this.shutdownFlag) ? icons.interrupt$1 : icons.sync(() => {
       const values = this.queue.pollUpTo(max);
       this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
-      return Effect.fromIterable$1(values);
+      return icons.fromIterable$1(values);
     }));
   }
   takeBetween(min, max) {
-    return Effect.suspend(() => takeRemainderLoop(this, min, max, Effect.empty$2()));
+    return icons.suspend(() => takeRemainderLoop(this, min, max, icons.empty$1()));
   }
 }
 /** @internal */
 const takeRemainderLoop = (self, min, max, acc) => {
   if (max < min) {
-    return Effect.succeed$1(acc);
+    return icons.succeed$1(acc);
   }
-  return Effect.pipe(takeUpTo(self, max), Effect.flatMap(bs => {
+  return icons.pipe(takeUpTo(self, max), icons.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))));
+      return icons.pipe(take$1(self), icons.map$1(b => icons.pipe(acc, icons.appendAll(bs), icons.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 icons.pipe(take$1(self), icons.flatMap(b => takeRemainderLoop(self, remaining - 1, max - bs.length - 1, icons.pipe(acc, icons.appendAll(bs), icons.append(b)))));
     }
-    return Effect.succeed$1(Effect.pipe(acc, Effect.appendAll(bs)));
+    return icons.succeed$1(icons.pipe(acc, icons.appendAll(bs)));
   }));
 };
 /** @internal */
-const bounded$1 = requestedCapacity => Effect.pipe(Effect.sync(() => Effect.bounded(requestedCapacity)), Effect.flatMap(queue => make$2(backingQueueFromMutableQueue(queue), backPressureStrategy())));
+const bounded$1 = requestedCapacity => icons.pipe(icons.sync(() => icons.bounded(requestedCapacity)), icons.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())));
+const unbounded$1 = () => icons.pipe(icons.sync(() => icons.unbounded()), icons.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)));
+const make$2 = (queue, strategy) => icons.pipe(icons.deferredMake(), icons.map$1(deferred => unsafeMake(queue, icons.unbounded(), deferred, icons.make$1(false), strategy)));
 /** @internal */
 class BackingQueueFromMutableQueue {
   mutable;
@@ -443,22 +445,22 @@ class BackingQueueFromMutableQueue {
     this.mutable = mutable;
   }
   poll(def) {
-    return Effect.poll(this.mutable, def);
+    return icons.poll(this.mutable, def);
   }
   pollUpTo(limit) {
-    return Effect.pollUpTo(this.mutable, limit);
+    return icons.pollUpTo(this.mutable, limit);
   }
   offerAll(elements) {
-    return Effect.offerAll(this.mutable, elements);
+    return icons.offerAll(this.mutable, elements);
   }
   offer(element) {
-    return Effect.offer(this.mutable, element);
+    return icons.offer(this.mutable, element);
   }
   capacity() {
-    return Effect.capacity(this.mutable);
+    return icons.capacity(this.mutable);
   }
   length() {
-    return Effect.length(this.mutable);
+    return icons.length(this.mutable);
   }
 }
 /** @internal */
@@ -470,13 +472,13 @@ 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));
+const offer$1 = /*#__PURE__*/icons.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));
+const takeUpTo = /*#__PURE__*/icons.dual(2, (self, max) => self.takeUpTo(max));
 /** @internal */
-const takeBetween$1 = /*#__PURE__*/Effect.dual(3, (self, min, max) => self.takeBetween(min, max));
+const takeBetween$1 = /*#__PURE__*/icons.dual(3, (self, min, max) => self.takeBetween(min, max));
 // -----------------------------------------------------------------------------
 // Strategy
 // -----------------------------------------------------------------------------
@@ -487,14 +489,14 @@ const droppingStrategy = () => new DroppingStrategy();
 /** @internal */
 class BackPressureStrategy {
   [QueueStrategyTypeId] = queueStrategyVariance;
-  putters = /*#__PURE__*/Effect.unbounded();
+  putters = /*#__PURE__*/icons.unbounded();
   surplusSize() {
-    return Effect.length(this.putters);
+    return icons.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);
+    while (!icons.isEmpty$1(this.putters) && !icons.isEmpty$1(takers)) {
+      const taker = icons.poll(takers, void 0);
+      const putter = icons.poll(this.putters, void 0);
       if (putter[2]) {
         unsafeCompleteDeferred(putter[1], true);
       }
@@ -502,49 +504,49 @@ class BackPressureStrategy {
     }
   }
   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)))));
+    return icons.pipe(icons.fiberId, icons.flatMap(fiberId => icons.pipe(icons.sync(() => unsafePollAll(this.putters)), icons.flatMap(putters => icons.forEachConcurrentDiscard(putters, ([_, deferred, isLastItem]) => isLastItem ? icons.pipe(icons.deferredInterruptWith(deferred, fiberId), icons.asVoid) : icons.void_, false, false)))));
   }
   handleSurplus(iterable, queue, takers, isShutdown) {
-    return Effect.withFiberRuntime(state => {
-      const deferred = Effect.deferredUnsafeMake(state.id());
-      return Effect.pipe(Effect.suspend(() => {
+    return icons.withFiberRuntime(state => {
+      const deferred = icons.deferredUnsafeMake(state.id());
+      return icons.pipe(icons.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))));
+        return icons.get$1(isShutdown) ? icons.interrupt$1 : icons.deferredAwait(deferred);
+      }), icons.onInterrupt(() => icons.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) {
+      const putter = icons.pipe(this.putters, icons.poll(icons.EmptyMutableQueue));
+      if (putter === icons.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)));
+          unsafeOfferAll(this.putters, icons.pipe(unsafePollAll(this.putters), icons.prepend(putter)));
         }
         unsafeCompleteTakers(this, queue, takers);
       }
     }
   }
   unsafeOffer(iterable, deferred) {
-    const stuff = Effect.fromIterable(iterable);
+    const stuff = icons.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]));
+        icons.pipe(this.putters, icons.offer([value, deferred, true]));
       } else {
-        Effect.pipe(this.putters, Effect.offer([value, deferred, false]));
+        icons.pipe(this.putters, icons.offer([value, deferred, false]));
       }
     }
   }
   unsafeRemove(deferred) {
-    unsafeOfferAll(this.putters, Effect.pipe(unsafePollAll(this.putters), Effect.filter(([, _]) => _ !== deferred)));
+    unsafeOfferAll(this.putters, icons.pipe(unsafePollAll(this.putters), icons.filter(([, _]) => _ !== deferred)));
   }
 }
 /** @internal */
@@ -554,11 +556,11 @@ class DroppingStrategy {
     return 0;
   }
   get shutdown() {
-    return Effect.void_;
+    return icons.void_;
   }
   onCompleteTakersWithEmptyQueue() {}
   handleSurplus(_iterable, _queue, _takers, _isShutdown) {
-    return Effect.succeed$1(false);
+    return icons.succeed$1(false);
   }
   unsafeOnQueueEmptySpace(_queue, _takers) {
     //
@@ -566,44 +568,44 @@ class DroppingStrategy {
 }
 /** @internal */
 const unsafeCompleteDeferred = (deferred, a) => {
-  return Effect.deferredUnsafeDone(deferred, Effect.succeed$1(a));
+  return icons.deferredUnsafeDone(deferred, icons.succeed$1(a));
 };
 /** @internal */
 const unsafeOfferAll = (queue, as) => {
-  return Effect.pipe(queue, Effect.offerAll(as));
+  return icons.pipe(queue, icons.offerAll(as));
 };
 /** @internal */
 const unsafePollAll = queue => {
-  return Effect.pipe(queue, Effect.pollUpTo(Number.POSITIVE_INFINITY));
+  return icons.pipe(queue, icons.pollUpTo(Number.POSITIVE_INFINITY));
 };
 /** @internal */
 const unsafePollN = (queue, max) => {
-  return Effect.pipe(queue, Effect.pollUpTo(max));
+  return icons.pipe(queue, icons.pollUpTo(max));
 };
 /** @internal */
 const unsafeRemove = (queue, a) => {
-  unsafeOfferAll(queue, Effect.pipe(unsafePollAll(queue), Effect.filter(b => a !== b)));
+  unsafeOfferAll(queue, icons.pipe(unsafePollAll(queue), icons.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) {
+    const taker = icons.pipe(takers, icons.poll(icons.EmptyMutableQueue));
+    if (taker !== icons.EmptyMutableQueue) {
+      const element = queue.poll(icons.EmptyMutableQueue);
+      if (element !== icons.EmptyMutableQueue) {
         unsafeCompleteDeferred(taker, element);
         strategy.unsafeOnQueueEmptySpace(queue, takers);
       } else {
-        unsafeOfferAll(takers, Effect.pipe(unsafePollAll(takers), Effect.prepend(taker)));
+        unsafeOfferAll(takers, icons.pipe(unsafePollAll(takers), icons.prepend(taker)));
       }
       keepPolling = true;
     } else {
       keepPolling = false;
     }
   }
-  if (keepPolling && queue.length() === 0 && !Effect.isEmpty$1(takers)) {
+  if (keepPolling && queue.length() === 0 && !icons.isEmpty$1(takers)) {
     strategy.onCompleteTakersWithEmptyQueue(takers);
   }
 };
@@ -737,7 +739,7 @@ class ContinuationKImpl {
     this.onHalt = onHalt;
   }
   onExit(exit) {
-    return Effect.isFailure(exit) ? this.onHalt(exit.cause) : this.onSuccess(exit.value);
+    return icons.isFailure(exit) ? this.onHalt(exit.cause) : this.onSuccess(exit.value);
   }
 }
 /** @internal */
@@ -828,13 +830,13 @@ const channelVariance = {
 const proto$5 = {
   [ChannelTypeId]: channelVariance,
   pipe() {
-    return Effect.pipeArguments(this, arguments);
+    return icons.pipeArguments(this, arguments);
   }
 };
 /** @internal */
-const isChannel = u => Effect.hasProperty(u, ChannelTypeId) || Effect.isEffect(u);
+const isChannel = u => icons.hasProperty(u, ChannelTypeId) || icons.isEffect(u);
 /** @internal */
-const acquireReleaseOut = /*#__PURE__*/Effect.dual(2, (self, release) => {
+const acquireReleaseOut = /*#__PURE__*/icons.dual(2, (self, release) => {
   const op = Object.create(proto$5);
   op._tag = OP_BRACKET_OUT;
   op.acquire = () => self;
@@ -847,26 +849,26 @@ const concatAllWith = (channels, f, g) => {
   op._tag = OP_CONCAT_ALL;
   op.combineInners = f;
   op.combineAll = g;
-  op.onPull = () => PullAfterNext(Effect.none());
+  op.onPull = () => PullAfterNext(icons.none());
   op.onEmit = () => Continue;
   op.value = () => channels;
-  op.k = Effect.identity;
+  op.k = icons.identity;
   return op;
 };
 /** @internal */
-const concatMapWith = /*#__PURE__*/Effect.dual(4, (self, f, g, h) => {
+const concatMapWith = /*#__PURE__*/icons.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.onPull = () => PullAfterNext(icons.none());
   op.onEmit = () => Continue;
   op.value = () => self;
   op.k = f;
   return op;
 });
 /** @internal */
-const embedInput = /*#__PURE__*/Effect.dual(2, (self, input) => {
+const embedInput = /*#__PURE__*/icons.dual(2, (self, input) => {
   const op = Object.create(proto$5);
   op._tag = OP_BRIDGE;
   op.input = input;
@@ -874,7 +876,7 @@ const embedInput = /*#__PURE__*/Effect.dual(2, (self, input) => {
   return op;
 });
 /** @internal */
-const ensuringWith = /*#__PURE__*/Effect.dual(2, (self, finalizer) => {
+const ensuringWith = /*#__PURE__*/icons.dual(2, (self, finalizer) => {
   const op = Object.create(proto$5);
   op._tag = OP_ENSURING;
   op.channel = self;
@@ -893,7 +895,7 @@ const failCauseSync = evaluate => {
   return op;
 };
 /** @internal */
-const flatMap$1 = /*#__PURE__*/Effect.dual(2, (self, f) => {
+const flatMap$1 = /*#__PURE__*/icons.dual(2, (self, f) => {
   const op = Object.create(proto$5);
   op._tag = OP_FOLD;
   op.channel = self;
@@ -908,7 +910,7 @@ const fromEffect$3 = effect => {
   return op;
 };
 /** @internal */
-const pipeTo = /*#__PURE__*/Effect.dual(2, (self, that) => {
+const pipeTo = /*#__PURE__*/icons.dual(2, (self, that) => {
   const op = Object.create(proto$5);
   op._tag = OP_PIPE_TO;
   op.left = () => self;
@@ -918,7 +920,7 @@ const pipeTo = /*#__PURE__*/Effect.dual(2, (self, that) => {
 /** @internal */
 const readWith = options => readWithCause({
   onInput: options.onInput,
-  onFailure: cause => Effect.match$1(failureOrCause(cause), {
+  onFailure: cause => icons.match(failureOrCause(cause), {
     onLeft: options.onFailure,
     onRight: failCause$2
   }),
@@ -1016,9 +1018,9 @@ const Read = (upstream, onEffect, onEmit, onDone) => {
 /** @internal */
 const isFromEffect = self => self._tag === OP_FROM_EFFECT;
 /** @internal */
-const effect = self => isFromEffect(self) ? self.effect : Effect._void;
+const effect = self => isFromEffect(self) ? self.effect : icons._void;
 /** @internal */
-const effectOrUndefinedIgnored = self => isFromEffect(self) ? Effect.ignore(self.effect) : undefined;
+const effectOrUndefinedIgnored = self => isFromEffect(self) ? icons.ignore(self.effect) : undefined;
 
 /** @internal */
 const OP_PULL_FROM_CHILD = "PullFromChild";
@@ -1048,7 +1050,7 @@ class PullFromChild {
     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)));
+      return icons.zipWith(icons.exit(fin1), icons.exit(fin2), (exit1, exit2) => icons.pipe(exit1, icons.zipRight$1(exit2)));
     } else if (fin1 !== undefined) {
       return fin1;
     } else if (fin2 !== undefined) {
@@ -1092,11 +1094,11 @@ class PullFromUpstream {
     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));
+        return icons.zipWith(acc, icons.exit(next), (exit1, exit2) => icons.zipRight$1(exit1, exit2));
       } else if (acc !== undefined) {
         return acc;
       } else if (next !== undefined) {
-        return Effect.exit$1(next);
+        return icons.exit(next);
       } else {
         return undefined;
       }
@@ -1136,11 +1138,11 @@ class DrainChildExecutors {
     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));
+        return icons.zipWith(acc, icons.exit(next), (exit1, exit2) => icons.zipRight$1(exit1, exit2));
       } else if (acc !== undefined) {
         return acc;
       } else if (next !== undefined) {
-        return Effect.exit$1(next);
+        return icons.exit(next);
       } else {
         return undefined;
       }
@@ -1231,7 +1233,7 @@ class ChannelExecutor {
           if (this._currentChannel === undefined) {
             result = Done();
           } else {
-            if (Effect.isEffect(this._currentChannel)) {
+            if (icons.isEffect(this._currentChannel)) {
               this._currentChannel = fromEffect$3(this._currentChannel);
             }
             switch (this._currentChannel._tag) {
@@ -1250,23 +1252,23 @@ class ChannelExecutor {
                   if (this._input !== undefined) {
                     const inputExecutor = this._input;
                     this._input = undefined;
-                    const drainer = () => Effect.flatMap$1(bridgeInput.awaitRead(), () => Effect.suspend$1(() => {
+                    const drainer = () => icons.flatMap$1(bridgeInput.awaitRead(), () => icons.suspend$1(() => {
                       const state = inputExecutor.run();
                       switch (state._tag) {
                         case OP_DONE$1:
                           {
-                            return Effect.match$2(inputExecutor.getDone(), {
+                            return icons.match$1(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());
+                            return icons.flatMap$1(bridgeInput.emit(inputExecutor.getEmit()), () => drainer());
                           }
                         case OP_FROM_EFFECT:
                           {
-                            return Effect.matchCauseEffect(state.effect, {
+                            return icons.matchCauseEffect(state.effect, {
                               onFailure: cause => bridgeInput.error(cause),
                               onSuccess: () => drainer()
                             });
@@ -1277,18 +1279,18 @@ class ChannelExecutor {
                           }
                       }
                     }));
-                    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(() => {
+                    result = fromEffect$2(icons.flatMap$1(icons.forkDaemon(icons.interruptible(drainer())), fiber => icons.sync$1(() => this.addFinalizer(exit => icons.flatMap$1(interrupt(fiber), () => icons.suspend$1(() => {
                       const effect = this.restorePipe(exit, inputExecutor);
-                      return effect !== undefined ? effect : Effect._void;
+                      return effect !== undefined ? effect : icons._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));
+                  const executor = new ChannelExecutor(this._currentChannel.value(), this._providedEnv, effect => icons.sync$1(() => {
+                    const prevLastClose = this._closeLastSubstream === undefined ? icons._void : this._closeLastSubstream;
+                    this._closeLastSubstream = icons.pipe(prevLastClose, icons.zipRight$2(effect));
                   }));
                   executor._input = this._input;
                   const channel = this._currentChannel;
@@ -1322,15 +1324,15 @@ class ChannelExecutor {
                 }
               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, {
+                  const effect = this._providedEnv === undefined ? this._currentChannel.effect() : icons.pipe(this._currentChannel.effect(), icons.provide(this._providedEnv));
+                  result = fromEffect$2(icons.matchCauseEffect(effect, {
                     onFailure: cause => {
                       const state = this.doneHalt(cause);
-                      return state !== undefined && isFromEffect(state) ? state.effect : Effect._void;
+                      return state !== undefined && isFromEffect(state) ? state.effect : icons._void;
                     },
                     onSuccess: value => {
                       const state = this.doneSucceed(value);
-                      return state !== undefined && isFromEffect(state) ? state.effect : Effect._void;
+                      return state !== undefined && isFromEffect(state) ? state.effect : icons._void;
                     }
                   }));
                   break;
@@ -1343,7 +1345,7 @@ class ChannelExecutor {
                   this._input = leftExec;
                   this.addFinalizer(exit => {
                     const effect = this.restorePipe(exit, previousInput);
-                    return effect !== undefined ? effect : Effect._void;
+                    return effect !== undefined ? effect : icons._void;
                   });
                   this._currentChannel = this._currentChannel.right();
                   break;
@@ -1353,7 +1355,7 @@ class ChannelExecutor {
                   const previousEnv = this._providedEnv;
                   this._providedEnv = this._currentChannel.context();
                   this._currentChannel = this._currentChannel.inner;
-                  this.addFinalizer(() => Effect.sync$1(() => {
+                  this.addFinalizer(() => icons.sync$1(() => {
                     this._providedEnv = previousEnv;
                   }));
                   break;
@@ -1361,11 +1363,11 @@ class ChannelExecutor {
               case OP_READ$1:
                 {
                   const read = this._currentChannel;
-                  result = Read(this._input, Effect.identity, emitted => {
+                  result = Read(this._input, icons.identity, emitted => {
                     try {
                       this._currentChannel = read.more(emitted);
                     } catch (error) {
-                      this._currentChannel = read.done.onExit(Effect.die$1(error));
+                      this._currentChannel = read.done.onExit(icons.die$1(error));
                     }
                     return undefined;
                   }, exit => {
@@ -1425,7 +1427,7 @@ class ChannelExecutor {
       }
       next = this._doneStack.pop();
     }
-    const effect = finalizers.length === 0 ? Effect._void : runFinalizers(finalizers, exit);
+    const effect = finalizers.length === 0 ? icons._void : runFinalizers(finalizers, exit);
     this.storeInProgressFinalizer(effect);
     return effect;
   }
@@ -1448,30 +1450,30 @@ class ChannelExecutor {
       const effect = currInput.close(exit);
       return effect;
     }
-    return Effect._void;
+    return icons._void;
   }
   close(exit) {
     let runInProgressFinalizers = undefined;
     const finalizer = this._inProgressFinalizer;
     if (finalizer !== undefined) {
-      runInProgressFinalizers = Effect.pipe(finalizer, Effect.ensuring(Effect.sync$1(() => this.clearInProgressFinalizer())));
+      runInProgressFinalizers = icons.pipe(finalizer, icons.ensuring(icons.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())));
+      closeSelf = icons.pipe(selfFinalizers, icons.ensuring(icons.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,
+    return icons.pipe(icons.exit(ifNotNull(closeSubexecutors)), icons.zip(icons.exit(ifNotNull(runInProgressFinalizers))), icons.zip(icons.exit(ifNotNull(closeSelf))), icons.map$2(([[exit1, exit2], exit3]) => icons.pipe(exit1, icons.zipRight$1(exit2), icons.zipRight$1(exit3))), icons.uninterruptible$1,
     // TODO: remove
-    Effect.flatMap$1(exit => Effect.suspend$1(() => exit)));
+    icons.flatMap$1(exit => icons.suspend$1(() => exit)));
   }
   doneSucceed(value) {
     if (this._doneStack.length === 0) {
-      this._done = Effect.succeed$2(value);
+      this._done = icons.succeed$2(value);
       this._currentChannel = undefined;
       return Done();
     }
@@ -1484,18 +1486,18 @@ class ChannelExecutor {
     const finalizers = this.popNextFinalizers();
     if (this._doneStack.length === 0) {
       this._doneStack = finalizers.reverse();
-      this._done = Effect.succeed$2(value);
+      this._done = icons.succeed$2(value);
       this._currentChannel = undefined;
       return Done();
     }
-    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), Effect.succeed$2(value));
+    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), icons.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))));
+    const effect = icons.pipe(finalizerEffect, icons.ensuring(icons.sync$1(() => this.clearInProgressFinalizer())), icons.uninterruptible$1, icons.flatMap$1(() => icons.sync$1(() => this.doneSucceed(value))));
     return fromEffect$2(effect);
   }
   doneHalt(cause) {
     if (this._doneStack.length === 0) {
-      this._done = Effect.failCause(cause);
+      this._done = icons.failCause(cause);
       this._currentChannel = undefined;
       return Done();
     }
@@ -1512,13 +1514,13 @@ class ChannelExecutor {
     const finalizers = this.popNextFinalizers();
     if (this._doneStack.length === 0) {
       this._doneStack = finalizers.reverse();
-      this._done = Effect.failCause(cause);
+      this._done = icons.failCause(cause);
       this._currentChannel = undefined;
       return Done();
     }
-    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), Effect.failCause(cause));
+    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), icons.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))));
+    const effect = icons.pipe(finalizerEffect, icons.ensuring(icons.sync$1(() => this.clearInProgressFinalizer())), icons.uninterruptible$1, icons.flatMap$1(() => icons.sync$1(() => this.doneHalt(cause))));
     return fromEffect$2(effect);
   }
   processCancellation() {
@@ -1528,11 +1530,11 @@ class ChannelExecutor {
     return Done();
   }
   runBracketOut(bracketOut) {
-    const effect = Effect.uninterruptible$1(Effect.matchCauseEffect(this.provide(bracketOut.acquire()), {
-      onFailure: cause => Effect.sync$1(() => {
+    const effect = icons.uninterruptible$1(icons.matchCauseEffect(this.provide(bracketOut.acquire()), {
+      onFailure: cause => icons.sync$1(() => {
         this._currentChannel = failCause$2(cause);
       }),
-      onSuccess: out => Effect.sync$1(() => {
+      onSuccess: out => icons.sync$1(() => {
         this.addFinalizer(exit => this.provide(bracketOut.finalizer(out, exit)));
         this._currentChannel = write(out);
       })
@@ -1543,7 +1545,7 @@ class ChannelExecutor {
     if (this._providedEnv === undefined) {
       return effect;
     }
-    return Effect.pipe(effect, Effect.provide(this._providedEnv));
+    return icons.pipe(effect, icons.provide(this._providedEnv));
   }
   runEnsuring(ensuring) {
     this.addFinalizer(ensuring.finalizer);
@@ -1580,18 +1582,18 @@ class ChannelExecutor {
     this._activeSubexecutor = nextSubExec;
   }
   finishWithExit(exit) {
-    const state = Effect.match$2(exit, {
+    const state = icons.match$1(exit, {
       onFailure: cause => this.doneHalt(cause),
       onSuccess: value => this.doneSucceed(value)
     });
     this._activeSubexecutor = undefined;
-    return state === undefined ? Effect._void : effect(state);
+    return state === undefined ? icons._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)), {
+    this.addFinalizer(() => icons.pipe(closeFuncs, icons.forEach(closeFunc => icons.pipe(icons.sync$1(() => closeFunc(subexecutorDone)), icons.flatMap$1(closeEffect => closeEffect !== undefined ? closeEffect : icons._void)), {
       discard: true
     })));
-    const state = Effect.pipe(subexecutorDone, Effect.match$2({
+    const state = icons.pipe(subexecutorDone, icons.match$1({
       onFailure: cause => this.doneHalt(cause),
       onSuccess: value => this.doneSucceed(value)
     }));
@@ -1613,7 +1615,7 @@ class ChannelExecutor {
     }
   }
   pullFromChild(childExecutor, parentSubexecutor, onEmitted, subexecutor) {
-    return Read(childExecutor, Effect.identity, emitted => {
+    return Read(childExecutor, icons.identity, emitted => {
       const childExecutorDecision = onEmitted(emitted);
       switch (childExecutorDecision._tag) {
         case OP_CONTINUE:
@@ -1634,7 +1636,7 @@ class ChannelExecutor {
       }
       this._activeSubexecutor = new Emit(emitted, this._activeSubexecutor);
       return undefined;
-    }, Effect.match$2({
+    }, icons.match$1({
       onFailure: cause => {
         const state = this.handleSubexecutorFailure(childExecutor, parentSubexecutor, cause);
         return state === undefined ? undefined : effectOrUndefinedIgnored(state);
@@ -1651,21 +1653,21 @@ class ChannelExecutor {
       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._closeLastSubstream = childExecutor.close(icons.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._closeLastSubstream = childExecutor.close(icons.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));
+    return this.finishSubexecutorWithCloseEffect(icons.failCause(cause), exit => parentSubexecutor.close(exit), exit => childExecutor.close(exit));
   }
   pullFromUpstream(subexecutor) {
     if (subexecutor.activeChildExecutors.length === 0) {
@@ -1681,19 +1683,19 @@ class ChannelExecutor {
   }
   performPullFromUpstream(subexecutor) {
     return Read(subexecutor.upstreamExecutor, effect => {
-      const closeLastSubstream = this._closeLastSubstream === undefined ? Effect._void : this._closeLastSubstream;
+      const closeLastSubstream = this._closeLastSubstream === undefined ? icons._void : this._closeLastSubstream;
       this._closeLastSubstream = undefined;
-      return Effect.pipe(this._executeCloseLastSubstream(closeLastSubstream), Effect.zipRight$2(effect));
+      return icons.pipe(this._executeCloseLastSubstream(closeLastSubstream), icons.zipRight$2(effect));
     }, emitted => {
       if (this._closeLastSubstream !== undefined) {
         const closeLastSubstream = this._closeLastSubstream;
         this._closeLastSubstream = undefined;
-        return Effect.pipe(this._executeCloseLastSubstream(closeLastSubstream), Effect.map$2(() => {
+        return icons.pipe(this._executeCloseLastSubstream(closeLastSubstream), icons.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)) {
+          if (icons.isSome(emitSeparator)) {
             this._activeSubexecutor = new Emit(emitSeparator.value, this._activeSubexecutor);
           }
           return undefined;
@@ -1703,7 +1705,7 @@ class ChannelExecutor {
       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)) {
+      if (icons.isSome(emitSeparator)) {
         this._activeSubexecutor = new Emit(emitSeparator.value, this._activeSubexecutor);
       }
       return undefined;
@@ -1713,13 +1715,13 @@ class ChannelExecutor {
         if (this._closeLastSubstream !== undefined) {
           const closeLastSubstream = this._closeLastSubstream;
           this._closeLastSubstream = undefined;
-          return Effect.pipe(this._executeCloseLastSubstream(closeLastSubstream), Effect.map$2(() => this.replaceSubexecutor(drain)));
+          return icons.pipe(this._executeCloseLastSubstream(closeLastSubstream), icons.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));
+      const state = this.finishSubexecutorWithCloseEffect(icons.pipe(exit, icons.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);
@@ -1729,7 +1731,7 @@ class ChannelExecutor {
     if (subexecutor.activeChildExecutors.length === 0) {
       const lastClose = this._closeLastSubstream;
       if (lastClose !== undefined) {
-        this.addFinalizer(() => Effect.succeed(lastClose));
+        this.addFinalizer(() => icons.succeed(lastClose));
       }
       return this.finishSubexecutorWithCloseEffect(subexecutor.upstreamDone, () => lastClose, exit => subexecutor.upstreamExecutor.close(exit));
     }
@@ -1738,7 +1740,7 @@ class ChannelExecutor {
     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)) {
+      if (icons.isSome(emitSeparator)) {
         this._emitted = emitSeparator.value;
         return Emit$1();
       }
@@ -1749,9 +1751,9 @@ class ChannelExecutor {
     return undefined;
   }
 }
-const ifNotNull = effect => effect !== undefined ? effect : Effect._void;
+const ifNotNull = effect => effect !== undefined ? effect : icons._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)));
+  return icons.pipe(icons.forEach(finalizers, fin => icons.exit(fin(exit))), icons.map$2(exits => icons.pipe(icons.all(exits), icons.getOrElse(() => icons.void_$1))), icons.flatMap$1(exit => icons.suspend$1(() => exit)));
 };
 /**
  * @internal
@@ -1761,7 +1763,7 @@ const readUpstream = (r, onSuccess, onFailure) => {
   const read = () => {
     const current = readStack.pop();
     if (current === undefined || current.upstream === undefined) {
-      return Effect.dieMessage("Unexpected end of input for channel execution");
+      return icons.dieMessage("Unexpected end of input for channel execution");
     }
     const state = current.upstream.run();
     switch (state._tag) {
@@ -1770,17 +1772,17 @@ const readUpstream = (r, onSuccess, onFailure) => {
           const emitEffect = current.onEmit(current.upstream.getEmit());
           if (readStack.length === 0) {
             if (emitEffect === undefined) {
-              return Effect.suspend$1(onSuccess);
+              return icons.suspend$1(onSuccess);
             }
-            return Effect.pipe(emitEffect, Effect.matchCauseEffect({
+            return icons.pipe(emitEffect, icons.matchCauseEffect({
               onFailure,
               onSuccess
             }));
           }
           if (emitEffect === undefined) {
-            return Effect.suspend$1(() => read());
+            return icons.suspend$1(() => read());
           }
-          return Effect.pipe(emitEffect, Effect.matchCauseEffect({
+          return icons.pipe(emitEffect, icons.matchCauseEffect({
             onFailure,
             onSuccess: () => read()
           }));
@@ -1790,17 +1792,17 @@ const readUpstream = (r, onSuccess, onFailure) => {
           const doneEffect = current.onDone(current.upstream.getDone());
           if (readStack.length === 0) {
             if (doneEffect === undefined) {
-              return Effect.suspend$1(onSuccess);
+              return icons.suspend$1(onSuccess);
             }
-            return Effect.pipe(doneEffect, Effect.matchCauseEffect({
+            return icons.pipe(doneEffect, icons.matchCauseEffect({
               onFailure,
               onSuccess
             }));
           }
           if (doneEffect === undefined) {
-            return Effect.suspend$1(() => read());
+            return icons.suspend$1(() => read());
           }
-          return Effect.pipe(doneEffect, Effect.matchCauseEffect({
+          return icons.pipe(doneEffect, icons.matchCauseEffect({
             onFailure,
             onSuccess: () => read()
           }));
@@ -1808,10 +1810,10 @@ const readUpstream = (r, onSuccess, onFailure) => {
       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({
+          return icons.pipe(current.onEffect(state.effect), icons.catchAllCause(cause => icons.suspend$1(() => {
+            const doneEffect = current.onDone(icons.failCause(cause));
+            return doneEffect === undefined ? icons._void : doneEffect;
+          })), icons.matchCauseEffect({
             onFailure,
             onSuccess: () => read()
           }));
@@ -1820,25 +1822,25 @@ const readUpstream = (r, onSuccess, onFailure) => {
         {
           readStack.push(current);
           readStack.push(state);
-          return Effect.suspend$1(() => read());
+          return icons.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 runIn = /*#__PURE__*/icons.dual(2, (self, scope) => {
+  const run = (channelDeferred, scopeDeferred, scope) => icons.acquireUseRelease(icons.sync$1(() => new ChannelExecutor(self, void 0, icons.identity)), exec => icons.suspend$1(() => runScopedInterpret(exec.run(), exec).pipe(icons.intoDeferred(channelDeferred), icons.zipRight$2(icons._await$1(channelDeferred)), icons.zipLeft(icons._await$1(scopeDeferred)))), (exec, exit) => {
     const finalize = exec.close(exit);
     if (finalize === undefined) {
-      return Effect._void;
+      return icons._void;
     }
-    return Effect.tapErrorCause(finalize, cause => Effect.addFinalizer(scope, Effect.failCause$1(cause)));
+    return icons.tapErrorCause(finalize, cause => icons.addFinalizer(scope, icons.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)))))))));
+  return icons.uninterruptibleMask(restore => icons.all$1([icons.fork(scope, icons.sequential), icons.make$2(), icons.make$2()]).pipe(icons.flatMap$1(([child, channelDeferred, scopeDeferred]) => restore(run(channelDeferred, scopeDeferred, child)).pipe(icons.forkIn(scope), icons.flatMap$1(fiber => scope.addFinalizer(exit => {
+    const interruptors$1 = icons.isFailure(exit) ? interruptors(exit.cause) : undefined;
+    return icons.isDone(channelDeferred).pipe(icons.flatMap$1(isDone => isDone ? icons.succeed$3(scopeDeferred, void 0).pipe(icons.zipRight$2(_await(fiber)), icons.zipRight$2(inheritAll(fiber))) : icons.succeed$3(scopeDeferred, void 0).pipe(icons.zipRight$2(interruptors$1 && icons.size(interruptors$1) > 0 ? interruptAs(fiber, icons.combineAll(interruptors$1)) : interrupt(fiber)), icons.zipRight$2(inheritAll(fiber)))));
+  }).pipe(icons.zipRight$2(restore(icons._await$1(channelDeferred)))))))));
 });
 /** @internal */
 const runScopedInterpret = (channelState, exec) => {
@@ -1846,7 +1848,7 @@ const runScopedInterpret = (channelState, exec) => {
   switch (op._tag) {
     case OP_FROM_EFFECT:
       {
-        return Effect.pipe(op.effect, Effect.flatMap$1(() => runScopedInterpret(exec.run(), exec)));
+        return icons.pipe(op.effect, icons.flatMap$1(() => runScopedInterpret(exec.run(), exec)));
       }
     case OP_EMIT$1:
       {
@@ -1855,11 +1857,11 @@ const runScopedInterpret = (channelState, exec) => {
       }
     case OP_DONE$1:
       {
-        return Effect.suspend$1(() => exec.getDone());
+        return icons.suspend$1(() => exec.getDone());
       }
     case OP_READ:
       {
-        return readUpstream(op, () => runScopedInterpret(exec.run(), exec), Effect.failCause$1);
+        return readUpstream(op, () => runScopedInterpret(exec.run(), exec), icons.failCause$1);
       }
   }
 };
@@ -1955,7 +1957,7 @@ const BufferSliding = _ => {
   return op;
 };
 /** @internal */
-const match = /*#__PURE__*/Effect.dual(2, (self, {
+const match = /*#__PURE__*/icons.dual(2, (self, {
   onBackPressure,
   onBufferSliding
 }) => {
@@ -2006,97 +2008,97 @@ class SingleProducerAsyncInputImpl {
     this.ref = ref;
   }
   awaitRead() {
-    return Effect.flatten(modify(this.ref, state => state._tag === OP_STATE_EMPTY ? [Effect._await(state.notifyProducer), state] : [Effect._void, state]));
+    return icons.flatten(modify(this.ref, state => state._tag === OP_STATE_EMPTY ? [icons._await$1(state.notifyProducer), state] : [icons._void, state]));
   }
   get close() {
-    return Effect.fiberIdWith(fiberId => this.error(interrupt$1(fiberId)));
+    return icons.fiberIdWith(fiberId => this.error(interrupt$1(fiberId)));
   }
   done(value) {
-    return Effect.flatten(modify(this.ref, state => {
+    return icons.flatten(modify(this.ref, state => {
       switch (state._tag) {
         case OP_STATE_EMPTY:
           {
-            return [Effect._await(state.notifyProducer), state];
+            return [icons._await$1(state.notifyProducer), state];
           }
         case OP_STATE_EMIT:
           {
-            return [Effect.forEach(state.notifyConsumers, deferred => Effect.succeed$3(deferred, Effect.left(value)), {
+            return [icons.forEach(state.notifyConsumers, deferred => icons.succeed$3(deferred, icons.left(value)), {
               discard: true
             }), stateDone(value)];
           }
         case OP_STATE_ERROR:
           {
-            return [Effect.interrupt$3, state];
+            return [icons.interrupt$2, state];
           }
         case OP_STATE_DONE:
           {
-            return [Effect.interrupt$3, state];
+            return [icons.interrupt$2, state];
           }
       }
     }));
   }
   emit(element) {
-    return Effect.flatMap$1(Effect.make$2(), deferred => Effect.flatten(modify(this.ref, state => {
+    return icons.flatMap$1(icons.make$2(), deferred => icons.flatten(modify(this.ref, state => {
       switch (state._tag) {
         case OP_STATE_EMPTY:
           {
-            return [Effect._await(state.notifyProducer), state];
+            return [icons._await$1(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)];
+              return [icons.succeed$3(notifyConsumer, icons.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];
+            return [icons.interrupt$2, state];
           }
         case OP_STATE_DONE:
           {
-            return [Effect.interrupt$3, state];
+            return [icons.interrupt$2, state];
           }
       }
     })));
   }
   error(cause) {
-    return Effect.flatten(modify(this.ref, state => {
+    return icons.flatten(modify(this.ref, state => {
       switch (state._tag) {
         case OP_STATE_EMPTY:
           {
-            return [Effect._await(state.notifyProducer), state];
+            return [icons._await$1(state.notifyProducer), state];
           }
         case OP_STATE_EMIT:
           {
-            return [Effect.forEach(state.notifyConsumers, deferred => Effect.failCause$2(deferred, cause), {
+            return [icons.forEach(state.notifyConsumers, deferred => icons.failCause$2(deferred, cause), {
               discard: true
             }), stateError(cause)];
           }
         case OP_STATE_ERROR:
           {
-            return [Effect.interrupt$3, state];
+            return [icons.interrupt$2, state];
           }
         case OP_STATE_DONE:
           {
-            return [Effect.interrupt$3, state];
+            return [icons.interrupt$2, state];
           }
       }
     }));
   }
   get take() {
-    return this.takeWith(cause => Effect.failCause(map$2(cause, Effect.left)), elem => Effect.succeed$2(elem), done => Effect.fail$2(Effect.right(done)));
+    return this.takeWith(cause => icons.failCause(map$2(cause, icons.left)), elem => icons.succeed$2(elem), done => icons.fail$1(icons.right(done)));
   }
   takeWith(onError, onElement, onDone) {
-    return Effect.flatMap$1(Effect.make$2(), deferred => Effect.flatten(modify(this.ref, state => {
+    return icons.flatMap$1(icons.make$2(), deferred => icons.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), {
+            return [icons.zipRight$2(icons.succeed$3(state.notifyProducer, void 0), icons.matchCause(icons._await$1(deferred), {
               onFailure: onError,
-              onSuccess: Effect.match$1({
+              onSuccess: icons.match({
                 onLeft: onDone,
                 onRight: onElement
               })
@@ -2104,9 +2106,9 @@ class SingleProducerAsyncInputImpl {
           }
         case OP_STATE_EMIT:
           {
-            return [Effect.matchCause(Effect._await(deferred), {
+            return [icons.matchCause(icons._await$1(deferred), {
               onFailure: onError,
-              onSuccess: Effect.match$1({
+              onSuccess: icons.match({
                 onLeft: onDone,
                 onRight: onElement
               })
@@ -2114,21 +2116,21 @@ class SingleProducerAsyncInputImpl {
           }
         case OP_STATE_ERROR:
           {
-            return [Effect.succeed(onError(state.cause)), state];
+            return [icons.succeed(onError(state.cause)), state];
           }
         case OP_STATE_DONE:
           {
-            return [Effect.succeed(onDone(state.done)), state];
+            return [icons.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)));
+const make$1 = () => icons.pipe(icons.make$2(), icons.flatMap$1(deferred => make$3(stateEmpty(deferred))), icons.map$2(ref => new SingleProducerAsyncInputImpl(ref)));
 
 /** @internal */
-const concatMap = /*#__PURE__*/Effect.dual(2, (self, f) => concatMapWith(self, f, () => void 0, () => void 0));
+const concatMap = /*#__PURE__*/icons.dual(2, (self, f) => concatMapWith(self, f, () => void 0, () => void 0));
 /** @internal */
 const drain$1 = self => {
   const drainer = readWithCause({
@@ -2139,9 +2141,9 @@ const drain$1 = self => {
   return pipeTo(self, drainer);
 };
 /** @internal */
-const ensuring$1 = /*#__PURE__*/Effect.dual(2, (self, finalizer) => ensuringWith(self, () => finalizer));
+const ensuring$1 = /*#__PURE__*/icons.dual(2, (self, finalizer) => ensuringWith(self, () => finalizer));
 /** @internal */
-const flatten$1 = self => flatMap$1(self, Effect.identity);
+const flatten$1 = self => flatMap$1(self, icons.identity);
 /** @internal */
 const fromInput = input => unwrap(input.takeWith(failCause$2, elem => flatMap$1(write(elem), () => fromInput(input)), succeed));
 /** @internal */
@@ -2151,9 +2153,9 @@ const identityChannel = () => readWith({
   onDone: succeedNow
 });
 /** @internal */
-const map$1 = /*#__PURE__*/Effect.dual(2, (self, f) => flatMap$1(self, a => sync(() => f(a))));
+const map$1 = /*#__PURE__*/icons.dual(2, (self, f) => flatMap$1(self, a => sync(() => f(a))));
 /** @internal */
-const mapOut = /*#__PURE__*/Effect.dual(2, (self, f) => {
+const mapOut = /*#__PURE__*/icons.dual(2, (self, f) => {
   const reader = readWith({
     onInput: outElem => flatMap$1(write(f(outElem)), () => reader),
     onFailure: fail,
@@ -2162,30 +2164,30 @@ const mapOut = /*#__PURE__*/Effect.dual(2, (self, f) => {
   return pipeTo(self, reader);
 });
 /** @internal */
-const mapOutEffectPar = /*#__PURE__*/Effect.dual(3, (self, f, n) => unwrapScopedWith$1(scope => Effect.gen$1(function* () {
+const mapOutEffectPar = /*#__PURE__*/icons.dual(3, (self, f, n) => unwrapScopedWith$1(scope => icons.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;
+  yield* icons.addFinalizer(scope, shutdown(queue));
+  const errorSignal = yield* icons.make$2();
+  const withPermits = n === Number.POSITIVE_INFINITY ? _ => icons.identity : (yield* icons.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$1(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);
+  yield* pull.pipe(icons.matchCauseEffect({
+    onFailure: cause => offer(queue, icons.failCause$1(cause)),
+    onSuccess: icons.match({
+      onLeft: outDone => icons.zipRight$2(icons.interruptible(withPermits(n)(icons._void)), icons.asVoid$1(offer(queue, icons.succeed(icons.left(outDone))))),
+      onRight: outElem => icons.gen(function* () {
+        const deferred = yield* icons.make$2();
+        const latch = yield* icons.make$2();
+        yield* offer(queue, icons.map$2(icons._await$1(deferred), icons.right));
+        yield* icons.succeed$3(latch, void 0).pipe(icons.zipRight$2(icons.uninterruptibleMask(restore => icons.exit(restore(icons._await$1(errorSignal))).pipe(icons.raceFirst(icons.exit(restore(f(outElem)))), icons.flatMap$1(icons.identity))).pipe(icons.tapErrorCause(cause => icons.failCause$2(errorSignal, cause)), icons.intoDeferred(deferred))), withPermits(1), icons.forkIn(scope));
+        yield* icons._await$1(latch);
       })
     })
-  }), Effect.forever, Effect.interruptible, Effect.forkIn(scope));
-  const consumer = unwrap(Effect.matchCause(Effect.flatten(take(queue)), {
+  }), icons.forever, icons.interruptible, icons.forkIn(scope));
+  const consumer = unwrap(icons.matchCause(icons.flatten(take(queue)), {
     onFailure: failCause$2,
-    onSuccess: Effect.match$1({
+    onSuccess: icons.match({
       onLeft: succeedNow,
       onRight: outElem => flatMap$1(write(outElem), () => consumer)
     })
@@ -2194,75 +2196,75 @@ const mapOutEffectPar = /*#__PURE__*/Effect.dual(3, (self, f, n) => unwrapScoped
 })));
 /** @internal */
 const mergeAll = options => {
-  return channels => mergeAllWith(options)(channels, Effect.constVoid);
+  return channels => mergeAllWith(options)(channels, icons.constVoid);
 };
 /** @internal */
 const mergeAllWith = ({
   bufferSize = 16,
   concurrency,
   mergeStrategy = BackPressure()
-}) => (channels, f) => unwrapScopedWith$1(scope => Effect.gen$1(function* () {
+}) => (channels, f) => unwrapScopedWith$1(scope => icons.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));
+  yield* icons.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;
+  yield* icons.addFinalizer(scope, shutdown(cancelers));
+  const lastDone = yield* make$3(icons.none());
+  const errorSignal = yield* icons.make$2();
+  const withPermits = (yield* icons.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)));
+    return pull.pipe(icons.flatMap$1(icons.match({
+      onLeft: done => icons.succeed(icons.some(done)),
+      onRight: outElem => icons.as(offer(queue, icons.succeed(icons.right(outElem))), icons.none())
+    })), icons.repeat({
+      until: _ => icons.isSome(_)
+    }), icons.flatMap$1(outDone => update(lastDone, icons.match$2({
+      onNone: () => icons.some(outDone.value),
+      onSome: lastDone => icons.some(f(lastDone, outDone.value))
+    }))), icons.catchAllCause(cause => isInterrupted(cause) ? icons.failCause$1(cause) : offer(queue, icons.failCause$1(cause)).pipe(icons.zipRight$2(icons.succeed$3(errorSignal, void 0)), icons.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)))
+  yield* pull.pipe(icons.matchCauseEffect({
+    onFailure: cause => offer(queue, icons.failCause$1(cause)).pipe(icons.zipRight$2(icons.succeed(false))),
+    onSuccess: icons.match({
+      onLeft: outDone => icons.raceWith(icons.interruptible(icons._await$1(errorSignal)), icons.interruptible(withPermits(concurrencyN)(icons._void)), {
+        onSelfDone: (_, permitAcquisition) => icons.as(interrupt(permitAcquisition), false),
+        onOtherDone: (_, failureAwait) => icons.zipRight$2(interrupt(failureAwait), get(lastDone).pipe(icons.flatMap$1(icons.match$2({
+          onNone: () => offer(queue, icons.succeed(icons.left(outDone))),
+          onSome: lastDone => offer(queue, icons.succeed(icons.left(f(lastDone, outDone))))
+        })), icons.as(false)))
       }),
       onRight: channel => match(mergeStrategy, {
-        onBackPressure: () => Effect.gen$1(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);
+        onBackPressure: () => icons.gen(function* () {
+          const latch = yield* icons.make$2();
+          const raceEffects = icons.scopedWith(scope => toPullIn(pipeTo(queueReader, channel), scope).pipe(icons.flatMap$1(pull => icons.race(icons.exit(evaluatePull(pull)), icons.exit(icons.interruptible(icons._await$1(errorSignal))))), icons.flatMap$1(icons.identity)));
+          yield* icons.succeed$3(latch, void 0).pipe(icons.zipRight$2(raceEffects), withPermits(1), icons.forkIn(scope));
+          yield* icons._await$1(latch);
+          const errored = yield* icons.isDone(errorSignal);
           return !errored;
         }),
-        onBufferSliding: () => Effect.gen$1(function* () {
-          const canceler = yield* Effect.make$2();
-          const latch = yield* Effect.make$2();
+        onBufferSliding: () => icons.gen(function* () {
+          const canceler = yield* icons.make$2();
+          const latch = yield* icons.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* take(cancelers).pipe(icons.flatMap$1(canceler => icons.succeed$3(canceler, void 0)), icons.when(() => 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);
+          const raceEffects = icons.scopedWith(scope => toPullIn(pipeTo(queueReader, channel), scope).pipe(icons.flatMap$1(pull => icons.exit(evaluatePull(pull)).pipe(icons.race(icons.exit(icons.interruptible(icons._await$1(errorSignal)))), icons.race(icons.exit(icons.interruptible(icons._await$1(canceler)))))), icons.flatMap$1(icons.identity)));
+          yield* icons.succeed$3(latch, void 0).pipe(icons.zipRight$2(raceEffects), withPermits(1), icons.forkIn(scope));
+          yield* icons._await$1(latch);
+          const errored = yield* icons.isDone(errorSignal);
           return !errored;
         })
       })
     })
-  }), Effect.repeat({
+  }), icons.repeat({
     while: _ => _
-  }), Effect.forkIn(scope));
-  const consumer = Effect.pipe(take(queue), Effect.flatten, Effect.matchCause({
+  }), icons.forkIn(scope));
+  const consumer = icons.pipe(take(queue), icons.flatten, icons.matchCause({
     onFailure: failCause$2,
-    onSuccess: Effect.match$1({
+    onSuccess: icons.match({
       onLeft: succeedNow,
       onRight: outElem => flatMap$1(write(outElem), () => consumer)
     })
@@ -2270,11 +2272,11 @@ const mergeAllWith = ({
   return embedInput(consumer, input);
 }));
 /** @internal */
-const mergeMap = /*#__PURE__*/Effect.dual(3, (self, f, options) => mergeAll(options)(mapOut(self, f)));
+const mergeMap = /*#__PURE__*/icons.dual(3, (self, f, options) => mergeAll(options)(mapOut(self, f)));
 /** @internal */
-const mergeWith = /*#__PURE__*/Effect.dual(2, (self, options) => {
+const mergeWith = /*#__PURE__*/icons.dual(2, (self, options) => {
   function merge(scope) {
-    return Effect.gen$1(function* () {
+    return icons.gen(function* () {
       const input = yield* make$1();
       const queueReader = fromInput(input);
       const pullL = yield* toPullIn(pipeTo(queueReader, self), scope);
@@ -2284,21 +2286,21 @@ const mergeWith = /*#__PURE__*/Effect.dual(2, (self, options) => {
           function onDecision(decision) {
             const op = decision;
             if (op._tag === OP_DONE) {
-              return Effect.succeed(fromEffect$3(Effect.zipRight$2(interrupt(fiber), op.effect)));
+              return icons.succeed(fromEffect$3(icons.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))),
+            return icons.map$2(_await(fiber), icons.match$1({
+              onFailure: cause => fromEffect$3(op.f(icons.failCause(cause))),
+              onSuccess: icons.match({
+                onLeft: done => fromEffect$3(op.f(icons.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)))))
+          return icons.match$1(exit, {
+            onFailure: cause => onDecision(done(icons.failCause(cause))),
+            onSuccess: icons.match({
+              onLeft: z => onDecision(done(icons.succeed$2(z))),
+              onRight: elem => icons.succeed(flatMap$1(write(elem), () => flatMap$1(fromEffect$3(icons.forkIn(icons.interruptible(pull), scope)), leftFiber => go(both(leftFiber, fiber)))))
             })
           });
         };
@@ -2307,50 +2309,50 @@ const mergeWith = /*#__PURE__*/Effect.dual(2, (self, options) => {
         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)))
+              const leftJoin = icons.interruptible(join(state.left));
+              const rightJoin = icons.interruptible(join(state.right));
+              return unwrap(icons.raceWith(leftJoin, rightJoin, {
+                onSelfDone: (leftExit, rf) => icons.zipRight$2(interrupt(rf), handleSide(leftExit, state.right, pullL)(options.onSelfDone, BothRunning, f => LeftDone(f))),
+                onOtherDone: (rightExit, lf) => icons.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))),
+              return unwrap(icons.map$2(icons.exit(pullR), icons.match$1({
+                onFailure: cause => fromEffect$3(state.f(icons.failCause(cause))),
+                onSuccess: icons.match({
+                  onLeft: done => fromEffect$3(state.f(icons.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))),
+              return unwrap(icons.map$2(icons.exit(pullL), icons.match$1({
+                onFailure: cause => fromEffect$3(state.f(icons.failCause(cause))),
+                onSuccess: icons.match({
+                  onLeft: done => fromEffect$3(state.f(icons.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 => {
+      return fromEffect$3(icons.withFiberRuntime$1(parent => {
+        const inherit = icons.withFiberRuntime$1(state => {
           state.transferChildren(parent.scope());
-          return Effect._void;
+          return icons._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));
+        const leftFiber = icons.interruptible(pullL).pipe(icons.ensuring(inherit), icons.forkIn(scope));
+        const rightFiber = icons.interruptible(pullR).pipe(icons.ensuring(inherit), icons.forkIn(scope));
+        return icons.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(() => {
+const pipeToOrFail = /*#__PURE__*/icons.dual(2, (self, that) => suspend$1(() => {
   let channelException = undefined;
   const reader = readWith({
     onInput: outElem => flatMap$1(write(outElem), () => reader),
@@ -2361,47 +2363,47 @@ const pipeToOrFail = /*#__PURE__*/Effect.dual(2, (self, that) => suspend$1(() =>
     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),
+    onInput: outElem => icons.pipe(write(outElem), flatMap$1(() => writer)),
+    onFailure: cause => isDieType(cause) && isChannelException(cause.defect) && icons.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));
+const run$1 = self => icons.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)))));
+const scoped = effect => unwrap(icons.uninterruptibleMask(restore => icons.map$2(icons.make$3(), scope => acquireReleaseOut(icons.tapErrorCause(restore(icons.extend(effect, scope)), cause => icons.close(scope, icons.failCause(cause))), (_, exit) => icons.close(scope, exit)))));
 /** @internal */
-const scopedWith$1 = f => unwrapScoped(Effect.map$2(Effect.scope, scope => flatMap$1(fromEffect$3(f(scope)), write)));
+const scopedWith$1 = f => unwrapScoped(icons.map$2(icons.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 toPullIn = /*#__PURE__*/icons.dual(2, (self, scope) => icons.zip(icons.sync$1(() => new ChannelExecutor(self, void 0, icons.identity)), icons.runtime()).pipe(icons.tap(([executor, runtime]) => icons.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)))));
+  return finalizer !== undefined ? icons.provide(finalizer, runtime) : icons._void;
+})), icons.uninterruptible$1, icons.map$2(([executor]) => icons.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))
+        return icons.match$1(exec.getDone(), {
+          onFailure: icons.failCause$1,
+          onSuccess: done => icons.succeed(icons.left(done))
         });
       }
     case OP_EMIT$1:
       {
-        return Effect.succeed(Effect.right(exec.getEmit()));
+        return icons.succeed(icons.right(exec.getEmit()));
       }
     case OP_FROM_EFFECT:
       {
-        return Effect.pipe(state.effect, Effect.flatMap$1(() => interpretToPull(exec.run(), exec)));
+        return icons.pipe(state.effect, icons.flatMap$1(() => interpretToPull(exec.run(), exec)));
       }
     case OP_READ:
       {
-        return readUpstream(state, () => interpretToPull(exec.run(), exec), cause => Effect.failCause$1(cause));
+        return readUpstream(state, () => interpretToPull(exec.run(), exec), cause => icons.failCause$1(cause));
       }
   }
 };
@@ -2415,16 +2417,16 @@ const unwrapScopedWith$1 = f => concatAllWith(scopedWith$1(f), (d, _) => d, (d,
 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)));
+  return idx === len ? void_ : icons.pipe(write(icons.pipe(chunk, icons.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, {
+const zip = /*#__PURE__*/icons.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)))
+  onSelfDone: exit1 => Await(exit2 => icons.suspend$1(() => icons.zip$1(exit1, exit2))),
+  onOtherDone: exit2 => Await(exit1 => icons.suspend$1(() => icons.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, {
+const zipRight = /*#__PURE__*/icons.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 */
@@ -2436,7 +2438,7 @@ const ChannelException = error => ({
   error
 });
 /** @internal */
-const isChannelException = u => Effect.hasProperty(u, ChannelExceptionTypeId);
+const isChannelException = u => icons.hasProperty(u, ChannelExceptionTypeId);
 
 /** @internal */
 const SinkTypeId = /*#__PURE__*/Symbol.for("effect/Sink");
@@ -2460,7 +2462,7 @@ class SinkImpl {
     this.channel = channel;
   }
   pipe() {
-    return Effect.pipeArguments(this, arguments);
+    return icons.pipeArguments(this, arguments);
   }
 }
 /** @internal */
@@ -2468,7 +2470,7 @@ const drain = /*#__PURE__*/new SinkImpl(/*#__PURE__*/drain$1(/*#__PURE__*/identi
 /** @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;
+const toChannel$1 = self => icons.isEffect(self) ? toChannel$1(fromEffect$1(self)) : self.channel;
 
 /** @internal */
 const TakeSymbolKey = "effect/Take";
@@ -2488,22 +2490,22 @@ class TakeImpl {
     this.exit = exit;
   }
   pipe() {
-    return Effect.pipeArguments(this, arguments);
+    return icons.pipeArguments(this, arguments);
   }
 }
 /** @internal */
-const chunk = chunk => new TakeImpl(Effect.succeed$2(chunk));
+const chunk = chunk => new TakeImpl(icons.succeed$2(chunk));
 /** @internal */
-const end$1 = /*#__PURE__*/new TakeImpl(/*#__PURE__*/Effect.fail$2(/*#__PURE__*/Effect.none()));
+const end$1 = /*#__PURE__*/new TakeImpl(/*#__PURE__*/icons.fail$1(/*#__PURE__*/icons.none()));
 /** @internal */
-const failCause$1 = cause => new TakeImpl(Effect.failCause(Effect.pipe(cause, map$2(Effect.some))));
+const failCause$1 = cause => new TakeImpl(icons.failCause(icons.pipe(cause, map$2(icons.some))));
 /** @internal */
-const of = value => new TakeImpl(Effect.succeed$2(Effect.of(value)));
+const of = value => new TakeImpl(icons.succeed$2(icons.of(value)));
 
 /** @internal */
-const end = () => Effect.fail$3(Effect.none());
+const end = () => icons.fail$2(icons.none());
 /** @internal */
-const failCause = cause => Effect.mapError(Effect.failCause$1(cause), Effect.some);
+const failCause = cause => icons.mapError(icons.failCause$1(cause), icons.some);
 
 /** @internal */
 const StreamSymbolKey = "effect/Stream";
@@ -2523,22 +2525,22 @@ class StreamImpl {
     this.channel = channel;
   }
   pipe() {
-    return Effect.pipeArguments(this, arguments);
+    return icons.pipeArguments(this, arguments);
   }
 }
 /** @internal */
-const isStream = u => Effect.hasProperty(u, StreamTypeId) || Effect.isEffect(u);
+const isStream = u => icons.hasProperty(u, StreamTypeId) || icons.isEffect(u);
 /** @internal */
 const DefaultChunkSize = 4096;
 /** @internal */
-const ensuring = /*#__PURE__*/Effect.dual(2, (self, finalizer) => new StreamImpl(Effect.pipe(toChannel(self), ensuring$1(finalizer))));
+const ensuring = /*#__PURE__*/icons.dual(2, (self, finalizer) => new StreamImpl(icons.pipe(toChannel(self), ensuring$1(finalizer))));
 /** @internal */
-const flatMap = /*#__PURE__*/Effect.dual(args => isStream(args[0]), (self, f, options) => {
+const flatMap = /*#__PURE__*/icons.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))));
+  return matchConcurrency(options?.concurrency, () => new StreamImpl(concatMap(toChannel(self), as => icons.pipe(as, icons.map$4(a => toChannel(f(a))), icons.reduce(void_, (left, right) => icons.pipe(left, zipRight(right)))))), _ => new StreamImpl(icons.pipe(toChannel(self), concatMap(writeChunk), mergeMap(out => toChannel(f(out)), options))));
 });
 /** @internal */
 const matchConcurrency = (concurrency, sequential, bounded) => {
@@ -2551,13 +2553,13 @@ const matchConcurrency = (concurrency, sequential, bounded) => {
       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)), {
+const flatMapParSwitchBuffer = /*#__PURE__*/icons.dual(4, (self, n, bufferSize, f) => new StreamImpl(icons.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));
+const flatten = /*#__PURE__*/icons.dual(args => isStream(args[0]), (self, options) => flatMap(self, icons.identity, options));
 /** @internal */
 const flattenChunks = self => {
   const flatten = readWithCause({
@@ -2565,59 +2567,59 @@ const flattenChunks = self => {
     onFailure: failCause$2,
     onDone: () => void_
   });
-  return new StreamImpl(Effect.pipe(toChannel(self), pipeTo(flatten)));
+  return new StreamImpl(icons.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({
+    const [toEmit, rest] = icons.pipe(chunk, icons.splitWhere(exit => !icons.isSuccess(exit)));
+    const next = icons.pipe(icons.head(rest), icons.match$2({
       onNone: () => cont,
-      onSome: Effect.match$2({
-        onFailure: cause => Effect.match(flipCauseOption(cause), {
+      onSome: icons.match$1({
+        onFailure: cause => icons.match$2(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));
+    return icons.pipe(write(icons.pipe(toEmit, icons.filterMap(exit => icons.isSuccess(exit) ? icons.some(exit.value) : icons.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)));
+  return new StreamImpl(icons.pipe(toChannel(self), pipeTo(process)));
 };
 /** @internal */
-const flattenTake = self => flattenChunks(flattenExitOption(Effect.pipe(self, map(take => take.exit))));
+const flattenTake = self => flattenChunks(flattenExitOption(icons.pipe(self, map(take => take.exit))));
 /** @internal */
 const toChannel = stream => {
   if ("channel" in stream) {
     return stream.channel;
-  } else if (Effect.isEffect(stream)) {
+  } else if (icons.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);
+const fromEffect = effect => icons.pipe(effect, icons.mapError(icons.some), fromEffectOption);
 /** @internal */
-const fromEffectOption = effect => new StreamImpl(unwrap(Effect.match$3(effect, {
-  onFailure: Effect.match({
+const fromEffectOption = effect => new StreamImpl(unwrap(icons.match$3(effect, {
+  onFailure: icons.match$2({
     onNone: () => void_,
     onSome: fail
   }),
-  onSuccess: a => write(Effect.of(a))
+  onSuccess: a => write(icons.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);
+const fromQueue$1 = (queue, options) => icons.pipe(takeBetween(queue, 1, options?.maxChunkSize ?? DefaultChunkSize), icons.catchAllCause(cause => icons.pipe(isShutdown(queue), icons.flatMap$1(isShutdown => isShutdown && isInterrupted(cause) ? end() : failCause(cause)))), repeatEffectChunkOption, options?.shutdown ? ensuring(shutdown(queue)) : icons.identity);
 /** @internal */
-const map = /*#__PURE__*/Effect.dual(2, (self, f) => new StreamImpl(Effect.pipe(toChannel(self), mapOut(Effect.map$4(f)))));
+const map = /*#__PURE__*/icons.dual(2, (self, f) => new StreamImpl(icons.pipe(toChannel(self), mapOut(icons.map$4(f)))));
 /** @internal */
-const mapEffectSequential = /*#__PURE__*/Effect.dual(2, (self, f) => {
+const mapEffectSequential = /*#__PURE__*/icons.dual(2, (self, f) => {
   const loop = iterator => {
     const next = iterator.next();
     if (next.done) {
@@ -2628,29 +2630,29 @@ const mapEffectSequential = /*#__PURE__*/Effect.dual(2, (self, f) => {
       });
     } else {
       const value = next.value;
-      return unwrap(Effect.map$2(f(value), a2 => flatMap$1(write(Effect.of(a2)), () => loop(iterator))));
+      return unwrap(icons.map$2(f(value), a2 => flatMap$1(write(icons.of(a2)), () => loop(iterator))));
     }
   };
-  return new StreamImpl(Effect.pipe(toChannel(self), pipeTo(suspend$1(() => loop(Effect.empty$2()[Symbol.iterator]())))));
+  return new StreamImpl(icons.pipe(toChannel(self), pipeTo(suspend$1(() => loop(icons.empty$1()[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))));
+const mapEffectPar = /*#__PURE__*/icons.dual(3, (self, n, f) => new StreamImpl(icons.pipe(toChannel(self), concatMap(writeChunk), mapOutEffectPar(f, n), mapOut(icons.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$3
+const repeatEffectChunkOption = effect => unfoldChunkEffect(effect, effect => icons.pipe(icons.map$2(effect, chunk => icons.some([chunk, effect])), icons.catchAll(icons.match$2({
+  onNone: () => icons.succeed(icons.none()),
+  onSome: icons.fail$2
 }))));
 /** @internal */
-const run = /*#__PURE__*/Effect.dual(2, (self, sink) => toChannel(self).pipe(pipeToOrFail(toChannel$1(sink)), runDrain$2));
+const run = /*#__PURE__*/icons.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))));
+const scopedWith = f => new StreamImpl(scopedWith$1(scope => f(scope).pipe(icons.map$2(icons.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({
+  const loop = s => unwrap(icons.map$2(f(s), icons.match$2({
     onNone: () => void_,
     onSome: ([chunk, s]) => flatMap$1(write(chunk), () => loop(s))
   })));
@@ -2674,9 +2676,9 @@ const groupByVariance = {
   _V: _ => _
 };
 /** @internal */
-const isGroupBy = u => Effect.hasProperty(u, GroupByTypeId);
+const isGroupBy = u => icons.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, {
+const evaluate = /*#__PURE__*/icons.dual(args => isGroupBy(args[0]), (self, f, options) => flatMap(self.grouped, ([key, queue]) => f(key, flattenTake(fromQueue$1(queue, {
   shutdown: true
 }))), {
   concurrency: "unbounded",
@@ -2686,12 +2688,12 @@ const evaluate = /*#__PURE__*/Effect.dual(args => isGroupBy(args[0]), (self, f,
 const make = grouped => ({
   [GroupByTypeId]: groupByVariance,
   pipe() {
-    return Effect.pipeArguments(this, arguments);
+    return icons.pipeArguments(this, arguments);
   },
   grouped
 });
 /** @internal */
-const mapEffectOptions = /*#__PURE__*/Effect.dual(args => typeof args[0] !== "function", (self, f, options) => {
+const mapEffectOptions = /*#__PURE__*/icons.dual(args => typeof args[0] !== "function", (self, f, options) => {
   if (options?.key) {
     return evaluate(groupByKey(self, options.key, {
       bufferSize: options.bufferSize
@@ -2702,29 +2704,29 @@ const mapEffectOptions = /*#__PURE__*/Effect.dual(args => typeof args[0] !== "fu
   }) : mapEffectPar(self, n, f));
 });
 /** @internal */
-const groupByKey = /*#__PURE__*/Effect.dual(args => typeof args[0] !== "function", (self, f, options) => {
+const groupByKey = /*#__PURE__*/icons.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]) => {
+    onInput: input => flatMap$1(fromEffect$3(icons.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(() => {
+        return icons.pipe(bounded(options?.bufferSize ?? 16), icons.flatMap$1(innerQueue => icons.pipe(icons.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()))))));
+        }), icons.zipRight$2(offer(outerQueue, of([key, innerQueue]))), icons.zipRight$2(icons.pipe(offer(innerQueue, chunk(values)), icons.catchSomeCause(cause => isInterruptedOnly(cause) ? icons.some(icons._void) : icons.none()))))));
       }
-      return Effect.catchSomeCause(offer(innerQueue, chunk(values)), cause => isInterruptedOnly(cause) ? Effect.some(Effect._void) : Effect.none());
+      return icons.catchSomeCause(offer(innerQueue, chunk(values)), cause => isInterruptedOnly(cause) ? icons.some(icons._void) : icons.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())), {
+    onDone: () => fromEffect$3(icons.pipe(icons.forEach(map.entries(), ([_, innerQueue]) => icons.pipe(offer(innerQueue, end$1), icons.catchSomeCause(cause => isInterruptedOnly(cause) ? icons.some(icons._void) : icons.none())), {
       discard: true
-    }), Effect.zipRight$2(offer(outerQueue, end$1))))
+    }), icons.zipRight$2(offer(outerQueue, end$1))))
   });
-  return make(unwrapScopedWith(scope => Effect.gen$1(function* () {
+  return make(unwrapScopedWith(scope => icons.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, {
+    yield* icons.addFinalizer(scope, shutdown(queue));
+    return yield* toChannel(self).pipe(pipeTo(loop(map, queue)), drain$1, runIn(scope), icons.forkIn(scope), icons.as(flattenTake(fromQueue$1(queue, {
       shutdown: true
     }))));
   })));
@@ -2734,7 +2736,7 @@ const groupByKey = /*#__PURE__*/Effect.dual(args => typeof args[0] !== "function
  *
  * @internal
  */
-const groupByIterable = /*#__PURE__*/Effect.dual(2, (iterable, f) => {
+const groupByIterable = /*#__PURE__*/icons.dual(2, (iterable, f) => {
   const builder = [];
   const iterator = iterable[Symbol.iterator]();
   const map = new Map();
@@ -2751,7 +2753,7 @@ const groupByIterable = /*#__PURE__*/Effect.dual(2, (iterable, f) => {
       map.set(key, innerBuilder);
     }
   }
-  return Effect.unsafeFromArray(builder.map(tuple => [tuple[0], Effect.unsafeFromArray(tuple[1])]));
+  return icons.unsafeFromArray(builder.map(tuple => [tuple[0], icons.unsafeFromArray(tuple[1])]));
 });
 
 /**
@@ -35606,24 +35608,27 @@ let validationQueue = null;
 function initializeValidationStream() {
     if (validationStreamFiber)
         return;
-    const program = Effect.gen$1(function* () {
+    const program = icons.gen(function* () {
         const queue = (validationQueue = yield* bounded(100));
-        const stream = fromQueue(queue).pipe(mapEffect(({ context, onComplete }) => Effect.async((resume) => {
+        const stream = fromQueue(queue).pipe(mapEffect(({ context, onComplete }) => icons.async((resume) => {
             axeExports.run(context, {}, (error, results) => {
                 onComplete(error, results);
-                resume(Effect._void);
+                resume(icons._void);
             });
         })));
         yield* runDrain(stream);
     });
-    validationStreamFiber = Effect.runFork(program);
+    validationStreamFiber = icons.runFork(program);
 }
 function enqueueValidation(validationRequest) {
     initializeValidationStream();
     if (!validationQueue)
         return;
-    Effect.runPromise(validationQueue.offer(validationRequest));
+    icons.runPromise(validationQueue.offer(validationRequest));
 }
 
 exports.enqueueValidation = enqueueValidation;
 exports.initializeValidationStream = initializeValidationStream;
+//# sourceMappingURL=index-ww_DCXU7.js.map
+
+//# sourceMappingURL=index-ww_DCXU7.js.map