@lmvz-ds/components 0.14.1 → 0.16.0

package/dist/cjs/{Effect-CpZhfb0D.js → icons-BOM23oli.js}

@@ -1,5 +1,120 @@
 'use strict';
 
+var assets = require('./assets-XY-cBmal.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 = Promise.resolve().then(function () { return require('./index-ww_DCXU7.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`.
  *
@@ -275,19 +390,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;
   }
@@ -1032,10 +1147,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) {
@@ -1218,7 +1336,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 */
@@ -1602,17 +1720,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.
  *
@@ -2094,7 +2212,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.
@@ -2458,7 +2576,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.
@@ -2913,6 +3031,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 */
@@ -2947,7 +3113,7 @@ const TagProto = {
     return self;
   },
   context(self) {
-    return make$r(this, self);
+    return make$t(this, self);
   }
 };
 const ReferenceProto = {
@@ -3057,7 +3223,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);
@@ -3176,7 +3342,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`.
  *
@@ -3395,7 +3561,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]: {
@@ -3507,7 +3673,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.
  *
@@ -4116,7 +4282,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) {
@@ -4173,52 +4339,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
@@ -4437,7 +4603,7 @@ function fromBitmap(bitmap, bit) {
   return popcount(bitmap & bit - 1);
 }
 
-const make$n = (value, previous) => ({
+const make$p = (value, previous) => ({
   value,
   previous
 });
@@ -4723,7 +4889,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;
@@ -5047,7 +5213,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);
@@ -5555,7 +5721,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`.
  *
@@ -5784,7 +5950,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;
@@ -5940,7 +6106,7 @@ const ids = self => {
       }
     case OP_RUNTIME:
       {
-        return make$l(self.id);
+        return make$n(self.id);
       }
     case OP_COMPOSITE:
       {
@@ -5948,7 +6114,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(",");
@@ -6739,7 +6905,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;
@@ -6748,21 +6914,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({
@@ -6775,7 +6941,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) {
@@ -6804,15 +6970,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 */
@@ -6841,18 +7007,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),
@@ -7419,7 +7585,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];
           }
@@ -7428,7 +7594,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];
           }
@@ -7437,7 +7603,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];
           }
@@ -7655,34 +7821,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`.
  *
@@ -7770,10 +7935,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],
@@ -7797,7 +7962,7 @@ const deferredVariance = {
   _A: _ => _
 };
 /** @internal */
-const pending = joiners => {
+const pending$1 = joiners => {
   return {
     _tag: OP_STATE_PENDING,
     joiners
@@ -8848,7 +9013,7 @@ const deferredUnsafeMake = fiberId => {
   const _deferred = {
     ...CommitPrototype,
     [DeferredTypeId]: deferredVariance,
-    state: make$k(pending([])),
+    state: make$m(pending$1([])),
     commit() {
       return deferredAwait(this);
     },
@@ -8955,7 +9120,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
@@ -9427,7 +9592,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;
@@ -9439,14 +9604,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.
  *
@@ -9615,7 +9780,7 @@ class ClockImpl {
   }
 }
 /** @internal */
-const make$e = () => new ClockImpl();
+const make$g = () => new ClockImpl();
 
 /** @internal */
 const OP_AND = "And";
@@ -9862,7 +10027,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);
@@ -9877,7 +10042,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
@@ -10212,7 +10377,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
@@ -10220,7 +10385,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
 });
@@ -10289,13 +10454,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.
  *
@@ -10547,7 +10716,7 @@ const Fatal = logLevelFatal;
  * @since 2.0.0
  * @category constructors
  */
-const Error$1 = logLevelError;
+const Error$2 = logLevelError;
 /**
  * @since 2.0.0
  * @category constructors
@@ -10594,7 +10763,7 @@ const fromLiteral = literal => {
     case "Debug":
       return Debug;
     case "Error":
-      return Error$1;
+      return Error$2;
     case "Fatal":
       return Fatal;
     case "Info":
@@ -10671,9 +10840,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 */
@@ -10812,7 +10981,7 @@ class MetricLabelImpl {
   }
 }
 /** @internal */
-const make$9 = (key, value) => {
+const make$b = (key, value) => {
   return new MetricLabelImpl(key, value);
 };
 /** @internal */
@@ -10885,7 +11054,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)),
@@ -10930,6 +11099,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";
@@ -11883,6 +12053,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
@@ -11921,14 +12146,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
@@ -11936,33 +12160,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
    */
