effect 2.0.0-next.5 → 2.0.0-next.50

package/dist/core-effect-6666f2dc.cjs.prod.js

@@ -0,0 +1,1039 @@
+'use strict';
+
+var Chunk_dist_effectChunk = require('../Chunk/dist/effect-Chunk.cjs.prod.js');
+var Clock_dist_effectClock = require('../Clock/dist/effect-Clock.cjs.prod.js');
+var Context_dist_effectContext = require('../Context/dist/effect-Context.cjs.prod.js');
+var Duration_dist_effectDuration = require('../Duration/dist/effect-Duration.cjs.prod.js');
+var Either_dist_effectEither = require('../Either/dist/effect-Either.cjs.prod.js');
+var FiberId_dist_effectFiberId = require('./FiberId-0f0b7779.cjs.prod.js');
+var FiberRefs_dist_effectFiberRefs = require('../FiberRefs/dist/effect-FiberRefs.cjs.prod.js');
+var Function_dist_effectFunction = require('../Function/dist/effect-Function.cjs.prod.js');
+var HashMap_dist_effectHashMap = require('../HashMap/dist/effect-HashMap.cjs.prod.js');
+var HashSet_dist_effectHashSet = require('../HashSet/dist/effect-HashSet.cjs.prod.js');
+var core = require('./core-473934ce.cjs.prod.js');
+var defaultServices = require('./defaultServices-8ea5e664.cjs.prod.js');
+var patch = require('./patch-256bc574.cjs.prod.js');
+var label = require('./label-a588e6cd.cjs.prod.js');
+var RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch = require('./RuntimeFlagsPatch-3890e860.cjs.prod.js');
+var List_dist_effectList = require('../List/dist/effect-List.cjs.prod.js');
+var LogLevel_dist_effectLogLevel = require('../LogLevel/dist/effect-LogLevel.cjs.prod.js');
+var LogSpan_dist_effectLogSpan = require('../LogSpan/dist/effect-LogSpan.cjs.prod.js');
+var Option_dist_effectOption = require('../Option/dist/effect-Option.cjs.prod.js');
+var Predicate_dist_effectPredicate = require('../Predicate/dist/effect-Predicate.cjs.prod.js');
+var ReadonlyArray_dist_effectReadonlyArray = require('../ReadonlyArray/dist/effect-ReadonlyArray.cjs.prod.js');
+var Ref_dist_effectRef = require('./Ref-00103de4.cjs.prod.js');
+var Tracer_dist_effectTracer = require('../Tracer/dist/effect-Tracer.cjs.prod.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);
+  }
+}
+
+/* @internal */
+const annotateLogs = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[0]), function () {
+  const args = arguments;
+  return core.fiberRefLocallyWith(args[0], core.currentLogAnnotations, typeof args[1] === "string" ? HashMap_dist_effectHashMap.set(args[1], args[2]) : annotations => Object.entries(args[1]).reduce((acc, [key, value]) => HashMap_dist_effectHashMap.set(acc, key, value), annotations));
+});
+
+/* @internal */
+const asSome = self => core.map$1(self, Option_dist_effectOption.some);
+
+/* @internal */
+const asSomeError = self => core.mapError(self, Option_dist_effectOption.some);
+
+/* @internal */
+const asyncOption = (register, blockingOn = FiberId_dist_effectFiberId.none) => core.asyncEither(cb => {
+  const option = register(cb);
+  switch (option._tag) {
+    case "None":
+      {
+        return Either_dist_effectEither.left(core.unit);
+      }
+    case "Some":
+      {
+        return Either_dist_effectEither.right(option.value);
+      }
+  }
+}, blockingOn);
+
+/* @internal */
+const try_ = arg => {
+  let evaluate;
+  let onFailure = undefined;
+  if (typeof arg === "function") {
+    evaluate = arg;
+  } else {
+    evaluate = arg.try;
+    onFailure = arg.catch;
+  }
+  return core.sync(() => {
+    try {
+      return evaluate();
+    } catch (error) {
+      throw core.makeEffectError(core.fail(onFailure ? onFailure(error) : error));
+    }
+  });
+};
+
+/* @internal */
+const _catch = /*#__PURE__*/Function_dist_effectFunction.dual(
+// @ts-expect-error
+3, (self, tag, options) => core.catchAll(self, e => {
+  if (typeof e === "object" && e != null && tag in e && e[tag] === options.failure) {
+    return options.onFailure(e);
+  }
+  return core.fail$1(e);
+}));
+
+/* @internal */
+const catchAllDefect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.catchAllCause(self, core.unified(cause => {
+  const option = core.find(cause, _ => core.isDieType(_) ? Option_dist_effectOption.some(_) : Option_dist_effectOption.none());
+  switch (option._tag) {
+    case "None":
+      {
+        return core.failCause(cause);
+      }
+    case "Some":
+      {
+        return f(option.value.defect);
+      }
+  }
+})));
+
+/* @internal */
+const catchSomeCause = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.matchCauseEffect(self, {
+  onFailure: cause => {
+    const option = f(cause);
+    switch (option._tag) {
+      case "None":
+        {
+          return core.failCause(cause);
+        }
+      case "Some":
+        {
+          return option.value;
+        }
+    }
+  },
+  onSuccess: core.succeed
+}));
+
+/* @internal */
+const catchSomeDefect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => core.catchAllCause(self, core.unified(cause => {
+  const option = core.find(cause, _ => core.isDieType(_) ? Option_dist_effectOption.some(_) : Option_dist_effectOption.none());
+  switch (option._tag) {
+    case "None":
+      {
+        return core.failCause(cause);
+      }
+    case "Some":
+      {
+        const optionEffect = pf(option.value.defect);
+        return optionEffect._tag === "Some" ? optionEffect.value : core.failCause(cause);
+      }
+  }
+})));
+
+/* @internal */
+const catchTag = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, k, f) => core.catchIf(self, Predicate_dist_effectPredicate.isTagged(k), f));
+
+/** @internal */
+const catchTags = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, cases) => {
+  let keys;
+  return core.catchIf(self, e => {
+    keys ??= Object.keys(cases);
+    return Predicate_dist_effectPredicate.isObject(e) && "_tag" in e && keys.includes(e["_tag"]);
+  }, e => cases[e["_tag"]](e));
+});
+
+/* @internal */
+const cause = self => core.matchCause(self, {
+  onFailure: Function_dist_effectFunction.identity,
+  onSuccess: () => core.empty
+});
+
+/* @internal */
+const clockWith = Clock_dist_effectClock.clockWith;
+
+/* @internal */
+const clock = /*#__PURE__*/clockWith(core.succeed);
+
+/* @internal */
+const delay = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, duration) => core.zipRight(Clock_dist_effectClock.sleep(duration), self));
+
+/* @internal */
+const descriptorWith = f => core.withFiberRuntime((state, status) => f({
+  id: state.id(),
+  status,
+  interruptors: core.interruptors(state.getFiberRef(core.currentInterruptedCause))
+}));
+
+/* @internal */
+const allowInterrupt = /*#__PURE__*/descriptorWith(descriptor => HashSet_dist_effectHashSet.size(descriptor.interruptors) > 0 ? core.interrupt$1 : core.unit);
+
+/* @internal */
+const descriptor = /*#__PURE__*/descriptorWith(core.succeed);
+
+/* @internal */
+const diffFiberRefs = self => summarized(self, fiberRefs, patch.diff);
+
+/* @internal */
+const diffFiberRefsAndRuntimeFlags = self => summarized(self, core.zip(fiberRefs, core.runtimeFlags), ([refs, flags], [refsNew, flagsNew]) => [patch.diff(refs, refsNew), RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.diff(flags, flagsNew)]);
+
+/* @internal */
+const Do = /*#__PURE__*/core.succeed({});
+
+/* @internal */
+const bind = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, f) => core.flatMap$1(self, k => core.map$1(f(k), a => ({
+  ...k,
+  [tag]: a
+}))));
+
+/* @internal */
+const bindTo = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, tag) => core.map$1(self, a => ({
+  [tag]: a
+})));
+
+/* @internal */
+const bindValue = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, f) => core.map$1(self, k => ({
+  ...k,
+  [tag]: f(k)
+})));
+
+/* @internal */
+const dropUntil = /*#__PURE__*/Function_dist_effectFunction.dual(2, (elements, predicate) => core.suspend(() => {
+  const iterator = elements[Symbol.iterator]();
+  const builder = [];
+  let next;
+  let dropping = core.succeed(false);
+  let i = 0;
+  while ((next = iterator.next()) && !next.done) {
+    const a = next.value;
+    const index = i++;
+    dropping = core.flatMap$1(dropping, bool => {
+      if (bool) {
+        builder.push(a);
+        return core.succeed(true);
+      }
+      return predicate(a, index);
+    });
+  }
+  return core.map$1(dropping, () => builder);
+}));
+
+/* @internal */
+const dropWhile = /*#__PURE__*/Function_dist_effectFunction.dual(2, (elements, f) => core.suspend(() => {
+  const iterator = elements[Symbol.iterator]();
+  const builder = [];
+  let next;
+  let dropping = core.succeed(true);
+  let i = 0;
+  while ((next = iterator.next()) && !next.done) {
+    const a = next.value;
+    const index = i++;
+    dropping = core.flatMap$1(dropping, d => core.map$1(d ? f(a, index) : core.succeed(false), b => {
+      if (!b) {
+        builder.push(a);
+      }
+      return b;
+    }));
+  }
+  return core.map$1(dropping, () => builder);
+}));
+
+/* @internal */
+const contextWith = f => core.map$1(core.context(), f);
+
+/* @internal */
+const eventually = self => core.orElse(self, () => core.flatMap$1(core.yieldNow(), () => eventually(self)));
+
+/* @internal */
+const filterOrDie = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, filter, orDieWith) => filterOrElse(self, filter, a => core.dieSync(() => orDieWith(a))));
+
+/* @internal */
+const filterOrDieMessage = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, filter, message) => filterOrElse(self, filter, () => core.dieMessage(message)));
+
+/* @internal */
+const filterOrElse = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, filter, orElse) => core.flatMap$1(self, a => filter(a) ? core.succeed(a) : orElse(a)));
+
+/* @internal */
+const filterOrFail = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, filter, orFailWith) => filterOrElse(self, filter, a => core.failSync(() => orFailWith(a))));
+
+/* @internal */
+const findFirst = /*#__PURE__*/Function_dist_effectFunction.dual(2, (elements, f) => core.suspend(() => {
+  const iterator = elements[Symbol.iterator]();
+  const next = iterator.next();
+  if (!next.done) {
+    return findLoop(iterator, 0, f, next.value);
+  }
+  return core.succeed(Option_dist_effectOption.none());
+}));
+const findLoop = (iterator, index, f, value) => core.flatMap$1(f(value, index), result => {
+  if (result) {
+    return core.succeed(Option_dist_effectOption.some(value));
+  }
+  const next = iterator.next();
+  if (!next.done) {
+    return findLoop(iterator, index + 1, f, next.value);
+  }
+  return core.succeed(Option_dist_effectOption.none());
+});
+
+/* @internal */
+const firstSuccessOf = effects => core.suspend(() => {
+  const list = Chunk_dist_effectChunk.fromIterable(effects);
+  if (!Chunk_dist_effectChunk.isNonEmpty(list)) {
+    return core.dieSync(() => core.IllegalArgumentException(`Received an empty collection of effects`));
+  }
+  return Function_dist_effectFunction.pipe(Chunk_dist_effectChunk.tailNonEmpty(list), ReadonlyArray_dist_effectReadonlyArray.reduce(Chunk_dist_effectChunk.headNonEmpty(list), (left, right) => core.orElse(left, () => right)));
+});
+
+/* @internal */
+const flipWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.flip(f(core.flip(self))));
+
+/* @internal */
+const match = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
+  onFailure,
+  onSuccess
+}) => core.matchEffect(self, {
+  onFailure: e => core.succeed(onFailure(e)),
+  onSuccess: a => core.succeed(onSuccess(a))
+}));
+
+/* @internal */
+const every = /*#__PURE__*/Function_dist_effectFunction.dual(2, (elements, f) => core.suspend(() => forAllLoop(elements[Symbol.iterator](), 0, f)));
+const forAllLoop = (iterator, index, f) => {
+  const next = iterator.next();
+  return next.done ? core.succeed(true) : core.flatMap$1(f(next.value, index), b => b ? forAllLoop(iterator, index + 1, f) : core.succeed(b));
+};
+
+/* @internal */
+const forever = self => {
+  const loop = core.flatMap$1(core.flatMap$1(self, () => core.yieldNow()), () => loop);
+  return loop;
+};
+
+/** @internal */
+class EffectGen {
+  constructor(value) {
+    this.value = value;
+  }
+  [Symbol.iterator]() {
+    return new SingleShotGen(this);
+  }
+}
+const adapter = function () {
+  let x = arguments[0];
+  for (let i = 1; i < arguments.length; i++) {
+    x = arguments[i](x);
+  }
+  return new EffectGen(x);
+};
+
+/**
+ * Inspired by https://github.com/tusharmath/qio/pull/22 (revised)
+  @internal */
+const gen = function () {
+  let f;
+  if (arguments.length === 1) {
+    f = arguments[0];
+  } else {
+    f = arguments[1].bind(arguments[0]);
+  }
+  return core.suspend(() => {
+    const iterator = f(adapter);
+    const state = iterator.next();
+    const run = state => state.done ? core.succeed(state.value) : Function_dist_effectFunction.pipe(state.value.value, core.flatMap$1(val => run(iterator.next(val))));
+    return run(state);
+  });
+};
+
+/* @internal */
+const fiberRefs = /*#__PURE__*/core.withFiberRuntime(state => core.succeed(state.getFiberRefs()));
+
+/* @internal */
+const head = self => core.matchEffect(self, {
+  onFailure: e => core.fail$1(Option_dist_effectOption.some(e)),
+  onSuccess: as => {
+    const iterator = as[Symbol.iterator]();
+    const next = iterator.next();
+    if (next.done) {
+      return core.fail$1(Option_dist_effectOption.none());
+    }
+    return core.succeed(next.value);
+  }
+});
+
+/* @internal */
+const ignore = self => match(self, {
+  onFailure: Function_dist_effectFunction.constVoid,
+  onSuccess: Function_dist_effectFunction.constVoid
+});
+
+/* @internal */
+const ignoreLogged = self => core.matchCauseEffect(self, {
+  onFailure: cause => logDebug(cause, "An error was silently ignored because it is not anticipated to be useful"),
+  onSuccess: () => core.unit
+});
+
+/* @internal */
+const inheritFiberRefs = childFiberRefs => updateFiberRefs((parentFiberId, parentFiberRefs) => FiberRefs_dist_effectFiberRefs.joinAs(parentFiberRefs, parentFiberId, childFiberRefs));
+
+/* @internal */
+const isFailure = self => match(self, {
+  onFailure: Function_dist_effectFunction.constTrue,
+  onSuccess: Function_dist_effectFunction.constFalse
+});
+
+/* @internal */
+const isSuccess = self => match(self, {
+  onFailure: Function_dist_effectFunction.constFalse,
+  onSuccess: Function_dist_effectFunction.constTrue
+});
+
+/* @internal */
+const iterate = (initial, options) => core.suspend(() => {
+  if (options.while(initial)) {
+    return core.flatMap$1(options.body(initial), z2 => iterate(z2, options));
+  }
+  return core.succeed(initial);
+});
+const logWithLevel = level => (messageOrCause, supplementary) => {
+  const levelOption = Option_dist_effectOption.fromNullable(level);
+  let message;
+  let cause;
+  if (core.isCause(messageOrCause)) {
+    cause = messageOrCause;
+    message = supplementary ?? "";
+  } else {
+    message = messageOrCause;
+    cause = supplementary ?? core.empty;
+  }
+  return core.withFiberRuntime(fiberState => {
+    fiberState.log(message, cause, levelOption);
+    return core.unit;
+  });
+};
+
+/** @internal */
+const log = /*#__PURE__*/logWithLevel();
+
+/** @internal */
+const logTrace = /*#__PURE__*/logWithLevel(LogLevel_dist_effectLogLevel.Trace);
+
+/** @internal */
+const logDebug = /*#__PURE__*/logWithLevel(LogLevel_dist_effectLogLevel.Debug);
+
+/** @internal */
+const logInfo = /*#__PURE__*/logWithLevel(LogLevel_dist_effectLogLevel.Info);
+
+/** @internal */
+const logWarning = /*#__PURE__*/logWithLevel(LogLevel_dist_effectLogLevel.Warning);
+
+/** @internal */
+const logError = /*#__PURE__*/logWithLevel(LogLevel_dist_effectLogLevel.Error);
+
+/** @internal */
+const logFatal = /*#__PURE__*/logWithLevel(LogLevel_dist_effectLogLevel.Fatal);
+
+/* @internal */
+const withLogSpan = /*#__PURE__*/Function_dist_effectFunction.dual(2, (effect, label) => core.flatMap$1(Clock_dist_effectClock.currentTimeMillis, now => core.fiberRefLocallyWith(effect, core.currentLogSpan, List_dist_effectList.prepend(LogSpan_dist_effectLogSpan.make(label, now)))));
+
+/* @internal */
+const logAnnotations = /*#__PURE__*/core.fiberRefGet(core.currentLogAnnotations);
+
+/* @internal */
+// @ts-expect-error
+const loop = (initial, options) => options.discard ? loopDiscard(initial, options.while, options.step, options.body) : core.map$1(loopInternal(initial, options.while, options.step, options.body), x => Array.from(x));
+const loopInternal = (initial, cont, inc, body) => core.suspend(() => cont(initial) ? core.flatMap$1(body(initial), a => core.map$1(loopInternal(inc(initial), cont, inc, body), List_dist_effectList.prepend(a))) : core.sync(() => List_dist_effectList.empty()));
+const loopDiscard = (initial, cont, inc, body) => core.suspend(() => cont(initial) ? core.flatMap$1(body(initial), () => loopDiscard(inc(initial), cont, inc, body)) : core.unit);
+
+/* @internal */
+const mapAccum = /*#__PURE__*/Function_dist_effectFunction.dual(3, (elements, zero, f) => core.suspend(() => {
+  const iterator = elements[Symbol.iterator]();
+  const builder = [];
+  let result = core.succeed(zero);
+  let next;
+  let i = 0;
+  while (!(next = iterator.next()).done) {
+    const index = i++;
+    result = core.flatMap$1(result, state => core.map$1(f(state, next.value, index), ([z, b]) => {
+      builder.push(b);
+      return z;
+    }));
+  }
+  return core.map$1(result, z => [z, builder]);
+}));
+
+/* @internal */
+const mapErrorCause = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.matchCauseEffect(self, {
+  onFailure: c => core.failCauseSync(() => f(c)),
+  onSuccess: core.succeed
+}));
+
+/* @internal */
+const memoize = self => Function_dist_effectFunction.pipe(core.deferredMake(), core.flatMap$1(deferred => Function_dist_effectFunction.pipe(diffFiberRefsAndRuntimeFlags(self), core.intoDeferred(deferred), once, core.map$1(complete => core.zipRight(complete, Function_dist_effectFunction.pipe(core.deferredAwait(deferred), core.flatMap$1(([patch, a]) => core.as$1(core.zip(patchFiberRefs(patch[0]), core.updateRuntimeFlags(patch[1])), a))))))));
+
+/* @internal */
+const merge = self => core.matchEffect(self, {
+  onFailure: e => core.succeed(e),
+  onSuccess: core.succeed
+});
+
+/* @internal */
+const negate = self => core.map$1(self, b => !b);
+
+/* @internal */
+const none = self => core.matchEffect(self, {
+  onFailure: e => core.fail$1(Option_dist_effectOption.some(e)),
+  onSuccess: option => {
+    switch (option._tag) {
+      case "None":
+        {
+          return core.unit;
+        }
+      case "Some":
+        {
+          return core.fail$1(Option_dist_effectOption.none());
+        }
+    }
+  }
+});
+
+/* @internal */
+const once = self => core.map$1(Ref_dist_effectRef.make(true), ref => core.asUnit(core.whenEffect(self, Ref_dist_effectRef.getAndSet(ref, false))));
+
+/* @internal */
+const option = self => core.matchEffect(self, {
+  onFailure: () => core.succeed(Option_dist_effectOption.none()),
+  onSuccess: a => core.succeed(Option_dist_effectOption.some(a))
+});
+
+/* @internal */
+const orElseFail = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, evaluate) => core.orElse(self, () => core.failSync(evaluate)));
+
+/* @internal */
+const orElseSucceed = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, evaluate) => core.orElse(self, () => core.sync(evaluate)));
+
+/* @internal */
+const parallelErrors = self => core.matchCauseEffect(self, {
+  onFailure: cause => {
+    const errors = Array.from(core.failures(cause));
+    return errors.length === 0 ? core.failCause(cause) : core.fail$1(errors);
+  },
+  onSuccess: core.succeed
+});
+
+/* @internal */
+const patchFiberRefs = patch$1 => updateFiberRefs((fiberId, fiberRefs) => Function_dist_effectFunction.pipe(patch$1, patch.patch(fiberId, fiberRefs)));
+
+/* @internal */
+const promise = evaluate => evaluate.length >= 1 ? core.async((resolve, signal) => {
+  evaluate(signal).then(a => resolve(core.exitSucceed(a))).catch(e => resolve(core.exitDie(e)));
+}) : core.async(resolve => {
+  evaluate().then(a => resolve(core.exitSucceed(a))).catch(e => resolve(core.exitDie(e)));
+});
+
+/* @internal */
+const provideService = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, service) => core.contextWithEffect(env => core.provideContext(self, Context_dist_effectContext.add(env, tag, service))));
+
+/* @internal */
+const provideServiceEffect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, effect) => core.contextWithEffect(env => core.flatMap$1(effect, service => core.provideContext(self, Function_dist_effectFunction.pipe(env, Context_dist_effectContext.add(tag, service))))));
+
+/* @internal */
+const random = /*#__PURE__*/defaultServices.randomWith(core.succeed);
+
+/* @internal */
+const reduce = /*#__PURE__*/Function_dist_effectFunction.dual(3, (elements, zero, f) => ReadonlyArray_dist_effectReadonlyArray.fromIterable(elements).reduce((acc, el, i) => core.flatMap$1(acc, a => f(a, el, i)), core.succeed(zero)));
+
+/* @internal */
+const reduceRight = /*#__PURE__*/Function_dist_effectFunction.dual(3, (elements, zero, f) => ReadonlyArray_dist_effectReadonlyArray.fromIterable(elements).reduceRight((acc, el, i) => core.flatMap$1(acc, a => f(el, a, i)), core.succeed(zero)));
+
+/* @internal */
+const reduceWhile = /*#__PURE__*/Function_dist_effectFunction.dual(3, (elements, zero, options) => core.flatMap$1(core.sync(() => elements[Symbol.iterator]()), iterator => reduceWhileLoop(iterator, 0, zero, options.while, options.body)));
+const reduceWhileLoop = (iterator, index, state, predicate, f) => {
+  const next = iterator.next();
+  if (!next.done && predicate(state)) {
+    return core.flatMap$1(f(state, next.value, index), nextState => reduceWhileLoop(iterator, index + 1, nextState, predicate, f));
+  }
+  return core.succeed(state);
+};
+
+/* @internal */
+const repeatN = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => core.suspend(() => repeatNLoop(self, n)));
+
+/* @internal */
+const repeatNLoop = (self, n) => core.flatMap$1(self, a => n <= 0 ? core.succeed(a) : core.zipRight(core.yieldNow(), repeatNLoop(self, n - 1)));
+
+/* @internal */
+const sandbox = self => core.matchCauseEffect(self, {
+  onFailure: core.fail$1,
+  onSuccess: core.succeed
+});
+
+/* @internal */
+const setFiberRefs = fiberRefs => core.suspend(() => FiberRefs_dist_effectFiberRefs.setAll(fiberRefs));
+
+/* @internal */
+const sleep = Clock_dist_effectClock.sleep;
+
+/* @internal */
+const succeedNone = /*#__PURE__*/core.succeed( /*#__PURE__*/Option_dist_effectOption.none());
+
+/* @internal */
+const succeedSome = value => core.succeed(Option_dist_effectOption.some(value));
+
+/* @internal */
+const summarized = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, summary, f) => core.flatMap$1(summary, start => core.flatMap$1(self, value => core.map$1(summary, end => [f(start, end), value]))));
+
+/* @internal */
+const tagMetrics = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[0]), function () {
+  return labelMetrics(arguments[0], typeof arguments[1] === "string" ? [label.make(arguments[1], arguments[2])] : Object.entries(arguments[1]).map(([k, v]) => label.make(k, v)));
+});
+
+/* @internal */
+const labelMetrics = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, labels) => labelMetricsSet(self, HashSet_dist_effectHashSet.fromIterable(labels)));
+
+/* @internal */
+const labelMetricsSet = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, labels) => core.fiberRefLocallyWith(core.currentMetricLabels, set => Function_dist_effectFunction.pipe(set, HashSet_dist_effectHashSet.union(labels)))(self));
+
+/* @internal */
+const takeUntil = /*#__PURE__*/Function_dist_effectFunction.dual(2, (elements, predicate) => core.suspend(() => {
+  const iterator = elements[Symbol.iterator]();
+  const builder = [];
+  let next;
+  let effect = core.succeed(false);
+  let i = 0;
+  while ((next = iterator.next()) && !next.done) {
+    const a = next.value;
+    const index = i++;
+    effect = core.flatMap$1(effect, bool => {
+      if (bool) {
+        return core.succeed(true);
+      }
+      builder.push(a);
+      return predicate(a, index);
+    });
+  }
+  return core.map$1(effect, () => builder);
+}));
+
+/* @internal */
+const takeWhile = /*#__PURE__*/Function_dist_effectFunction.dual(2, (elements, predicate) => core.suspend(() => {
+  const iterator = elements[Symbol.iterator]();
+  const builder = [];
+  let next;
+  let taking = core.succeed(true);
+  let i = 0;
+  while ((next = iterator.next()) && !next.done) {
+    const a = next.value;
+    const index = i++;
+    taking = core.flatMap$1(taking, taking => Function_dist_effectFunction.pipe(taking ? predicate(a, index) : core.succeed(false), core.map$1(bool => {
+      if (bool) {
+        builder.push(a);
+      }
+      return bool;
+    })));
+  }
+  return core.map$1(taking, () => builder);
+}));
+
+/* @internal */
+const tapBoth = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
+  onFailure,
+  onSuccess
+}) => core.matchCauseEffect(self, {
+  onFailure: cause => {
+    const either = core.failureOrCause(cause);
+    switch (either._tag) {
+      case "Left":
+        {
+          return core.zipRight(onFailure(either.left), core.failCause(cause));
+        }
+      case "Right":
+        {
+          return core.failCause(cause);
+        }
+    }
+  },
+  onSuccess: a => core.as$1(onSuccess(a), a)
+}));
+
+/* @internal */
+const tapDefect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.catchAllCause(self, cause => Option_dist_effectOption.match(core.keepDefects(cause), {
+  onNone: () => core.failCause(cause),
+  onSome: a => core.zipRight(f(a), core.failCause(cause))
+})));
+
+/* @internal */
+const tapError = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.matchCauseEffect(self, {
+  onFailure: cause => {
+    const either = core.failureOrCause(cause);
+    switch (either._tag) {
+      case "Left":
+        {
+          return core.zipRight(f(either.left), core.failCause(cause));
+        }
+      case "Right":
+        {
+          return core.failCause(cause);
+        }
+    }
+  },
+  onSuccess: core.succeed
+}));
+
+/* @internal */
+const tapErrorTag = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, k, f) => tapError(self, e => {
+  if (Predicate_dist_effectPredicate.isTagged(e, k)) {
+    return f(e);
+  }
+  return core.unit;
+}));
+
+/* @internal */
+const tapErrorCause = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.matchCauseEffect(self, {
+  onFailure: cause => core.zipRight(f(cause), core.failCause(cause)),
+  onSuccess: core.succeed
+}));
+
+/* @internal */
+const timed = self => timedWith(self, Clock_dist_effectClock.currentTimeNanos);
+
+/* @internal */
+const timedWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, nanos) => summarized(self, nanos, (start, end) => Duration_dist_effectDuration.nanos(end - start)));
+
+/* @internal */
+const tracerWith = Tracer_dist_effectTracer.tracerWith;
+
+/** @internal */
+const tracer = /*#__PURE__*/tracerWith(core.succeed);
+
+/* @internal */
+const tryPromise = arg => {
+  let evaluate;
+  let catcher = undefined;
+  if (typeof arg === "function") {
+    evaluate = arg;
+  } else {
+    evaluate = arg.try;
+    catcher = arg.catch;
+  }
+  if (evaluate.length >= 1) {
+    return core.suspend(() => {
+      const controller = new AbortController();
+      return core.flatMap$1(try_(() => evaluate(controller.signal)), promise => core.async(resolve => {
+        promise.then(a => resolve(core.exitSucceed(a))).catch(e => resolve(core.fail$1(catcher ? catcher(e) : e)));
+        return core.sync(() => controller.abort());
+      }));
+    });
+  }
+  return core.flatMap$1(try_(arg), promise => core.async(resolve => {
+    promise.then(a => resolve(core.exitSucceed(a))).catch(e => resolve(core.fail$1(catcher ? catcher(e) : e)));
+  }));
+};
+
+/* @internal */
+const tryMap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => core.flatMap$1(self, a => try_({
+  try: () => options.try(a),
+  catch: options.catch
+})));
+
+/* @internal */
+const tryMapPromise = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => core.flatMap$1(self, a => tryPromise({
+  try: options.try.length >= 1 ? signal => options.try(a, signal) : () => options.try(a),
+  catch: options.catch
+})));
+
+/* @internal */
+const unless = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => core.suspend(() => predicate() ? succeedNone : asSome(self)));
+
+/* @internal */
+const unlessEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => core.flatMap$1(predicate, b => b ? succeedNone : asSome(self)));
+
+/* @internal */
+const unsandbox = self => mapErrorCause(self, core.flatten);
+
+/* @internal */
+const updateFiberRefs = f => core.withFiberRuntime(state => {
+  state.setFiberRefs(f(state.id(), state.getFiberRefs()));
+  return core.unit;
+});
+
+/* @internal */
+const updateService = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, f) => core.mapInputContext(self, context => Context_dist_effectContext.add(context, tag, f(Context_dist_effectContext.unsafeGet(context, tag)))));
+
+/* @internal */
+const when = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => core.suspend(() => predicate() ? core.map$1(self, Option_dist_effectOption.some) : core.succeed(Option_dist_effectOption.none())));
+
+/* @internal */
+const whenFiberRef = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, fiberRef, predicate) => core.flatMap$1(core.fiberRefGet(fiberRef), s => predicate(s) ? core.map$1(self, a => [s, Option_dist_effectOption.some(a)]) : core.succeed([s, Option_dist_effectOption.none()])));
+
+/* @internal */
+const whenRef = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, ref, predicate) => core.flatMap$1(Ref_dist_effectRef.get(ref), s => predicate(s) ? core.map$1(self, a => [s, Option_dist_effectOption.some(a)]) : core.succeed([s, Option_dist_effectOption.none()])));
+
+/* @internal */
+const withMetric = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, metric) => metric(self));
+
+/** @internal */
+const serviceFunctionEffect = (service, f) => (...args) => core.flatMap$1(service, a => f(a)(...args));
+
+/** @internal */
+const serviceFunction = (service, f) => (...args) => core.map$1(service, a => f(a)(...args));
+
+/** @internal */
+const serviceFunctions = tag => new Proxy({}, {
+  get(_target, prop, _receiver) {
+    return (...args) => core.flatMap$1(tag, s => s[prop](...args));
+  }
+});
+
+/** @internal */
+const serviceConstants = tag => new Proxy({}, {
+  get(_target, prop, _receiver) {
+    return core.flatMap$1(tag, s => s[prop]);
+  }
+});
+
+/** @internal */
+const serviceMembers = tag => ({
+  functions: serviceFunctions(tag),
+  constants: serviceConstants(tag)
+});
+
+/** @internal */
+const serviceOption = tag => core.map$1(core.context(), Context_dist_effectContext.getOption(tag));
+
+// -----------------------------------------------------------------------------
+// tracing
+// -----------------------------------------------------------------------------
+
+/* @internal */
+const annotateCurrentSpan = function () {
+  const args = arguments;
+  return core.flatMap$1(currentSpan, span => span._tag === "Some" ? core.sync(() => {
+    if (typeof args[0] === "string") {
+      span.value.attribute(args[0], args[1]);
+    } else {
+      for (const key in args[0]) {
+        span.value.attribute(key, args[0][key]);
+      }
+    }
+  }) : core.unit);
+};
+
+/* @internal */
+const annotateSpans = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[0]), function () {
+  const args = arguments;
+  return core.fiberRefLocallyWith(args[0], core.currentTracerSpanAnnotations, typeof args[1] === "string" ? HashMap_dist_effectHashMap.set(args[1], args[2]) : annotations => Object.entries(args[1]).reduce((acc, [key, value]) => HashMap_dist_effectHashMap.set(acc, key, value), annotations));
+});
+
+/** @internal */
+const currentParentSpan = /*#__PURE__*/serviceOption(core.spanTag);
+
+/** @internal */
+const currentSpan = /*#__PURE__*/core.map$1( /*#__PURE__*/core.context(), context => {
+  const span = context.unsafeMap.get(core.spanTag);
+  return span !== undefined && span._tag === "Span" ? Option_dist_effectOption.some(span) : Option_dist_effectOption.none();
+});
+const bigint0 = /*#__PURE__*/BigInt(0);
+/** @internal */
+const currentTimeNanosTracing = /*#__PURE__*/core.fiberRefGetWith(core.currentTracerTimingEnabled, enabled => enabled ? Clock_dist_effectClock.currentTimeNanos : core.succeed(bigint0));
+
+/* @internal */
+const linkSpans = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[0]), (self, span, attributes) => core.fiberRefLocallyWith(self, core.currentTracerSpanLinks, Chunk_dist_effectChunk.append({
+  _tag: "SpanLink",
+  span,
+  attributes: attributes ?? {}
+})));
+
+/** @internal */
+const makeSpan = (name, options) => tracerWith(tracer => core.flatMap$1(options?.parent ? succeedSome(options.parent) : options?.root ? succeedNone : currentParentSpan, parent => core.flatMap$1(core.fiberRefGet(core.currentTracerSpanAnnotations), annotations => core.flatMap$1(core.fiberRefGet(core.currentTracerSpanLinks), links => core.flatMap$1(currentTimeNanosTracing, startTime => core.sync(() => {
+  const linksArray = options?.links ? [...Chunk_dist_effectChunk.toReadonlyArray(links), ...options.links] : Chunk_dist_effectChunk.toReadonlyArray(links);
+  const span = tracer.span(name, parent, options?.context ?? Context_dist_effectContext.empty(), linksArray, startTime);
+  HashMap_dist_effectHashMap.forEach(annotations, (value, key) => span.attribute(key, value));
+  Object.entries(options?.attributes ?? {}).forEach(([k, v]) => span.attribute(k, v));
+  return span;
+}))))));
+
+/* @internal */
+const spanAnnotations = /*#__PURE__*/core.fiberRefGet(core.currentTracerSpanAnnotations);
+
+/* @internal */
+const spanLinks = /*#__PURE__*/core.fiberRefGet(core.currentTracerSpanLinks);
+
+/** @internal */
+const useSpan = (name, ...args) => {
+  const options = args.length === 1 ? undefined : args[0];
+  const evaluate = args[args.length - 1];
+  return core.acquireUseRelease(makeSpan(name, options), evaluate, (span, exit) => core.flatMap$1(currentTimeNanosTracing, endTime => core.sync(() => span.end(endTime, exit))));
+};
+
+/** @internal */
+const withParentSpan = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, span) => provideService(self, core.spanTag, span));
+
+/** @internal */
+const withSpan = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[0] !== "string", (self, name, options) => useSpan(name, options ?? {}, span => withParentSpan(self, span)));
+
+// -------------------------------------------------------------------------------------
+// optionality
+// -------------------------------------------------------------------------------------
+
+/* @internal */
+const fromNullable = value => value == null ? core.fail$1(core.NoSuchElementException()) : core.succeed(value);
+
+/* @internal */
+const optionFromOptional = self => core.catchAll(core.map$1(self, Option_dist_effectOption.some), error => core.isNoSuchElementException(error) ? succeedNone : core.fail$1(error));
+
+exports.Do = Do;
+exports.SingleShotGen = SingleShotGen;
+exports._catch = _catch;
+exports.allowInterrupt = allowInterrupt;
+exports.annotateCurrentSpan = annotateCurrentSpan;
+exports.annotateLogs = annotateLogs;
+exports.annotateSpans = annotateSpans;
+exports.asSome = asSome;
+exports.asSomeError = asSomeError;
+exports.asyncOption = asyncOption;
+exports.bind = bind;
+exports.bindTo = bindTo;
+exports.bindValue = bindValue;
+exports.catchAllDefect = catchAllDefect;
+exports.catchSomeCause = catchSomeCause;
+exports.catchSomeDefect = catchSomeDefect;
+exports.catchTag = catchTag;
+exports.catchTags = catchTags;
+exports.cause = cause;
+exports.clock = clock;
+exports.clockWith = clockWith;
+exports.contextWith = contextWith;
+exports.currentParentSpan = currentParentSpan;
+exports.currentSpan = currentSpan;
+exports.currentTimeNanosTracing = currentTimeNanosTracing;
+exports.delay = delay;
+exports.descriptor = descriptor;
+exports.descriptorWith = descriptorWith;
+exports.diffFiberRefs = diffFiberRefs;
+exports.dropUntil = dropUntil;
+exports.dropWhile = dropWhile;
+exports.eventually = eventually;
+exports.every = every;
+exports.fiberRefs = fiberRefs;
+exports.filterOrDie = filterOrDie;
+exports.filterOrDieMessage = filterOrDieMessage;
+exports.filterOrElse = filterOrElse;
+exports.filterOrFail = filterOrFail;
+exports.findFirst = findFirst;
+exports.firstSuccessOf = firstSuccessOf;
+exports.flipWith = flipWith;
+exports.forever = forever;
+exports.fromNullable = fromNullable;
+exports.gen = gen;
+exports.head = head;
+exports.ignore = ignore;
+exports.ignoreLogged = ignoreLogged;
+exports.inheritFiberRefs = inheritFiberRefs;
+exports.isFailure = isFailure;
+exports.isSuccess = isSuccess;
+exports.iterate = iterate;
+exports.labelMetrics = labelMetrics;
+exports.labelMetricsSet = labelMetricsSet;
+exports.linkSpans = linkSpans;
+exports.log = log;
+exports.logAnnotations = logAnnotations;
+exports.logDebug = logDebug;
+exports.logError = logError;
+exports.logFatal = logFatal;
+exports.logInfo = logInfo;
+exports.logTrace = logTrace;
+exports.logWarning = logWarning;
+exports.loop = loop;
+exports.makeSpan = makeSpan;
+exports.mapAccum = mapAccum;
+exports.mapErrorCause = mapErrorCause;
+exports.match = match;
+exports.memoize = memoize;
+exports.merge = merge;
+exports.negate = negate;
+exports.none = none;
+exports.once = once;
+exports.option = option;
+exports.optionFromOptional = optionFromOptional;
+exports.orElseFail = orElseFail;
+exports.orElseSucceed = orElseSucceed;
+exports.parallelErrors = parallelErrors;
+exports.patchFiberRefs = patchFiberRefs;
+exports.promise = promise;
+exports.provideService = provideService;
+exports.provideServiceEffect = provideServiceEffect;
+exports.random = random;
+exports.reduce = reduce;
+exports.reduceRight = reduceRight;
+exports.reduceWhile = reduceWhile;
+exports.repeatN = repeatN;
+exports.sandbox = sandbox;
+exports.serviceConstants = serviceConstants;
+exports.serviceFunction = serviceFunction;
+exports.serviceFunctionEffect = serviceFunctionEffect;
+exports.serviceFunctions = serviceFunctions;
+exports.serviceMembers = serviceMembers;
+exports.serviceOption = serviceOption;
+exports.setFiberRefs = setFiberRefs;
+exports.sleep = sleep;
+exports.spanAnnotations = spanAnnotations;
+exports.spanLinks = spanLinks;
+exports.succeedNone = succeedNone;
+exports.succeedSome = succeedSome;
+exports.summarized = summarized;
+exports.tagMetrics = tagMetrics;
+exports.takeUntil = takeUntil;
+exports.takeWhile = takeWhile;
+exports.tapBoth = tapBoth;
+exports.tapDefect = tapDefect;
+exports.tapError = tapError;
+exports.tapErrorCause = tapErrorCause;
+exports.tapErrorTag = tapErrorTag;
+exports.timed = timed;
+exports.timedWith = timedWith;
+exports.tracer = tracer;
+exports.tryMap = tryMap;
+exports.tryMapPromise = tryMapPromise;
+exports.tryPromise = tryPromise;
+exports.try_ = try_;
+exports.unless = unless;
+exports.unlessEffect = unlessEffect;
+exports.unsandbox = unsandbox;
+exports.updateFiberRefs = updateFiberRefs;
+exports.updateService = updateService;
+exports.useSpan = useSpan;
+exports.when = when;
+exports.whenFiberRef = whenFiberRef;
+exports.whenRef = whenRef;
+exports.withLogSpan = withLogSpan;
+exports.withMetric = withMetric;
+exports.withParentSpan = withParentSpan;
+exports.withSpan = withSpan;