effect 2.0.0-next.38 → 2.0.0-next.39

package/internal/clock.esm.js

@@ -0,0 +1,82 @@
+import { Tag } from '../Context/dist/effect-Context.esm.js';
+import { toMillis } from '../Duration/dist/effect-Duration.esm.js';
+import { left } from '../Either/dist/effect-Either.esm.js';
+import { constFalse } from '../Function/dist/effect-Function.esm.js';
+import { sync, succeed, asyncEither, unit, asUnit } from './core.esm.js';
+import { set, clear } from './timeout.esm.js';
+
+/** @internal */
+const ClockSymbolKey = "effect/Clock";
+
+/** @internal */
+const ClockTypeId = /*#__PURE__*/Symbol.for(ClockSymbolKey);
+
+/** @internal */
+const clockTag = /*#__PURE__*/Tag(ClockTypeId);
+
+/** @internal */
+const MAX_TIMER_MILLIS = 2 ** 31 - 1;
+
+/** @internal */
+const globalClockScheduler = {
+  unsafeSchedule(task, duration) {
+    const millis = toMillis(duration);
+    // If the duration is greater than the value allowable by the JS timer
+    // functions, treat the value as an infinite duration
+    if (millis > MAX_TIMER_MILLIS) {
+      return constFalse;
+    }
+    let completed = false;
+    const handle = set(() => {
+      completed = true;
+      task();
+    }, millis);
+    return () => {
+      clear(handle);
+      return !completed;
+    };
+  }
+};
+const performanceNowNanos = /*#__PURE__*/function () {
+  const bigint1e6 = /*#__PURE__*/BigInt(1_000_000);
+  if (typeof performance === "undefined") {
+    return () => BigInt(Date.now()) * bigint1e6;
+  }
+  const origin = "timeOrigin" in performance && typeof performance.timeOrigin === "number" ? /*#__PURE__*/BigInt( /*#__PURE__*/Math.round(performance.timeOrigin * 1_000_000)) : /*#__PURE__*/BigInt( /*#__PURE__*/Date.now()) * bigint1e6;
+  return () => origin + BigInt(Math.round(performance.now() * 1_000_000));
+}();
+const processOrPerformanceNow = /*#__PURE__*/function () {
+  const processHrtime = typeof process === "object" && "hrtime" in process && typeof process.hrtime.bigint === "function" ? process.hrtime : undefined;
+  if (!processHrtime) {
+    return performanceNowNanos;
+  }
+  const origin = /*#__PURE__*/performanceNowNanos() - /*#__PURE__*/processHrtime.bigint();
+  return () => origin + processHrtime.bigint();
+}();
+
+/** @internal */
+class ClockImpl {
+  [ClockTypeId] = ClockTypeId;
+  unsafeCurrentTimeMillis() {
+    return Date.now();
+  }
+  unsafeCurrentTimeNanos() {
+    return processOrPerformanceNow();
+  }
+  currentTimeMillis = sync(() => this.unsafeCurrentTimeMillis());
+  currentTimeNanos = sync(() => this.unsafeCurrentTimeNanos());
+  scheduler() {
+    return succeed(globalClockScheduler);
+  }
+  sleep(duration) {
+    return asyncEither(cb => {
+      const canceler = globalClockScheduler.unsafeSchedule(() => cb(unit), duration);
+      return left(asUnit(sync(canceler)));
+    });
+  }
+}
+
+/** @internal */
+const make = () => new ClockImpl();
+
+export { ClockTypeId, MAX_TIMER_MILLIS, clockTag, globalClockScheduler, make };

package/internal/completedRequestMap.esm.js

@@ -0,0 +1,7 @@
+import { globalValue } from '../GlobalValue/dist/effect-GlobalValue.esm.js';
+import { fiberRefUnsafeMake } from './core.esm.js';
+
+/** @internal */
+const currentRequestMap = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentRequestMap"), () => fiberRefUnsafeMake(new Map()));
+
+export { currentRequestMap };

package/internal/concurrency.esm.js

@@ -0,0 +1,47 @@
+import { fiberRefGetWith, currentConcurrency } from './core.esm.js';
+
+/** @internal */
+const match = (options, sequential, unbounded, bounded) => {
+  switch (options?.concurrency) {
+    case undefined:
+      {
+        return sequential();
+      }
+    case "unbounded":
+      {
+        return unbounded();
+      }
+    case "inherit":
+      {
+        return fiberRefGetWith(currentConcurrency, concurrency => concurrency === "unbounded" ? unbounded() : concurrency > 1 ? bounded(concurrency) : sequential());
+      }
+    default:
+      {
+        return options.concurrency > 1 ? bounded(options.concurrency) : sequential();
+      }
+  }
+};
+
+/** @internal */
+const matchSimple = (options, sequential, concurrent) => {
+  switch (options?.concurrency) {
+    case undefined:
+      {
+        return sequential();
+      }
+    case "unbounded":
+      {
+        return concurrent();
+      }
+    case "inherit":
+      {
+        return fiberRefGetWith(currentConcurrency, concurrency => concurrency === "unbounded" ? concurrent() : concurrency > 1 ? concurrent() : sequential());
+      }
+    default:
+      {
+        return options.concurrency > 1 ? concurrent() : sequential();
+      }
+  }
+};
+
+export { match, matchSimple };

