@lmvz-ds/components 0.14.1 → 0.16.0

package/dist/esm/{Effect-DyamyJqO.js → icons-D1lxdRXP.js}

@@ -1,3 +1,118 @@
+import { c as createAssetUrlSafely } from './assets-BD98wsl7.js';
+
+/**
+ * Verify whether a value is a Promise by duck-testing for a 'then' function
+ */
+function isPromise(value) {
+    if (!value)
+        return false;
+    return typeof value === 'object' && typeof value.then === 'function';
+}
+
+/**
+ * Resolve the result of a function that may be async or not, as a Promise.
+ */
+function resolvePossiblyAsyncFunction(func, args = []) {
+    const res = func(...args);
+    if (isPromise(res)) {
+        return res;
+    }
+    return Promise.resolve(res);
+}
+
+const GLOBAL_STATE_KEY = Symbol('__lmvzAriaValidationRuntimeState');
+const ARIA_VALIDATION_RUNTIME_CHANGED_EVENT = 'lmvz:aria-validation-runtime-changed';
+function getRuntimeState() {
+    const globalState = globalThis;
+    if (!globalState[GLOBAL_STATE_KEY]) {
+        globalState[GLOBAL_STATE_KEY] = {
+            enabled: false,
+        };
+    }
+    return globalState[GLOBAL_STATE_KEY];
+}
+function notifyRuntimeChange() {
+    if (typeof window === 'undefined')
+        return;
+    window.dispatchEvent(new CustomEvent(ARIA_VALIDATION_RUNTIME_CHANGED_EVENT));
+}
+async function fetchRuntime() {
+    const state = getRuntimeState();
+    if (!state.enabled)
+        return null;
+    if (state.runtime)
+        return state.runtime;
+    if (!state.loadPromise) {
+        state.loadPromise = import('./index-DoNkkDv1.js').catch(() => null);
+    }
+    const runtime = await state.loadPromise;
+    if (runtime) {
+        state.runtime = runtime;
+    }
+    return runtime;
+}
+async function initializeValidation(...args) {
+    const runtime = await fetchRuntime();
+    const s = getRuntimeState();
+    if (!s.enabled)
+        return;
+    if (!runtime) {
+        console.warn('Failed to load aria validation runtime');
+        return;
+    }
+    runtime.initializeValidationStream(...args);
+}
+const isAriaValidationEnabled = () => getRuntimeState().enabled;
+const useVerboseLogging = () => getRuntimeState().verboseLogging ?? false;
+const enableAriaValidation = (options = {}) => {
+    const state = getRuntimeState();
+    if (state.enabled)
+        return;
+    Object.assign(state, options);
+    state.enabled = true;
+    initializeValidation().then(() => {
+        notifyRuntimeChange();
+    });
+};
+const disableAriaValidation = () => {
+    const state = getRuntimeState();
+    if (!state.enabled)
+        return;
+    state.enabled = false;
+    notifyRuntimeChange();
+};
+function queueValidation(...args) {
+    const { enabled, runtime, loadPromise, lazyCondition } = getRuntimeState();
+    if (!enabled)
+        return;
+    if (!lazyCondition)
+        return q();
+    resolvePossiblyAsyncFunction(lazyCondition).then((shouldEnqueue) => {
+        if (!shouldEnqueue)
+            return;
+        q();
+    });
+    function q() {
+        if (runtime)
+            return runtime.enqueueValidation(...args);
+        if (!loadPromise) {
+            console.warn('neither runtime nor load promise found for aria validation. This should not happen, as enabling aria validation should have triggered the loading of the runtime.');
+            return;
+        }
+        loadPromise
+            .then((loadedRuntime) => {
+            if (!loadedRuntime?.enqueueValidation) {
+                console.error('Failed to load aria validation runtime');
+                return;
+            }
+            loadedRuntime.enqueueValidation(...args);
+        })
+            .catch(() => {
+            console.error('Failed to enqueue validation due to an error while loading the runtime');
+        });
+    }
+}
+
 /**
  * Tests if a value is a `function`.
  *
@@ -273,19 +388,19 @@ function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
  * @category constructors
  * @since 2.0.0
  */
-const make$u = isEquivalent => (self, that) => self === that || isEquivalent(self, that);
+const make$w = isEquivalent => (self, that) => self === that || isEquivalent(self, that);
 /**
  * @category mapping
  * @since 2.0.0
  */
-const mapInput$1 = /*#__PURE__*/dual(2, (self, f) => make$u((x, y) => self(f(x), f(y))));
+const mapInput$1 = /*#__PURE__*/dual(2, (self, f) => make$w((x, y) => self(f(x), f(y))));
 /**
  * Creates a new `Equivalence` for an array of values based on a given `Equivalence` for the elements of the array.
  *
  * @category combinators
  * @since 2.0.0
  */
