@lmvz-ds/components 0.12.5 → 0.13.0

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

@@ -1,8 +1,6 @@
 'use strict';
 
-var Effect = require('./Effect-CNhHt4Xb.js');
-var MutableQueue = require('./MutableQueue-Bk9tBfaK.js');
-var assets = require('./assets-BguFB3wV.js');
+var assets = require('./assets-CB5ikzmP.js');
 
 /**
  * This module provides types and utility functions to create and work with branded types,
@@ -38,22 +36,274 @@ const error = (message, meta) => [{
   meta
 }];
 function refined(...args) {
-  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
+  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
     });
   };
-  return Object.assign(unbranded => Effect.getOrThrowWith(either(unbranded), Effect.identity), {
+  return Object.assign(unbranded => assets.getOrThrowWith(either(unbranded), assets.identity), {
     [RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
-    option: args => Effect.getRight(either(args)),
+    option: args => assets.getRight(either(args)),
     either,
-    is: args => Effect.isRight(either(args))
+    is: args => assets.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) => Effect.struct({
+const complete = (key, exit, entryStats, timeToLiveMillis) => assets.struct({
   _tag: "Complete",
   key,
   exit,
@@ -61,13 +311,13 @@ const complete = (key, exit, entryStats, timeToLiveMillis) => Effect.struct({
   timeToLiveMillis
 });
 /** @internal */