package/{dist/config-b039b99f.esm.js → internal/config.esm.js}

@@ -1,68 +1,14 @@
-import { n as toReadonlyArray, l as unsafeFromArray } from './Chunk-4c1f4599.esm.js';
-import { i as isMissingDataOnly } from './ConfigError-41421a53.esm.js';
-import { l as left, r as right } from './Either-aa46c018.esm.js';
-import { p as pipe, d as dual, c as constTrue } from './Function-12511160.esm.js';
-import { c as fromIterable } from './HashSet-ae2856c1.esm.js';
-import { U as Unsupported, I as InvalidData, M as MissingData } from './configError-8b2e2999.esm.js';
-import { f as fromString } from './configSecret-6e9eaf9d.esm.js';
-import { bV as allLogLevels } from './core-64ab7ff5.esm.js';
-import { s as some, n as none } from './Option-df40d2b9.esm.js';
-import { p as pipeArguments } from './Pipeable-10760a1d.esm.js';
-
-/** @internal */
-
-/** @internal */
-const OP_CONSTANT = "Constant";
-
-/** @internal */
-
-/** @internal */
-const OP_FAIL = "Fail";
-
-/** @internal */
-
-/** @internal */
-const OP_FALLBACK = "Fallback";
-
-/** @internal */
-
-/** @internal */
-const OP_DESCRIBED = "Described";
-
-/** @internal */
-
-/** @internal */
-const OP_LAZY = "Lazy";
-
-/** @internal */
-
-/** @internal */
-const OP_MAP_OR_FAIL = "MapOrFail";
-
-/** @internal */
-
-/** @internal */
-const OP_NESTED = "Nested";
-
-/** @internal */
-
-/** @internal */
-const OP_PRIMITIVE = "Primitive";
-
-/** @internal */
-
-/** @internal */
-const OP_SEQUENCE = "Sequence";
-
-/** @internal */
-
-/** @internal */
-const OP_HASHMAP = "HashMap";
-
-/** @internal */
-
-/** @internal */
-const OP_ZIP_WITH = "ZipWith";
+import { toReadonlyArray, unsafeFromArray } from '../Chunk/dist/effect-Chunk.esm.js';
+import { isMissingDataOnly } from '../ConfigError/dist/effect-ConfigError.esm.js';
+import { left, right } from '../Either/dist/effect-Either.esm.js';
+import { pipe, dual, constTrue } from '../Function/dist/effect-Function.esm.js';
+import { fromIterable } from '../HashSet/dist/effect-HashSet.esm.js';
+import { Unsupported, InvalidData, MissingData } from './configError.esm.js';
+import { fromString } from './configSecret.esm.js';
+import { allLogLevels } from './core.esm.js';
+import { OP_FAIL, OP_MAP_OR_FAIL, OP_NESTED, OP_FALLBACK, OP_PRIMITIVE, OP_SEQUENCE, OP_CONSTANT, OP_LAZY, OP_HASHMAP, OP_DESCRIBED, OP_ZIP_WITH } from './opCodes/config.esm.js';
+import { some, none } from '../Option/dist/effect-Option.esm.js';
+import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
 
 /** @internal */
 const ConfigSymbolKey = "effect/Config";
@@ -425,4 +371,4 @@ const zipWith = /*#__PURE__*/dual(3, (self, that, f) => {
   return zipWith;
 });
 
-export { orElseIf as A, option as B, ConfigTypeId as C, primitive as D, repeat as E, secret as F, hashSet as G, string as H, succeed as I, suspend as J, sync as K, hashMap as L, unwrap as M, validate as N, OP_ZIP_WITH as O, withDefault as P, withDescription as Q, zip as R, zipWith as S, OP_HASHMAP as a, OP_SEQUENCE as b, OP_PRIMITIVE as c, OP_NESTED as d, OP_MAP_OR_FAIL as e, OP_LAZY as f, OP_FALLBACK as g, OP_FAIL as h, OP_DESCRIBED as i, OP_CONSTANT as j, all as k, array as l, missingError as m, boolean as n, chunk as o, date as p, fail as q, number as r, integer as s, logLevel as t, isConfig as u, map as v, mapAttempt as w, mapOrFail as x, nested as y, orElse as z };
+export { ConfigTypeId, all, array, boolean, chunk, date, fail, hashMap, hashSet, integer, isConfig, logLevel, map, mapAttempt, mapOrFail, missingError, nested, number, option, orElse, orElseIf, primitive, repeat, secret, string, succeed, suspend, sync, unwrap, validate, withDefault, withDescription, zip, zipWith };