@@ -11972,12 +12169,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);
   }
 }
 /**
@@ -12517,7 +12710,7 @@ const metricHookVariance = {
   _Out: _ => _
 };
 /** @internal */
-const make$8 = options => ({
+const make$a = options => ({
   [MetricHookTypeId]: metricHookVariance,
   pipe() {
     return pipeArguments(this, arguments);
@@ -12534,7 +12727,7 @@ const counter$1 = key => {
       sum = sum + value;
     }
   };
-  return make$8({
+  return make$a({
     get: () => counter$2(sum),
     update,
     modify: update
@@ -12550,7 +12743,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
@@ -12559,7 +12752,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;
@@ -12629,7 +12822,7 @@ const histogram$1 = key => {
     }
     return builder;
   };
-  return make$8({
+  return make$a({
     get: () => histogram$2({
       buckets: getBuckets(),
       count,
@@ -12696,7 +12889,7 @@ const summary = key => {
     count = count + 1;
     sum = sum + value;
   };
-  return make$8({
+  return make$a({
     get: () => summary$1({
       error,
       quantiles: snapshot(Date.now()),
@@ -12963,7 +13156,7 @@ class MetricRegistryImpl {
   }
 }
 /** @internal */
-const make$7 = () => {
+const make$9 = () => {
   return new MetricRegistryImpl();
 };
 
@@ -12980,9 +13173,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,
@@ -13021,21 +13214,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) {
@@ -13178,7 +13371,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";
@@ -13270,7 +13463,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);
     }
   }
 };
@@ -13292,7 +13485,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,
@@ -13553,6 +13746,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);
@@ -13772,7 +13969,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,
@@ -14436,7 +14633,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;
   }
@@ -14455,7 +14652,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)) {
@@ -14563,7 +14760,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();
@@ -14587,7 +14784,7 @@ const forEachConcurrentDiscard = (self, f, batching, processAll, n) => uninterru
         fiber.unsafeInterruptAsFork(parent.id());
       }
       fiber.resume(runnable);
-    }, 0);
+    }, 0, fiber);
     return fiber;
   };
   const onInterruptSignal = () => {
@@ -14638,7 +14835,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;
@@ -14897,7 +15094,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, {
@@ -14952,7 +15149,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 => {
@@ -15018,9 +15215,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 */
@@ -15327,20 +15993,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);
@@ -15352,7 +16022,7 @@ class Semaphore {
           item.value();
           item = iter.next();
         }
-      }, fiber.getFiberRef(currentSchedulingPriority));
+      }, fiber.getFiberRef(currentSchedulingPriority), fiber);
     }
     return succeed$4(this.free);
   }
@@ -15616,7 +16286,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(),
@@ -15691,7 +16361,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:
@@ -15833,6 +16503,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 */
@@ -15961,7 +16678,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 */
@@ -18789,18 +19506,98 @@ const zipRight = zipRightOptions;
  */
 const zipWith = zipWithOptions;
 
+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 = assets.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');
+        }
+    });
+}
+
+exports.ARIA_VALIDATION_RUNTIME_CHANGED_EVENT = ARIA_VALIDATION_RUNTIME_CHANGED_EVENT;
 exports.Class = Class;
 exports.EmptyMutableQueue = EmptyMutableQueue;
-exports.YieldableError = YieldableError;
-exports._await = _await$1;
-exports._await$1 = _await;
+exports._await = _await;
+exports._await$1 = _await$1;
 exports._void = _void;
 exports.acquireUseRelease = acquireUseRelease;
 exports.addFinalizer = addFinalizer;
 exports.addFinalizerExit = addFinalizerExit;
-exports.all = all$1;
-exports.all$1 = all$2;
-exports.all$2 = all;
+exports.all = all$2;
+exports.all$1 = all;
 exports.append = append$1;
 exports.appendAll = appendAll$1;
 exports.as = as;
