@lmvz-ds/components 0.16.0 → 0.17.1

package/dist/esm/icons-B255FOe4.js

@@ -0,0 +1,649 @@
+import { g as getOrThrowWith, a as right, b as left, i as identity, d as isRight, e as getRight, m as match, f as decode, h as map, j as all, k as merge, n as sync, o as suspend, p as get, q as succeed, u as none, v as getOrUndefined, w as unsafeMake, x as has, y as set, z as struct, A as flatMap, B as clockWith, C as offer, D as compareAndSet, E as poll, F as EmptyMutableQueue, G as remove, H as set$1, I as size, J as isSome, K as some, L as empty, M as make$2, N as unbounded, O as symbol, P as pipe, Q as cached, R as combine, S as hash, T as symbol$1, U as hasProperty, V as equals, W as asVoid, _ as _await, X as when, Y as succeed$1, Z as toMillis, $ as onInterrupt, a0 as zipRight, a1 as interrupt, a2 as done, a3 as exit, a4 as provideContext, a5 as context, a6 as fiberId, a7 as YieldableError, a8 as gen, a9 as tryPromise, aa as fail, ab as try_, ac as gen$1, ad as infinity, ae as logWarning } from './Effect-9SROYpxM.js';
+import { c as createAssetUrlSafely } from './assets-CNHv_WMG.js';
+
+/**
+ * This module provides types and utility functions to create and work with branded types,
+ * which are TypeScript types with an added type tag to prevent accidental usage of a value in the wrong context.
+ *
+ * The `refined` and `nominal` functions are both used to create branded types in TypeScript.
+ * The main difference between them is that `refined` allows for validation of the data, while `nominal` does not.
+ *
+ * The `nominal` function is used to create a new branded type that has the same underlying type as the input, but with a different name.
+ * This is useful when you want to distinguish between two values of the same type that have different meanings.
+ * The `nominal` function does not perform any validation of the input data.
+ *
+ * On the other hand, the `refined` function is used to create a new branded type that has the same underlying type as the input,
+ * but with a different name, and it also allows for validation of the input data.
+ * The `refined` function takes a predicate that is used to validate the input data.
+ * If the input data fails the validation, a `BrandErrors` is returned, which provides information about the specific validation failure.
+ *
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const RefinedConstructorsTypeId = /*#__PURE__*/Symbol.for("effect/Brand/Refined");
+/**
+ * Returns a `BrandErrors` that contains a single `RefinementError`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const error = (message, meta) => [{
+  message,
+  meta
+}];
+function refined(...args) {
+  const either = args.length === 2 ? unbranded => args[0](unbranded) ? right(unbranded) : left(args[1](unbranded)) : unbranded => {
+    return match(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 complete = (key, exit, entryStats, timeToLiveMillis) => struct({
+  _tag: "Complete",
+  key,
+  exit,
+  entryStats,
+  timeToLiveMillis
+});
+/** @internal */
+const pending = (key, deferred) => struct({
+  _tag: "Pending",
+  key,
+  deferred
+});
+/** @internal */
+const refreshing = (deferred, complete) => struct({
+  _tag: "Refreshing",
+  deferred,
+  complete
+});
+/** @internal */
+const MapKeyTypeId = /*#__PURE__*/Symbol.for("effect/Cache/MapKey");
+class MapKeyImpl {
+  current;
+  [MapKeyTypeId] = MapKeyTypeId;
+  previous = undefined;
+  next = undefined;
+  constructor(current) {
+    this.current = current;
+  }
+  [symbol]() {
+    return pipe(hash(this.current), combine(hash(this.previous)), combine(hash(this.next)), cached(this));
+  }
+  [symbol$1](that) {
+    if (this === that) {
+      return true;
+    }
+    return isMapKey(that) && equals(this.current, that.current) && equals(this.previous, that.previous) && equals(this.next, that.next);
+  }
+}
+/** @internal */
+const makeMapKey = current => new MapKeyImpl(current);
+/** @internal */
+const isMapKey = u => hasProperty(u, MapKeyTypeId);
+class KeySetImpl {
+  head = undefined;
+  tail = undefined;
+  add(key) {
+    if (key !== this.tail) {
+      if (this.tail === undefined) {
+        this.head = key;
+        this.tail = key;
+      } else {
+        const previous = key.previous;
+        const next = key.next;
+        if (next !== undefined) {
+          key.next = undefined;
+          if (previous !== undefined) {
+            previous.next = next;
+            next.previous = previous;
+          } else {
+            this.head = next;
+            this.head.previous = undefined;
+          }
+        }
+        this.tail.next = key;
+        key.previous = this.tail;
+        this.tail = key;
+      }
+    }
+  }
+  remove() {
+    const key = this.head;
+    if (key !== undefined) {
+      const next = key.next;
+      if (next !== undefined) {
+        key.next = undefined;
+        this.head = next;
+        this.head.previous = undefined;
+      } else {
+        this.head = undefined;
+        this.tail = undefined;
+      }
+    }
+    return key;
+  }
+}
+/** @internal */
+const makeKeySet = () => new KeySetImpl();
+/**
+ * Constructs a new `CacheState` from the specified values.
+ *
+ * @internal
+ */
+const makeCacheState = (map, keys, accesses, updating, hits, misses) => ({
+  map,
+  keys,
+  accesses,
+  updating,
+  hits,
+  misses
+});
+/**
+ * Constructs an initial cache state.
+ *
+ * @internal
+ */
+const initialCacheState = () => makeCacheState(empty(), makeKeySet(), unbounded(), make$2(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(this.getEither(key), merge);
+  }
+  get cacheStats() {
+    return sync(() => makeCacheStats({
+      hits: this.cacheState.hits,
+      misses: this.cacheState.misses,
+      size: size(this.cacheState.map)
+    }));
+  }
+  getOption(key) {
+    return suspend(() => match(get(this.cacheState.map, key), {
+      onNone: () => {
+        const mapKey = makeMapKey(key);
+        this.trackAccess(mapKey);
+        this.trackMiss();
+        return succeed(none());
+      },
+      onSome: value => this.resolveMapValue(value)
+    }));
+  }
+  getOptionComplete(key) {
+    return suspend(() => match(get(this.cacheState.map, key), {
+      onNone: () => {
+        const mapKey = makeMapKey(key);
+        this.trackAccess(mapKey);
+        this.trackMiss();
+        return succeed(none());
+      },
+      onSome: value => this.resolveMapValue(value, true)
+    }));
+  }
+  contains(key) {
+    return sync(() => has(this.cacheState.map, key));
+  }
+  entryStats(key) {
+    return sync(() => {
+      const option = get(this.cacheState.map, key);
+      if (isSome(option)) {
+        switch (option.value._tag) {
+          case "Complete":
+            {
+              const loaded = option.value.entryStats.loadedMillis;
+              return some(makeEntryStats(loaded));
+            }
+          case "Pending":
+            {
+              return none();
+            }
+          case "Refreshing":
+            {
+              const loaded = option.value.complete.entryStats.loadedMillis;
+              return some(makeEntryStats(loaded));
+            }
+        }
+      }
+      return none();
+    });
+  }
+  getEither(key) {
+    return suspend(() => {
+      const k = key;
+      let mapKey = undefined;
+      let deferred = undefined;
+      let value = getOrUndefined(get(this.cacheState.map, k));
+      if (value === undefined) {
+        deferred = unsafeMake(this.fiberId);
+        mapKey = makeMapKey(k);
+        if (has(this.cacheState.map, k)) {
+          value = getOrUndefined(get(this.cacheState.map, k));
+        } else {
+          set(this.cacheState.map, k, pending(mapKey, deferred));
+        }
+      }
+      if (value === undefined) {
+        this.trackAccess(mapKey);
+        this.trackMiss();
+        return map(this.lookupValueOf(key, deferred), right);
+      } else {
+        return flatMap(this.resolveMapValue(value), match({
+          onNone: () => this.getEither(key),
+          onSome: value => succeed(left(value))
+        }));
+      }
+    });
+  }
+  invalidate(key) {
+    return sync(() => {
+      remove(this.cacheState.map, key);
+    });
+  }
+  invalidateWhen(key, when) {
+    return sync(() => {
+      const value = get(this.cacheState.map, key);
+      if (isSome(value) && value.value._tag === "Complete") {
+        if (value.value.exit._tag === "Success") {
+          if (when(value.value.exit.value)) {
+            remove(this.cacheState.map, key);
+          }
+        }
+      }
+    });
+  }
+  get invalidateAll() {
+    return sync(() => {
+      this.cacheState.map = empty();
+    });
+  }
+  refresh(key) {
+    return clockWith(clock => suspend(() => {
+      const k = key;
+      const deferred = unsafeMake(this.fiberId);
+      let value = getOrUndefined(get(this.cacheState.map, k));
+      if (value === undefined) {
+        if (has(this.cacheState.map, k)) {
+          value = getOrUndefined(get(this.cacheState.map, k));
+        } else {
+          set(this.cacheState.map, k, pending(makeMapKey(k), deferred));
+        }
+      }
+      if (value === undefined) {
+        return asVoid(this.lookupValueOf(key, deferred));
+      } else {
+        switch (value._tag) {
+          case "Complete":
+            {
+              if (this.hasExpired(clock, value.timeToLiveMillis)) {
+                const found = getOrUndefined(get(this.cacheState.map, k));
+                if (equals(found, value)) {
+                  remove(this.cacheState.map, k);
+                }
+                return asVoid(this.get(key));
+              }
+              // Only trigger the lookup if we're still the current value, `completedResult`
+              return pipe(this.lookupValueOf(key, deferred), when(() => {
+                const current = getOrUndefined(get(this.cacheState.map, k));
+                if (equals(current, value)) {
+                  const mapValue = refreshing(deferred, value);
+                  set(this.cacheState.map, k, mapValue);
+                  return true;
+                }
+                return false;
+              }), asVoid);
+            }
+          case "Pending":
+            {
+              return _await(value.deferred);
+            }
+          case "Refreshing":
+            {
+              return _await(value.deferred);
+            }
+        }
+      }
+    }));
+  }
+  set(key, value) {
+    return clockWith(clock => sync(() => {
+      const now = clock.unsafeCurrentTimeMillis();
+      const k = key;
+      const lookupResult = succeed$1(value);
+      const mapValue = complete(makeMapKey(k), lookupResult, makeEntryStats(now), now + toMillis(decode(this.timeToLive(lookupResult))));
+      set(this.cacheState.map, k, mapValue);
+    }));
+  }
+  get size() {
+    return sync(() => {
+      return size(this.cacheState.map);
+    });
+  }
+  get values() {
+    return sync(() => {
+      const values = [];
+      for (const entry of this.cacheState.map) {
+        if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
+          values.push(entry[1].exit.value);
+        }
+      }
+      return values;
+    });
+  }
+  get entries() {
+    return sync(() => {
+      const values = [];
+      for (const entry of this.cacheState.map) {
+        if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
+          values.push([entry[0], entry[1].exit.value]);
+        }
+      }
+      return values;
+    });
+  }
+  get keys() {
+    return sync(() => {
+      const keys = [];
+      for (const entry of this.cacheState.map) {
+        if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
+          keys.push(entry[0]);
+        }
+      }
+      return keys;
+    });
+  }
+  resolveMapValue(value, ignorePending = false) {
+    return clockWith(clock => {
+      switch (value._tag) {
+        case "Complete":
+          {
+            this.trackAccess(value.key);
+            if (this.hasExpired(clock, value.timeToLiveMillis)) {
+              remove(this.cacheState.map, value.key.current);
+              return succeed(none());
+            }
+            this.trackHit();
+            return map(value.exit, some);
+          }
+        case "Pending":
+          {
+            this.trackAccess(value.key);
+            this.trackHit();
+            if (ignorePending) {
+              return succeed(none());
+            }
+            return map(_await(value.deferred), some);
+          }
+        case "Refreshing":
+          {
+            this.trackAccess(value.complete.key);
+            this.trackHit();
+            if (this.hasExpired(clock, value.complete.timeToLiveMillis)) {
+              if (ignorePending) {
+                return succeed(none());
+              }
+              return map(_await(value.deferred), some);
+            }
+            return map(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(this.cacheState.map, key.current);
+            size$1 = size$1 - 1;
+            loop = size$1 > this.capacity;
+          }
+        } else {
+          loop = false;
+        }
+      }
+      set$1(this.cacheState.updating, false);
+    }
+  }
+  hasExpired(clock, timeToLiveMillis) {
+    return clock.unsafeCurrentTimeMillis() > timeToLiveMillis;
+  }
+  lookupValueOf(input, deferred) {
+    return clockWith(clock => suspend(() => {
+      const key = input;
+      return pipe(this.lookup(input), provideContext(this.context), exit, flatMap(exit => {
+        const now = clock.unsafeCurrentTimeMillis();
+        const stats = makeEntryStats(now);
+        const value = complete(makeMapKey(key), exit, stats, now + toMillis(decode(this.timeToLive(exit))));
+        set(this.cacheState.map, key, value);
+        return zipRight(done(deferred, exit), exit);
+      }), onInterrupt(() => zipRight(interrupt(deferred), sync(() => {
+        remove(this.cacheState.map, key);
+      }))));
+    }));
+  }
+}
+/** @internal */
+const make$1 = options => {
+  const timeToLive = decode(options.timeToLive);
+  return makeWith({
+    capacity: options.capacity,
+    lookup: options.lookup,
+    timeToLive: () => timeToLive
+  });
+};
+/** @internal */
+const makeWith = options => map(all([context(), fiberId]), ([context, fiberId]) => new CacheImpl(options.capacity, context, fiberId, options.lookup, exit => decode(options.timeToLive(exit))));
+
+/**
+ * Constructs a new cache with the specified capacity, time to live, and
+ * lookup function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const make = make$1;
+
+/**
+ * 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;
+};
+
+class FetchError extends TaggedError('FetchError') {
+}
+class NotFoundError extends TaggedError('NotFoundError') {
+}
+const httpClient = (input, init) => gen(function* () {
+    const response = yield* tryPromise({
+        try: () => fetch(input, init),
+        catch: error => new FetchError({ cause: error }),
+    });
+    if (response.status === 404) {
+        return yield* fail(new NotFoundError({ url: response.url }));
+    }
+    return response;
+});
+class ResponseTextError extends TaggedError('ResponseTextError') {
+    constructor(error) {
+        super(new Error(`Failed to read response text`, { cause: error }));
+    }
+}
+const responseAsText = (res) => tryPromise({
+    try: () => res.text(),
+    catch: error => new ResponseTextError(error),
+});
+
+const SVGString = refined(isValidSVG, () => error('SVG data is malformed'));
+class BrandValidationError extends TaggedError('BrandValidationError') {
+    constructor(error, type) {
+        super(new Error(`Brand validation failed for type ${type}.`, { cause: error }));
+    }
+}
+const createValidSVGString = (svg) => try_({
+    try: () => SVGString(svg),
+    catch: error => new BrandValidationError(error, 'SVGString'),
+});
+function isValidSVG(svg) {
+    if (typeof svg !== 'string') {
+        return false;
+    }
+    try {
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(svg, 'image/svg+xml');
+        return doc.documentElement.nodeName === 'svg';
+    }
+    catch {
+        return false;
+    }
+}
+
+const emptyDefaultSvg = () => SVGString(`<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg"></svg>`);
+const createIconCache = () => make({
+    capacity: 200,
+    timeToLive: infinity,
+    lookup: (key) => gen$1(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$1(function* () {
+        if (!cacheInstance) {
+            cacheInstance = yield* createIconCache();
+        }
+        return yield* cacheInstance.get(key);
+    });
+}
+function clearIconCache() {
+    return gen$1(function* () {
+        if (cacheInstance) {
+            yield* cacheInstance.invalidateAll;
+        }
+        else {
+            logWarning('Attempted to clear icon cache before it was initialized');
+        }
+    });
+}
+
+export { clearIconCache as c, emptyDefaultSvg as e, fetchIconSvg as f };

package/dist/esm/{index-DoNkkDv1.js → index-BW1YMEA3.js}

@@ -1,6 +1,4 @@
-import { m as make$4, g as modify$1, h as get$1, j as update$1, k as isInterrupted$1, n as fail$2, o as failureOrCause$1, p as flipCauseOption$1, v as interrupt$2, w as map$3, x as die$1, y as isDieType$1, z as interruptors$1, B as isInterruptedOnly$1, C as join$1, D as interruptFiber, _ as _await$1, E as inheritAll$1, F as interruptAsFiber, G as pipe, H as flatMap$2, I as sync$1, J as dual, K as map$4, L as make$5, M as unbounded$2, N as deferredMake, O as Class, P as pipeArguments, Q as suspend$2, R as catchAll, S as interrupt$3, T as get$2, U as none, V as some, W as length, X as uninterruptible, Y as withFiberRuntime, Z as set, $ as asVoid, a0 as whenEffect, a1 as deferredSucceed, a2 as zipRight$1, a3 as forEachConcurrentDiscard, a4 as deferredAwait, a5 as poll, a6 as EmptyMutableQueue, a7 as succeed$1, a8 as fromIterable, a9 as empty, aa as splitAt, ab as isEmpty, ac as deferredUnsafeMake, ad as onInterrupt, ae as offer$2, af as fromIterable$1, ag as pollUpTo, ah as deferredUnsafeDone, ai as prepend, aj as isEmpty$1, ak as filter, al as appendAll, am as append, an as offerAll, ao as deferredInterruptWith, ap as empty$1, aq as bounded$2, ar as capacity, as as void_$1, at as fiberId, au as isFailure, av as hasProperty, aw as isEffect, ax as identity, ay as match$1, az as _void, aA as ignore, aB as zipWith, aC as exit, aD as zipRight$2, aE as sync$2, aF as provide, aG as matchCauseEffect, aH as zipRight$3, aI as flatMap$3, aJ as forkDaemon, aK as interruptible, aL as suspend$3, aM as ensuring$2, aN as uninterruptible$1, aO as map$5, aP as zip$1, aQ as succeed$2, aR as failCause$3, aS as match$2, aT as forEach, s as succeed$3, aU as isSome, aV as all, aW as getOrElse, aX as void_$2, aY as dieMessage, aZ as catchAllCause, a_ as die$2, a$ as map$6, b0 as uninterruptibleMask, b1 as all$1, b2 as fork, b3 as make$6, b4 as sequential, b5 as acquireUseRelease, b6 as forkIn, b7 as isDone, b8 as succeed$4, b9 as size$2, ba as combineAll, bb as _await$2, bc as intoDeferred, bd as zipLeft, be as tapErrorCause, bf as addFinalizer, bg as failCause$4, bh as flatten$2, bi as fiberIdWith, bj as interrupt$4, bk as left, bl as right, bm as failCause$5, bn as fail$3, bo as matchCause, bp as scopedWith$2, bq as unsafeGet, br as constVoid, bs as scope, bt as gen, bu as withFiberRuntime$1, bv as make$7, bw as extend, bx as close, by as raceWith, bz as runtime, bA as tap, bB as addFinalizerExit, bC as makeSemaphore, bD as when, bE as race, bF as as, bG as match$3, bH as repeat, bI as asVoid$1, bJ as equals, bK as zip$2, bL as raceFirst, bM as forever, bN as of$1, bO as fail$4, bP as mapError, bQ as reduce, bR as map$7, bS as match$4, bT as splitWhere, bU as isSuccess, bV as head, bW as filterMap, a as catchAll$1, bX as catchSomeCause, bY as unsafeFromArray, bZ as async, b_ as runFork, r as runPromise } from './icons-D1lxdRXP.js';
-import './assets-BD98wsl7.js';
-import './index-WeqgWisK.js';
+import { af as make$4, ag as modify$1, ah as get$1, ai as update$1, aj as isInterrupted$1, ak as fail$2, al as failureOrCause$1, am as flipCauseOption$1, an as interrupt$2, ao as map$3, ap as die$1, aq as isDieType$1, ar as interruptors$1, as as isInterruptedOnly$1, at as join$1, au as interruptFiber, av as _await$1, aw as inheritAll$1, ax as interruptAsFiber, P as pipe, A as flatMap$2, n as sync$1, ay as dual, h as map$4, M as make$5, N as unbounded$2, az as deferredMake, aA as Class, aB as pipeArguments, o as suspend$2, aC as catchAll, aD as interrupt$3, aE as get$2, u as none, K as some, aF as length, aG as uninterruptible, aH as withFiberRuntime, H as set, W as asVoid, aI as whenEffect, aJ as deferredSucceed, a0 as zipRight$1, aK as forEachConcurrentDiscard, aL as deferredAwait, E as poll, F as EmptyMutableQueue, q as succeed$1, aM as fromIterable, aN as empty, aO as splitAt, aP as isEmpty, aQ as deferredUnsafeMake, $ as onInterrupt, C as offer$2, aR as fromIterable$1, aS as pollUpTo, aT as deferredUnsafeDone, aU as prepend, aV as isEmpty$1, aW as filter, aX as appendAll, aY as append, aZ as offerAll, a_ as deferredInterruptWith, a$ as empty$1, b0 as bounded$2, b1 as capacity, b2 as void_$1, a6 as fiberId, b3 as isFailure, U as hasProperty, b4 as isEffect, i as identity, b5 as match$1, b6 as _void, b7 as ignore, b8 as zipWith, b9 as exit, ba as zipRight$2, bb as sync$2, bc as provide, bd as matchCauseEffect, be as zipRight$3, bf as flatMap$3, bg as forkDaemon, bh as interruptible, bi as suspend$3, bj as ensuring$2, bk as uninterruptible$1, bl as map$5, bm as zip$1, Y as succeed$2, bn as failCause$3, bo as match$2, bp as forEach, s as succeed$3, J as isSome, bq as all, br as getOrElse, bs as void_$2, bt as dieMessage, bu as catchAllCause, bv as die$2, bw as map$6, bx as uninterruptibleMask, by as all$1, bz as fork, bA as make$6, bB as sequential, bC as acquireUseRelease, bD as forkIn, bE as isDone, bF as succeed$4, bG as size$2, bH as combineAll, _ as _await$2, bI as intoDeferred, bJ as zipLeft, bK as tapErrorCause, bL as addFinalizer, bM as failCause$4, bN as flatten$2, bO as fiberIdWith, bP as interrupt$4, b as left, a as right, bQ as failCause$5, bR as fail$3, bS as matchCause, bT as scopedWith$2, bU as unsafeGet, bV as constVoid, bW as scope, ac as gen, bX as withFiberRuntime$1, bY as make$7, bZ as extend, b_ as close, b$ as raceWith, c0 as runtime, c1 as tap, c2 as addFinalizerExit, c3 as makeSemaphore, c4 as when, c5 as race, c6 as as, m as match$3, c7 as repeat, c8 as asVoid$1, V as equals, c9 as zip$2, ca as raceFirst, cb as forever, cc as of$1, cd as fail$4, ce as mapError, cf as reduce, cg as map$7, ch as match$4, ci as splitWhere, cj as isSuccess, ck as head, cl as filterMap, c as catchAll$1, cm as catchSomeCause, cn as unsafeFromArray, co as async, cp as runFork, r as runPromise } from './Effect-9SROYpxM.js';
 
 /**
  * @since 2.0.0
@@ -35626,6 +35624,3 @@ function enqueueValidation(validationRequest) {
 }
 
 export { enqueueValidation, initializeValidationStream };
-//# sourceMappingURL=index-DoNkkDv1.js.map
-
-//# sourceMappingURL=index-DoNkkDv1.js.map