package/{dist/configError-8b2e2999.esm.js → internal/configError.esm.js}

@@ -1,36 +1,7 @@
-import { r as right, l as left } from './Either-aa46c018.esm.js';
-import { p as pipe, d as dual, a as constFalse, c as constTrue } from './Function-12511160.esm.js';
-import { y as join } from './ReadonlyArray-0a71b226.esm.js';
-
-/** @internal */
-
-/** @internal */
-const OP_AND = "And";
-
-/** @internal */
-
-/** @internal */
-const OP_OR = "Or";
-
-/** @internal */
-
-/** @internal */
-const OP_INVALID_DATA = "InvalidData";
-
-/** @internal */
-
-/** @internal */
-const OP_MISSING_DATA = "MissingData";
-
-/** @internal */
-
-/** @internal */
-const OP_SOURCE_UNAVAILABLE = "SourceUnavailable";
-
-/** @internal */
-
-/** @internal */
-const OP_UNSUPPORTED = "Unsupported";
+import { right, left } from '../Either/dist/effect-Either.esm.js';
+import { pipe, dual, constFalse, constTrue } from '../Function/dist/effect-Function.esm.js';
+import { OP_AND, OP_OR, OP_INVALID_DATA, OP_MISSING_DATA, OP_SOURCE_UNAVAILABLE, OP_UNSUPPORTED } from './opCodes/configError.esm.js';
+import { join } from '../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
 
 /** @internal */
 const ConfigErrorSymbolKey = "effect/ConfigError";