@@ -18808,20 +19605,15 @@ exports.asVoid = asVoid$1;
 exports.asVoid$1 = asVoid;
 exports.async = async;
 exports.bounded = bounded;
-exports.cached = cached;
 exports.capacity = capacity;
 exports.catchAll = catchAll;
 exports.catchAll$1 = catchAll$1;
 exports.catchAllCause = catchAllCause;
 exports.catchSomeCause = catchSomeCause;
-exports.clockWith = clockWith;
+exports.clearIconCache = clearIconCache;
 exports.close = close;
-exports.combine = combine$7;
 exports.combineAll = combineAll;
-exports.compareAndSet = compareAndSet;
 exports.constVoid = constVoid;
-exports.context = context;
-exports.decode = decode;
 exports.deferredAwait = deferredAwait;
 exports.deferredInterruptWith = deferredInterruptWith;
 exports.deferredMake = deferredMake;
@@ -18831,24 +19623,24 @@ exports.deferredUnsafeMake = deferredUnsafeMake;
 exports.die = die$2;
 exports.die$1 = die;
 exports.dieMessage = dieMessage;
-exports.done = done$4;
+exports.disableAriaValidation = disableAriaValidation;
 exports.dual = dual;
-exports.empty = empty$8;
-exports.empty$1 = empty$m;
-exports.empty$2 = empty$j;
+exports.empty = empty$m;
+exports.empty$1 = empty$j;
+exports.emptyDefaultSvg = emptyDefaultSvg;
+exports.enableAriaValidation = enableAriaValidation;
 exports.ensuring = ensuring;
 exports.equals = equals$1;
-exports.exit = exit$1;
-exports.exit$1 = exit;
+exports.exit = exit;
 exports.extend = extend;
-exports.fail = fail$1;
-exports.fail$1 = fail$4;
-exports.fail$2 = fail$2;
-exports.fail$3 = fail;
+exports.fail = fail$4;
+exports.fail$1 = fail$2;
+exports.fail$2 = fail;
 exports.failCause = failCause$2;
 exports.failCause$1 = failCause;
 exports.failCause$2 = failCause$3;
 exports.failureOrCause = failureOrCause;
+exports.fetchIconSvg = fetchIconSvg;
 exports.fiberId = fiberId;
 exports.fiberIdWith = fiberIdWith;
 exports.filter = filter;
@@ -18865,32 +19657,24 @@ exports.forkDaemon = forkDaemon;
 exports.forkIn = forkIn;
 exports.fromIterable = fromIterable$6;
 exports.fromIterable$1 = fromIterable$5;
-exports.gen = gen$1;
-exports.gen$1 = gen;
-exports.get = get$2;
-exports.get$1 = get;
-exports.get$2 = get$4;
+exports.gen = gen;
+exports.get = get;
+exports.get$1 = get$4;
 exports.getOrElse = getOrElse;
-exports.getOrThrowWith = getOrThrowWith;
-exports.getOrUndefined = getOrUndefined;
-exports.getRight = getRight;
-exports.has = has;
 exports.hasProperty = hasProperty;
-exports.hash = hash;
 exports.head = head;
 exports.identity = identity;
 exports.ignore = ignore;
-exports.infinity = infinity;
 exports.inheritAll = inheritAll;
-exports.interrupt = interrupt$1;
-exports.interrupt$1 = interrupt$3;
-exports.interrupt$2 = interrupt$2;
-exports.interrupt$3 = interrupt;
+exports.interrupt = interrupt$3;
+exports.interrupt$1 = interrupt$2;
+exports.interrupt$2 = interrupt;
 exports.interruptAsFiber = interruptAsFiber;
 exports.interruptFiber = interruptFiber;
 exports.interruptible = interruptible;
 exports.interruptors = interruptors;
 exports.intoDeferred = intoDeferred;
+exports.isAriaValidationEnabled = isAriaValidationEnabled;
 exports.isDieType = isDieType;
 exports.isDone = isDone$4;
 exports.isEffect = isEffect;