-const pending = (key, deferred) => Effect.struct({
+const pending = (key, deferred) => assets.struct({
   _tag: "Pending",
   key,
   deferred
 });
 /** @internal */
-const refreshing = (deferred, complete) => Effect.struct({
+const refreshing = (deferred, complete) => assets.struct({
   _tag: "Refreshing",
   deferred,
   complete
@@ -82,20 +332,20 @@ class MapKeyImpl {
   constructor(current) {
     this.current = current;
   }
-  [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]() {
+    return assets.pipe(assets.hash(this.current), assets.combine(assets.hash(this.previous)), assets.combine(assets.hash(this.next)), assets.cached(this));
   }
-  [Effect.symbol$1](that) {
+  [assets.symbol$1](that) {
     if (this === that) {
       return true;
     }
-    return isMapKey(that) && Effect.equals(this.current, that.current) && Effect.equals(this.previous, that.previous) && Effect.equals(this.next, that.next);
+    return isMapKey(that) && assets.equals(this.current, that.current) && assets.equals(this.previous, that.previous) && assets.equals(this.next, that.next);
   }
 }
 /** @internal */
 const makeMapKey = current => new MapKeyImpl(current);
 /** @internal */
-const isMapKey = u => Effect.hasProperty(u, MapKeyTypeId);
+const isMapKey = u => assets.hasProperty(u, MapKeyTypeId);
 class KeySetImpl {
   head = undefined;
   tail = undefined;
@@ -159,7 +409,7 @@ const makeCacheState = (map, keys, accesses, updating, hits, misses) => ({
  *
  * @internal
  */
-const initialCacheState = () => makeCacheState(Effect.empty(), makeKeySet(), MutableQueue.unbounded(), Effect.make(false), 0, 0);
+const initialCacheState = () => makeCacheState(assets.empty(), makeKeySet(), unbounded(), assets.make(false), 0, 0);
 /** @internal */
 const CacheSymbolKey = "effect/Cache";
 /** @internal */
@@ -208,177 +458,177 @@ class CacheImpl {
     this.cacheState = initialCacheState();
   }
   get(key) {
-    return Effect.map(this.getEither(key), Effect.merge);
+    return assets.map(this.getEither(key), assets.merge);
   }
   get cacheStats() {
-    return Effect.sync(() => makeCacheStats({
+    return assets.sync(() => makeCacheStats({
       hits: this.cacheState.hits,
       misses: this.cacheState.misses,
-      size: Effect.size(this.cacheState.map)
+      size: assets.size(this.cacheState.map)
     }));
   }
   getOption(key) {
-    return Effect.suspend(() => Effect.match(Effect.get(this.cacheState.map, key), {
+    return assets.suspend(() => assets.match(assets.get(this.cacheState.map, key), {
       onNone: () => {
         const mapKey = makeMapKey(key);
         this.trackAccess(mapKey);
         this.trackMiss();
-        return Effect.succeed$1(Effect.none());
+        return assets.succeed$1(assets.none());
       },
       onSome: value => this.resolveMapValue(value)
     }));
   }
   getOptionComplete(key) {
-    return Effect.suspend(() => Effect.match(Effect.get(this.cacheState.map, key), {
+    return assets.suspend(() => assets.match(assets.get(this.cacheState.map, key), {
       onNone: () => {
         const mapKey = makeMapKey(key);
         this.trackAccess(mapKey);
         this.trackMiss();
-        return Effect.succeed$1(Effect.none());
+        return assets.succeed$1(assets.none());
       },
       onSome: value => this.resolveMapValue(value, true)
     }));
   }
   contains(key) {
-    return Effect.sync(() => Effect.has(this.cacheState.map, key));
+    return assets.sync(() => assets.has(this.cacheState.map, key));
   }
   entryStats(key) {
-    return Effect.sync(() => {
-      const option = Effect.get(this.cacheState.map, key);
-      if (Effect.isSome(option)) {
+    return assets.sync(() => {
+      const option = assets.get(this.cacheState.map, key);
+      if (assets.isSome(option)) {
         switch (option.value._tag) {
           case "Complete":
             {
               const loaded = option.value.entryStats.loadedMillis;
-              return Effect.some(makeEntryStats(loaded));
+              return assets.some(makeEntryStats(loaded));
             }
           case "Pending":
             {
-              return Effect.none();
+              return assets.none();
             }
           case "Refreshing":
             {
               const loaded = option.value.complete.entryStats.loadedMillis;
-              return Effect.some(makeEntryStats(loaded));
+              return assets.some(makeEntryStats(loaded));
             }
         }
       }
-      return Effect.none();
+      return assets.none();
     });
   }
   getEither(key) {
-    return Effect.suspend(() => {
+    return assets.suspend(() => {
       const k = key;
       let mapKey = undefined;
       let deferred = undefined;
-      let value = Effect.getOrUndefined(Effect.get(this.cacheState.map, k));
+      let value = assets.getOrUndefined(assets.get(this.cacheState.map, k));
       if (value === undefined) {
-        deferred = MutableQueue.unsafeMake(this.fiberId);
+        deferred = unsafeMake(this.fiberId);
         mapKey = makeMapKey(k);
-        if (Effect.has(this.cacheState.map, k)) {
-          value = Effect.getOrUndefined(Effect.get(this.cacheState.map, k));
+        if (assets.has(this.cacheState.map, k)) {
+          value = assets.getOrUndefined(assets.get(this.cacheState.map, k));
         } else {
-          Effect.set(this.cacheState.map, k, pending(mapKey, deferred));
+          assets.set(this.cacheState.map, k, pending(mapKey, deferred));
         }
       }
       if (value === undefined) {
         this.trackAccess(mapKey);
         this.trackMiss();
-        return Effect.map(this.lookupValueOf(key, deferred), Effect.right);
+        return assets.map(this.lookupValueOf(key, deferred), assets.right);
       } else {
-        return Effect.flatMap(this.resolveMapValue(value), Effect.match({
+        return assets.flatMap(this.resolveMapValue(value), assets.match({
           onNone: () => this.getEither(key),
-          onSome: value => Effect.succeed$1(Effect.left(value))
+          onSome: value => assets.succeed$1(assets.left(value))
         }));
       }
     });
   }
   invalidate(key) {
-    return Effect.sync(() => {
-      Effect.remove(this.cacheState.map, key);
+    return assets.sync(() => {
+      assets.remove(this.cacheState.map, key);
     });
   }
   invalidateWhen(key, when) {
-    return Effect.sync(() => {
-      const value = Effect.get(this.cacheState.map, key);
-      if (Effect.isSome(value) && value.value._tag === "Complete") {
+    return assets.sync(() => {
+      const value = assets.get(this.cacheState.map, key);
+      if (assets.isSome(value) && value.value._tag === "Complete") {
         if (value.value.exit._tag === "Success") {
           if (when(value.value.exit.value)) {
-            Effect.remove(this.cacheState.map, key);
+            assets.remove(this.cacheState.map, key);
           }
         }
       }
     });
   }
   get invalidateAll() {
-    return Effect.sync(() => {
-      this.cacheState.map = Effect.empty();
+    return assets.sync(() => {
+      this.cacheState.map = assets.empty();
     });
   }
   refresh(key) {
-    return Effect.clockWith(clock => Effect.suspend(() => {
+    return assets.clockWith(clock => assets.suspend(() => {
       const k = key;
-      const deferred = MutableQueue.unsafeMake(this.fiberId);
-      let value = Effect.getOrUndefined(Effect.get(this.cacheState.map, k));
+      const deferred = unsafeMake(this.fiberId);
+      let value = assets.getOrUndefined(assets.get(this.cacheState.map, k));
       if (value === undefined) {
-        if (Effect.has(this.cacheState.map, k)) {
-          value = Effect.getOrUndefined(Effect.get(this.cacheState.map, k));
+        if (assets.has(this.cacheState.map, k)) {
+          value = assets.getOrUndefined(assets.get(this.cacheState.map, k));
         } else {
-          Effect.set(this.cacheState.map, k, pending(makeMapKey(k), deferred));
+          assets.set(this.cacheState.map, k, pending(makeMapKey(k), deferred));
         }
       }
       if (value === undefined) {
-        return Effect.asVoid(this.lookupValueOf(key, deferred));
+        return assets.asVoid(this.lookupValueOf(key, deferred));
       } else {
         switch (value._tag) {
           case "Complete":
             {
               if (this.hasExpired(clock, value.timeToLiveMillis)) {
-                const found = Effect.getOrUndefined(Effect.get(this.cacheState.map, k));
-                if (Effect.equals(found, value)) {
-                  Effect.remove(this.cacheState.map, k);
+                const found = assets.getOrUndefined(assets.get(this.cacheState.map, k));
+                if (assets.equals(found, value)) {
+                  assets.remove(this.cacheState.map, k);
                 }
-                return Effect.asVoid(this.get(key));
+                return assets.asVoid(this.get(key));
               }
               // Only trigger the lookup if we're still the current value, `completedResult`
-              return Effect.pipe(this.lookupValueOf(key, deferred), Effect.when(() => {
-                const current = Effect.getOrUndefined(Effect.get(this.cacheState.map, k));
-                if (Effect.equals(current, value)) {
+              return assets.pipe(this.lookupValueOf(key, deferred), assets.when(() => {
+                const current = assets.getOrUndefined(assets.get(this.cacheState.map, k));
+                if (assets.equals(current, value)) {
                   const mapValue = refreshing(deferred, value);
-                  Effect.set(this.cacheState.map, k, mapValue);
+                  assets.set(this.cacheState.map, k, mapValue);
                   return true;
                 }
                 return false;
-              }), Effect.asVoid);
+              }), assets.asVoid);
             }
           case "Pending":
             {
-              return MutableQueue._await(value.deferred);
+              return _await(value.deferred);
             }
           case "Refreshing":
             {
-              return MutableQueue._await(value.deferred);
+              return _await(value.deferred);
             }
         }
       }
     }));
   }
   set(key, value) {
-    return Effect.clockWith(clock => Effect.sync(() => {
+    return assets.clockWith(clock => assets.sync(() => {
       const now = clock.unsafeCurrentTimeMillis();
       const k = key;
-      const lookupResult = MutableQueue.succeed(value);
-      const mapValue = complete(makeMapKey(k), lookupResult, makeEntryStats(now), now + Effect.toMillis(Effect.decode(this.timeToLive(lookupResult))));
-      Effect.set(this.cacheState.map, k, mapValue);
+      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);
     }));
   }
   get size() {
-    return Effect.sync(() => {
-      return Effect.size(this.cacheState.map);
+    return assets.sync(() => {
+      return assets.size(this.cacheState.map);
     });
   }
   get values() {
-    return Effect.sync(() => {
+    return assets.sync(() => {
       const values = [];
       for (const entry of this.cacheState.map) {
         if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
@@ -389,7 +639,7 @@ class CacheImpl {
     });
   }
   get entries() {
-    return Effect.sync(() => {
+    return assets.sync(() => {
       const values = [];
       for (const entry of this.cacheState.map) {
         if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
@@ -400,7 +650,7 @@ class CacheImpl {
     });
   }
   get keys() {
-    return Effect.sync(() => {
+    return assets.sync(() => {
       const keys = [];
       for (const entry of this.cacheState.map) {
         if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
@@ -411,26 +661,26 @@ class CacheImpl {
     });
   }
   resolveMapValue(value, ignorePending = false) {
-    return Effect.clockWith(clock => {
+    return assets.clockWith(clock => {
       switch (value._tag) {
         case "Complete":
           {
             this.trackAccess(value.key);
             if (this.hasExpired(clock, value.timeToLiveMillis)) {
-              Effect.remove(this.cacheState.map, value.key.current);
-              return Effect.succeed$1(Effect.none());
+              assets.remove(this.cacheState.map, value.key.current);
+              return assets.succeed$1(assets.none());
             }
             this.trackHit();
-            return Effect.map(value.exit, Effect.some);
+            return assets.map(value.exit, assets.some);
           }
         case "Pending":
           {
             this.trackAccess(value.key);
             this.trackHit();
             if (ignorePending) {
-              return Effect.succeed$1(Effect.none());
+              return assets.succeed$1(assets.none());
             }
-            return Effect.map(MutableQueue._await(value.deferred), Effect.some);
+            return assets.map(_await(value.deferred), assets.some);
           }
         case "Refreshing":
           {
@@ -438,11 +688,11 @@ class CacheImpl {
             this.trackHit();
             if (this.hasExpired(clock, value.complete.timeToLiveMillis)) {
               if (ignorePending) {
-                return Effect.succeed$1(Effect.none());
+                return assets.succeed$1(assets.none());
               }
-              return Effect.map(MutableQueue._await(value.deferred), Effect.some);
+              return assets.map(_await(value.deferred), assets.some);
             }
-            return Effect.map(value.complete.exit, Effect.some);
+            return assets.map(value.complete.exit, assets.some);
           }
       }
     });
@@ -454,24 +704,24 @@ class CacheImpl {
     this.cacheState.misses = this.cacheState.misses + 1;
   }
   trackAccess(key) {
-    MutableQueue.offer(this.cacheState.accesses, key);
-    if (Effect.compareAndSet(this.cacheState.updating, false, true)) {
+    offer(this.cacheState.accesses, key);
+    if (assets.compareAndSet(this.cacheState.updating, false, true)) {
       let loop = true;
       while (loop) {
-        const key = MutableQueue.poll(this.cacheState.accesses, MutableQueue.EmptyMutableQueue);
-        if (key === MutableQueue.EmptyMutableQueue) {
+        const key = poll(this.cacheState.accesses, EmptyMutableQueue);
+        if (key === EmptyMutableQueue) {
           loop = false;
         } else {
           this.cacheState.keys.add(key);
         }
       }
-      let size = Effect.size(this.cacheState.map);
+      let size = assets.size(this.cacheState.map);
       loop = size > this.capacity;
       while (loop) {
         const key = this.cacheState.keys.remove();
         if (key !== undefined) {
-          if (Effect.has(this.cacheState.map, key.current)) {
-            Effect.remove(this.cacheState.map, key.current);
+          if (assets.has(this.cacheState.map, key.current)) {
+            assets.remove(this.cacheState.map, key.current);
             size = size - 1;
             loop = size > this.capacity;
           }
@@ -479,30 +729,30 @@ class CacheImpl {
           loop = false;
         }
       }
-      Effect.set$1(this.cacheState.updating, false);
+      assets.set$1(this.cacheState.updating, false);
     }
   }
   hasExpired(clock, timeToLiveMillis) {
     return clock.unsafeCurrentTimeMillis() > timeToLiveMillis;
   }
   lookupValueOf(input, deferred) {
-    return Effect.clockWith(clock => Effect.suspend(() => {
+    return assets.clockWith(clock => assets.suspend(() => {
       const key = input;
-      return Effect.pipe(this.lookup(input), Effect.provideContext(this.context), Effect.exit, Effect.flatMap(exit => {
+      return assets.pipe(this.lookup(input), assets.provideContext(this.context), assets.exit, assets.flatMap(exit => {
         const now = clock.unsafeCurrentTimeMillis();
         const stats = makeEntryStats(now);
-        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(MutableQueue.done(deferred, exit), exit);
-      }), Effect.onInterrupt(() => Effect.zipRight(MutableQueue.interrupt(deferred), Effect.sync(() => {
-        Effect.remove(this.cacheState.map, key);
+        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);
       }))));
     }));
   }
 }
 /** @internal */
 const make$1 = options => {
-  const timeToLive = Effect.decode(options.timeToLive);
+  const timeToLive = assets.decode(options.timeToLive);
   return makeWith({
     capacity: options.capacity,
     lookup: options.lookup,
@@ -510,7 +760,7 @@ const make$1 = options => {
   });
 };
 /** @internal */
-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))));
+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))));
 
 /**
  * Constructs a new cache with the specified capacity, time to live, and
@@ -525,8 +775,8 @@ class FetchError extends assets.TaggedError('FetchError') {
 }
 class NotFoundError extends assets.TaggedError('NotFoundError') {
 }
-const httpClient = (input, init) => Effect.gen(function* () {
-    const response = yield* Effect.tryPromise({
+const httpClient = (input, init) => assets.gen(function* () {
+    const response = yield* assets.tryPromise({
         try: () => fetch(input, init),
         catch: error => new FetchError({ cause: error }),
     });
@@ -540,7 +790,7 @@ class ResponseTextError extends assets.TaggedError('ResponseTextError') {
         super(new Error(`Failed to read response text`, { cause: error }));
     }
 }
-const responseAsText = (res) => Effect.tryPromise({
+const responseAsText = (res) => assets.tryPromise({
     try: () => res.text(),
     catch: error => new ResponseTextError(error),
 });
@@ -551,7 +801,7 @@ class BrandValidationError extends assets.TaggedError('BrandValidationError') {
         super(new Error(`Brand validation failed for type ${type}.`, { cause: error }));
     }
 }
-const createValidSVGString = (svg) => Effect.try_({
+const createValidSVGString = (svg) => assets.try_({
     try: () => SVGString(svg),
     catch: error => new BrandValidationError(error, 'SVGString'),
 });
@@ -572,8 +822,8 @@ 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: Effect.infinity,
-    lookup: (key) => Effect.gen(function* () {
+    timeToLive: assets.infinity,
+    lookup: (key) => assets.gen(function* () {
         const name = key;
         const assetPath = yield* assets.syncCreateAssetUrlSafely(`${name}.svg`, 'icons');
         const res = yield* httpClient(assetPath);
@@ -584,7 +834,7 @@ const createIconCache = () => make({
 let cacheInstance = null;
 function fetchIconSvg(name) {
     const key = name;
-    return Effect.gen(function* () {
+    return assets.gen(function* () {
         if (!cacheInstance) {
             cacheInstance = yield* createIconCache();
         }
@@ -592,12 +842,12 @@ function fetchIconSvg(name) {
     });
 }
 function clearIconCache() {
-    return Effect.gen(function* () {
+    return assets.gen(function* () {
         if (cacheInstance) {
             yield* cacheInstance.invalidateAll;
         }
         else {
-            Effect.logWarning('Attempted to clear icon cache before it was initialized');
+            assets.logWarning('Attempted to clear icon cache before it was initialized');
         }
     });
 }