-const array$1 = item => make$u((self, that) => {
+const array$1 = item => make$w((self, that) => {
   if (self.length !== that.length) {
     return false;
   }
@@ -1030,10 +1145,13 @@ function compareBoth(self, that) {
       }
     }
     if (structuralRegionState.enabled) {
+      if (self === null || that === null) {
+        return false;
+      }
       if (Array.isArray(self) && Array.isArray(that)) {
         return self.length === that.length && self.every((v, i) => compareBoth(v, that[i]));
       }
-      if (Object.getPrototypeOf(self) === Object.prototype && Object.getPrototypeOf(self) === Object.prototype) {
+      if (Object.getPrototypeOf(self) === Object.prototype && Object.getPrototypeOf(that) === Object.prototype) {
         const keysSelf = Object.keys(self);
         const keysThat = Object.keys(that);
         if (keysSelf.length === keysThat.length) {
@@ -1216,7 +1334,7 @@ const OP_YIELD = "Yield";
 /** @internal */
 const OP_REVERT_FLAGS = "RevertFlags";
 
-let moduleVersion = "3.19.14";
+let moduleVersion = "3.21.0";
 const getCurrentVersion = () => moduleVersion;
 
 /** @internal */
@@ -1600,17 +1718,17 @@ const isNonEmptyArray$1 = self => self.length > 0;
  * @category constructors
  * @since 2.0.0
  */
-const make$t = compare => (self, that) => self === that ? 0 : compare(self, that);
+const make$v = compare => (self, that) => self === that ? 0 : compare(self, that);
 /**
  * @category instances
  * @since 2.0.0
  */
-const number = /*#__PURE__*/make$t((self, that) => self < that ? -1 : 1);
+const number = /*#__PURE__*/make$v((self, that) => self < that ? -1 : 1);
 /**
  * @category mapping
  * @since 2.0.0
  */
-const mapInput = /*#__PURE__*/dual(2, (self, f) => make$t((b1, b2) => self(f(b1), f(b2))));
+const mapInput = /*#__PURE__*/dual(2, (self, f) => make$v((b1, b2) => self(f(b1), f(b2))));
 /**
  * Test whether one value is _strictly greater than_ another.
  *
@@ -2092,7 +2210,7 @@ const mergeWith = f => (o1, o2) => {
  * @category constructors
  * @since 2.0.0
  */
-const make$s = (...elements) => elements;
+const make$u = (...elements) => elements;
 
 /**
  * This module provides utility functions for working with arrays in TypeScript.
@@ -2456,7 +2574,7 @@ const sort = /*#__PURE__*/dual(2, (self, O) => {
  * @category zipping
  * @since 2.0.0
  */
-const zip$3 = /*#__PURE__*/dual(2, (self, that) => zipWith$2(self, that, make$s));
+const zip$3 = /*#__PURE__*/dual(2, (self, that) => zipWith$2(self, that, make$u));
 /**
  * Apply a function to pairs of elements at the same index in two `Iterable`s, collecting the results in a new `Array`. If one
  * input `Iterable` is short, excess elements of the longer `Iterable` are discarded.
@@ -2911,6 +3029,54 @@ const Order$1 = number;
  */
 const escape = string => string.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&");
 
+/**
+ * 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$6(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))
+  });
+}
+
 /** @internal */
 const TagTypeId = /*#__PURE__*/Symbol.for("effect/Context/Tag");
 /** @internal */
@@ -2945,7 +3111,7 @@ const TagProto = {
     return self;
   },
   context(self) {
-    return make$r(this, self);
+    return make$t(this, self);
   }
 };
 const ReferenceProto = {
@@ -3055,7 +3221,7 @@ const _empty$6 = /*#__PURE__*/makeContext(/*#__PURE__*/new Map());
 /** @internal */
 const empty$l = () => _empty$6;
 /** @internal */
-const make$r = (tag, service) => makeContext(new Map([[tag.key, service]]));
+const make$t = (tag, service) => makeContext(new Map([[tag.key, service]]));
 /** @internal */
 const add$3 = /*#__PURE__*/dual(3, (self, tag, service) => {
   const map = new Map(self.unsafeMap);
@@ -3174,7 +3340,7 @@ const empty$k = empty$l;
  * @since 2.0.0
  * @category constructors
  */
-const make$q = make$r;
+const make$s = make$t;
 /**
  * Adds a service to a given `Context`.
  *
@@ -3393,7 +3559,7 @@ const emptyArray = [];
  * @category equivalence
  * @since 2.0.0
  */
-const getEquivalence$1 = isEquivalent => make$u((self, that) => self.length === that.length && toReadonlyArray(self).every((value, i) => isEquivalent(value, unsafeGet(that, i))));
+const getEquivalence$1 = isEquivalent => make$w((self, that) => self.length === that.length && toReadonlyArray(self).every((value, i) => isEquivalent(value, unsafeGet(that, i))));
 const _equivalence$1 = /*#__PURE__*/getEquivalence$1(equals$1);
 const ChunkProto = {
   [TypeId$a]: {
@@ -3505,7 +3671,7 @@ const empty$j = () => _empty$5;
  * @category constructors
  * @since 2.0.0
  */
-const make$p = (...as) => unsafeFromNonEmptyArray(as);
+const make$r = (...as) => unsafeFromNonEmptyArray(as);
 /**
  * Builds a `NonEmptyChunk` from a single element.
  *
@@ -4114,7 +4280,7 @@ const DurationProto = {
     return pipeArguments(this, arguments);
   }
 };
-const make$o = input => {
+const make$q = input => {
   const duration = Object.create(DurationProto);
   if (isNumber(input)) {
     if (isNaN(input) || input <= 0) {
@@ -4171,52 +4337,52 @@ const isZero = self => {
  * @since 2.0.0
  * @category constructors
  */
-const zero = /*#__PURE__*/make$o(0);
+const zero = /*#__PURE__*/make$q(0);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const infinity = /*#__PURE__*/make$o(Infinity);
+const infinity = /*#__PURE__*/make$q(Infinity);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const nanos = nanos => make$o(nanos);
+const nanos = nanos => make$q(nanos);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const micros = micros => make$o(micros * bigint1e3);
+const micros = micros => make$q(micros * bigint1e3);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const millis = millis => make$o(millis);
+const millis = millis => make$q(millis);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const seconds = seconds => make$o(seconds * 1000);
+const seconds = seconds => make$q(seconds * 1000);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const minutes = minutes => make$o(minutes * 60_000);
+const minutes = minutes => make$q(minutes * 60_000);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const hours = hours => make$o(hours * 3_600_000);
+const hours = hours => make$q(hours * 3_600_000);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const days = days => make$o(days * 86_400_000);
+const days = days => make$q(days * 86_400_000);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const weeks = weeks => make$o(weeks * 604_800_000);
+const weeks = weeks => make$q(weeks * 604_800_000);
 /**
  * @since 2.0.0
  * @category getters
@@ -4435,7 +4601,7 @@ function fromBitmap(bitmap, bit) {
   return popcount(bitmap & bit - 1);
 }
 
-const make$n = (value, previous) => ({
+const make$p = (value, previous) => ({
   value,
   previous
 });
@@ -4721,7 +4887,7 @@ function mergeLeaves(edit, shift, h1, n1, h2, n2) {
   while (true) {
     const res = mergeLeavesInner(edit, currentShift, h1, n1, h2, n2);
     if (typeof res === "function") {
-      stack = make$n(res, stack);
+      stack = make$p(res, stack);
       currentShift = currentShift + SIZE;
     } else {
       let final = res;
@@ -5045,7 +5211,7 @@ const fromIterable$3 = elements => {
   return endMutation(set);
 };
 /** @internal */
-const make$m = (...elements) => {
+const make$o = (...elements) => {
   const set = beginMutation(empty$h());
   for (const value of elements) {
     add$1(set, value);
@@ -5553,7 +5719,7 @@ const fromIterable$2 = fromIterable$3;
  *
  * @see Other `HashSet` constructors are {@link module:HashSet.fromIterable} {@link module:HashSet.empty}
  */
-const make$l = make$m;
+const make$n = make$o;
 /**
  * Checks if the specified value exists in the `HashSet`.
  *
@@ -5782,7 +5948,7 @@ const MutableRefProto = {
  * @since 2.0.0
  * @category constructors
  */
-const make$k = value => {
+const make$m = value => {
   const ref = Object.create(MutableRefProto);
   ref.current = value;
   return ref;
@@ -5938,7 +6104,7 @@ const ids = self => {
       }
     case OP_RUNTIME:
       {
-        return make$l(self.id);
+        return make$n(self.id);
       }
     case OP_COMPOSITE:
       {
@@ -5946,7 +6112,7 @@ const ids = self => {
       }
   }
 };
-const _fiberCounter = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/Fiber/Id/_fiberCounter"), () => make$k(0));
+const _fiberCounter = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/Fiber/Id/_fiberCounter"), () => make$m(0));
 /** @internal */
 const threadName$1 = self => {
   const identifiers = Array.from(ids(self)).map(n => `#${n}`).join(",");
@@ -6737,7 +6903,7 @@ const DifferProto = {
   }
 };
 /** @internal */
-const make$j = params => {
+const make$l = params => {
   const differ = Object.create(DifferProto);
   differ.empty = params.empty;
   differ.diff = params.diff;
@@ -6746,21 +6912,21 @@ const make$j = params => {
   return differ;
 };
 /** @internal */
-const environment = () => make$j({
+const environment = () => make$l({
   empty: empty$d(),
   combine: (first, second) => combine$4(second)(first),
   diff: (oldValue, newValue) => diff$6(oldValue, newValue),
   patch: (patch, oldValue) => patch$7(oldValue)(patch)
 });
 /** @internal */
-const hashSet = () => make$j({
+const hashSet = () => make$l({
   empty: empty$c(),
   combine: (first, second) => combine$3(second)(first),
   diff: (oldValue, newValue) => diff$5(oldValue, newValue),
   patch: (patch, oldValue) => patch$6(oldValue)(patch)
 });
 /** @internal */
-const readonlyArray = differ => make$j({
+const readonlyArray = differ => make$l({
   empty: empty$b(),
   combine: (first, second) => combine$2(first, second),
   diff: (oldValue, newValue) => diff$4({
@@ -6773,7 +6939,7 @@ const readonlyArray = differ => make$j({
 /** @internal */
 const update$2 = () => updateWith((_, a) => a);
 /** @internal */
-const updateWith = f => make$j({
+const updateWith = f => make$l({
   empty: identity,
   combine: (first, second) => {
     if (first === identity) {
@@ -6802,15 +6968,15 @@ const active = patch => patch & BIT_MASK;
 /** @internal */
 const enabled = patch => patch >> BIT_SHIFT & BIT_MASK;
 /** @internal */
-const make$i = (active, enabled) => (active & BIT_MASK) + ((enabled & active & BIT_MASK) << BIT_SHIFT);
+const make$k = (active, enabled) => (active & BIT_MASK) + ((enabled & active & BIT_MASK) << BIT_SHIFT);
 /** @internal */
-const empty$a = /*#__PURE__*/make$i(0, 0);
+const empty$a = /*#__PURE__*/make$k(0, 0);
 /** @internal */
-const enable$2 = flag => make$i(flag, flag);
+const enable$2 = flag => make$k(flag, flag);
 /** @internal */
-const disable$1 = flag => make$i(flag, 0);
+const disable$1 = flag => make$k(flag, 0);
 /** @internal */
-const exclude$1 = /*#__PURE__*/dual(2, (self, flag) => make$i(active(self) & ~flag, enabled(self)));
+const exclude$1 = /*#__PURE__*/dual(2, (self, flag) => make$k(active(self) & ~flag, enabled(self)));
 /** @internal */
 const andThen = /*#__PURE__*/dual(2, (self, that) => self | that);
 /** @internal */
@@ -6839,18 +7005,18 @@ const interruption = self => isEnabled(self, Interruption);
 /** @internal */
 const isEnabled = /*#__PURE__*/dual(2, (self, flag) => (self & flag) !== 0);
 /** @internal */
-const make$h = (...flags) => flags.reduce((a, b) => a | b, 0);
+const make$j = (...flags) => flags.reduce((a, b) => a | b, 0);
 /** @internal */
-const none$1 = /*#__PURE__*/make$h(None$1);
+const none$1 = /*#__PURE__*/make$j(None$1);
 /** @internal */
 const runtimeMetrics = self => isEnabled(self, RuntimeMetrics);
 const windDown = self => isEnabled(self, WindDown);
 /** @internal */
-const diff$3 = /*#__PURE__*/dual(2, (self, that) => make$i(self ^ that, that));
+const diff$3 = /*#__PURE__*/dual(2, (self, that) => make$k(self ^ that, that));
 /** @internal */
 const patch$4 = /*#__PURE__*/dual(2, (self, patch) => self & (invert(active(patch)) | enabled(patch)) | active(patch) & enabled(patch));
 /** @internal */
-const differ$1 = /*#__PURE__*/make$j({
+const differ$1 = /*#__PURE__*/make$l({
   empty: empty$a,
   diff: (oldValue, newValue) => diff$3(oldValue, newValue),
   combine: (first, second) => andThen(second)(first),
@@ -7417,7 +7583,7 @@ const evaluateCause = self => {
         }
       case OP_FAIL$1:
         {
-          _parallel = add(_parallel, make$p(cause._tag, cause.error));
+          _parallel = add(_parallel, make$r(cause._tag, cause.error));
           if (stack.length === 0) {
             return [_parallel, _sequential];
           }
@@ -7426,7 +7592,7 @@ const evaluateCause = self => {
         }
       case OP_DIE:
         {
-          _parallel = add(_parallel, make$p(cause._tag, cause.defect));
+          _parallel = add(_parallel, make$r(cause._tag, cause.defect));
           if (stack.length === 0) {
             return [_parallel, _sequential];
           }
@@ -7435,7 +7601,7 @@ const evaluateCause = self => {
         }
       case OP_INTERRUPT:
         {
-          _parallel = add(_parallel, make$p(cause._tag, cause.fiberId));
+          _parallel = add(_parallel, make$r(cause._tag, cause.fiberId));
           if (stack.length === 0) {
             return [_parallel, _sequential];
           }
@@ -7653,34 +7819,33 @@ const renderErrorCause = (cause, prefix) => {
   return stack;
 };
 /** @internal */
-class PrettyError extends globalThis.Error {
-  span = undefined;
-  constructor(originalError) {
-    const originalErrorIsObject = typeof originalError === "object" && originalError !== null;
-    const prevLimit = Error.stackTraceLimit;
-    Error.stackTraceLimit = 1;
-    super(prettyErrorMessage(originalError), originalErrorIsObject && "cause" in originalError && typeof originalError.cause !== "undefined" ? {
-      cause: new PrettyError(originalError.cause)
-    } : undefined);
-    if (this.message === "") {
-      this.message = "An error has occurred";
+const makePrettyError = originalError => {
+  const originalErrorIsObject = typeof originalError === "object" && originalError !== null;
+  const prevLimit = Error.stackTraceLimit;
+  Error.stackTraceLimit = 1;
+  const error = new Error(prettyErrorMessage(originalError), originalErrorIsObject && "cause" in originalError && typeof originalError.cause !== "undefined" ? {
+    cause: makePrettyError(originalError.cause)
+  } : undefined);
+  Error.stackTraceLimit = prevLimit;
+  if (error.message === "") {
+    error.message = "An error has occurred";
+  }
+  Error.stackTraceLimit = prevLimit;
+  error.name = originalError instanceof Error ? originalError.name : "Error";
+  if (originalErrorIsObject) {
+    if (spanSymbol in originalError) {
+      error.span = originalError[spanSymbol];
     }
-    Error.stackTraceLimit = prevLimit;
-    this.name = originalError instanceof Error ? originalError.name : "Error";
-    if (originalErrorIsObject) {
-      if (spanSymbol in originalError) {
-        this.span = originalError[spanSymbol];
+    Object.keys(originalError).forEach(key => {
+      if (!(key in error)) {
+        // @ts-expect-error
+        error[key] = originalError[key];
       }
-      Object.keys(originalError).forEach(key => {
-        if (!(key in this)) {
-          // @ts-expect-error
-          this[key] = originalError[key];
-        }
-      });
-    }
-    this.stack = prettyErrorStack(`${this.name}: ${this.message}`, originalError instanceof Error && originalError.stack ? originalError.stack : "", this.span);
+    });
   }
-}
+  error.stack = prettyErrorStack(`${error.name}: ${error.message}`, originalError instanceof Error && originalError.stack ? originalError.stack : "", error.span);
+  return error;
+};
 /**
  * A utility function for generating human-readable error messages from a generic error of type `unknown`.
  *
@@ -7768,10 +7933,10 @@ const spanSymbol = /*#__PURE__*/Symbol.for("effect/SpanAnnotation");
 const prettyErrors = cause => reduceWithContext(cause, void 0, {
   emptyCase: () => [],
   dieCase: (_, unknownError) => {
-    return [new PrettyError(unknownError)];
+    return [makePrettyError(unknownError)];
   },
   failCase: (_, error) => {
-    return [new PrettyError(error)];
+    return [makePrettyError(error)];
   },
   interruptCase: () => [],
   parallelCase: (_, l, r) => [...l, ...r],
@@ -7795,7 +7960,7 @@ const deferredVariance = {
   _A: _ => _
 };
 /** @internal */
-const pending = joiners => {
+const pending$1 = joiners => {
   return {
     _tag: OP_STATE_PENDING,
     joiners
@@ -8846,7 +9011,7 @@ const deferredUnsafeMake = fiberId => {
   const _deferred = {
     ...CommitPrototype,
     [DeferredTypeId]: deferredVariance,
-    state: make$k(pending([])),
+    state: make$m(pending$1([])),
     commit() {
       return deferredAwait(this);
     },
@@ -8953,7 +9118,7 @@ const currentSpanFromFiber = fiber => {
  * @since 2.0.0
  * @category constructors
  */
-const make$g = deferredMake;
+const make$i = deferredMake;
 const _await$1 = deferredAwait;
 /**
  * Exits the `Deferred` with the specified `Exit` value, which will be
@@ -9425,7 +9590,7 @@ const MutableQueueProto = {
     return pipeArguments(this, arguments);
   }
 };
-const make$f = capacity => {
+const make$h = capacity => {
   const queue = Object.create(MutableQueueProto);
   queue.queue = empty$7();
   queue.capacity = capacity;
@@ -9437,14 +9602,14 @@ const make$f = capacity => {
  * @since 2.0.0
  * @category constructors
  */
-const bounded = capacity => make$f(capacity);
+const bounded = capacity => make$h(capacity);
 /**
  * Creates a new unbounded `MutableQueue`.
  *
  * @since 2.0.0
  * @category constructors
  */
-const unbounded = () => make$f(undefined);
+const unbounded = () => make$h(undefined);
 /**
  * Returns the current number of elements in the queue.
  *
@@ -9613,7 +9778,7 @@ class ClockImpl {
   }
 }
 /** @internal */
-const make$e = () => new ClockImpl();
+const make$g = () => new ClockImpl();
 
 /** @internal */
 const OP_AND = "And";
@@ -9860,7 +10025,7 @@ const FlatConfigProviderSymbolKey = "effect/ConfigProviderFlat";
 /** @internal */
 const FlatConfigProviderTypeId = /*#__PURE__*/Symbol.for(FlatConfigProviderSymbolKey);
 /** @internal */
-const make$d = options => ({
+const make$f = options => ({
   [ConfigProviderTypeId]: ConfigProviderTypeId,
   pipe() {
     return pipeArguments(this, arguments);
@@ -9875,7 +10040,7 @@ const makeFlat = options => ({
   enumerateChildren: options.enumerateChildren
 });
 /** @internal */
-const fromFlat = flat => make$d({
+const fromFlat = flat => make$f({
   load: config => flatMap$2(fromFlatLoop(flat, empty$m(), config, false), chunk => match$6(head$1(chunk), {
     onNone: () => fail$3(MissingData(empty$m(), `Expected a single value having structure: ${config}`)),
     onSome: succeed$4
@@ -10210,7 +10375,7 @@ const swap = (buffer, index1, index2) => {
   buffer[index2] = tmp;
   return buffer;
 };
-const make$c = seed => new RandomImpl(hash(seed));
+const make$e = seed => new RandomImpl(hash(seed));
 
 /**
  * @since 2.0.0
@@ -10218,7 +10383,7 @@ const make$c = seed => new RandomImpl(hash(seed));
 /** @internal */
 const TracerTypeId = /*#__PURE__*/Symbol.for("effect/Tracer");
 /** @internal */
-const make$b = options => ({
+const make$d = options => ({
   [TracerTypeId]: TracerTypeId,
   ...options
 });
@@ -10287,13 +10452,17 @@ class NativeSpan {
   }
 }
 /** @internal */
-const nativeTracer = /*#__PURE__*/make$b({
+const nativeTracer = /*#__PURE__*/make$d({
   span: (name, parent, context, links, startTime, kind) => new NativeSpan(name, parent, context, links, startTime, kind),
   context: f => f()
 });
+/** @internal */
+const DisablePropagation = /*#__PURE__*/Reference()("effect/Tracer/DisablePropagation", {
+  defaultValue: constFalse
+});
 
 /** @internal */
-const liveServices = /*#__PURE__*/pipe(/*#__PURE__*/empty$k(), /*#__PURE__*/add$2(clockTag, /*#__PURE__*/make$e()), /*#__PURE__*/add$2(consoleTag, defaultConsole), /*#__PURE__*/add$2(randomTag, /*#__PURE__*/make$c(/*#__PURE__*/Math.random())), /*#__PURE__*/add$2(configProviderTag, /*#__PURE__*/fromEnv()), /*#__PURE__*/add$2(tracerTag, nativeTracer));
+const liveServices = /*#__PURE__*/pipe(/*#__PURE__*/empty$k(), /*#__PURE__*/add$2(clockTag, /*#__PURE__*/make$g()), /*#__PURE__*/add$2(consoleTag, defaultConsole), /*#__PURE__*/add$2(randomTag, /*#__PURE__*/make$e(/*#__PURE__*/Math.random())), /*#__PURE__*/add$2(configProviderTag, /*#__PURE__*/fromEnv()), /*#__PURE__*/add$2(tracerTag, nativeTracer));
 /**
  * The `FiberRef` holding the default `Effect` services.
  *
@@ -10545,7 +10714,7 @@ const Fatal = logLevelFatal;
  * @since 2.0.0
  * @category constructors
  */
-const Error$1 = logLevelError;
+const Error$2 = logLevelError;
 /**
  * @since 2.0.0
  * @category constructors
@@ -10592,7 +10761,7 @@ const fromLiteral = literal => {
     case "Debug":
       return Debug;
     case "Error":
-      return Error$1;
+      return Error$2;
     case "Fatal":
       return Fatal;
     case "Info":
@@ -10669,9 +10838,9 @@ class RefImpl extends Class {
   }
 }
 /** @internal */
-const unsafeMake$2 = value => new RefImpl(make$k(value));
+const unsafeMake$2 = value => new RefImpl(make$m(value));
 /** @internal */
-const make$a = value => sync$1(() => unsafeMake$2(value));
+const make$c = value => sync$1(() => unsafeMake$2(value));
 /** @internal */
 const get = self => self.get;
 /** @internal */
@@ -10810,7 +10979,7 @@ class MetricLabelImpl {
   }
 }
 /** @internal */
-const make$9 = (key, value) => {
+const make$b = (key, value) => {
   return new MetricLabelImpl(key, value);
 };
 /** @internal */
@@ -10883,7 +11052,7 @@ const logWithLevel = level => (...message) => {
 /** @internal */
 const logWarning$1 = /*#__PURE__*/logWithLevel(Warning);
 /** @internal */
-const logError$1 = /*#__PURE__*/logWithLevel(Error$1);
+const logError$1 = /*#__PURE__*/logWithLevel(Error$2);
 /* @internal */
 const mapErrorCause = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect$2(self, {
   onFailure: c => failCauseSync(() => f(c)),
@@ -10928,6 +11097,7 @@ const updateFiberRefs = f => withFiberRuntime$1(state => {
 });
 /* @internal */
 const when$1 = /*#__PURE__*/dual(2, (self, condition) => suspend$2(() => condition() ? map$3(self, some) : succeed$4(none$4())));
+const filterDisablePropagation = /*#__PURE__*/flatMap$5(span => get$7(span.context, DisablePropagation) ? span._tag === "Span" ? filterDisablePropagation(span.parent) : none$4() : some(span));
 
 /** @internal */
 const OP_SEQUENTIAL = "Sequential";
@@ -11881,6 +12051,61 @@ const runFork$1 = (effect, options) => {
 /**
  * @since 2.0.0
  */
+/**
+ * @since 3.20.0
+ * @category models
+ */
+class SchedulerRunner {
+  scheduleDrain;
+  running = false;
+  tasks = /*#__PURE__*/new PriorityBuckets();
+  constructor(scheduleDrain) {
+    this.scheduleDrain = scheduleDrain;
+  }
+  starveInternal = depth => {
+    const tasks = this.tasks.buckets;
+    this.tasks.buckets = [];
+    for (const [_, toRun] of tasks) {
+      for (let i = 0; i < toRun.length; i++) {
+        toRun[i]();
+      }
+    }
+    if (this.tasks.buckets.length === 0) {
+      this.running = false;
+    } else {
+      this.starve(depth);
+    }
+  };
+  starve(depth = 0) {
+    this.scheduleDrain(depth, this.starveInternal);
+  }
+  scheduleTask(task, priority) {
+    this.tasks.scheduleTask(task, priority);
+    if (!this.running) {
+      this.running = true;
+      this.starve();
+    }
+  }
+  /**
+   * @since 3.20.0
+   * @category constructors
+   */
+  static cached(scheduleDrain) {
+    const fallback = new SchedulerRunner(scheduleDrain);
+    const runners = new WeakMap();
+    return fiber => {
+      if (fiber === undefined) {
+        return fallback;
+      }
+      let runner = runners.get(fiber);
+      if (runner === undefined) {
+        runner = new SchedulerRunner(scheduleDrain);
+        runners.set(fiber, runner);
+      }
+      return runner;
+    };
+  }
+}
 /**
  * @since 2.0.0
  * @category utils
@@ -11919,14 +12144,13 @@ class PriorityBuckets {
  */
 class MixedScheduler {
   maxNextTickBeforeTimer;
-  /**
-   * @since 2.0.0
-   */
-  running = false;
-  /**
-   * @since 2.0.0
-   */
-  tasks = /*#__PURE__*/new PriorityBuckets();
+  getRunner = /*#__PURE__*/SchedulerRunner.cached((depth, drain) => {
+    if (depth >= this.maxNextTickBeforeTimer) {
+      setTimeout(() => drain(0), 0);
+    } else {
+      Promise.resolve(void 0).then(() => drain(depth + 1));
+    }
+  });
   constructor(
   /**
    * @since 2.0.0
@@ -11934,33 +12158,6 @@ class MixedScheduler {
   maxNextTickBeforeTimer) {
     this.maxNextTickBeforeTimer = maxNextTickBeforeTimer;
   }
-  /**
-   * @since 2.0.0
-   */
-  starveInternal(depth) {
-    const tasks = this.tasks.buckets;
-    this.tasks.buckets = [];
-    for (const [_, toRun] of tasks) {
-      for (let i = 0; i < toRun.length; i++) {
-        toRun[i]();
-      }
-    }
-    if (this.tasks.buckets.length === 0) {
-      this.running = false;
-    } else {
-      this.starve(depth);
-    }
-  }
-  /**
-   * @since 2.0.0
-   */
-  starve(depth = 0) {
-    if (depth >= this.maxNextTickBeforeTimer) {
-      setTimeout(() => this.starveInternal(0), 0);
-    } else {
-      Promise.resolve(void 0).then(() => this.starveInternal(depth + 1));
-    }
-  }
   /**
    * @since 2.0.0
    */
@@ -11970,12 +12167,8 @@ class MixedScheduler {
   /**
    * @since 2.0.0
    */
-  scheduleTask(task, priority) {
-    this.tasks.scheduleTask(task, priority);
-    if (!this.running) {
-      this.running = true;
-      this.starve();
-    }
+  scheduleTask(task, priority, fiber) {
+    this.getRunner(fiber).scheduleTask(task, priority);
   }
 }
 /**
@@ -12515,7 +12708,7 @@ const metricHookVariance = {
   _Out: _ => _
 };
 /** @internal */
-const make$8 = options => ({
+const make$a = options => ({
   [MetricHookTypeId]: metricHookVariance,
   pipe() {
     return pipeArguments(this, arguments);
@@ -12532,7 +12725,7 @@ const counter$1 = key => {
       sum = sum + value;
     }
   };
-  return make$8({
+  return make$a({
     get: () => counter$2(sum),
     update,
     modify: update
@@ -12548,7 +12741,7 @@ const frequency = key => {
     const slotCount = values.get(word) ?? 0;
     values.set(word, slotCount + 1);
   };
-  return make$8({
+  return make$a({
     get: () => frequency$1(values),
     update,
     modify: update
@@ -12557,7 +12750,7 @@ const frequency = key => {
 /** @internal */
 const gauge = (_key, startAt) => {
   let value = startAt;
-  return make$8({
+  return make$a({
     get: () => gauge$1(value),
     update: v => {
       value = v;
@@ -12627,7 +12820,7 @@ const histogram$1 = key => {
     }
     return builder;
   };
-  return make$8({
+  return make$a({
     get: () => histogram$2({
       buckets: getBuckets(),
       count,
@@ -12694,7 +12887,7 @@ const summary = key => {
     count = count + 1;
     sum = sum + value;
   };
-  return make$8({
+  return make$a({
     get: () => summary$1({
       error,
       quantiles: snapshot(Date.now()),
@@ -12961,7 +13154,7 @@ class MetricRegistryImpl {
   }
 }
 /** @internal */
-const make$7 = () => {
+const make$9 = () => {
   return new MetricRegistryImpl();
 };
 
@@ -12978,9 +13171,9 @@ const metricVariance = {
   _Out: _ => _
 };
 /** @internal */
-const globalMetricRegistry = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/Metric/globalMetricRegistry"), () => make$7());
+const globalMetricRegistry = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/Metric/globalMetricRegistry"), () => make$9());
 /** @internal */
-const make$6 = function (keyType, unsafeUpdate, unsafeValue, unsafeModify) {
+const make$8 = function (keyType, unsafeUpdate, unsafeValue, unsafeModify) {
   const metric = Object.assign(effect => tap$1(effect, a => update(metric, a)), {
     [MetricTypeId]: metricVariance,
     keyType,
@@ -13019,21 +13212,21 @@ const fromMetricKey = key => {
     hookCache.set(extraTags, hook);
     return hook;
   };
-  return make$6(key.keyType, (input, extraTags) => hook(extraTags).update(input), extraTags => hook(extraTags).get(), (input, extraTags) => hook(extraTags).modify(input));
+  return make$8(key.keyType, (input, extraTags) => hook(extraTags).update(input), extraTags => hook(extraTags).get(), (input, extraTags) => hook(extraTags).modify(input));
 };
 /** @internal */
 const histogram = (name, boundaries, description) => fromMetricKey(histogram$3(name, boundaries, description));
 /** @internal */
-const tagged = /*#__PURE__*/dual(3, (self, key, value) => taggedWithLabels(self, [make$9(key, value)]));
+const tagged = /*#__PURE__*/dual(3, (self, key, value) => taggedWithLabels(self, [make$b(key, value)]));
 /** @internal */
 const taggedWithLabels = /*#__PURE__*/dual(2, (self, extraTags) => {
-  return make$6(self.keyType, (input, extraTags1) => self.unsafeUpdate(input, union$2(extraTags, extraTags1)), extraTags1 => self.unsafeValue(union$2(extraTags, extraTags1)), (input, extraTags1) => self.unsafeModify(input, union$2(extraTags, extraTags1)));
+  return make$8(self.keyType, (input, extraTags1) => self.unsafeUpdate(input, union$2(extraTags, extraTags1)), extraTags1 => self.unsafeValue(union$2(extraTags, extraTags1)), (input, extraTags1) => self.unsafeModify(input, union$2(extraTags, extraTags1)));
 });
 /* @internal */
 const update = /*#__PURE__*/dual(2, (self, input) => fiberRefGetWith(currentMetricLabels, tags => sync$1(() => self.unsafeUpdate(input, tags))));
 
 /** @internal */
-const complete = /*#__PURE__*/dual(2, (self, result) => fiberRefGetWith(currentRequestMap, map => sync$1(() => {
+const complete$1 = /*#__PURE__*/dual(2, (self, result) => fiberRefGetWith(currentRequestMap, map => sync$1(() => {
   if (map.has(self)) {
     const entry = map.get(self);
     if (!entry.state.completed) {
@@ -13176,7 +13369,7 @@ const none = /*#__PURE__*/globalValue("effect/Supervisor/none", () => fromEffect
  * @since 2.0.0
  * @category constructors
  */
-const make$5 = make$j;
+const make$7 = make$l;
 
 /** @internal */
 const OP_EMPTY = "Empty";
@@ -13268,7 +13461,7 @@ const toSet = self => {
     if (isZip(self)) {
       return pipe(toSet(self.left), union(toSet(self.right)));
     } else {
-      return make$l(self);
+      return make$n(self);
     }
   }
 };
@@ -13290,7 +13483,7 @@ const diff = (oldValue, newValue) => {
   return combine(added, removed);
 };
 /** @internal */
-const differ = /*#__PURE__*/make$5({
+const differ = /*#__PURE__*/make$7({
   empty: empty$2,
   patch,
   combine,
@@ -13551,6 +13744,10 @@ class FiberRuntime extends Class {
   get await() {
     return async_(resume => {
       const cb = exit => resume(succeed$4(exit));
+      if (this._exitValue !== null) {
+        cb(this._exitValue);
+        return;
+      }
       this.tell(stateful((fiber, _) => {
         if (fiber._exitValue !== null) {
           cb(this._exitValue);
@@ -13770,7 +13967,7 @@ class FiberRuntime extends Class {
    * **NOTE**: This method must be invoked by the fiber itself.
    */
   drainQueueLaterOnExecutor() {
-    this.currentScheduler.scheduleTask(this.run, this.getFiberRef(currentSchedulingPriority));
+    this.currentScheduler.scheduleTask(this.run, this.getFiberRef(currentSchedulingPriority), this);
   }
   /**
    * Drains the fiber's message queue while the fiber is actively running,
@@ -14434,7 +14631,7 @@ const tracerLogger = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/Lo
   logLevel,
   message
 }) => {
-  const span = getOption(getOrDefault$1(context, currentContext), spanTag);
+  const span = filterDisablePropagation(getOption(getOrDefault$1(context, currentContext), spanTag));
   if (span._tag === "None" || span.value._tag === "ExternalSpan") {
     return;
   }
@@ -14453,7 +14650,7 @@ const tracerLogger = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/Lo
   span.value.event(toStringUnknown(Array.isArray(message) && message.length === 1 ? message[0] : message), clockService.unsafeCurrentTimeNanos(), attributes);
 }));
 /** @internal */
-const currentLoggers = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentLoggers"), () => fiberRefUnsafeMakeHashSet(make$l(defaultLogger, tracerLogger)));
+const currentLoggers = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentLoggers"), () => fiberRefUnsafeMakeHashSet(make$n(defaultLogger, tracerLogger)));
 // === all
 const allResolveInput = input => {
   if (Array.isArray(input) || isIterable(input)) {
@@ -14561,7 +14758,7 @@ const forEachConcurrentDiscard = (self, f, batching, processAll, n) => uninterru
   const interruptAll = () => fibers.forEach(fiber => {
     fiber.currentScheduler.scheduleTask(() => {
       fiber.unsafeInterruptAsFork(parent.id());
-    }, 0);
+    }, 0, fiber);
   });
   const startOrder = new Array();
   const joinOrder = new Array();
@@ -14585,7 +14782,7 @@ const forEachConcurrentDiscard = (self, f, batching, processAll, n) => uninterru
         fiber.unsafeInterruptAsFork(parent.id());
       }
       fiber.resume(runnable);
-    }, 0);
+    }, 0, fiber);
     return fiber;
   };
   const onInterruptSignal = () => {
@@ -14636,7 +14833,7 @@ const forEachConcurrentDiscard = (self, f, batching, processAll, n) => uninterru
         if (interrupted) {
           fiber.currentScheduler.scheduleTask(() => {
             fiber.unsafeInterruptAsFork(parent.id());
-          }, 0);
+          }, 0, fiber);
         }
         fiber.addObserver(wrapped => {
           let exit;
@@ -14895,7 +15092,7 @@ const scopeMake = (strategy = sequential$1) => sync$1(() => scopeUnsafeMake(stra
 /* @internal */
 const scopeExtend = /*#__PURE__*/dual(2, (effect, scope) => mapInputContext(effect,
 // @ts-expect-error
-merge$1(make$q(scopeTag, scope))));
+merge$1(make$s(scopeTag, scope))));
 // circular with Supervisor
 /** @internal */
 const fiberRefUnsafeMakeSupervisor = initial => fiberRefUnsafeMakePatch(initial, {
@@ -14950,7 +15147,7 @@ const race$1 = /*#__PURE__*/dual(2, (self, that) => fiberIdWith$1(parentFiberId
 /** @internal */
 const raceFibersWith = /*#__PURE__*/dual(3, (self, other, options) => withFiberRuntime$1((parentFiber, parentStatus) => {
   const parentRuntimeFlags = parentStatus.runtimeFlags;
-  const raceIndicator = make$k(true);
+  const raceIndicator = make$m(true);
   const leftFiber = unsafeMakeChildFiber(self, parentFiber, parentRuntimeFlags, options.selfScope);
   const rightFiber = unsafeMakeChildFiber(other, parentFiber, parentRuntimeFlags, options.otherScope);
   return async_(cb => {
@@ -15016,9 +15213,478 @@ const invokeWithInterrupt = (self, entries, onInterrupt) => fiberIdWith$1(id =>
     }
     return [];
   });
-  return forEachSequentialDiscard(residual, entry => complete(entry.request, exitInterrupt$1(id)));
+  return forEachSequentialDiscard(residual, entry => complete$1(entry.request, exitInterrupt$1(id)));
 })));
 
+/** @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$1]() {
+    return pipe(hash(this.current), combine$7(hash(this.previous)), combine$7(hash(this.next)), cached(this));
+  }
+  [symbol](that) {
+    if (this === that) {
+      return true;
+    }
+    return isMapKey(that) && equals$1(this.current, that.current) && equals$1(this.previous, that.previous) && equals$1(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$8(), makeKeySet(), unbounded(), make$m(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$3(this.getEither(key), merge$3);
+  }
+  get cacheStats() {
+    return sync$1(() => makeCacheStats({
+      hits: this.cacheState.hits,
+      misses: this.cacheState.misses,
+      size: size(this.cacheState.map)
+    }));
+  }
+  getOption(key) {
+    return suspend$2(() => match$6(get$2(this.cacheState.map, key), {
+      onNone: () => {
+        const mapKey = makeMapKey(key);
+        this.trackAccess(mapKey);
+        this.trackMiss();
+        return succeed$4(none$4());
+      },
+      onSome: value => this.resolveMapValue(value)
+    }));
+  }
+  getOptionComplete(key) {
+    return suspend$2(() => match$6(get$2(this.cacheState.map, key), {
+      onNone: () => {
+        const mapKey = makeMapKey(key);
+        this.trackAccess(mapKey);
+        this.trackMiss();
+        return succeed$4(none$4());
+      },
+      onSome: value => this.resolveMapValue(value, true)
+    }));
+  }
+  contains(key) {
+    return sync$1(() => has(this.cacheState.map, key));
+  }
+  entryStats(key) {
+    return sync$1(() => {
+      const option = get$2(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$4();
+            }
+          case "Refreshing":
+            {
+              const loaded = option.value.complete.entryStats.loadedMillis;
+              return some(makeEntryStats(loaded));
+            }
+        }
+      }
+      return none$4();
+    });
+  }
+  getEither(key) {
+    return suspend$2(() => {
+      const k = key;
+      let mapKey = undefined;
+      let deferred = undefined;
+      let value = getOrUndefined(get$2(this.cacheState.map, k));
+      if (value === undefined) {
+        deferred = unsafeMake$4(this.fiberId);
+        mapKey = makeMapKey(k);
+        if (has(this.cacheState.map, k)) {
+          value = getOrUndefined(get$2(this.cacheState.map, k));
+        } else {
+          set$1(this.cacheState.map, k, pending(mapKey, deferred));
+        }
+      }
+      if (value === undefined) {
+        this.trackAccess(mapKey);
+        this.trackMiss();
+        return map$3(this.lookupValueOf(key, deferred), right);
+      } else {
+        return flatMap$2(this.resolveMapValue(value), match$6({
+          onNone: () => this.getEither(key),
+          onSome: value => succeed$4(left(value))
+        }));
+      }
+    });
+  }
+  invalidate(key) {
+    return sync$1(() => {
+      remove$1(this.cacheState.map, key);
+    });
+  }
+  invalidateWhen(key, when) {
+    return sync$1(() => {
+      const value = get$2(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$1(() => {
+      this.cacheState.map = empty$8();
+    });
+  }
+  refresh(key) {
+    return clockWith(clock => suspend$2(() => {
+      const k = key;
+      const deferred = unsafeMake$4(this.fiberId);
+      let value = getOrUndefined(get$2(this.cacheState.map, k));
+      if (value === undefined) {
+        if (has(this.cacheState.map, k)) {
+          value = getOrUndefined(get$2(this.cacheState.map, k));
+        } else {
+          set$1(this.cacheState.map, k, pending(makeMapKey(k), deferred));
+        }
+      }
+      if (value === undefined) {
+        return asVoid$1(this.lookupValueOf(key, deferred));
+      } else {
+        switch (value._tag) {
+          case "Complete":
+            {
+              if (this.hasExpired(clock, value.timeToLiveMillis)) {
+                const found = getOrUndefined(get$2(this.cacheState.map, k));
+                if (equals$1(found, value)) {
+                  remove$1(this.cacheState.map, k);
+                }
+                return asVoid$1(this.get(key));
+              }
+              // Only trigger the lookup if we're still the current value, `completedResult`
+              return pipe(this.lookupValueOf(key, deferred), when$1(() => {
+                const current = getOrUndefined(get$2(this.cacheState.map, k));
+                if (equals$1(current, value)) {
+                  const mapValue = refreshing(deferred, value);
+                  set$1(this.cacheState.map, k, mapValue);
+                  return true;
+                }
+                return false;
+              }), asVoid$1);
+            }
+          case "Pending":
+            {
+              return _await$1(value.deferred);
+            }
+          case "Refreshing":
+            {
+              return _await$1(value.deferred);
+            }
+        }
+      }
+    }));
+  }
+  set(key, value) {
+    return clockWith(clock => sync$1(() => {
+      const now = clock.unsafeCurrentTimeMillis();
+      const k = key;
+      const lookupResult = succeed$2(value);
+      const mapValue = complete(makeMapKey(k), lookupResult, makeEntryStats(now), now + toMillis(decode(this.timeToLive(lookupResult))));
+      set$1(this.cacheState.map, k, mapValue);
+    }));
+  }
+  get size() {
+    return sync$1(() => {
+      return size(this.cacheState.map);
+    });
+  }
+  get values() {
+    return sync$1(() => {
+      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$1(() => {
+      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$1(() => {
+      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$4(none$4());
+            }
+            this.trackHit();
+            return map$3(value.exit, some);
+          }
+        case "Pending":
+          {
+            this.trackAccess(value.key);
+            this.trackHit();
+            if (ignorePending) {
+              return succeed$4(none$4());
+            }
+            return map$3(_await$1(value.deferred), some);
+          }
+        case "Refreshing":
+          {
+            this.trackAccess(value.complete.key);
+            this.trackHit();
+            if (this.hasExpired(clock, value.complete.timeToLiveMillis)) {
+              if (ignorePending) {
+                return succeed$4(none$4());
+              }
+              return map$3(_await$1(value.deferred), some);
+            }
+            return map$3(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$3(this.cacheState.updating, false);
+    }
+  }
+  hasExpired(clock, timeToLiveMillis) {
+    return clock.unsafeCurrentTimeMillis() > timeToLiveMillis;
+  }
+  lookupValueOf(input, deferred) {
+    return clockWith(clock => suspend$2(() => {
+      const key = input;
+      return pipe(this.lookup(input), provideContext$1(this.context), exit$1, flatMap$2(exit => {
+        const now = clock.unsafeCurrentTimeMillis();
+        const stats = makeEntryStats(now);
+        const value = complete(makeMapKey(key), exit, stats, now + toMillis(decode(this.timeToLive(exit))));
+        set$1(this.cacheState.map, key, value);
+        return zipRight$2(done$4(deferred, exit), exit);
+      }), onInterrupt(() => zipRight$2(interrupt$1(deferred), sync$1(() => {
+        remove$1(this.cacheState.map, key);
+      }))));
+    }));
+  }
+}
+/** @internal */
+const make$6 = options => {
+  const timeToLive = decode(options.timeToLive);
+  return makeWith({
+    capacity: options.capacity,
+    lookup: options.lookup,
+    timeToLive: () => timeToLive
+  });
+};
+/** @internal */
+const makeWith = options => map$3(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$5 = make$6;
+
 /** @internal */
 const IntervalSymbolKey = "effect/ScheduleInterval";
 /** @internal */
@@ -15325,20 +15991,24 @@ class Semaphore {
   take = n => asyncInterrupt(resume => {
     if (this.free < n) {
       const observer = () => {
-        if (this.free < n) {
-          return;
-        }
+        if (this.free < n) return;
         this.waiters.delete(observer);
-        this.taken += n;
-        resume(succeed$4(n));
+        resume(suspend$2(() => {
+          if (this.free < n) return this.take(n);
+          this.taken += n;
+          return succeed$4(n);
+        }));
       };
       this.waiters.add(observer);
       return sync$1(() => {
         this.waiters.delete(observer);
       });
     }
-    this.taken += n;
-    return resume(succeed$4(n));
+    resume(suspend$2(() => {
+      if (this.free < n) return this.take(n);
+      this.taken += n;
+      return succeed$4(n);
+    }));
   });
   updateTakenUnsafe(fiber, f) {
     this.taken = f(this.taken);
@@ -15350,7 +16020,7 @@ class Semaphore {
           item.value();
           item = iter.next();
         }
-      }, fiber.getFiberRef(currentSchedulingPriority));
+      }, fiber.getFiberRef(currentSchedulingPriority), fiber);
     }
     return succeed$4(this.free);
   }
@@ -15614,7 +16284,7 @@ const make = options => new RuntimeImpl(options.context, options.runtimeFlags, o
 /** @internal */
 const runtime$1 = () => withFiberRuntime$1((state, status) => succeed$4(new RuntimeImpl(state.getFiberRef(currentContext), status.runtimeFlags, state.getFiberRefs())));
 /** @internal */
-const defaultRuntimeFlags = /*#__PURE__*/make$h(Interruption, CooperativeYielding, RuntimeMetrics);
+const defaultRuntimeFlags = /*#__PURE__*/make$j(Interruption, CooperativeYielding, RuntimeMetrics);
 /** @internal */
 const defaultRuntime = /*#__PURE__*/make({
   context: /*#__PURE__*/empty$k(),
@@ -15689,7 +16359,7 @@ class MemoMapImpl {
         })));
         return succeed$4([cached, map]);
       }
-      return pipe(make$a(0), flatMap$2(observers => pipe(deferredMake(), flatMap$2(deferred => pipe(make$a(() => void_$2), map$3(finalizerRef => {
+      return pipe(make$c(0), flatMap$2(observers => pipe(deferredMake(), flatMap$2(deferred => pipe(make$c(() => void_$2), map$3(finalizerRef => {
         const resource = uninterruptibleMask$2(restore => pipe(scopeMake(), flatMap$2(innerScope => pipe(restore(flatMap$2(makeBuilder(layer, innerScope, true), f => diffFiberRefs(f(this)))), exit$1, flatMap$2(exit => {
           switch (exit._tag) {
             case OP_FAILURE:
@@ -15831,6 +16501,53 @@ const effect_provide = /*#__PURE__*/dual(2, (self, source) => {
   }
 });
 
+/**
+ * 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 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;
+};
+
 /** @internal */
 const ScheduleSymbolKey = "effect/Schedule";
 /** @internal */
@@ -15959,7 +16676,7 @@ const checkEffect = /*#__PURE__*/dual(2, (self, test) => makeWithState(self.init
   return map$3(test(input, out), cont => cont ? [state, out, decision] : [state, out, done]);
 })));
 /** @internal */
-const driver = self => pipe(make$a([none$4(), self.initial]), map$3(ref => new ScheduleDriverImpl(self, ref)));
+const driver = self => pipe(make$c([none$4(), self.initial]), map$3(ref => new ScheduleDriverImpl(self, ref)));
 /** @internal */
 const intersect = /*#__PURE__*/dual(2, (self, that) => intersectWith(self, that, intersect$1));
 /** @internal */
@@ -18787,4 +19504,88 @@ const zipRight = zipRightOptions;
  */
 const zipWith = zipWithOptions;
 
-export { onInterrupt as $, flatMap$2 as A, clockWith as B, offer as C, compareAndSet as D, poll as E, EmptyMutableQueue as F, remove$1 as G, set$3 as H, size as I, isSome as J, some as K, empty$8 as L, make$k as M, unbounded as N, symbol$1 as O, pipe as P, cached as Q, combine$7 as R, hash as S, symbol as T, hasProperty as U, equals$1 as V, asVoid$1 as W, when$1 as X, succeed$2 as Y, toMillis as Z, _await$1 as _, right as a, empty$j as a$, zipRight$2 as a0, interrupt$1 as a1, done$4 as a2, exit$1 as a3, provideContext$1 as a4, context as a5, fiberId as a6, YieldableError as a7, gen$1 as a8, tryPromise as a9, Class as aA, pipeArguments as aB, catchAll$1 as aC, interrupt$2 as aD, get$4 as aE, length as aF, uninterruptible$1 as aG, withFiberRuntime$1 as aH, whenEffect as aI, deferredSucceed as aJ, forEachConcurrentDiscard as aK, deferredAwait as aL, fromIterable$6 as aM, empty$m as aN, splitAt$1 as aO, isEmpty$7 as aP, deferredUnsafeMake as aQ, fromIterable$5 as aR, pollUpTo as aS, deferredUnsafeDone as aT, prepend$1 as aU, isEmpty$2 as aV, filter as aW, appendAll$1 as aX, append$1 as aY, offerAll as aZ, deferredInterruptWith as a_, fail$1 as aa, try_ as ab, gen as ac, infinity as ad, logWarning as ae, make$a as af, modify as ag, get as ah, update$1 as ai, isInterrupted as aj, fail$4 as ak, failureOrCause as al, flipCauseOption as am, interrupt$3 as an, map$4 as ao, die$2 as ap, isDieType as aq, interruptors as ar, isInterruptedOnly as as, join as at, interruptFiber as au, _await as av, inheritAll as aw, interruptAsFiber as ax, dual as ay, deferredMake as az, left as b, raceWith as b$, bounded as b0, capacity as b1, void_$2 as b2, isFailure as b3, isEffect as b4, match$7 as b5, _void as b6, ignore as b7, zipWith as b8, exit as b9, make$g as bA, sequential as bB, acquireUseRelease as bC, forkIn as bD, isDone$4 as bE, succeed$3 as bF, size$1 as bG, combineAll as bH, intoDeferred as bI, zipLeft as bJ, tapErrorCause as bK, addFinalizer as bL, failCause as bM, flatten as bN, fiberIdWith as bO, interrupt as bP, failCause$3 as bQ, fail$2 as bR, matchCause as bS, scopedWith as bT, unsafeGet as bU, constVoid as bV, scope as bW, withFiberRuntime as bX, make$1 as bY, extend as bZ, close as b_, zipRight$1 as ba, sync as bb, provide as bc, matchCauseEffect as bd, zipRight as be, flatMap as bf, forkDaemon as bg, interruptible as bh, suspend as bi, ensuring as bj, uninterruptible as bk, map as bl, zip as bm, failCause$2 as bn, match$3 as bo, forEach as bp, all$2 as bq, getOrElse as br, void_$1 as bs, dieMessage as bt, catchAllCause as bu, die as bv, map$2 as bw, uninterruptibleMask as bx, all as by, fork as bz, catchAll as c, runtime as c0, tap as c1, addFinalizerExit as c2, makeSemaphore as c3, when as c4, race as c5, as as c6, repeat as c7, asVoid as c8, zip$1 as c9, raceFirst as ca, forever as cb, of$1 as cc, fail as cd, mapError as ce, reduce$6 as cf, map$7 as cg, match as ch, splitWhere as ci, isSuccess as cj, head as ck, filterMap as cl, catchSomeCause as cm, unsafeFromArray as cn, async as co, runFork as cp, isRight as d, getRight as e, decode as f, getOrThrowWith as g, map$3 as h, identity as i, all$1 as j, merge$3 as k, logError as l, match$6 as m, sync$1 as n, suspend$2 as o, get$2 as p, succeed$4 as q, runPromise as r, succeed as s, tapError as t, none$4 as u, getOrUndefined as v, unsafeMake$4 as w, has as x, set$1 as y, struct as z };
+class FetchError extends TaggedError('FetchError') {
+}
+class NotFoundError extends TaggedError('NotFoundError') {
+}
+const httpClient = (input, init) => gen$1(function* () {
+    const response = yield* tryPromise({
+        try: () => fetch(input, init),
+        catch: error => new FetchError({ cause: error }),
+    });
+    if (response.status === 404) {
+        return yield* fail$1(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$5({
+    capacity: 200,
+    timeToLive: infinity,
+    lookup: (key) => gen(function* () {
+        const name = key;
+        const assetPath = createAssetUrlSafely(`${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 { asVoid$1 as $, ARIA_VALIDATION_RUNTIME_CHANGED_EVENT as A, isInterruptedOnly as B, join as C, interruptFiber as D, inheritAll as E, interruptAsFiber as F, pipe as G, flatMap$2 as H, sync$1 as I, dual as J, map$3 as K, make$m as L, unbounded as M, deferredMake as N, Class as O, pipeArguments as P, suspend$2 as Q, catchAll$1 as R, interrupt$2 as S, get$4 as T, none$4 as U, some as V, length as W, uninterruptible$1 as X, withFiberRuntime$1 as Y, set$3 as Z, _await as _, catchAll as a, map$2 as a$, whenEffect as a0, deferredSucceed as a1, zipRight$2 as a2, forEachConcurrentDiscard as a3, deferredAwait as a4, poll as a5, EmptyMutableQueue as a6, succeed$4 as a7, fromIterable$6 as a8, empty$m as a9, ignore as aA, zipWith as aB, exit as aC, zipRight$1 as aD, sync as aE, provide as aF, matchCauseEffect as aG, zipRight as aH, flatMap as aI, forkDaemon as aJ, interruptible as aK, suspend as aL, ensuring as aM, uninterruptible as aN, map as aO, zip as aP, succeed$2 as aQ, failCause$2 as aR, match$3 as aS, forEach as aT, isSome as aU, all$2 as aV, getOrElse as aW, void_$1 as aX, dieMessage as aY, catchAllCause as aZ, die as a_, splitAt$1 as aa, isEmpty$7 as ab, deferredUnsafeMake as ac, onInterrupt as ad, offer as ae, fromIterable$5 as af, pollUpTo as ag, deferredUnsafeDone as ah, prepend$1 as ai, isEmpty$2 as aj, filter as ak, appendAll$1 as al, append$1 as am, offerAll as an, deferredInterruptWith as ao, empty$j as ap, bounded as aq, capacity as ar, void_$2 as as, fiberId as at, isFailure as au, hasProperty as av, isEffect as aw, identity as ax, match$7 as ay, _void as az, emptyDefaultSvg as b, uninterruptibleMask as b0, all as b1, fork as b2, make$i as b3, sequential as b4, acquireUseRelease as b5, forkIn as b6, isDone$4 as b7, succeed$3 as b8, size$1 as b9, tap as bA, addFinalizerExit as bB, makeSemaphore as bC, when as bD, race as bE, as as bF, match$6 as bG, repeat as bH, asVoid as bI, equals$1 as bJ, zip$1 as bK, raceFirst as bL, forever as bM, of$1 as bN, fail as bO, mapError as bP, reduce$6 as bQ, map$7 as bR, match as bS, splitWhere as bT, isSuccess as bU, head as bV, filterMap as bW, catchSomeCause as bX, unsafeFromArray as bY, async as bZ, runFork as b_, combineAll as ba, _await$1 as bb, intoDeferred as bc, zipLeft as bd, tapErrorCause as be, addFinalizer as bf, failCause as bg, flatten as bh, fiberIdWith as bi, interrupt as bj, left as bk, right as bl, failCause$3 as bm, fail$2 as bn, matchCause as bo, scopedWith as bp, unsafeGet as bq, constVoid as br, scope as bs, gen as bt, withFiberRuntime as bu, make$1 as bv, extend as bw, close as bx, raceWith as by, runtime as bz, clearIconCache as c, disableAriaValidation as d, enableAriaValidation as e, fetchIconSvg as f, modify as g, get as h, isAriaValidationEnabled as i, update$1 as j, isInterrupted as k, logError as l, make$c as m, fail$4 as n, failureOrCause as o, flipCauseOption as p, queueValidation as q, runPromise as r, succeed as s, tapError as t, useVerboseLogging as u, interrupt$3 as v, map$4 as w, die$2 as x, isDieType as y, interruptors as z };
+//# sourceMappingURL=icons-D1lxdRXP.js.map
+
+//# sourceMappingURL=icons-D1lxdRXP.js.map