@@ -18899,32 +19683,29 @@ exports.isEmpty$1 = isEmpty$2;
 exports.isFailure = isFailure;
 exports.isInterrupted = isInterrupted;
 exports.isInterruptedOnly = isInterruptedOnly;
-exports.isRight = isRight;
 exports.isSome = isSome;
 exports.isSuccess = isSuccess;
 exports.join = join;
 exports.left = left;
 exports.length = length;
 exports.logError = logError;
-exports.logWarning = logWarning;
-exports.make = make$k;
-exports.make$1 = make$a;
-exports.make$2 = make$g;
+exports.make = make$c;
+exports.make$1 = make$m;
+exports.make$2 = make$i;
 exports.make$3 = make$1;
 exports.makeSemaphore = makeSemaphore;
-exports.map = map$3;
-exports.map$1 = map$4;
+exports.map = map$4;
+exports.map$1 = map$3;
 exports.map$2 = map;
 exports.map$3 = map$2;
 exports.map$4 = map$7;
 exports.mapError = mapError;
-exports.match = match$6;
-exports.match$1 = match$7;
-exports.match$2 = match$3;
+exports.match = match$7;
+exports.match$1 = match$3;
+exports.match$2 = match$6;
 exports.match$3 = match;
 exports.matchCause = matchCause;
 exports.matchCauseEffect = matchCauseEffect;
-exports.merge = merge$3;
 exports.modify = modify;
 exports.none = none$4;
 exports.of = of$1;
@@ -18937,12 +19718,11 @@ exports.poll = poll;
 exports.pollUpTo = pollUpTo;
 exports.prepend = prepend$1;
 exports.provide = provide;
-exports.provideContext = provideContext$1;
+exports.queueValidation = queueValidation;
 exports.race = race;
 exports.raceFirst = raceFirst;
 exports.raceWith = raceWith;
 exports.reduce = reduce$6;
-exports.remove = remove$1;
 exports.repeat = repeat;
 exports.right = right;
 exports.runFork = runFork;
@@ -18951,42 +19731,33 @@ exports.runtime = runtime;
 exports.scope = scope;
 exports.scopedWith = scopedWith;
 exports.sequential = sequential;
-exports.set = set$1;
-exports.set$1 = set$3;
-exports.size = size;
-exports.size$1 = size$1;
+exports.set = set$3;
+exports.size = size$1;
 exports.some = some;
 exports.splitAt = splitAt$1;
 exports.splitWhere = splitWhere;
-exports.struct = struct;
 exports.succeed = succeed;
 exports.succeed$1 = succeed$4;
 exports.succeed$2 = succeed$2;
 exports.succeed$3 = succeed$3;
 exports.suspend = suspend$2;
 exports.suspend$1 = suspend;
-exports.symbol = symbol$1;
-exports.symbol$1 = symbol;
 exports.sync = sync$1;
 exports.sync$1 = sync;
 exports.tap = tap;
 exports.tapError = tapError;
 exports.tapErrorCause = tapErrorCause;
-exports.toMillis = toMillis;
-exports.tryPromise = tryPromise;
-exports.try_ = try_;
 exports.unbounded = unbounded;
 exports.uninterruptible = uninterruptible$1;
 exports.uninterruptible$1 = uninterruptible;
 exports.uninterruptibleMask = uninterruptibleMask;
 exports.unsafeFromArray = unsafeFromArray;
 exports.unsafeGet = unsafeGet;
-exports.unsafeMake = unsafeMake$4;
 exports.update = update$1;
+exports.useVerboseLogging = useVerboseLogging;
 exports.void_ = void_$2;
 exports.void_$1 = void_$1;
-exports.when = when$1;
-exports.when$1 = when;
+exports.when = when;
 exports.whenEffect = whenEffect;
 exports.withFiberRuntime = withFiberRuntime$1;
 exports.withFiberRuntime$1 = withFiberRuntime;
@@ -18997,3 +19768,6 @@ exports.zipRight = zipRight$2;
 exports.zipRight$1 = zipRight$1;
 exports.zipRight$2 = zipRight;
 exports.zipWith = zipWith;
+//# sourceMappingURL=icons-BOM23oli.js.map
+
+//# sourceMappingURL=icons-BOM23oli.js.map