@@ -302,4 +273,4 @@ const reduceWithContext = /*#__PURE__*/dual(3, (self, context, reducer) => {
 /** @internal */
 const isMissingDataOnly = self => reduceWithContext(self, void 0, IsMissingDataOnlyReducer);
 
-export { And as A, ConfigErrorTypeId as C, InvalidData as I, MissingData as M, Or as O, SourceUnavailable as S, Unsupported as U, isAnd as a, isOr as b, isInvalidData as c, isMissingData as d, isMissingDataOnly as e, isSourceUnavailable as f, isUnsupported as g, isConfigError as i, prefixed as p, reduceWithContext as r };
+export { And, ConfigErrorTypeId, InvalidData, MissingData, Or, SourceUnavailable, Unsupported, isAnd, isConfigError, isInvalidData, isMissingData, isMissingDataOnly, isOr, isSourceUnavailable, isUnsupported, prefixed, proto, reduceWithContext };

package/{dist/pathPatch-f393ab1b.esm.js → internal/configProvider/pathPatch.esm.js}

@@ -1,9 +1,9 @@
-import { l as left, r as right } from './Either-aa46c018.esm.js';
-import { d as dual, p as pipe } from './Function-12511160.esm.js';
-import { M as MissingData } from './configError-8b2e2999.esm.js';
-import { o as of, i as isCons, c as cons } from './List-6e58a1e9.esm.js';
-import { j as contains } from './Option-df40d2b9.esm.js';
-import { I as head, T as tailNonEmpty, S as prepend, m as map } from './ReadonlyArray-0a71b226.esm.js';
+import { left, right } from '../../Either/dist/effect-Either.esm.js';
+import { dual, pipe } from '../../Function/dist/effect-Function.esm.js';
+import { MissingData } from '../configError.esm.js';
+import { of, isCons, cons } from '../../List/dist/effect-List.esm.js';
+import { contains } from '../../Option/dist/effect-Option.esm.js';
+import { head, tailNonEmpty, prepend, map } from '../../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
 
 /** @internal */
 const empty = {
@@ -80,4 +80,4 @@ const patch = /*#__PURE__*/dual(2, (path, patch) => {
   return right(output);
 });
 
-export { andThen as a, empty as e, mapName as m, nested as n, patch as p, unnested as u };
+export { andThen, empty, mapName, nested, patch, unnested };

package/{dist/configProvider-c997961d.esm.js → internal/configProvider.esm.js}

@@ -1,81 +1,18 @@
-import { T as Tag } from './Context-c41aa832.esm.js';
-import { a as isLeft, i as isRight, m as merge, r as right, l as left } from './Either-aa46c018.esm.js';
-import { p as pipe, d as dual } from './Function-12511160.esm.js';
-import { e as empty$2, f as fromIterable$1 } from './HashMap-6c230bde.esm.js';
-import { u as union, c as fromIterable } from './HashSet-ae2856c1.esm.js';
-import { O as OP_ZIP_WITH, a as OP_HASHMAP, b as OP_SEQUENCE, c as OP_PRIMITIVE, m as missingError, d as OP_NESTED, e as OP_MAP_OR_FAIL, f as OP_LAZY, g as OP_FALLBACK, h as OP_FAIL, i as OP_DESCRIBED, j as OP_CONSTANT } from './config-b039b99f.esm.js';
-import { M as MissingData, O as Or, A as And, p as prefixed } from './configError-8b2e2999.esm.js';
-import { e as empty$1, p as patch, m as mapName, n as nested$1, u as unnested$1 } from './pathPatch-f393ab1b.esm.js';
-import { f as flatMap, V as fail, j as succeed, a as suspend, Z as forEachSequential, m as map, b6 as catchAll, s as sync, U as either, bm as mapBoth, bn as mapError, J as zip$1 } from './core-64ab7ff5.esm.js';
-import { O as Order } from './Number-4b836a09.esm.js';
-import { b as match, g as getOrElse, f as flatMap$1, s as some, n as none, h as all } from './Option-df40d2b9.esm.js';
-import { p as pipeArguments } from './Pipeable-10760a1d.esm.js';
-import { I as head, F as empty, J as append, D as flatten, K as of, L as last, A as reduce, B as reduceRight, e as sort, M as flatMap$2, N as make$1, O as unsafeGet, y as join, m as map$1, P as zip, f as fromIterable$2, Q as unfold } from './ReadonlyArray-0a71b226.esm.js';
-
-/**
- * Adapted from the `change-case` library.
- *
- * Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
- */
-
-/** @internal */
-const lowerCase$1 = str => str.toLowerCase();
-
-/** @internal */
-const upperCase$1 = str => str.toUpperCase();
-/**
- * Replace `re` in the input string with the replacement value.
- */
-const replace = (input, re, value) => re instanceof RegExp ? input.replace(re, value) : re.reduce((input, re) => input.replace(re, value), input);
-
-// Support camel case ("camelCase" -> "camel Case" and "CAMELCase" -> "CAMEL Case").
-const DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
-
-// Remove all non-word characters.
-const DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
-
-/**
- * Normalize the string into something other libraries can manipulate easier.
- */
-const noCase = (input, options = {}) => {
-  const {
-    delimiter = " ",
-    splitRegexp = DEFAULT_SPLIT_REGEXP,
-    stripRegexp = DEFAULT_STRIP_REGEXP,
-    transform = lowerCase$1
-  } = options;
-  const result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
-  let start = 0;
-  let end = result.length;
-  // Trim the delimiter from around the output string.
-  while (result.charAt(start) === "\0") {
-    start++;
-  }
-  while (result.charAt(end - 1) === "\0") {
-    end--;
-  }
-  // Transform each token independently.
-  return result.slice(start, end).split("\0").map(transform).join(delimiter);
-};
-
-/** @internal */
-const constantCase$1 = (input, options = {}) => noCase(input, {
-  delimiter: "_",
-  transform: upperCase$1,
-  ...options
-});
-
-/** @internal */
-const kebabCase$1 = (input, options = {}) => noCase(input, {
-  delimiter: "-",
-  ...options
-});
-
-/** @internal */
-const snakeCase$1 = (input, options = {}) => noCase(input, {
-  delimiter: "_",
-  ...options
-});
+import { Tag } from '../Context/dist/effect-Context.esm.js';
+import { isLeft, isRight, merge, right, left } from '../Either/dist/effect-Either.esm.js';
+import { pipe, dual } from '../Function/dist/effect-Function.esm.js';
+import { empty as empty$2, fromIterable as fromIterable$1 } from '../HashMap/dist/effect-HashMap.esm.js';
+import { union, fromIterable } from '../HashSet/dist/effect-HashSet.esm.js';
+import { missingError } from './config.esm.js';
+import { MissingData, Or, And, prefixed } from './configError.esm.js';
+import { empty as empty$1, patch, mapName, nested as nested$1, unnested as unnested$1 } from './configProvider/pathPatch.esm.js';
+import { flatMap, fail, succeed, suspend, forEachSequential, map, catchAll, sync, either, mapBoth, mapError, zip as zip$1 } from './core.esm.js';
+import { OP_ZIP_WITH, OP_HASHMAP, OP_SEQUENCE, OP_PRIMITIVE, OP_NESTED, OP_MAP_OR_FAIL, OP_LAZY, OP_FALLBACK, OP_FAIL, OP_DESCRIBED, OP_CONSTANT } from './opCodes/config.esm.js';
+import { constantCase as constantCase$1, kebabCase as kebabCase$1, lowerCase as lowerCase$1, snakeCase as snakeCase$1, upperCase as upperCase$1 } from './string-utils.esm.js';
+import { Order } from '../Number/dist/effect-Number.esm.js';
+import { match, getOrElse, flatMap as flatMap$1, some, none, all } from '../Option/dist/effect-Option.esm.js';
+import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { head, empty, append, flatten, of, last, reduce, reduceRight, sort, flatMap as flatMap$2, make as make$1, unsafeGet, join, map as map$1, zip, fromIterable as fromIterable$2, unfold } from '../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
 
 const concat = (l, r) => [...l, ...r];
 
@@ -425,4 +362,4 @@ const parseInteger = str => {
   return Number.isNaN(parsedIndex) ? none() : some(parsedIndex);
 };
 
-export { ConfigProviderTypeId as C, FlatConfigProviderTypeId as F, makeFlat as a, fromFlat as b, configProviderTag as c, fromMap as d, constantCase as e, fromEnv as f, mapInputPath as g, upperCase as h, kebabCase as k, lowerCase as l, make as m, nested as n, orElse as o, snakeCase as s, unnested as u, within as w };
+export { ConfigProviderTypeId, FlatConfigProviderTypeId, configProviderTag, constantCase, fromEnv, fromFlat, fromMap, kebabCase, lowerCase, make, makeFlat, mapInputPath, nested, orElse, snakeCase, unnested, upperCase, within };

package/{dist/configSecret-6e9eaf9d.esm.js → internal/configSecret.esm.js}

@@ -1,7 +1,7 @@
-import { n as toReadonlyArray } from './Chunk-4c1f4599.esm.js';
-import { s as symbol$1, e as equals } from './Equal-2a99fde3.esm.js';
-import { p as pipe } from './Function-12511160.esm.js';
-import { s as symbol, c as combine, a as array, h as hash } from './Hash-7910f34f.esm.js';
+import { toReadonlyArray } from '../Chunk/dist/effect-Chunk.esm.js';
+import { symbol as symbol$1, equals } from '../Equal/dist/effect-Equal.esm.js';
+import { pipe } from '../Function/dist/effect-Function.esm.js';
+import { symbol, combine, array, hash } from '../Hash/dist/effect-Hash.esm.js';
 
 /** @internal */
 const ConfigSecretSymbolKey = "effect/ConfigSecret";
@@ -63,4 +63,4 @@ const unsafeWipe = self => {
   }
 };
 
-export { ConfigSecretTypeId as C, fromChunk as a, fromString as f, isConfigSecret as i, make as m, unsafeWipe as u, value as v };
+export { ConfigSecretTypeId, fromChunk, fromString, isConfigSecret, make, proto, unsafeWipe, value };

package/internal/console.esm.js

@@ -0,0 +1,72 @@
+import { get, add } from '../Context/dist/effect-Context.esm.js';
+import { dual } from '../Function/dist/effect-Function.esm.js';
+import { fiberRefGetWith, fiberRefLocallyWith, acquireUseRelease, isEffect } from './core.esm.js';
+import { currentServices } from './defaultServices.esm.js';
+import { consoleTag } from './defaultServices/console.esm.js';
+import { fiberRefLocallyScopedWith, acquireRelease } from './fiberRuntime.esm.js';
+import { scopedDiscard } from './layer.esm.js';
+
+/** @internal */
+const consoleWith = f => fiberRefGetWith(currentServices, services => f(get(services, consoleTag)));
+
+/** @internal */
+const withConsole = /*#__PURE__*/dual(2, (effect, value) => fiberRefLocallyWith(effect, currentServices, add(consoleTag, value)));
+
+/** @internal */
+const setConsole = console => scopedDiscard(fiberRefLocallyScopedWith(currentServices, add(consoleTag, console)));
+
+/** @internal */
+const assert = (condition, ...args) => consoleWith(_ => _.assert(condition, ...args));
+
+/** @internal */
+const clear = /*#__PURE__*/consoleWith(_ => _.clear);
+
+/** @internal */
+const count = label => consoleWith(_ => _.count(label));
+
+/** @internal */
+const countReset = label => consoleWith(_ => _.countReset(label));
+
+/** @internal */
+const debug = (...args) => consoleWith(_ => _.debug(...args));
+
+/** @internal */
+const dir = (item, options) => consoleWith(_ => _.dir(item, options));
+
+/** @internal */
+const dirxml = (...args) => consoleWith(_ => _.dirxml(...args));
+
+/** @internal */
+const error = (...args) => consoleWith(_ => _.error(...args));
+
+/** @internal */
+const group = options => consoleWith(_ => acquireRelease(_.group(options), () => _.groupEnd));
+
+/** @internal */
+const info = (...args) => consoleWith(_ => _.info(...args));
+
+/** @internal */
+const log = (...args) => consoleWith(_ => _.log(...args));
+
+/** @internal */
+const table = (tabularData, properties) => consoleWith(_ => _.table(tabularData, properties));
+
+/** @internal */
+const time = label => consoleWith(_ => acquireRelease(_.time(label), () => _.timeEnd(label)));
+
+/** @internal */
+const timeLog = (label, ...args) => consoleWith(_ => _.timeLog(label, ...args));
+
+/** @internal */
+const trace = (...args) => consoleWith(_ => _.trace(...args));
+
+/** @internal */
+const warn = (...args) => consoleWith(_ => _.warn(...args));
+
+/** @internal */
+const withGroup = /*#__PURE__*/dual(args => isEffect(args[0]), (self, options) => consoleWith(_ => acquireUseRelease(_.group(options), () => self, () => _.groupEnd)));
+
+/** @internal */
+const withTime = /*#__PURE__*/dual(args => isEffect(args[0]), (self, label) => consoleWith(_ => acquireUseRelease(_.time(label), () => self, () => _.timeEnd(label))));
+
+export { assert, clear, consoleWith, count, countReset, debug, dir, dirxml, error, group, info, log, setConsole, table, time, timeLog, trace, warn, withConsole, withGroup, withTime };

package/{dist/core-effect-57445976.esm.js → internal/core-effect.esm.js}

@@ -1,55 +1,28 @@
-import { c as append, n as toReadonlyArray, f as fromIterable$2, h as isNonEmpty, j as headNonEmpty, t as tailNonEmpty } from './Chunk-4c1f4599.esm.js';
-import { c as clockWith$1, s as sleep$1, a as currentTimeMillis, b as currentTimeNanos } from './Clock-f8b987d7.esm.js';
-import { b as add, u as unsafeGet, e as empty$1 } from './Context-c41aa832.esm.js';
-import { n as nanos } from './Duration-98bca14c.esm.js';
-import { r as right, l as left } from './Either-aa46c018.esm.js';
-import { n as none$1 } from './FiberId-17e50f05.esm.js';
-import { s as setAll, j as joinAs } from './FiberRefs-f705c1b5.esm.js';
-import { d as dual, i as identity, b as constVoid, c as constTrue, a as constFalse, p as pipe } from './Function-12511160.esm.js';
-import { s as set, d as forEach } from './HashMap-6c230bde.esm.js';
-import { c as fromIterable$1, u as union, s as size } from './HashSet-ae2856c1.esm.js';
-import { bl as fiberRefLocallyWith, aE as currentLogAnnotations, M as isEffect, m as map, bn as mapError, bk as asyncEither, p as unit, s as sync, bo as makeEffectError, bp as fail, b6 as catchAll, V as fail$1, aM as catchAllCause, bq as unified, br as find, bs as isDieType, C as failCause, B as matchCauseEffect, j as succeed, bt as catchIf, bu as matchCause, y as empty, z as zipRight, w as withFiberRuntime, f as flatMap, a as suspend, bv as context, bw as orElse, aP as yieldNow, W as dieSync, bx as dieMessage, by as failSync, aa as flip, F as matchEffect, aD as currentLogSpan, an as fiberRefGet, bz as failCauseSync, bA as intoDeferred, b as deferredAwait, aj as as, J as zip, ac as updateRuntimeFlags, d as deferredMake, c as asUnit, e as whenEffect, bB as failures, av as async, a3 as contextWithEffect, bC as provideContext, E as currentMetricLabels, S as failureOrCause, bD as keepDefects, bE as flatten, ak as mapInputContext, bF as currentTracerSpanAnnotations, K as currentTracerSpan, bG as currentTracerSpanLinks, a5 as acquireUseRelease, aJ as NoSuchElementException, bH as isNoSuchElementException, bI as interruptors, au as currentInterruptedCause, i as interrupt, ad as runtimeFlags, b0 as IllegalArgumentException, v as fiberRefGetWith, bJ as currentTracerTimingEnabled, bK as isCause, H as exitSucceed, bL as exitDie, G as exitFail } from './core-64ab7ff5.esm.js';
-import { r as randomWith } from './defaultServices-b9ca1236.esm.js';
-import { d as diff, p as patch } from './patch-743d675c.esm.js';
-import { m as make$2 } from './label-0cc6c9a0.esm.js';
-import { c as diff$1 } from './RuntimeFlagsPatch-51f77dce.esm.js';
-import { p as prepend, h as head$1, g as findFirst$1, e as empty$2 } from './List-6e58a1e9.esm.js';
-import { T as Trace, D as Debug, I as Info, W as Warning, E as Error, F as Fatal } from './LogLevel-5a4fa506.esm.js';
-import { m as make } from './LogSpan-f36e9619.esm.js';
-import { s as some, n as none$2, b as match$1, e as fromNullable$1 } from './Option-df40d2b9.esm.js';
-import { d as isTagged, i as isObject } from './Predicate-6b61b95b.esm.js';
-import { f as fromIterable, A as reduce$1 } from './ReadonlyArray-0a71b226.esm.js';
-import { m as make$1, b as getAndSet, g as get } from './Ref-5eefaff1.esm.js';
-import { t as tracerWith$1 } from './Tracer-da65ce12.esm.js';
-
-/** @internal */
-class SingleShotGen {
-  called = false;
-  constructor(self) {
-    this.self = self;
-  }
-  next(a) {
-    return this.called ? {
-      value: a,
-      done: true
-    } : (this.called = true, {
-      value: this.self,
-      done: false
-    });
-  }
-  return(a) {
-    return {
-      value: a,
-      done: true
-    };
-  }
-  throw(e) {
-    throw e;
-  }
-  [Symbol.iterator]() {
-    return new SingleShotGen(this.self);
-  }
-}
+import { append, toReadonlyArray, fromIterable as fromIterable$2, isNonEmpty, headNonEmpty, tailNonEmpty } from '../Chunk/dist/effect-Chunk.esm.js';
+import { clockWith as clockWith$1, sleep as sleep$1, currentTimeMillis, currentTimeNanos } from '../Clock/dist/effect-Clock.esm.js';
+import { add, unsafeGet, empty as empty$1 } from '../Context/dist/effect-Context.esm.js';
+import { nanos } from '../Duration/dist/effect-Duration.esm.js';
+import { right, left } from '../Either/dist/effect-Either.esm.js';
+import { none as none$1 } from '../FiberId/dist/effect-FiberId.esm.js';
+import { setAll, joinAs } from '../FiberRefs/dist/effect-FiberRefs.esm.js';
+import { dual, identity, constVoid, constTrue, constFalse, pipe } from '../Function/dist/effect-Function.esm.js';
+import { set, forEach } from '../HashMap/dist/effect-HashMap.esm.js';
+import { fromIterable as fromIterable$1, union, size } from '../HashSet/dist/effect-HashSet.esm.js';
+import { fail, find, isDieType, empty, failures, failureOrCause, keepDefects, flatten, NoSuchElementException, isNoSuchElementException, interruptors, IllegalArgumentException, isCause } from './cause.esm.js';
+import { fiberRefLocallyWith, currentLogAnnotations, isEffect, map, mapError, asyncEither, unit, sync, makeEffectError, catchAll, fail as fail$1, catchAllCause, unified, failCause, matchCauseEffect, succeed, catchIf, matchCause, zipRight, withFiberRuntime, flatMap, suspend, context, orElse, yieldNow, dieSync, dieMessage, failSync, flip, matchEffect, currentLogSpan, fiberRefGet, failCauseSync, intoDeferred, deferredAwait, as, zip, updateRuntimeFlags, deferredMake, asUnit, whenEffect, async, contextWithEffect, provideContext, currentMetricLabels, mapInputContext, currentTracerSpanAnnotations, currentTracerSpan, currentTracerSpanLinks, acquireUseRelease, currentInterruptedCause, interrupt, runtimeFlags, fiberRefGetWith, currentTracerTimingEnabled, exitSucceed, exitDie, exitFail } from './core.esm.js';
+import { randomWith } from './defaultServices.esm.js';
+import { diff, patch } from './fiberRefs/patch.esm.js';
+import { make as make$2 } from './metric/label.esm.js';
+import { diff as diff$1 } from './runtimeFlags.esm.js';
+import { SingleShotGen } from './singleShotGen.esm.js';
+import { prepend, head as head$1, findFirst as findFirst$1, empty as empty$2 } from '../List/dist/effect-List.esm.js';
+import { Trace, Debug, Info, Warning, Error, Fatal } from '../LogLevel/dist/effect-LogLevel.esm.js';
+import { make } from '../LogSpan/dist/effect-LogSpan.esm.js';
+import { some, none as none$2, match as match$1, fromNullable as fromNullable$1 } from '../Option/dist/effect-Option.esm.js';
+import { isTagged, isObject } from '../Predicate/dist/effect-Predicate.esm.js';
+import { fromIterable, reduce as reduce$1 } from '../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
+import { make as make$1, getAndSet, get } from '../Ref/dist/effect-Ref.esm.js';
+import { tracerWith as tracerWith$1 } from '../Tracer/dist/effect-Tracer.esm.js';
 
 /* @internal */
 const annotateLogs = /*#__PURE__*/dual(args => isEffect(args[0]), function () {
@@ -899,4 +872,4 @@ const fromNullable = value => value == null ? fail$1(NoSuchElementException()) :
 /* @internal */
 const optionFromOptional = self => catchAll(map(self, some), error => isNoSuchElementException(error) ? succeedNone : fail$1(error));
 
-export { clockWith as $, catchSomeDefect as A, catchTag as B, catchTags as C, cause as D, eventually as E, ignore as F, ignoreLogged as G, parallelErrors as H, sandbox as I, try_ as J, tryMap as K, tryMapPromise as L, tryPromise as M, unsandbox as N, allowInterrupt as O, asSome as P, asSomeError as Q, flipWith as R, SingleShotGen as S, mapAccum as T, merge as U, negate as V, descriptor as W, descriptorWith as X, diffFiberRefs as Y, clock as Z, _catch as _, tapError as a, currentSpan as a$, delay as a0, sleep as a1, timed as a2, timedWith as a3, contextWith as a4, provideService as a5, provideServiceEffect as a6, serviceFunction as a7, serviceFunctionEffect as a8, serviceFunctions as a9, inheritFiberRefs as aA, patchFiberRefs as aB, setFiberRefs as aC, updateFiberRefs as aD, isFailure as aE, isSuccess as aF, match as aG, log as aH, logTrace as aI, logDebug as aJ, logInfo as aK, logWarning as aL, logError as aM, logFatal as aN, withLogSpan as aO, annotateLogs as aP, logAnnotations as aQ, orElseFail as aR, orElseSucceed as aS, random as aT, tagMetrics as aU, labelMetrics as aV, labelMetricsSet as aW, withMetric as aX, tracer as aY, annotateSpans as aZ, annotateCurrentSpan as a_, serviceConstants as aa, serviceMembers as ab, updateService as ac, Do as ad, bind as ae, bindTo as af, bindValue as ag, option as ah, filterOrDie as ai, filterOrDieMessage as aj, filterOrElse as ak, filterOrFail as al, unless as am, unlessEffect as an, when as ao, whenFiberRef as ap, whenRef as aq, summarized as ar, tapBoth as as, tapErrorTag as at, tapErrorCause as au, forever as av, iterate as aw, loop as ax, repeatN as ay, fiberRefs as az, mapErrorCause as b, currentParentSpan as b0, spanAnnotations as b1, spanLinks as b2, linkSpans as b3, useSpan as b4, withSpan as b5, withParentSpan as b6, fromNullable as b7, optionFromOptional as b8, currentTimeNanosTracing as c, memoize as d, dropUntil as e, dropWhile as f, every as g, findFirst as h, firstSuccessOf as i, head as j, reduceRight as k, reduceWhile as l, makeSpan as m, takeUntil as n, once as o, takeWhile as p, asyncOption as q, reduce as r, gen as s, tapDefect as t, none as u, promise as v, succeedNone as w, succeedSome as x, catchAllDefect as y, catchSomeCause as z };
+export { Do, _catch, allowInterrupt, annotateCurrentSpan, annotateLogs, annotateSpans, asSome, asSomeError, asyncOption, bind, bindTo, bindValue, catchAllDefect, catchSomeCause, catchSomeDefect, catchTag, catchTags, cause, clock, clockWith, contextWith, currentParentSpan, currentSpan, currentTimeNanosTracing, delay, descriptor, descriptorWith, diffFiberRefs, diffFiberRefsAndRuntimeFlags, dropUntil, dropWhile, eventually, every, fiberRefs, filterOrDie, filterOrDieMessage, filterOrElse, filterOrFail, findFirst, firstSuccessOf, flipWith, forever, fromNullable, gen, head, ignore, ignoreLogged, inheritFiberRefs, isFailure, isSuccess, iterate, labelMetrics, labelMetricsSet, linkSpans, log, logAnnotations, logDebug, logError, logFatal, logInfo, logTrace, logWarning, loop, makeSpan, mapAccum, mapErrorCause, match, memoize, merge, negate, none, once, option, optionFromOptional, orElseFail, orElseSucceed, parallelErrors, patchFiberRefs, promise, provideService, provideServiceEffect, random, reduce, reduceRight, reduceWhile, repeatN, sandbox, serviceConstants, serviceFunction, serviceFunctionEffect, serviceFunctions, serviceMembers, setFiberRefs, sleep, spanAnnotations, spanLinks, succeedNone, succeedSome, summarized, tagMetrics, takeUntil, takeWhile, tapBoth, tapDefect, tapError, tapErrorCause, tapErrorTag, timed, timedWith, tracer, tracerWith, tryMap, tryMapPromise, tryPromise, try_, unless, unlessEffect, unsandbox, updateFiberRefs, updateService, useSpan, when, whenFiberRef, whenRef, withLogSpan, withMetric, withParentSpan, withSpan };