@lmvz-ds/components 0.13.0 → 0.13.2

package/dist/cjs/{icons-DM_TTn48.js → icons-Brr4vqiE.js}

@@ -1,6 +1,7 @@
 'use strict';
 
-var assets = require('./assets-CB5ikzmP.js');
+var Effect = require('./Effect-CpZhfb0D.js');
+var assets = require('./assets-BnJmIx_h.js');
 
 /**
  * This module provides types and utility functions to create and work with branded types,
@@ -36,274 +37,22 @@ const error = (message, meta) => [{
   meta
 }];
 function refined(...args) {
-  const either = args.length === 2 ? unbranded => args[0](unbranded) ? assets.right(unbranded) : assets.left(args[1](unbranded)) : unbranded => {
-    return assets.match(args[0](unbranded), {
-      onNone: () => assets.right(unbranded),
-      onSome: assets.left
+  const either = args.length === 2 ? unbranded => args[0](unbranded) ? Effect.right(unbranded) : Effect.left(args[1](unbranded)) : unbranded => {
+    return Effect.match(args[0](unbranded), {
+      onNone: () => Effect.right(unbranded),
+      onSome: Effect.left
     });
   };
-  return Object.assign(unbranded => assets.getOrThrowWith(either(unbranded), assets.identity), {
+  return Object.assign(unbranded => Effect.getOrThrowWith(either(unbranded), Effect.identity), {
     [RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
-    option: args => assets.getRight(either(args)),
+    option: args => Effect.getRight(either(args)),
     either,
-    is: args => assets.isRight(either(args))
+    is: args => Effect.isRight(either(args))
   });
 }
 
-const _await = assets.deferredAwait;
-/**
- * Exits the `Deferred` with the specified `Exit` value, which will be
- * propagated to all fibers waiting on the value of the `Deferred`.
- *
- * @since 2.0.0
- * @category utils
- */
-const done = assets.deferredDone;
-/**
- * Completes the `Deferred` with interruption. This will interrupt all fibers
- * waiting on the value of the `Deferred` with the `FiberId` of the fiber
- * calling this method.
- *
- * @since 2.0.0
- * @category utils
- */
-const interrupt = assets.deferredInterrupt;
-/**
- * Unsafely creates a new `Deferred` from the specified `FiberId`.
- *
- * @since 2.0.0
- * @category unsafe
- */
-const unsafeMake = assets.deferredUnsafeMake;
-
-/**
- * Constructs a new `Exit.Success` containing the specified value of type `A`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const succeed = assets.exitSucceed;
-
-/**
- * @since 2.0.0
- */
-const TypeId$1 = /*#__PURE__*/Symbol.for("effect/MutableList");
-const MutableListProto = {
-  [TypeId$1]: TypeId$1,
-  [Symbol.iterator]() {
-    let done = false;
-    let head = this.head;
-    return {
-      next() {
-        if (done) {
-          return this.return();
-        }
-        if (head == null) {
-          done = true;
-          return this.return();
-        }
-        const value = head.value;
-        head = head.next;
-        return {
-          done,
-          value
-        };
-      },
-      return(value) {
-        if (!done) {
-          done = true;
-        }
-        return {
-          done: true,
-          value
-        };
-      }
-    };
-  },
-  toString() {
-    return assets.format(this.toJSON());
-  },
-  toJSON() {
-    return {
-      _id: "MutableList",
-      values: Array.from(this).map(assets.toJSON)
-    };
-  },
-  [assets.NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  pipe() {
-    return assets.pipeArguments(this, arguments);
-  }
-};
-/** @internal */
-const makeNode = value => ({
-  value,
-  removed: false,
-  prev: undefined,
-  next: undefined
-});
-/**
- * Creates an empty `MutableList`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const empty = () => {
-  const list = Object.create(MutableListProto);
-  list.head = undefined;
-  list.tail = undefined;
-  list._length = 0;
-  return list;
-};
-/**
- * Returns `true` if the list contains zero elements, `false`, otherwise.
- *
- * @since 2.0.0
- * @category getters
- */
-const isEmpty = self => length(self) === 0;
-/**
- * Returns the length of the list.
- *
- * @since 2.0.0
- * @category getters
- */
-const length = self => self._length;
-/**
- * Appends the specified element to the end of the `MutableList`.
- *
- * @category concatenating
- * @since 2.0.0
- */
-const append = /*#__PURE__*/assets.dual(2, (self, value) => {
-  const node = makeNode(value);
-  if (self.head === undefined) {
-    self.head = node;
-  }
-  if (self.tail === undefined) {
-    self.tail = node;
-  } else {
-    self.tail.next = node;
-    node.prev = self.tail;
-    self.tail = node;
-  }
-  self._length += 1;
-  return self;
-});
-/**
- * Removes the first value from the list and returns it, if it exists.
- *
- * @since 0.0.1
- */
-const shift = self => {
-  const head = self.head;
-  if (head !== undefined) {
-    remove(self, head);
-    return head.value;
-  }
-  return undefined;
-};
-const remove = (self, node) => {
-  if (node.removed) {
-    return;
-  }
-  node.removed = true;
-  if (node.prev !== undefined && node.next !== undefined) {
-    node.prev.next = node.next;
-    node.next.prev = node.prev;
-  } else if (node.prev !== undefined) {
-    self.tail = node.prev;
-    node.prev.next = undefined;
-  } else if (node.next !== undefined) {
-    self.head = node.next;
-    node.next.prev = undefined;
-  } else {
-    self.tail = undefined;
-    self.head = undefined;
-  }
-  if (self._length > 0) {
-    self._length -= 1;
-  }
-};
-
-/**
- * @since 2.0.0
- */
-const TypeId = /*#__PURE__*/Symbol.for("effect/MutableQueue");
-/**
- * @since 2.0.0
- * @category symbol
- */
-const EmptyMutableQueue = /*#__PURE__*/Symbol.for("effect/mutable/MutableQueue/Empty");
-const MutableQueueProto = {
-  [TypeId]: TypeId,
-  [Symbol.iterator]() {
-    return Array.from(this.queue)[Symbol.iterator]();
-  },
-  toString() {
-    return assets.format(this.toJSON());
-  },
-  toJSON() {
-    return {
-      _id: "MutableQueue",
-      values: Array.from(this).map(assets.toJSON)
-    };
-  },
-  [assets.NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  pipe() {
-    return assets.pipeArguments(this, arguments);
-  }
-};
-const make$2 = capacity => {
-  const queue = Object.create(MutableQueueProto);
-  queue.queue = empty();
-  queue.capacity = capacity;
-  return queue;
-};
-/**
- * Creates a new unbounded `MutableQueue`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const unbounded = () => make$2(undefined);
-/**
- * Offers an element to the queue.
- *
- * Returns whether the enqueue was successful or not.
- *
- * @since 2.0.0
- */
-const offer = /*#__PURE__*/assets.dual(2, (self, value) => {
-  const queueLength = length(self.queue);
-  if (self.capacity !== undefined && queueLength === self.capacity) {
-    return false;
-  }
-  append(value)(self.queue);
-  return true;
-});
-/**
- * Dequeues an element from the queue.
- *
- * Returns either an element from the queue, or the `def` param.
- *
- * **Note**: if there is no meaningful default for your type, you can always
- * use `poll(MutableQueue.EmptyMutableQueue)`.
- *
- * @since 2.0.0
- */
-const poll = /*#__PURE__*/assets.dual(2, (self, def) => {
-  if (isEmpty(self.queue)) {
-    return def;
-  }
-  return shift(self.queue);
-});
-
 /** @internal */
-const complete = (key, exit, entryStats, timeToLiveMillis) => assets.struct({
+const complete = (key, exit, entryStats, timeToLiveMillis) => Effect.struct({
   _tag: "Complete",
   key,
   exit,
@@ -311,13 +60,13 @@ const complete = (key, exit, entryStats, timeToLiveMillis) => assets.struct({
   timeToLiveMillis
 });
 /** @internal */
-const pending = (key, deferred) => assets.struct({
+const pending = (key, deferred) => Effect.struct({
   _tag: "Pending",
   key,
   deferred
 });
 /** @internal */
-const refreshing = (deferred, complete) => assets.struct({
+const refreshing = (deferred, complete) => Effect.struct({
   _tag: "Refreshing",
   deferred,
   complete
@@ -332,20 +81,20 @@ class MapKeyImpl {
   constructor(current) {
     this.current = current;
   }
-  [assets.symbol]() {
-    return assets.pipe(assets.hash(this.current), assets.combine(assets.hash(this.previous)), assets.combine(assets.hash(this.next)), assets.cached(this));
+  [Effect.symbol]() {
+    return Effect.pipe(Effect.hash(this.current), Effect.combine(Effect.hash(this.previous)), Effect.combine(Effect.hash(this.next)), Effect.cached(this));
   }
-  [assets.symbol$1](that) {
+  [Effect.symbol$1](that) {
     if (this === that) {
       return true;
     }
-    return isMapKey(that) && assets.equals(this.current, that.current) && assets.equals(this.previous, that.previous) && assets.equals(this.next, that.next);
+    return isMapKey(that) && Effect.equals(this.current, that.current) && Effect.equals(this.previous, that.previous) && Effect.equals(this.next, that.next);
   }
 }
 /** @internal */
 const makeMapKey = current => new MapKeyImpl(current);
 /** @internal */
-const isMapKey = u => assets.hasProperty(u, MapKeyTypeId);
+const isMapKey = u => Effect.hasProperty(u, MapKeyTypeId);
 class KeySetImpl {
   head = undefined;
   tail = undefined;
@@ -409,7 +158,7 @@ const makeCacheState = (map, keys, accesses, updating, hits, misses) => ({
  *
  * @internal
  */
-const initialCacheState = () => makeCacheState(assets.empty(), makeKeySet(), unbounded(), assets.make(false), 0, 0);
+const initialCacheState = () => makeCacheState(Effect.empty(), makeKeySet(), Effect.unbounded(), Effect.make(false), 0, 0);
 /** @internal */
 const CacheSymbolKey = "effect/Cache";
 /** @internal */
@@ -458,177 +207,177 @@ class CacheImpl {
     this.cacheState = initialCacheState();
   }
   get(key) {
-    return assets.map(this.getEither(key), assets.merge);
+    return Effect.map(this.getEither(key), Effect.merge);
   }
   get cacheStats() {
-    return assets.sync(() => makeCacheStats({
+    return Effect.sync(() => makeCacheStats({
       hits: this.cacheState.hits,
       misses: this.cacheState.misses,
-      size: assets.size(this.cacheState.map)
+      size: Effect.size(this.cacheState.map)
     }));
   }
   getOption(key) {
-    return assets.suspend(() => assets.match(assets.get(this.cacheState.map, key), {
+    return Effect.suspend(() => Effect.match(Effect.get(this.cacheState.map, key), {
       onNone: () => {
         const mapKey = makeMapKey(key);
         this.trackAccess(mapKey);
         this.trackMiss();
-        return assets.succeed$1(assets.none());
+        return Effect.succeed$1(Effect.none());
       },
       onSome: value => this.resolveMapValue(value)
     }));
   }
   getOptionComplete(key) {
-    return assets.suspend(() => assets.match(assets.get(this.cacheState.map, key), {
+    return Effect.suspend(() => Effect.match(Effect.get(this.cacheState.map, key), {
       onNone: () => {
         const mapKey = makeMapKey(key);
         this.trackAccess(mapKey);
         this.trackMiss();
-        return assets.succeed$1(assets.none());
+        return Effect.succeed$1(Effect.none());
       },
       onSome: value => this.resolveMapValue(value, true)
     }));
   }
   contains(key) {
-    return assets.sync(() => assets.has(this.cacheState.map, key));
+    return Effect.sync(() => Effect.has(this.cacheState.map, key));
   }
   entryStats(key) {
-    return assets.sync(() => {
-      const option = assets.get(this.cacheState.map, key);
-      if (assets.isSome(option)) {
+    return Effect.sync(() => {
+      const option = Effect.get(this.cacheState.map, key);
+      if (Effect.isSome(option)) {
         switch (option.value._tag) {
           case "Complete":
             {
               const loaded = option.value.entryStats.loadedMillis;
-              return assets.some(makeEntryStats(loaded));
+              return Effect.some(makeEntryStats(loaded));
             }
           case "Pending":
             {
-              return assets.none();
+              return Effect.none();
             }
           case "Refreshing":
             {
               const loaded = option.value.complete.entryStats.loadedMillis;
-              return assets.some(makeEntryStats(loaded));
+              return Effect.some(makeEntryStats(loaded));
             }
         }
       }
-      return assets.none();
+      return Effect.none();
     });
   }
   getEither(key) {
-    return assets.suspend(() => {
+    return Effect.suspend(() => {
       const k = key;
       let mapKey = undefined;
       let deferred = undefined;
-      let value = assets.getOrUndefined(assets.get(this.cacheState.map, k));
+      let value = Effect.getOrUndefined(Effect.get(this.cacheState.map, k));
       if (value === undefined) {
-        deferred = unsafeMake(this.fiberId);
+        deferred = Effect.unsafeMake(this.fiberId);
         mapKey = makeMapKey(k);
-        if (assets.has(this.cacheState.map, k)) {
-          value = assets.getOrUndefined(assets.get(this.cacheState.map, k));
+        if (Effect.has(this.cacheState.map, k)) {
+          value = Effect.getOrUndefined(Effect.get(this.cacheState.map, k));
         } else {
-          assets.set(this.cacheState.map, k, pending(mapKey, deferred));
+          Effect.set(this.cacheState.map, k, pending(mapKey, deferred));
         }
       }
       if (value === undefined) {
         this.trackAccess(mapKey);
         this.trackMiss();
-        return assets.map(this.lookupValueOf(key, deferred), assets.right);
+        return Effect.map(this.lookupValueOf(key, deferred), Effect.right);
       } else {
-        return assets.flatMap(this.resolveMapValue(value), assets.match({
+        return Effect.flatMap(this.resolveMapValue(value), Effect.match({
           onNone: () => this.getEither(key),
-          onSome: value => assets.succeed$1(assets.left(value))
+          onSome: value => Effect.succeed$1(Effect.left(value))
         }));
       }
     });
   }
   invalidate(key) {
-    return assets.sync(() => {
-      assets.remove(this.cacheState.map, key);
+    return Effect.sync(() => {
+      Effect.remove(this.cacheState.map, key);
     });
   }
   invalidateWhen(key, when) {
-    return assets.sync(() => {
-      const value = assets.get(this.cacheState.map, key);
-      if (assets.isSome(value) && value.value._tag === "Complete") {
+    return Effect.sync(() => {
+      const value = Effect.get(this.cacheState.map, key);
+      if (Effect.isSome(value) && value.value._tag === "Complete") {
         if (value.value.exit._tag === "Success") {
           if (when(value.value.exit.value)) {
-            assets.remove(this.cacheState.map, key);
+            Effect.remove(this.cacheState.map, key);
           }
         }
       }
     });
   }
   get invalidateAll() {
-    return assets.sync(() => {
-      this.cacheState.map = assets.empty();
+    return Effect.sync(() => {
+      this.cacheState.map = Effect.empty();
     });
   }
   refresh(key) {
-    return assets.clockWith(clock => assets.suspend(() => {
+    return Effect.clockWith(clock => Effect.suspend(() => {
       const k = key;
-      const deferred = unsafeMake(this.fiberId);
-      let value = assets.getOrUndefined(assets.get(this.cacheState.map, k));
+      const deferred = Effect.unsafeMake(this.fiberId);
+      let value = Effect.getOrUndefined(Effect.get(this.cacheState.map, k));
       if (value === undefined) {
-        if (assets.has(this.cacheState.map, k)) {
-          value = assets.getOrUndefined(assets.get(this.cacheState.map, k));
+        if (Effect.has(this.cacheState.map, k)) {
+          value = Effect.getOrUndefined(Effect.get(this.cacheState.map, k));
         } else {
-          assets.set(this.cacheState.map, k, pending(makeMapKey(k), deferred));
+          Effect.set(this.cacheState.map, k, pending(makeMapKey(k), deferred));
         }
       }
       if (value === undefined) {
-        return assets.asVoid(this.lookupValueOf(key, deferred));
+        return Effect.asVoid(this.lookupValueOf(key, deferred));
       } else {
         switch (value._tag) {
           case "Complete":
             {
               if (this.hasExpired(clock, value.timeToLiveMillis)) {
-                const found = assets.getOrUndefined(assets.get(this.cacheState.map, k));
-                if (assets.equals(found, value)) {
-                  assets.remove(this.cacheState.map, k);
+                const found = Effect.getOrUndefined(Effect.get(this.cacheState.map, k));
+                if (Effect.equals(found, value)) {
+                  Effect.remove(this.cacheState.map, k);
                 }
-                return assets.asVoid(this.get(key));
+                return Effect.asVoid(this.get(key));
               }
               // Only trigger the lookup if we're still the current value, `completedResult`
-              return assets.pipe(this.lookupValueOf(key, deferred), assets.when(() => {
-                const current = assets.getOrUndefined(assets.get(this.cacheState.map, k));
-                if (assets.equals(current, value)) {
+              return Effect.pipe(this.lookupValueOf(key, deferred), Effect.when(() => {
+                const current = Effect.getOrUndefined(Effect.get(this.cacheState.map, k));
+                if (Effect.equals(current, value)) {
                   const mapValue = refreshing(deferred, value);
-                  assets.set(this.cacheState.map, k, mapValue);
+                  Effect.set(this.cacheState.map, k, mapValue);
                   return true;
                 }
                 return false;
-              }), assets.asVoid);
+              }), Effect.asVoid);
             }
           case "Pending":
             {
-              return _await(value.deferred);
+              return Effect._await(value.deferred);
             }
           case "Refreshing":
             {
-              return _await(value.deferred);
+              return Effect._await(value.deferred);
             }
         }
       }
     }));
   }
   set(key, value) {
-    return assets.clockWith(clock => assets.sync(() => {
+    return Effect.clockWith(clock => Effect.sync(() => {
       const now = clock.unsafeCurrentTimeMillis();
       const k = key;
-      const lookupResult = succeed(value);
-      const mapValue = complete(makeMapKey(k), lookupResult, makeEntryStats(now), now + assets.toMillis(assets.decode(this.timeToLive(lookupResult))));
-      assets.set(this.cacheState.map, k, mapValue);
+      const lookupResult = Effect.succeed$2(value);
+      const mapValue = complete(makeMapKey(k), lookupResult, makeEntryStats(now), now + Effect.toMillis(Effect.decode(this.timeToLive(lookupResult))));
+      Effect.set(this.cacheState.map, k, mapValue);
     }));
   }
   get size() {
-    return assets.sync(() => {
-      return assets.size(this.cacheState.map);
+    return Effect.sync(() => {
+      return Effect.size(this.cacheState.map);
     });
   }
   get values() {
-    return assets.sync(() => {
+    return Effect.sync(() => {
       const values = [];
       for (const entry of this.cacheState.map) {
         if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
@@ -639,7 +388,7 @@ class CacheImpl {
     });
   }
   get entries() {
-    return assets.sync(() => {
+    return Effect.sync(() => {
       const values = [];
       for (const entry of this.cacheState.map) {
         if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
@@ -650,7 +399,7 @@ class CacheImpl {
     });
   }
   get keys() {
-    return assets.sync(() => {
+    return Effect.sync(() => {
       const keys = [];
       for (const entry of this.cacheState.map) {
         if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
@@ -661,26 +410,26 @@ class CacheImpl {
     });
   }
   resolveMapValue(value, ignorePending = false) {
-    return assets.clockWith(clock => {
+    return Effect.clockWith(clock => {
       switch (value._tag) {
         case "Complete":
           {
             this.trackAccess(value.key);
             if (this.hasExpired(clock, value.timeToLiveMillis)) {
-              assets.remove(this.cacheState.map, value.key.current);
-              return assets.succeed$1(assets.none());
+              Effect.remove(this.cacheState.map, value.key.current);
+              return Effect.succeed$1(Effect.none());
             }
             this.trackHit();
-            return assets.map(value.exit, assets.some);
+            return Effect.map(value.exit, Effect.some);
           }
         case "Pending":
           {
             this.trackAccess(value.key);
             this.trackHit();
             if (ignorePending) {
-              return assets.succeed$1(assets.none());
+              return Effect.succeed$1(Effect.none());
             }
-            return assets.map(_await(value.deferred), assets.some);
+            return Effect.map(Effect._await(value.deferred), Effect.some);
           }
         case "Refreshing":
           {
@@ -688,11 +437,11 @@ class CacheImpl {
             this.trackHit();
             if (this.hasExpired(clock, value.complete.timeToLiveMillis)) {
               if (ignorePending) {
-                return assets.succeed$1(assets.none());
+                return Effect.succeed$1(Effect.none());
               }
-              return assets.map(_await(value.deferred), assets.some);
+              return Effect.map(Effect._await(value.deferred), Effect.some);
             }
-            return assets.map(value.complete.exit, assets.some);
+            return Effect.map(value.complete.exit, Effect.some);
           }
       }
     });
@@ -704,24 +453,24 @@ class CacheImpl {
     this.cacheState.misses = this.cacheState.misses + 1;
   }
   trackAccess(key) {
-    offer(this.cacheState.accesses, key);
-    if (assets.compareAndSet(this.cacheState.updating, false, true)) {
+    Effect.offer(this.cacheState.accesses, key);
+    if (Effect.compareAndSet(this.cacheState.updating, false, true)) {
       let loop = true;
       while (loop) {
-        const key = poll(this.cacheState.accesses, EmptyMutableQueue);
-        if (key === EmptyMutableQueue) {
+        const key = Effect.poll(this.cacheState.accesses, Effect.EmptyMutableQueue);
+        if (key === Effect.EmptyMutableQueue) {
           loop = false;
         } else {
           this.cacheState.keys.add(key);
         }
       }
-      let size = assets.size(this.cacheState.map);
+      let size = Effect.size(this.cacheState.map);
       loop = size > this.capacity;
       while (loop) {
         const key = this.cacheState.keys.remove();
         if (key !== undefined) {
-          if (assets.has(this.cacheState.map, key.current)) {
-            assets.remove(this.cacheState.map, key.current);
+          if (Effect.has(this.cacheState.map, key.current)) {
+            Effect.remove(this.cacheState.map, key.current);
             size = size - 1;
             loop = size > this.capacity;
           }
@@ -729,30 +478,30 @@ class CacheImpl {
           loop = false;
         }
       }
-      assets.set$1(this.cacheState.updating, false);
+      Effect.set$1(this.cacheState.updating, false);
     }
   }
   hasExpired(clock, timeToLiveMillis) {
     return clock.unsafeCurrentTimeMillis() > timeToLiveMillis;
   }
   lookupValueOf(input, deferred) {
-    return assets.clockWith(clock => assets.suspend(() => {
+    return Effect.clockWith(clock => Effect.suspend(() => {
       const key = input;
-      return assets.pipe(this.lookup(input), assets.provideContext(this.context), assets.exit, assets.flatMap(exit => {
+      return Effect.pipe(this.lookup(input), Effect.provideContext(this.context), Effect.exit, Effect.flatMap(exit => {
         const now = clock.unsafeCurrentTimeMillis();
         const stats = makeEntryStats(now);
-        const value = complete(makeMapKey(key), exit, stats, now + assets.toMillis(assets.decode(this.timeToLive(exit))));
-        assets.set(this.cacheState.map, key, value);
-        return assets.zipRight(done(deferred, exit), exit);
-      }), assets.onInterrupt(() => assets.zipRight(interrupt(deferred), assets.sync(() => {
-        assets.remove(this.cacheState.map, key);
+        const value = complete(makeMapKey(key), exit, stats, now + Effect.toMillis(Effect.decode(this.timeToLive(exit))));
+        Effect.set(this.cacheState.map, key, value);
+        return Effect.zipRight(Effect.done(deferred, exit), exit);
+      }), Effect.onInterrupt(() => Effect.zipRight(Effect.interrupt(deferred), Effect.sync(() => {
+        Effect.remove(this.cacheState.map, key);
       }))));
     }));
   }
 }
 /** @internal */
 const make$1 = options => {
-  const timeToLive = assets.decode(options.timeToLive);
+  const timeToLive = Effect.decode(options.timeToLive);
   return makeWith({
     capacity: options.capacity,
     lookup: options.lookup,
@@ -760,7 +509,7 @@ const make$1 = options => {
   });
 };
 /** @internal */
-const makeWith = options => assets.map(assets.all([assets.context(), assets.fiberId]), ([context, fiberId]) => new CacheImpl(options.capacity, context, fiberId, options.lookup, exit => assets.decode(options.timeToLive(exit))));
+const makeWith = options => Effect.map(Effect.all([Effect.context(), Effect.fiberId]), ([context, fiberId]) => new CacheImpl(options.capacity, context, fiberId, options.lookup, exit => Effect.decode(options.timeToLive(exit))));
 
 /**
  * Constructs a new cache with the specified capacity, time to live, and
@@ -771,37 +520,84 @@ const makeWith = options => assets.map(assets.all([assets.context(), assets.fibe
  */
 const make = make$1;
 
-class FetchError extends assets.TaggedError('FetchError') {
+/**
+ * Provides a constructor for a Case Class.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const Error$1 = /*#__PURE__*/function () {
+  const plainArgsSymbol = /*#__PURE__*/Symbol.for("effect/Data/Error/plainArgs");
+  const O = {
+    BaseEffectError: class extends Effect.YieldableError {
+      constructor(args) {
+        super(args?.message, args?.cause ? {
+          cause: args.cause
+        } : undefined);
+        if (args) {
+          Object.assign(this, args);
+          // @effect-diagnostics-next-line floatingEffect:off
+          Object.defineProperty(this, plainArgsSymbol, {
+            value: args,
+            enumerable: false
+          });
+        }
+      }
+      toJSON() {
+        return {
+          ...this[plainArgsSymbol],
+          ...this
+        };
+      }
+    }
+  };
+  return O.BaseEffectError;
+}();
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const TaggedError = tag => {
+  const O = {
+    BaseEffectError: class extends Error$1 {
+      _tag = tag;
+    }
+  };
+  O.BaseEffectError.prototype.name = tag;
+  return O.BaseEffectError;
+};
+
+class FetchError extends TaggedError('FetchError') {
 }
-class NotFoundError extends assets.TaggedError('NotFoundError') {
+class NotFoundError extends TaggedError('NotFoundError') {
 }
-const httpClient = (input, init) => assets.gen(function* () {
-    const response = yield* assets.tryPromise({
+const httpClient = (input, init) => Effect.gen(function* () {
+    const response = yield* Effect.tryPromise({
         try: () => fetch(input, init),
         catch: error => new FetchError({ cause: error }),
     });
     if (response.status === 404) {
-        return yield* new NotFoundError({ url: response.url });
+        return yield* Effect.fail(new NotFoundError({ url: response.url }));
     }
     return response;
 });
-class ResponseTextError extends assets.TaggedError('ResponseTextError') {
+class ResponseTextError extends TaggedError('ResponseTextError') {
     constructor(error) {
         super(new Error(`Failed to read response text`, { cause: error }));
     }
 }
-const responseAsText = (res) => assets.tryPromise({
+const responseAsText = (res) => Effect.tryPromise({
     try: () => res.text(),
     catch: error => new ResponseTextError(error),
 });
 
 const SVGString = refined(isValidSVG, () => error('SVG data is malformed'));
-class BrandValidationError extends assets.TaggedError('BrandValidationError') {
+class BrandValidationError extends TaggedError('BrandValidationError') {
     constructor(error, type) {
         super(new Error(`Brand validation failed for type ${type}.`, { cause: error }));
     }
 }
-const createValidSVGString = (svg) => assets.try_({
+const createValidSVGString = (svg) => Effect.try_({
     try: () => SVGString(svg),
     catch: error => new BrandValidationError(error, 'SVGString'),
 });
@@ -822,10 +618,10 @@ function isValidSVG(svg) {
 const emptyDefaultSvg = () => SVGString(`<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg"></svg>`);
 const createIconCache = () => make({
     capacity: 200,
-    timeToLive: assets.infinity,
-    lookup: (key) => assets.gen(function* () {
+    timeToLive: Effect.infinity,
+    lookup: (key) => Effect.gen$1(function* () {
         const name = key;
-        const assetPath = yield* assets.syncCreateAssetUrlSafely(`${name}.svg`, 'icons');
+        const assetPath = assets.createAssetUrlSafely(`${name}.svg`, 'icons');
         const res = yield* httpClient(assetPath);
         const responseString = yield* responseAsText(res);
         return yield* createValidSVGString(responseString);
@@ -834,7 +630,7 @@ const createIconCache = () => make({
 let cacheInstance = null;
 function fetchIconSvg(name) {
     const key = name;
-    return assets.gen(function* () {
+    return Effect.gen$1(function* () {
         if (!cacheInstance) {
             cacheInstance = yield* createIconCache();
         }
@@ -842,12 +638,12 @@ function fetchIconSvg(name) {
     });
 }
 function clearIconCache() {
-    return assets.gen(function* () {
+    return Effect.gen$1(function* () {
         if (cacheInstance) {
             yield* cacheInstance.invalidateAll;
         }
         else {
-            assets.logWarning('Attempted to clear icon cache before it was initialized');
+            Effect.logWarning('Attempted to clear icon cache before it was initialized');
         }
     });
 }