@lmvz-ds/components 0.12.4 → 0.12.5-alpha.1

package/dist/esm/icons-BITzEzmq.js

@@ -0,0 +1,1032 @@
+import { bs as getOrThrowWith, aO as right, aN as left, a9 as identity, bt as isRight, bu as getRight, b5 as match$1, z as deferredMake, Q as deferredAwait, N as deferredSucceed, bv as deferredFailCause, W as deferredUnsafeMake, bw as deferredInterrupt, bx as deferredDone, by as deferredIsDone, bz as exitIsFailure, bA as exitIsSuccess, bB as exitMatch, bC as exitFailCause, bD as exitSucceed, bE as exitFail, bF as exitZipRight, bG as exitCollectAll, bH as exitVoid, bI as exitDie, bJ as exitMap, bK as exitZip, w as dual, A as pipeArguments, bL as NodeInspectSymbol, bM as toJSON, bN as format, $ as prepend, a4 as empty$1, bO as reverse, bP as decode, x as map$1, bQ as all$1, bR as context, a6 as fiberId, bS as merge, v as sync, bT as size, B as suspend, bU as get, R as succeed$2, G as none, bV as has, at as isSome, H as some, bW as getOrUndefined, bX as set, bY as struct, t as flatMap, bZ as remove$1, b_ as empty$2, b$ as clockWith, c0 as compareAndSet, K as set$1, y as make$4, c1 as symbol, s as pipe, c2 as cached, c3 as combine, c4 as hash, c5 as symbol$1, a7 as hasProperty, b8 as equals, L as asVoid, c6 as when, c7 as toMillis, X as onInterrupt, O as zipRight$1, c8 as exit, c9 as provideContext, ca as TaggedError, aU as gen, cb as tryPromise, cc as try_, cd as logWarning, ce as infinity, cf as syncCreateAssetUrlSafely } from './assets-K2FHD9qn.js';
+
+/**
+ * This module provides types and utility functions to create and work with branded types,
+ * which are TypeScript types with an added type tag to prevent accidental usage of a value in the wrong context.
+ *
+ * The `refined` and `nominal` functions are both used to create branded types in TypeScript.
+ * The main difference between them is that `refined` allows for validation of the data, while `nominal` does not.
+ *
+ * The `nominal` function is used to create a new branded type that has the same underlying type as the input, but with a different name.
+ * This is useful when you want to distinguish between two values of the same type that have different meanings.
+ * The `nominal` function does not perform any validation of the input data.
+ *
+ * On the other hand, the `refined` function is used to create a new branded type that has the same underlying type as the input,
+ * but with a different name, and it also allows for validation of the input data.
+ * The `refined` function takes a predicate that is used to validate the input data.
+ * If the input data fails the validation, a `BrandErrors` is returned, which provides information about the specific validation failure.
+ *
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const RefinedConstructorsTypeId = /*#__PURE__*/Symbol.for("effect/Brand/Refined");
+/**
+ * Returns a `BrandErrors` that contains a single `RefinementError`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const error = (message, meta) => [{
+  message,
+  meta
+}];
+function refined(...args) {
+  const either = args.length === 2 ? unbranded => args[0](unbranded) ? right(unbranded) : left(args[1](unbranded)) : unbranded => {
+    return match$1(args[0](unbranded), {
+      onNone: () => right(unbranded),
+      onSome: left
+    });
+  };
+  return Object.assign(unbranded => getOrThrowWith(either(unbranded), identity), {
+    [RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
+    option: args => getRight(either(args)),
+    either,
+    is: args => isRight(either(args))
+  });
+}
+
+/**
+ * Creates a new `Deferred`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const make$3 = deferredMake;
+const _await = 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 = deferredDone;
+/**
+ * Fails the `Deferred` with the specified `Cause`, which will be propagated to
+ * all fibers waiting on the value of the `Deferred`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const failCause$1 = deferredFailCause;
+/**
+ * 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 = deferredInterrupt;
+/**
+ * Returns `true` if this `Deferred` has already been completed with a value or
+ * an error, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isDone = deferredIsDone;
+/**
+ * Completes the `Deferred` with the specified value.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const succeed$1 = deferredSucceed;
+/**
+ * Unsafely creates a new `Deferred` from the specified `FiberId`.
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+const unsafeMake = deferredUnsafeMake;
+
+/**
+ * Returns `true` if the specified `Exit` is a `Failure`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isFailure = exitIsFailure;
+/**
+ * Returns `true` if the specified `Exit` is a `Success`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isSuccess = exitIsSuccess;
+/**
+ * Collects all of the specified exit values into a `Some<Exit<List<A>, E>>`. If
+ * the provided iterable contains no elements, `None` will be returned.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const all = exitCollectAll;
+/**
+ * Constructs a new `Exit.Failure` from the specified unrecoverable defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const die = exitDie;
+/**
+ * Constructs a new `Exit.Failure` from the specified recoverable error of type
+ * `E`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = exitFail;
+/**
+ * Constructs a new `Exit.Failure` from the specified `Cause` of type `E`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCause = exitFailCause;
+/**
+ * Maps over the `Success` value of the specified exit using the provided
+ * function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = exitMap;
+/**
+ * @since 2.0.0
+ * @category folding
+ */
+const match = exitMatch;
+/**
+ * Constructs a new `Exit.Success` containing the specified value of type `A`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = exitSucceed;
+const void_ = exitVoid;
+/**
+ * Sequentially zips the this result with the specified result or else returns
+ * the failed `Cause<E | E2>`.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zip = exitZip;
+/**
+ * Sequentially zips the this result with the specified result discarding the
+ * first element of the tuple or else returns the failed `Cause<E | E2>`.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipRight = exitZipRight;
+
+/**
+ * @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 format(this.toJSON());
+  },
+  toJSON() {
+    return {
+      _id: "MutableList",
+      values: Array.from(this).map(toJSON)
+    };
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  pipe() {
+    return 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$1 = self => length$1(self) === 0;
+/**
+ * Returns the length of the list.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const length$1 = self => self._length;
+/**
+ * Appends the specified element to the end of the `MutableList`.
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+const append = /*#__PURE__*/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 format(this.toJSON());
+  },
+  toJSON() {
+    return {
+      _id: "MutableQueue",
+      values: Array.from(this).map(toJSON)
+    };
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+const make$2 = capacity => {
+  const queue = Object.create(MutableQueueProto);
+  queue.queue = empty();
+  queue.capacity = capacity;
+  return queue;
+};
+/**
+ * Creates a new bounded `MutableQueue`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const bounded = capacity => make$2(capacity);
+/**
+ * Creates a new unbounded `MutableQueue`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unbounded = () => make$2(undefined);
+/**
+ * Returns the current number of elements in the queue.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const length = self => length$1(self.queue);
+/**
+ * Returns `true` if the queue is empty, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isEmpty = self => isEmpty$1(self.queue);
+/**
+ * The **maximum** number of elements that a queue can hold.
+ *
+ * **Note**: unbounded queues can still implement this interface with
+ * `capacity = Infinity`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const capacity = self => self.capacity === undefined ? Infinity : self.capacity;
+/**
+ * Offers an element to the queue.
+ *
+ * Returns whether the enqueue was successful or not.
+ *
+ * @since 2.0.0
+ */
+const offer = /*#__PURE__*/dual(2, (self, value) => {
+  const queueLength = length$1(self.queue);
+  if (self.capacity !== undefined && queueLength === self.capacity) {
+    return false;
+  }
+  append(value)(self.queue);
+  return true;
+});
+/**
+ * Enqueues a collection of values into the queue.
+ *
+ * Returns a `Chunk` of the values that were **not** able to be enqueued.
+ *
+ * @since 2.0.0
+ */
+const offerAll = /*#__PURE__*/dual(2, (self, values) => {
+  const iterator = values[Symbol.iterator]();
+  let next;
+  let remainder = empty$1();
+  let offering = true;
+  while (offering && (next = iterator.next()) && !next.done) {
+    offering = offer(next.value)(self);
+  }
+  while (next != null && !next.done) {
+    remainder = prepend(next.value)(remainder);
+    next = iterator.next();
+  }
+  return reverse(remainder);
+});
+/**
+ * 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__*/dual(2, (self, def) => {
+  if (isEmpty$1(self.queue)) {
+    return def;
+  }
+  return shift(self.queue);
+});
+/**
+ * Dequeues up to `n` elements from the queue.
+ *
+ * Returns a `List` of up to `n` elements.
+ *
+ * @since 2.0.0
+ */
+const pollUpTo = /*#__PURE__*/dual(2, (self, n) => {
+  let result = empty$1();
+  let count = 0;
+  while (count < n) {
+    const element = poll(EmptyMutableQueue)(self);
+    if (element === EmptyMutableQueue) {
+      break;
+    }
+    result = prepend(element)(result);
+    count += 1;
+  }
+  return reverse(result);
+});
+
+/** @internal */
+const complete = (key, exit, entryStats, timeToLiveMillis) => struct({
+  _tag: "Complete",
+  key,
+  exit,
+  entryStats,
+  timeToLiveMillis
+});
+/** @internal */
+const pending = (key, deferred) => struct({
+  _tag: "Pending",
+  key,
+  deferred
+});
+/** @internal */
+const refreshing = (deferred, complete) => struct({
+  _tag: "Refreshing",
+  deferred,
+  complete
+});
+/** @internal */
+const MapKeyTypeId = /*#__PURE__*/Symbol.for("effect/Cache/MapKey");
+class MapKeyImpl {
+  current;
+  [MapKeyTypeId] = MapKeyTypeId;
+  previous = undefined;
+  next = undefined;
+  constructor(current) {
+    this.current = current;
+  }
+  [symbol]() {
+    return pipe(hash(this.current), combine(hash(this.previous)), combine(hash(this.next)), cached(this));
+  }
+  [symbol$1](that) {
+    if (this === that) {
+      return true;
+    }
+    return isMapKey(that) && equals(this.current, that.current) && equals(this.previous, that.previous) && equals(this.next, that.next);
+  }
+}
+/** @internal */
+const makeMapKey = current => new MapKeyImpl(current);
+/** @internal */
+const isMapKey = u => hasProperty(u, MapKeyTypeId);
+class KeySetImpl {
+  head = undefined;
+  tail = undefined;
+  add(key) {
+    if (key !== this.tail) {
+      if (this.tail === undefined) {
+        this.head = key;
+        this.tail = key;
+      } else {
+        const previous = key.previous;
+        const next = key.next;
+        if (next !== undefined) {
+          key.next = undefined;
+          if (previous !== undefined) {
+            previous.next = next;
+            next.previous = previous;
+          } else {
+            this.head = next;
+            this.head.previous = undefined;
+          }
+        }
+        this.tail.next = key;
+        key.previous = this.tail;
+        this.tail = key;
+      }
+    }
+  }
+  remove() {
+    const key = this.head;
+    if (key !== undefined) {
+      const next = key.next;
+      if (next !== undefined) {
+        key.next = undefined;
+        this.head = next;
+        this.head.previous = undefined;
+      } else {
+        this.head = undefined;
+        this.tail = undefined;
+      }
+    }
+    return key;
+  }
+}
+/** @internal */
+const makeKeySet = () => new KeySetImpl();
+/**
+ * Constructs a new `CacheState` from the specified values.
+ *
+ * @internal
+ */
+const makeCacheState = (map, keys, accesses, updating, hits, misses) => ({
+  map,
+  keys,
+  accesses,
+  updating,
+  hits,
+  misses
+});
+/**
+ * Constructs an initial cache state.
+ *
+ * @internal
+ */
+const initialCacheState = () => makeCacheState(empty$2(), makeKeySet(), unbounded(), make$4(false), 0, 0);
+/** @internal */
+const CacheSymbolKey = "effect/Cache";
+/** @internal */
+const CacheTypeId = /*#__PURE__*/Symbol.for(CacheSymbolKey);
+const cacheVariance = {
+  /* c8 ignore next */
+  _Key: _ => _,
+  /* c8 ignore next */
+  _Error: _ => _,
+  /* c8 ignore next */
+  _Value: _ => _
+};
+/** @internal */
+const ConsumerCacheSymbolKey = "effect/ConsumerCache";
+/** @internal */
+const ConsumerCacheTypeId = /*#__PURE__*/Symbol.for(ConsumerCacheSymbolKey);
+const consumerCacheVariance = {
+  /* c8 ignore next */
+  _Key: _ => _,
+  /* c8 ignore next */
+  _Error: _ => _,
+  /* c8 ignore next */
+  _Value: _ => _
+};
+/** @internal */
+const makeCacheStats = options => options;
+/** @internal */
+const makeEntryStats = loadedMillis => ({
+  loadedMillis
+});
+class CacheImpl {
+  capacity;
+  context;
+  fiberId;
+  lookup;
+  timeToLive;
+  [CacheTypeId] = cacheVariance;
+  [ConsumerCacheTypeId] = consumerCacheVariance;
+  cacheState;
+  constructor(capacity, context, fiberId, lookup, timeToLive) {
+    this.capacity = capacity;
+    this.context = context;
+    this.fiberId = fiberId;
+    this.lookup = lookup;
+    this.timeToLive = timeToLive;
+    this.cacheState = initialCacheState();
+  }
+  get(key) {
+    return map$1(this.getEither(key), merge);
+  }
+  get cacheStats() {
+    return sync(() => makeCacheStats({
+      hits: this.cacheState.hits,
+      misses: this.cacheState.misses,
+      size: size(this.cacheState.map)
+    }));
+  }
+  getOption(key) {
+    return suspend(() => match$1(get(this.cacheState.map, key), {
+      onNone: () => {
+        const mapKey = makeMapKey(key);
+        this.trackAccess(mapKey);
+        this.trackMiss();
+        return succeed$2(none());
+      },
+      onSome: value => this.resolveMapValue(value)
+    }));
+  }
+  getOptionComplete(key) {
+    return suspend(() => match$1(get(this.cacheState.map, key), {
+      onNone: () => {
+        const mapKey = makeMapKey(key);
+        this.trackAccess(mapKey);
+        this.trackMiss();
+        return succeed$2(none());
+      },
+      onSome: value => this.resolveMapValue(value, true)
+    }));
+  }
+  contains(key) {
+    return sync(() => has(this.cacheState.map, key));
+  }
+  entryStats(key) {
+    return sync(() => {
+      const option = get(this.cacheState.map, key);
+      if (isSome(option)) {
+        switch (option.value._tag) {
+          case "Complete":
+            {
+              const loaded = option.value.entryStats.loadedMillis;
+              return some(makeEntryStats(loaded));
+            }
+          case "Pending":
+            {
+              return none();
+            }
+          case "Refreshing":
+            {
+              const loaded = option.value.complete.entryStats.loadedMillis;
+              return some(makeEntryStats(loaded));
+            }
+        }
+      }
+      return none();
+    });
+  }
+  getEither(key) {
+    return suspend(() => {
+      const k = key;
+      let mapKey = undefined;
+      let deferred = undefined;
+      let value = getOrUndefined(get(this.cacheState.map, k));
+      if (value === undefined) {
+        deferred = unsafeMake(this.fiberId);
+        mapKey = makeMapKey(k);
+        if (has(this.cacheState.map, k)) {
+          value = getOrUndefined(get(this.cacheState.map, k));
+        } else {
+          set(this.cacheState.map, k, pending(mapKey, deferred));
+        }
+      }
+      if (value === undefined) {
+        this.trackAccess(mapKey);
+        this.trackMiss();
+        return map$1(this.lookupValueOf(key, deferred), right);
+      } else {
+        return flatMap(this.resolveMapValue(value), match$1({
+          onNone: () => this.getEither(key),
+          onSome: value => succeed$2(left(value))
+        }));
+      }
+    });
+  }
+  invalidate(key) {
+    return sync(() => {
+      remove$1(this.cacheState.map, key);
+    });
+  }
+  invalidateWhen(key, when) {
+    return sync(() => {
+      const value = get(this.cacheState.map, key);
+      if (isSome(value) && value.value._tag === "Complete") {
+        if (value.value.exit._tag === "Success") {
+          if (when(value.value.exit.value)) {
+            remove$1(this.cacheState.map, key);
+          }
+        }
+      }
+    });
+  }
+  get invalidateAll() {
+    return sync(() => {
+      this.cacheState.map = empty$2();
+    });
+  }
+  refresh(key) {
+    return clockWith(clock => suspend(() => {
+      const k = key;
+      const deferred = unsafeMake(this.fiberId);
+      let value = getOrUndefined(get(this.cacheState.map, k));
+      if (value === undefined) {
+        if (has(this.cacheState.map, k)) {
+          value = getOrUndefined(get(this.cacheState.map, k));
+        } else {
+          set(this.cacheState.map, k, pending(makeMapKey(k), deferred));
+        }
+      }
+      if (value === undefined) {
+        return asVoid(this.lookupValueOf(key, deferred));
+      } else {
+        switch (value._tag) {
+          case "Complete":
+            {
+              if (this.hasExpired(clock, value.timeToLiveMillis)) {
+                const found = getOrUndefined(get(this.cacheState.map, k));
+                if (equals(found, value)) {
+                  remove$1(this.cacheState.map, k);
+                }
+                return asVoid(this.get(key));
+              }
+              // Only trigger the lookup if we're still the current value, `completedResult`
+              return pipe(this.lookupValueOf(key, deferred), when(() => {
+                const current = getOrUndefined(get(this.cacheState.map, k));
+                if (equals(current, value)) {
+                  const mapValue = refreshing(deferred, value);
+                  set(this.cacheState.map, k, mapValue);
+                  return true;
+                }
+                return false;
+              }), asVoid);
+            }
+          case "Pending":
+            {
+              return _await(value.deferred);
+            }
+          case "Refreshing":
+            {
+              return _await(value.deferred);
+            }
+        }
+      }
+    }));
+  }
+  set(key, value) {
+    return clockWith(clock => sync(() => {
+      const now = clock.unsafeCurrentTimeMillis();
+      const k = key;
+      const lookupResult = succeed(value);
+      const mapValue = complete(makeMapKey(k), lookupResult, makeEntryStats(now), now + toMillis(decode(this.timeToLive(lookupResult))));
+      set(this.cacheState.map, k, mapValue);
+    }));
+  }
+  get size() {
+    return sync(() => {
+      return size(this.cacheState.map);
+    });
+  }
+  get values() {
+    return sync(() => {
+      const values = [];
+      for (const entry of this.cacheState.map) {
+        if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
+          values.push(entry[1].exit.value);
+        }
+      }
+      return values;
+    });
+  }
+  get entries() {
+    return sync(() => {
+      const values = [];
+      for (const entry of this.cacheState.map) {
+        if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
+          values.push([entry[0], entry[1].exit.value]);
+        }
+      }
+      return values;
+    });
+  }
+  get keys() {
+    return sync(() => {
+      const keys = [];
+      for (const entry of this.cacheState.map) {
+        if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
+          keys.push(entry[0]);
+        }
+      }
+      return keys;
+    });
+  }
+  resolveMapValue(value, ignorePending = false) {
+    return clockWith(clock => {
+      switch (value._tag) {
+        case "Complete":
+          {
+            this.trackAccess(value.key);
+            if (this.hasExpired(clock, value.timeToLiveMillis)) {
+              remove$1(this.cacheState.map, value.key.current);
+              return succeed$2(none());
+            }
+            this.trackHit();
+            return map$1(value.exit, some);
+          }
+        case "Pending":
+          {
+            this.trackAccess(value.key);
+            this.trackHit();
+            if (ignorePending) {
+              return succeed$2(none());
+            }
+            return map$1(_await(value.deferred), some);
+          }
+        case "Refreshing":
+          {
+            this.trackAccess(value.complete.key);
+            this.trackHit();
+            if (this.hasExpired(clock, value.complete.timeToLiveMillis)) {
+              if (ignorePending) {
+                return succeed$2(none());
+              }
+              return map$1(_await(value.deferred), some);
+            }
+            return map$1(value.complete.exit, some);
+          }
+      }
+    });
+  }
+  trackHit() {
+    this.cacheState.hits = this.cacheState.hits + 1;
+  }
+  trackMiss() {
+    this.cacheState.misses = this.cacheState.misses + 1;
+  }
+  trackAccess(key) {
+    offer(this.cacheState.accesses, key);
+    if (compareAndSet(this.cacheState.updating, false, true)) {
+      let loop = true;
+      while (loop) {
+        const key = poll(this.cacheState.accesses, EmptyMutableQueue);
+        if (key === EmptyMutableQueue) {
+          loop = false;
+        } else {
+          this.cacheState.keys.add(key);
+        }
+      }
+      let size$1 = size(this.cacheState.map);
+      loop = size$1 > this.capacity;
+      while (loop) {
+        const key = this.cacheState.keys.remove();
+        if (key !== undefined) {
+          if (has(this.cacheState.map, key.current)) {
+            remove$1(this.cacheState.map, key.current);
+            size$1 = size$1 - 1;
+            loop = size$1 > this.capacity;
+          }
+        } else {
+          loop = false;
+        }
+      }
+      set$1(this.cacheState.updating, false);
+    }
+  }
+  hasExpired(clock, timeToLiveMillis) {
+    return clock.unsafeCurrentTimeMillis() > timeToLiveMillis;
+  }
+  lookupValueOf(input, deferred) {
+    return clockWith(clock => suspend(() => {
+      const key = input;
+      return pipe(this.lookup(input), provideContext(this.context), exit, flatMap(exit => {
+        const now = clock.unsafeCurrentTimeMillis();
+        const stats = makeEntryStats(now);
+        const value = complete(makeMapKey(key), exit, stats, now + toMillis(decode(this.timeToLive(exit))));
+        set(this.cacheState.map, key, value);
+        return zipRight$1(done(deferred, exit), exit);
+      }), onInterrupt(() => zipRight$1(interrupt(deferred), sync(() => {
+        remove$1(this.cacheState.map, key);
+      }))));
+    }));
+  }
+}
+/** @internal */
+const make$1 = options => {
+  const timeToLive = decode(options.timeToLive);
+  return makeWith({
+    capacity: options.capacity,
+    lookup: options.lookup,
+    timeToLive: () => timeToLive
+  });
+};
+/** @internal */
+const makeWith = options => map$1(all$1([context(), fiberId]), ([context, fiberId]) => new CacheImpl(options.capacity, context, fiberId, options.lookup, exit => decode(options.timeToLive(exit))));
+
+/**
+ * Constructs a new cache with the specified capacity, time to live, and
+ * lookup function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const make = make$1;
+
+class FetchError extends TaggedError('FetchError') {
+}
+class NotFoundError extends TaggedError('NotFoundError') {
+}
+const httpClient = (input, init) => gen(function* () {
+    const response = yield* tryPromise({
+        try: () => fetch(input, init),
+        catch: error => new FetchError({ cause: error }),
+    });
+    if (response.status === 404) {
+        return yield* new NotFoundError({ url: response.url });
+    }
+    return response;
+});
+class ResponseTextError extends TaggedError('ResponseTextError') {
+    constructor(error) {
+        super(new Error(`Failed to read response text`, { cause: error }));
+    }
+}
+const responseAsText = (res) => tryPromise({
+    try: () => res.text(),
+    catch: error => new ResponseTextError(error),
+});
+
+const SVGString = refined(isValidSVG, () => error('SVG data is malformed'));
+class BrandValidationError extends TaggedError('BrandValidationError') {
+    constructor(error, type) {
+        super(new Error(`Brand validation failed for type ${type}.`, { cause: error }));
+    }
+}
+const createValidSVGString = (svg) => try_({
+    try: () => SVGString(svg),
+    catch: error => new BrandValidationError(error, 'SVGString'),
+});
+function isValidSVG(svg) {
+    if (typeof svg !== 'string') {
+        return false;
+    }
+    try {
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(svg, 'image/svg+xml');
+        return doc.documentElement.nodeName === 'svg';
+    }
+    catch {
+        return false;
+    }
+}
+
+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: infinity,
+    lookup: (key) => gen(function* () {
+        const name = key;
+        const assetPath = yield* syncCreateAssetUrlSafely(`${name}.svg`, 'icons');
+        const res = yield* httpClient(assetPath);
+        const responseString = yield* responseAsText(res);
+        return yield* createValidSVGString(responseString);
+    }),
+});
+let cacheInstance = null;
+function fetchIconSvg(name) {
+    const key = name;
+    return gen(function* () {
+        if (!cacheInstance) {
+            cacheInstance = yield* createIconCache();
+        }
+        return yield* cacheInstance.get(key);
+    });
+}
+function clearIconCache() {
+    return gen(function* () {
+        if (cacheInstance) {
+            yield* cacheInstance.invalidateAll;
+        }
+        else {
+            logWarning('Attempted to clear icon cache before it was initialized');
+        }
+    });
+}
+
+export { fetchIconSvg as A, emptyDefaultSvg as B, EmptyMutableQueue as E, _await as _, pollUpTo as a, offerAll as b, clearIconCache as c, bounded as d, capacity as e, isFailure as f, failCause as g, all as h, isEmpty as i, die as j, map as k, length as l, match as m, make$3 as n, offer as o, poll as p, isDone as q, succeed$1 as r, succeed as s, failCause$1 as t, unbounded as u, void_ as v, fail as w, zip as x, isSuccess as y, zipRight as z };
+//# sourceMappingURL=icons-BITzEzmq.js.map
+
+//# sourceMappingURL=icons-BITzEzmq.js.map