effect 2.0.0-next.37 → 2.0.0-next.39

package/dist/schedule-d3f9b258.cjs.dev.js

@@ -1,956 +0,0 @@
-'use strict';
-
-var Chunk_dist_effectChunk = require('./Chunk-937f4423.cjs.dev.js');
-var Clock_dist_effectClock = require('./Clock-589e9dc5.cjs.dev.js');
-var Context_dist_effectContext = require('./Context-fdaa5c44.cjs.dev.js');
-var Duration_dist_effectDuration = require('./Duration-8b174e0b.cjs.dev.js');
-var Either_dist_effectEither = require('./Either-ae722a9e.cjs.dev.js');
-var Equal_dist_effectEqual = require('./Equal-8654b1af.cjs.dev.js');
-var Function_dist_effectFunction = require('./Function-fd10bde3.cjs.dev.js');
-var core = require('./core-bedc63fe.cjs.dev.js');
-var Ref_dist_effectRef = require('./Ref-8d85fc7a.cjs.dev.js');
-var Option_dist_effectOption = require('./Option-837ae0da.cjs.dev.js');
-var Pipeable_dist_effectPipeable = require('./Pipeable-ef202667.cjs.dev.js');
-var Random_dist_effectRandom = require('./Random-f495bcbc.cjs.dev.js');
-var ScheduleDecision_dist_effectScheduleDecision = require('./ScheduleDecision-2ab823c2.cjs.dev.js');
-var ScheduleInterval_dist_effectScheduleInterval = require('./ScheduleInterval-2db9be83.cjs.dev.js');
-var ScheduleIntervals_dist_effectScheduleIntervals = require('./ScheduleIntervals-ab412802.cjs.dev.js');
-var coreEffect = require('./core-effect-a839563d.cjs.dev.js');
-
-/** @internal */
-const ScheduleSymbolKey = "effect/Schedule";
-
-/** @internal */
-const ScheduleTypeId = /*#__PURE__*/Symbol.for(ScheduleSymbolKey);
-
-/** @internal */
-const ScheduleDriverSymbolKey = "effect/ScheduleDriver";
-
-/** @internal */
-const ScheduleDriverTypeId = /*#__PURE__*/Symbol.for(ScheduleDriverSymbolKey);
-
-/** @internal */
-const scheduleVariance = {
-  _Env: _ => _,
-  _In: _ => _,
-  _Out: _ => _
-};
-const scheduleDriverVariance = {
-  _Env: _ => _,
-  _In: _ => _,
-  _Out: _ => _
-};
-
-/** @internal */
-class ScheduleImpl {
-  [ScheduleTypeId] = scheduleVariance;
-  constructor(initial, step) {
-    this.initial = initial;
-    this.step = step;
-  }
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-}
-
-/** @internal */
-class ScheduleDriverImpl {
-  [ScheduleDriverTypeId] = scheduleDriverVariance;
-  constructor(schedule, ref) {
-    this.schedule = schedule;
-    this.ref = ref;
-  }
-  state() {
-    return core.map(Ref_dist_effectRef.get$1(this.ref), tuple => tuple[1]);
-  }
-  last() {
-    return core.flatMap(Ref_dist_effectRef.get$1(this.ref), ([element, _]) => {
-      switch (element._tag) {
-        case "None":
-          {
-            return core.failSync(() => core.NoSuchElementException());
-          }
-        case "Some":
-          {
-            return core.succeed(element.value);
-          }
-      }
-    });
-  }
-  reset() {
-    return Ref_dist_effectRef.set$1(this.ref, [Option_dist_effectOption.none(), this.schedule.initial]);
-  }
-  next(input) {
-    return Function_dist_effectFunction.pipe(core.map(Ref_dist_effectRef.get$1(this.ref), tuple => tuple[1]), core.flatMap(state => Function_dist_effectFunction.pipe(Clock_dist_effectClock.currentTimeMillis, core.flatMap(now => Function_dist_effectFunction.pipe(core.suspend(() => this.schedule.step(now, input, state)), core.flatMap(([state, out, decision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(decision) ? Function_dist_effectFunction.pipe(Ref_dist_effectRef.set$1(this.ref, [Option_dist_effectOption.some(out), state]), core.zipRight(core.fail(Option_dist_effectOption.none()))) : Function_dist_effectFunction.pipe(Ref_dist_effectRef.set$1(this.ref, [Option_dist_effectOption.some(out), state]), core.zipRight(coreEffect.sleep(Duration_dist_effectDuration.millis(ScheduleIntervals_dist_effectScheduleIntervals.start(decision.intervals) - now))), core.as(out))))))));
-  }
-}
-
-/** @internal */
-const makeWithState = (initial, step) => new ScheduleImpl(initial, step);
-
-/** @internal */
-const addDelay = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => addDelayEffect(self, out => core.sync(() => f(out))));
-
-/** @internal */
-const addDelayEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => modifyDelayEffect(self, (out, duration) => core.map(f(out), delay => Duration_dist_effectDuration.sum(duration, Duration_dist_effectDuration.decode(delay)))));
-
-/** @internal */
-const andThen = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => map(andThenEither(self, that), Either_dist_effectEither.merge));
-
-/** @internal */
-const andThenEither = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => makeWithState([self.initial, that.initial, true], (now, input, state) => state[2] ? core.flatMap(self.step(now, input, state[0]), ([lState, out, decision]) => {
-  if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
-    return core.map(that.step(now, input, state[1]), ([rState, out, decision]) => [[lState, rState, false], Either_dist_effectEither.right(out), decision]);
-  }
-  return core.succeed([[lState, state[1], true], Either_dist_effectEither.left(out), decision]);
-}) : core.map(that.step(now, input, state[1]), ([rState, out, decision]) => [[state[0], rState, false], Either_dist_effectEither.right(out), decision])));
-
-/** @internal */
-const as = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, out) => map(self, () => out));
-
-/** @internal */
-const asUnit = self => map(self, Function_dist_effectFunction.constVoid);
-
-/** @internal */
-const bothInOut = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => makeWithState([self.initial, that.initial], (now, [in1, in2], state) => core.zipWith(self.step(now, in1, state[0]), that.step(now, in2, state[1]), ([lState, out, lDecision], [rState, out2, rDecision]) => {
-  if (ScheduleDecision_dist_effectScheduleDecision.isContinue(lDecision) && ScheduleDecision_dist_effectScheduleDecision.isContinue(rDecision)) {
-    const interval = Function_dist_effectFunction.pipe(lDecision.intervals, ScheduleIntervals_dist_effectScheduleIntervals.union(rDecision.intervals));
-    return [[lState, rState], [out, out2], ScheduleDecision_dist_effectScheduleDecision._continue(interval)];
-  }
-  return [[lState, rState], [out, out2], ScheduleDecision_dist_effectScheduleDecision.done];
-})));
-
-/** @internal */
-const check = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, test) => checkEffect(self, (input, out) => core.sync(() => test(input, out))));
-
-/** @internal */
-const checkEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, test) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => {
-  if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
-    return core.succeed([state, out, ScheduleDecision_dist_effectScheduleDecision.done]);
-  }
-  return core.map(test(input, out), cont => cont ? [state, out, decision] : [state, out, ScheduleDecision_dist_effectScheduleDecision.done]);
-})));
-/** @internal */
-const collectAllInputs = () => collectAllOutputs(identity());
-
-/** @internal */
-const collectAllOutputs = self => reduce(self, Chunk_dist_effectChunk.empty(), (outs, out) => Function_dist_effectFunction.pipe(outs, Chunk_dist_effectChunk.append(out)));
-
-/** @internal */
-const collectUntil = f => collectAllOutputs(recurUntil(f));
-
-/** @internal */
-const collectUntilEffect = f => collectAllOutputs(recurUntilEffect(f));
-
-/** @internal */
-const collectWhile = f => collectAllOutputs(recurWhile(f));
-
-/** @internal */
-const collectWhileEffect = f => collectAllOutputs(recurWhileEffect(f));
-
-/** @internal */
-const compose = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => makeWithState([self.initial, that.initial], (now, input, state) => core.flatMap(self.step(now, input, state[0]), ([lState, out, lDecision]) => core.map(that.step(now, out, state[1]), ([rState, out2, rDecision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(lDecision) ? [[lState, rState], out2, ScheduleDecision_dist_effectScheduleDecision.done] : ScheduleDecision_dist_effectScheduleDecision.isDone(rDecision) ? [[lState, rState], out2, ScheduleDecision_dist_effectScheduleDecision.done] : [[lState, rState], out2, ScheduleDecision_dist_effectScheduleDecision._continue(Function_dist_effectFunction.pipe(lDecision.intervals, ScheduleIntervals_dist_effectScheduleIntervals.max(rDecision.intervals)))]))));
-
-/** @internal */
-const mapInput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => mapInputEffect(self, input2 => core.sync(() => f(input2))));
-
-/** @internal */
-const mapInputContext = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.mapInputContext(self.step(now, input, state), f)));
-
-/** @internal */
-const mapInputEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input2, state) => core.flatMap(f(input2), input => self.step(now, input, state))));
-
-/** @internal */
-const dayOfMonth = day => {
-  return makeWithState([Number.NEGATIVE_INFINITY, 0], (now, _, state) => {
-    if (!Number.isInteger(day) || day < 1 || 31 < day) {
-      return core.dieSync(() => core.IllegalArgumentException(`Invalid argument in: dayOfMonth(${day}). Must be in range 1...31`));
-    }
-    const n = state[1];
-    const initial = n === 0;
-    const day0 = nextDayOfMonth(now, day, initial);
-    const start = beginningOfDay(day0);
-    const end = endOfDay(day0);
-    const interval = ScheduleInterval_dist_effectScheduleInterval.make(start, end);
-    return core.succeed([[end, n + 1], n, ScheduleDecision_dist_effectScheduleDecision.continueWith(interval)]);
-  });
-};
-
-/** @internal */
-const dayOfWeek = day => {
-  return makeWithState([Number.MIN_SAFE_INTEGER, 0], (now, _, state) => {
-    if (!Number.isInteger(day) || day < 1 || 7 < day) {
-      return core.dieSync(() => core.IllegalArgumentException(`Invalid argument in: dayOfWeek(${day}). Must be in range 1 (Monday)...7 (Sunday)`));
-    }
-    const n = state[1];
-    const initial = n === 0;
-    const day0 = nextDay(now, day, initial);
-    const start = beginningOfDay(day0);
-    const end = endOfDay(day0);
-    const interval = ScheduleInterval_dist_effectScheduleInterval.make(start, end);
-    return core.succeed([[end, n + 1], n, ScheduleDecision_dist_effectScheduleDecision.continueWith(interval)]);
-  });
-};
-
-/** @internal */
-const delayed = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => delayedEffect(self, duration => core.sync(() => f(duration))));
-
-/** @internal */
-const delayedEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => modifyDelayEffect(self, (_, delay) => f(delay)));
-
-/** @internal */
-const delayedSchedule = schedule => addDelay(schedule, x => x);
-
-/** @internal */
-const delays = self => makeWithState(self.initial, (now, input, state) => Function_dist_effectFunction.pipe(self.step(now, input, state), core.flatMap(([state, _, decision]) => {
-  if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
-    return core.succeed([state, Duration_dist_effectDuration.zero, decision]);
-  }
-  return core.succeed([state, Duration_dist_effectDuration.millis(ScheduleIntervals_dist_effectScheduleIntervals.start(decision.intervals) - now), decision]);
-})));
-
-/** @internal */
-const mapBoth = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
-  onInput,
-  onOutput
-}) => map(mapInput(self, onInput), onOutput));
-
-/** @internal */
-const mapBothEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
-  onInput,
-  onOutput
-}) => mapEffect(mapInputEffect(self, onInput), onOutput));
-
-/** @internal */
-const driver = self => Function_dist_effectFunction.pipe(Ref_dist_effectRef.make$1([Option_dist_effectOption.none(), self.initial]), core.map(ref => new ScheduleDriverImpl(self, ref)));
-
-/** @internal */
-const duration = durationInput => {
-  const duration = Duration_dist_effectDuration.decode(durationInput);
-  const durationMillis = Duration_dist_effectDuration.toMillis(duration);
-  return makeWithState(true, (now, _, state) => core.succeed(state ? [false, duration, ScheduleDecision_dist_effectScheduleDecision.continueWith(ScheduleInterval_dist_effectScheduleInterval.after(now + durationMillis))] : [false, Duration_dist_effectDuration.zero, ScheduleDecision_dist_effectScheduleDecision.done]));
-};
-
-/** @internal */
-const either = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => union(self, that));
-
-/** @internal */
-const eitherWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => unionWith(self, that, f));
-
-/** @internal */
-const ensuring = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, finalizer) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(decision) ? core.as(finalizer, [state, out, decision]) : core.succeed([state, out, decision]))));
-
-/** @internal */
-const exponential = (baseInput, factor = 2.0) => {
-  const base = Duration_dist_effectDuration.decode(baseInput);
-  return delayedSchedule(map(forever, i => Duration_dist_effectDuration.times(base, Math.pow(factor, i))));
-};
-
-/** @internal */
-const fibonacci = oneInput => {
-  const one = Duration_dist_effectDuration.decode(oneInput);
-  return delayedSchedule(Function_dist_effectFunction.pipe(unfold([one, one], ([a, b]) => [b, Duration_dist_effectDuration.sum(a, b)]), map(out => out[0])));
-};
-
-/** @internal */
-const fixed = intervalInput => {
-  const interval = Duration_dist_effectDuration.decode(intervalInput);
-  const intervalMillis = Duration_dist_effectDuration.toMillis(interval);
-  return makeWithState([Option_dist_effectOption.none(), 0], (now, _, [option, n]) => core.sync(() => {
-    switch (option._tag) {
-      case "None":
-        {
-          return [[Option_dist_effectOption.some([now, now + intervalMillis]), n + 1], n, ScheduleDecision_dist_effectScheduleDecision.continueWith(ScheduleInterval_dist_effectScheduleInterval.after(now + intervalMillis))];
-        }
-      case "Some":
-        {
-          const [startMillis, lastRun] = option.value;
-          const runningBehind = now > lastRun + intervalMillis;
-          const boundary = Equal_dist_effectEqual.equals(interval, Duration_dist_effectDuration.zero) ? interval : Duration_dist_effectDuration.millis(intervalMillis - (now - startMillis) % intervalMillis);
-          const sleepTime = Equal_dist_effectEqual.equals(boundary, Duration_dist_effectDuration.zero) ? interval : boundary;
-          const nextRun = runningBehind ? now : now + Duration_dist_effectDuration.toMillis(sleepTime);
-          return [[Option_dist_effectOption.some([startMillis, nextRun]), n + 1], n, ScheduleDecision_dist_effectScheduleDecision.continueWith(ScheduleInterval_dist_effectScheduleInterval.after(nextRun))];
-        }
-    }
-  }));
-};
-
-/** @internal */
-const fromDelay = delay => duration(delay);
-
-/** @internal */
-const fromDelays = (delay, ...delays) => makeWithState([[delay, ...delays].map(_ => Duration_dist_effectDuration.decode(_)), true], (now, _, [durations, cont]) => core.sync(() => {
-  if (cont) {
-    const x = durations[0];
-    const interval = ScheduleInterval_dist_effectScheduleInterval.after(now + Duration_dist_effectDuration.toMillis(x));
-    if (durations.length >= 2) {
-      return [[durations.slice(1), true], x, ScheduleDecision_dist_effectScheduleDecision.continueWith(interval)];
-    }
-    const y = durations.slice(1);
-    return [[[x, ...y], false], x, ScheduleDecision_dist_effectScheduleDecision.continueWith(interval)];
-  }
-  return [[durations, false], Duration_dist_effectDuration.zero, ScheduleDecision_dist_effectScheduleDecision.done];
-}));
-
-/** @internal */
-const fromFunction = f => map(identity(), f);
-
-/** @internal */
-const hourOfDay = hour => makeWithState([Number.NEGATIVE_INFINITY, 0], (now, _, state) => {
-  if (!Number.isInteger(hour) || hour < 0 || 23 < hour) {
-    return core.dieSync(() => core.IllegalArgumentException(`Invalid argument in: hourOfDay(${hour}). Must be in range 0...23`));
-  }
-  const n = state[1];
-  const initial = n === 0;
-  const hour0 = nextHour(now, hour, initial);
-  const start = beginningOfHour(hour0);
-  const end = endOfHour(hour0);
-  const interval = ScheduleInterval_dist_effectScheduleInterval.make(start, end);
-  return core.succeed([[end, n + 1], n, ScheduleDecision_dist_effectScheduleDecision.continueWith(interval)]);
-});
-
-/** @internal */
-const identity = () => makeWithState(void 0, (now, input, state) => core.succeed([state, input, ScheduleDecision_dist_effectScheduleDecision.continueWith(ScheduleInterval_dist_effectScheduleInterval.after(now))]));
-
-/** @internal */
-const intersect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => intersectWith(self, that, ScheduleIntervals_dist_effectScheduleIntervals.intersect));
-
-/** @internal */
-const intersectWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => makeWithState([self.initial, that.initial], (now, input, state) => Function_dist_effectFunction.pipe(core.zipWith(self.step(now, input, state[0]), that.step(now, input, state[1]), (a, b) => [a, b]), core.flatMap(([[lState, out, lDecision], [rState, out2, rDecision]]) => {
-  if (ScheduleDecision_dist_effectScheduleDecision.isContinue(lDecision) && ScheduleDecision_dist_effectScheduleDecision.isContinue(rDecision)) {
-    return intersectWithLoop(self, that, input, lState, out, lDecision.intervals, rState, out2, rDecision.intervals, f);
-  }
-  return core.succeed([[lState, rState], [out, out2], ScheduleDecision_dist_effectScheduleDecision.done]);
-}))));
-
-/** @internal */
-const intersectWithLoop = (self, that, input, lState, out, lInterval, rState, out2, rInterval, f) => {
-  const combined = f(lInterval, rInterval);
-  if (ScheduleIntervals_dist_effectScheduleIntervals.isNonEmpty(combined)) {
-    return core.succeed([[lState, rState], [out, out2], ScheduleDecision_dist_effectScheduleDecision._continue(combined)]);
-  }
-  if (Function_dist_effectFunction.pipe(lInterval, ScheduleIntervals_dist_effectScheduleIntervals.lessThan(rInterval))) {
-    return core.flatMap(self.step(ScheduleIntervals_dist_effectScheduleIntervals.end(lInterval), input, lState), ([lState, out, decision]) => {
-      if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
-        return core.succeed([[lState, rState], [out, out2], ScheduleDecision_dist_effectScheduleDecision.done]);
-      }
-      return intersectWithLoop(self, that, input, lState, out, decision.intervals, rState, out2, rInterval, f);
-    });
-  }
-  return core.flatMap(that.step(ScheduleIntervals_dist_effectScheduleIntervals.end(rInterval), input, rState), ([rState, out2, decision]) => {
-    if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
-      return core.succeed([[lState, rState], [out, out2], ScheduleDecision_dist_effectScheduleDecision.done]);
-    }
-    return intersectWithLoop(self, that, input, lState, out, lInterval, rState, out2, decision.intervals, f);
-  });
-};
-
-/** @internal */
-const jittered = self => jitteredWith(self, {
-  min: 0.8,
-  max: 1.2
-});
-
-/** @internal */
-const jitteredWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => {
-  const {
-    max,
-    min
-  } = Object.assign({
-    min: 0.8,
-    max: 1.2
-  }, options);
-  return delayedEffect(self, duration => core.map(Random_dist_effectRandom.next, random => {
-    const d = Duration_dist_effectDuration.toMillis(duration);
-    const jittered = d * min * (1 - random) + d * max * random;
-    return Duration_dist_effectDuration.millis(jittered);
-  }));
-});
-
-/** @internal */
-const linear = baseInput => {
-  const base = Duration_dist_effectDuration.decode(baseInput);
-  return delayedSchedule(map(forever, i => Duration_dist_effectDuration.times(base, i + 1)));
-};
-
-/** @internal */
-const map = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => mapEffect(self, out => core.sync(() => f(out))));
-
-/** @internal */
-const mapEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => core.map(f(out), out2 => [state, out2, decision]))));
-
-/** @internal */
-const minuteOfHour = minute => makeWithState([Number.MIN_SAFE_INTEGER, 0], (now, _, state) => {
-  if (!Number.isInteger(minute) || minute < 0 || 59 < minute) {
-    return core.dieSync(() => core.IllegalArgumentException(`Invalid argument in: minuteOfHour(${minute}). Must be in range 0...59`));
-  }
-  const n = state[1];
-  const initial = n === 0;
-  const minute0 = nextMinute(now, minute, initial);
-  const start = beginningOfMinute(minute0);
-  const end = endOfMinute(minute0);
-  const interval = ScheduleInterval_dist_effectScheduleInterval.make(start, end);
-  return core.succeed([[end, n + 1], n, ScheduleDecision_dist_effectScheduleDecision.continueWith(interval)]);
-});
-
-/** @internal */
-const modifyDelay = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => modifyDelayEffect(self, (out, duration) => core.sync(() => f(out, duration))));
-
-/** @internal */
-const modifyDelayEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => {
-  if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
-    return core.succeed([state, out, decision]);
-  }
-  const intervals = decision.intervals;
-  const delay = ScheduleInterval_dist_effectScheduleInterval.size(ScheduleInterval_dist_effectScheduleInterval.make(now, ScheduleIntervals_dist_effectScheduleIntervals.start(intervals)));
-  return core.map(f(out, delay), durationInput => {
-    const duration = Duration_dist_effectDuration.decode(durationInput);
-    const oldStart = ScheduleIntervals_dist_effectScheduleIntervals.start(intervals);
-    const newStart = now + Duration_dist_effectDuration.toMillis(duration);
-    const delta = newStart - oldStart;
-    const newEnd = Math.min(Math.max(0, ScheduleIntervals_dist_effectScheduleIntervals.end(intervals) + delta), Number.MAX_SAFE_INTEGER);
-    const newInterval = ScheduleInterval_dist_effectScheduleInterval.make(newStart, newEnd);
-    return [state, out, ScheduleDecision_dist_effectScheduleDecision.continueWith(newInterval)];
-  });
-})));
-
-/** @internal */
-const onDecision = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => core.as(f(out, decision), [state, out, decision]))));
-
-/** @internal */
-const passthrough = self => makeWithState(self.initial, (now, input, state) => Function_dist_effectFunction.pipe(self.step(now, input, state), core.map(([state, _, decision]) => [state, input, decision])));
-
-/** @internal */
-const provideContext = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, context) => makeWithState(self.initial, (now, input, state) => core.provideContext(self.step(now, input, state), context)));
-
-/** @internal */
-const provideService = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, service) => makeWithState(self.initial, (now, input, state) => core.contextWithEffect(env => core.provideContext(
-// @ts-expect-error
-self.step(now, input, state), Context_dist_effectContext.add(env, tag, service)))));
-
-/** @internal */
-const recurUntil = f => untilInput(identity(), f);
-
-/** @internal */
-const recurUntilEffect = f => untilInputEffect(identity(), f);
-
-/** @internal */
-const recurUntilOption = pf => untilOutput(map(identity(), pf), Option_dist_effectOption.isSome);
-
-/** @internal */
-const recurUpTo = durationInput => {
-  const duration = Duration_dist_effectDuration.decode(durationInput);
-  return whileOutput(elapsed, elapsed => Duration_dist_effectDuration.lessThan(elapsed, duration));
-};
-
-/** @internal */
-const recurWhile = f => whileInput(identity(), f);
-
-/** @internal */
-const recurWhileEffect = f => whileInputEffect(identity(), f);
-
-/** @internal */
-const recurs = n => whileOutput(forever, out => out < n);
-
-/** @internal */
-const reduce = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, zero, f) => reduceEffect(self, zero, (z, out) => core.sync(() => f(z, out))));
-
-/** @internal */
-const reduceEffect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, zero, f) => makeWithState([self.initial, zero], (now, input, [s, z]) => core.flatMap(self.step(now, input, s), ([s, out, decision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(decision) ? core.succeed([[s, z], z, decision]) : core.map(f(z, out), z2 => [[s, z2], z, decision]))));
-
-/** @internal */
-const repetitions = self => reduce(self, 0, (n, _) => n + 1);
-
-/** @internal */
-const resetAfter = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, durationInput) => {
-  const duration = Duration_dist_effectDuration.decode(durationInput);
-  return Function_dist_effectFunction.pipe(self, intersect(elapsed), resetWhen(([, time]) => Duration_dist_effectDuration.greaterThanOrEqualTo(time, duration)), map(out => out[0]));
-});
-
-/** @internal */
-const resetWhen = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => f(out) ? self.step(now, input, self.initial) : core.succeed([state, out, decision]))));
-
-/** @internal */
-const run = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, now, input) => Function_dist_effectFunction.pipe(runLoop(self, now, Chunk_dist_effectChunk.fromIterable(input), self.initial, Chunk_dist_effectChunk.empty()), core.map(list => Chunk_dist_effectChunk.reverse(list))));
-
-/** @internal */
-const runLoop = (self, now, inputs, state, acc) => {
-  if (!Chunk_dist_effectChunk.isNonEmpty(inputs)) {
-    return core.succeed(acc);
-  }
-  const input = Chunk_dist_effectChunk.headNonEmpty(inputs);
-  const nextInputs = Chunk_dist_effectChunk.tailNonEmpty(inputs);
-  return core.flatMap(self.step(now, input, state), ([state, out, decision]) => {
-    if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
-      return core.sync(() => Function_dist_effectFunction.pipe(acc, Chunk_dist_effectChunk.prepend(out)));
-    }
-    return runLoop(self, ScheduleIntervals_dist_effectScheduleIntervals.start(decision.intervals), nextInputs, state, Chunk_dist_effectChunk.prepend(acc, out));
-  });
-};
-
-/** @internal */
-const secondOfMinute = second => makeWithState([Number.NEGATIVE_INFINITY, 0], (now, _, state) => {
-  if (!Number.isInteger(second) || second < 0 || 59 < second) {
-    return core.dieSync(() => core.IllegalArgumentException(`Invalid argument in: secondOfMinute(${second}). Must be in range 0...59`));
-  }
-  const n = state[1];
-  const initial = n === 0;
-  const second0 = nextSecond(now, second, initial);
-  const start = beginningOfSecond(second0);
-  const end = endOfSecond(second0);
-  const interval = ScheduleInterval_dist_effectScheduleInterval.make(start, end);
-  return core.succeed([[end, n + 1], n, ScheduleDecision_dist_effectScheduleDecision.continueWith(interval)]);
-});
-
-/** @internal */
-const spaced = duration => addDelay(forever, () => duration);
-
-/** @internal */
-const succeed = value => map(forever, () => value);
-
-/** @internal */
-const sync = evaluate => map(forever, evaluate);
-
-/** @internal */
-const tapInput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.zipRight(f(input), self.step(now, input, state))));
-
-/** @internal */
-const tapOutput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.tap(self.step(now, input, state), ([, out]) => f(out))));
-
-/** @internal */
-const unfold = (initial, f) => makeWithState(initial, (now, _, state) => core.sync(() => [f(state), state, ScheduleDecision_dist_effectScheduleDecision.continueWith(ScheduleInterval_dist_effectScheduleInterval.after(now))]));
-
-/** @internal */
-const union = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => unionWith(self, that, ScheduleIntervals_dist_effectScheduleIntervals.union));
-
-/** @internal */
-const unionWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => makeWithState([self.initial, that.initial], (now, input, state) => core.zipWith(self.step(now, input, state[0]), that.step(now, input, state[1]), ([lState, l, lDecision], [rState, r, rDecision]) => {
-  if (ScheduleDecision_dist_effectScheduleDecision.isDone(lDecision) && ScheduleDecision_dist_effectScheduleDecision.isDone(rDecision)) {
-    return [[lState, rState], [l, r], ScheduleDecision_dist_effectScheduleDecision.done];
-  }
-  if (ScheduleDecision_dist_effectScheduleDecision.isDone(lDecision) && ScheduleDecision_dist_effectScheduleDecision.isContinue(rDecision)) {
-    return [[lState, rState], [l, r], ScheduleDecision_dist_effectScheduleDecision._continue(rDecision.intervals)];
-  }
-  if (ScheduleDecision_dist_effectScheduleDecision.isContinue(lDecision) && ScheduleDecision_dist_effectScheduleDecision.isDone(rDecision)) {
-    return [[lState, rState], [l, r], ScheduleDecision_dist_effectScheduleDecision._continue(lDecision.intervals)];
-  }
-  if (ScheduleDecision_dist_effectScheduleDecision.isContinue(lDecision) && ScheduleDecision_dist_effectScheduleDecision.isContinue(rDecision)) {
-    const combined = f(lDecision.intervals, rDecision.intervals);
-    return [[lState, rState], [l, r], ScheduleDecision_dist_effectScheduleDecision._continue(combined)];
-  }
-  throw new Error("BUG: Schedule.unionWith - please report an issue at https://github.com/Effect-TS/io/issues");
-})));
-
-/** @internal */
-const untilInput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => check(self, (input, _) => !f(input)));
-
-/** @internal */
-const untilInputEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => checkEffect(self, (input, _) => coreEffect.negate(f(input))));
-
-/** @internal */
-const untilOutput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => check(self, (_, out) => !f(out)));
-
-/** @internal */
-const untilOutputEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => checkEffect(self, (_, out) => coreEffect.negate(f(out))));
-
-/** @internal */
-const upTo = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, duration) => zipLeft(self, recurUpTo(duration)));
-
-/** @internal */
-const whileInput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => check(self, (input, _) => f(input)));
-
-/** @internal */
-const whileInputEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => checkEffect(self, (input, _) => f(input)));
-
-/** @internal */
-const whileOutput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => check(self, (_, out) => f(out)));
-
-/** @internal */
-const whileOutputEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => checkEffect(self, (_, out) => f(out)));
-
-/** @internal */
-const windowed = intervalInput => {
-  const interval = Duration_dist_effectDuration.decode(intervalInput);
-  const millis = Duration_dist_effectDuration.toMillis(interval);
-  return makeWithState([Option_dist_effectOption.none(), 0], (now, _, [option, n]) => {
-    switch (option._tag) {
-      case "None":
-        {
-          return core.succeed([[Option_dist_effectOption.some(now), n + 1], n, ScheduleDecision_dist_effectScheduleDecision.continueWith(ScheduleInterval_dist_effectScheduleInterval.after(now + millis))]);
-        }
-      case "Some":
-        {
-          return core.succeed([[Option_dist_effectOption.some(option.value), n + 1], n, ScheduleDecision_dist_effectScheduleDecision.continueWith(ScheduleInterval_dist_effectScheduleInterval.after(now + (millis - (now - option.value) % millis)))]);
-        }
-    }
-  });
-};
-
-/** @internal */
-const zipLeft = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => map(intersect(self, that), out => out[0]));
-
-/** @internal */
-const zipRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => map(intersect(self, that), out => out[1]));
-
-/** @internal */
-const zipWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => map(intersect(self, that), ([out, out2]) => f(out, out2)));
-
-// -----------------------------------------------------------------------------
-// Seconds
-// -----------------------------------------------------------------------------
-
-/** @internal */
-const beginningOfSecond = now => {
-  const date = new Date(now);
-  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), 0).getTime();
-};
-
-/** @internal */
-const endOfSecond = now => {
-  const date = new Date(beginningOfSecond(now));
-  return date.setSeconds(date.getSeconds() + 1);
-};
-
-/** @internal */
-const nextSecond = (now, second, initial) => {
-  const date = new Date(now);
-  if (date.getSeconds() === second && initial) {
-    return now;
-  }
-  if (date.getSeconds() < second) {
-    return date.setSeconds(second);
-  }
-  // Set seconds to the provided value and add one minute
-  const newDate = new Date(date.setSeconds(second));
-  return newDate.setTime(newDate.getTime() + 1000 * 60);
-};
-
-// -----------------------------------------------------------------------------
-// Minutes
-// -----------------------------------------------------------------------------
-
-/** @internal */
-const beginningOfMinute = now => {
-  const date = new Date(now);
-  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), 0, 0).getTime();
-};
-
-/** @internal */
-const endOfMinute = now => {
-  const date = new Date(beginningOfMinute(now));
-  return date.setMinutes(date.getMinutes() + 1);
-};
-
-/** @internal */
-const nextMinute = (now, minute, initial) => {
-  const date = new Date(now);
-  if (date.getMinutes() === minute && initial) {
-    return now;
-  }
-  if (date.getMinutes() < minute) {
-    return date.setMinutes(minute);
-  }
-  // Set minutes to the provided value and add one hour
-  const newDate = new Date(date.setMinutes(minute));
-  return newDate.setTime(newDate.getTime() + 1000 * 60 * 60);
-};
-
-// -----------------------------------------------------------------------------
-// Hours
-// -----------------------------------------------------------------------------
-
-/** @internal */
-const beginningOfHour = now => {
-  const date = new Date(now);
-  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), 0, 0, 0).getTime();
-};
-
-/** @internal */
-const endOfHour = now => {
-  const date = new Date(beginningOfHour(now));
-  return date.setHours(date.getHours() + 1);
-};
-
-/** @internal */
-const nextHour = (now, hour, initial) => {
-  const date = new Date(now);
-  if (date.getHours() === hour && initial) {
-    return now;
-  }
-  if (date.getHours() < hour) {
-    return date.setHours(hour);
-  }
-  // Set hours to the provided value and add one day
-  const newDate = new Date(date.setHours(hour));
-  return newDate.setTime(newDate.getTime() + 1000 * 60 * 60 * 24);
-};
-
-// -----------------------------------------------------------------------------
-// Days
-// -----------------------------------------------------------------------------
-
-/** @internal */
-const beginningOfDay = now => {
-  const date = new Date(now);
-  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0).getTime();
-};
-
-/** @internal */
-const endOfDay = now => {
-  const date = new Date(beginningOfDay(now));
-  return date.setDate(date.getDate() + 1);
-};
-
-/** @internal */
-const nextDay = (now, dayOfWeek, initial) => {
-  const date = new Date(now);
-  if (date.getDay() === dayOfWeek && initial) {
-    return now;
-  }
-  const nextDayOfWeek = (7 + dayOfWeek - date.getDay()) % 7;
-  return date.setDate(date.getDate() + (nextDayOfWeek === 0 ? 7 : nextDayOfWeek));
-};
-
-/** @internal */
-const nextDayOfMonth = (now, day, initial) => {
-  const date = new Date(now);
-  if (date.getDate() === day && initial) {
-    return now;
-  }
-  if (date.getDate() < day) {
-    return date.setDate(day);
-  }
-  return findNextMonth(now, day, 1);
-};
-
-/** @internal */
-const findNextMonth = (now, day, months) => {
-  const d = new Date(now);
-  const tmp1 = new Date(d.setDate(day));
-  const tmp2 = new Date(tmp1.setMonth(tmp1.getMonth() + months));
-  if (tmp2.getDate() === day) {
-    const d2 = new Date(now);
-    const tmp3 = new Date(d2.setDate(day));
-    return tmp3.setMonth(tmp3.getMonth() + months);
-  }
-  return findNextMonth(now, day, months + 1);
-};
-
-// circular with Effect
-
-/** @internal */
-const repeat_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => repeatOrElse_Effect(self, schedule, (e, _) => core.fail(e)));
-
-/** @internal */
-const repeatOrElse_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, schedule, orElse) => core.flatMap(driver(schedule), driver => core.matchEffect(self, {
-  onFailure: error => orElse(error, Option_dist_effectOption.none()),
-  onSuccess: value => repeatOrElseEffectLoop(self, driver, orElse, value)
-})));
-
-/** @internal */
-const repeatOrElseEffectLoop = (self, driver, orElse, value) => {
-  return core.matchEffect(driver.next(value), {
-    onFailure: () => core.orDie(driver.last()),
-    onSuccess: b => core.matchEffect(self, {
-      onFailure: error => orElse(error, Option_dist_effectOption.some(b)),
-      onSuccess: value => repeatOrElseEffectLoop(self, driver, orElse, value)
-    })
-  });
-};
-
-/** @internal */
-const repeatUntil_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => repeatUntilEffect_Effect(self, a => core.sync(() => f(a))));
-
-/** @internal */
-const repeatUntilEffect_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.flatMap(self, a => core.flatMap(f(a), result => result ? core.succeed(a) : core.flatMap(core.yieldNow(), () => repeatUntilEffect_Effect(self, f)))));
-
-/** @internal */
-const repeatWhile_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => repeatWhileEffect_Effect(self, a => core.sync(() => f(a))));
-
-/** @internal */
-const repeatWhileEffect_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => repeatUntilEffect_Effect(self, a => coreEffect.negate(f(a))));
-
-/** @internal */
-const retry_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, policy) => retryOrElse_Effect(self, policy, (e, _) => core.fail(e)));
-
-/** @internal */
-const retryN_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => retryN_EffectLoop(self, n));
-
-/** @internal */
-const retryN_EffectLoop = (self, n) => {
-  return core.catchAll(self, e => n < 0 ? core.fail(e) : core.flatMap(core.yieldNow(), () => retryN_EffectLoop(self, n - 1)));
-};
-
-/** @internal */
-const retryOrElse_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, policy, orElse) => core.flatMap(driver(policy), driver => retryOrElse_EffectLoop(self, driver, orElse)));
-
-/** @internal */
-const retryOrElse_EffectLoop = (self, driver, orElse) => {
-  return core.catchAll(self, e => core.matchEffect(driver.next(e), {
-    onFailure: () => Function_dist_effectFunction.pipe(driver.last(), core.orDie, core.flatMap(out => orElse(e, out))),
-    onSuccess: () => retryOrElse_EffectLoop(self, driver, orElse)
-  }));
-};
-
-/** @internal */
-const retryUntil_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => retryUntilEffect_Effect(self, e => core.sync(() => f(e))));
-
-/** @internal */
-const retryUntilEffect_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.catchAll(self, e => core.flatMap(f(e), b => b ? core.fail(e) : core.flatMap(core.yieldNow(), () => retryUntilEffect_Effect(self, f)))));
-
-/** @internal */
-const retryWhile_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => retryWhileEffect_Effect(self, e => core.sync(() => f(e))));
-
-/** @internal */
-const retryWhileEffect_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => retryUntilEffect_Effect(self, e => coreEffect.negate(f(e))));
-
-/** @internal */
-const schedule_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => scheduleFrom_Effect(self, void 0, schedule));
-
-/** @internal */
-const scheduleFrom_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, initial, schedule) => core.flatMap(driver(schedule), driver => scheduleFrom_EffectLoop(self, initial, driver)));
-
-/** @internal */
-const scheduleFrom_EffectLoop = (self, initial, driver) => core.matchEffect(driver.next(initial), {
-  onFailure: () => core.orDie(driver.last()),
-  onSuccess: () => core.flatMap(self, a => scheduleFrom_EffectLoop(self, a, driver))
-});
-
-/** @internal */
-const count = /*#__PURE__*/unfold(0, n => n + 1);
-
-/** @internal */
-const elapsed = /*#__PURE__*/makeWithState( /*#__PURE__*/Option_dist_effectOption.none(), (now, _, state) => {
-  switch (state._tag) {
-    case "None":
-      {
-        return core.succeed([Option_dist_effectOption.some(now), Duration_dist_effectDuration.zero, ScheduleDecision_dist_effectScheduleDecision.continueWith(ScheduleInterval_dist_effectScheduleInterval.after(now))]);
-      }
-    case "Some":
-      {
-        return core.succeed([Option_dist_effectOption.some(state.value), Duration_dist_effectDuration.millis(now - state.value), ScheduleDecision_dist_effectScheduleDecision.continueWith(ScheduleInterval_dist_effectScheduleInterval.after(now))]);
-      }
-  }
-});
-
-/** @internal */
-const forever = /*#__PURE__*/unfold(0, n => n + 1);
-
-/** @internal */
-const once = /*#__PURE__*/asUnit( /*#__PURE__*/recurs(1));
-
-/** @internal */
-const stop = /*#__PURE__*/asUnit( /*#__PURE__*/recurs(0));
-
-exports.ScheduleDriverTypeId = ScheduleDriverTypeId;
-exports.ScheduleTypeId = ScheduleTypeId;
-exports.addDelay = addDelay;
-exports.addDelayEffect = addDelayEffect;
-exports.andThen = andThen;
-exports.andThenEither = andThenEither;
-exports.as = as;
-exports.asUnit = asUnit;
-exports.bothInOut = bothInOut;
-exports.check = check;
-exports.checkEffect = checkEffect;
-exports.collectAllInputs = collectAllInputs;
-exports.collectAllOutputs = collectAllOutputs;
-exports.collectUntil = collectUntil;
-exports.collectUntilEffect = collectUntilEffect;
-exports.collectWhile = collectWhile;
-exports.collectWhileEffect = collectWhileEffect;
-exports.compose = compose;
-exports.count = count;
-exports.dayOfMonth = dayOfMonth;
-exports.dayOfWeek = dayOfWeek;
-exports.delayed = delayed;
-exports.delayedEffect = delayedEffect;
-exports.delayedSchedule = delayedSchedule;
-exports.delays = delays;
-exports.driver = driver;
-exports.duration = duration;
-exports.either = either;
-exports.eitherWith = eitherWith;
-exports.elapsed = elapsed;
-exports.ensuring = ensuring;
-exports.exponential = exponential;
-exports.fibonacci = fibonacci;
-exports.fixed = fixed;
-exports.forever = forever;
-exports.fromDelay = fromDelay;
-exports.fromDelays = fromDelays;
-exports.fromFunction = fromFunction;
-exports.hourOfDay = hourOfDay;
-exports.identity = identity;
-exports.intersect = intersect;
-exports.intersectWith = intersectWith;
-exports.jittered = jittered;
-exports.jitteredWith = jitteredWith;
-exports.linear = linear;
-exports.makeWithState = makeWithState;
-exports.map = map;
-exports.mapBoth = mapBoth;
-exports.mapBothEffect = mapBothEffect;
-exports.mapEffect = mapEffect;
-exports.mapInput = mapInput;
-exports.mapInputContext = mapInputContext;
-exports.mapInputEffect = mapInputEffect;
-exports.minuteOfHour = minuteOfHour;
-exports.modifyDelay = modifyDelay;
-exports.modifyDelayEffect = modifyDelayEffect;
-exports.onDecision = onDecision;
-exports.once = once;
-exports.passthrough = passthrough;
-exports.provideContext = provideContext;
-exports.provideService = provideService;
-exports.recurUntil = recurUntil;
-exports.recurUntilEffect = recurUntilEffect;
-exports.recurUntilOption = recurUntilOption;
-exports.recurUpTo = recurUpTo;
-exports.recurWhile = recurWhile;
-exports.recurWhileEffect = recurWhileEffect;
-exports.recurs = recurs;
-exports.reduce = reduce;
-exports.reduceEffect = reduceEffect;
-exports.repeatOrElse_Effect = repeatOrElse_Effect;
-exports.repeatUntilEffect_Effect = repeatUntilEffect_Effect;
-exports.repeatUntil_Effect = repeatUntil_Effect;
-exports.repeatWhileEffect_Effect = repeatWhileEffect_Effect;
-exports.repeatWhile_Effect = repeatWhile_Effect;
-exports.repeat_Effect = repeat_Effect;
-exports.repetitions = repetitions;
-exports.resetAfter = resetAfter;
-exports.resetWhen = resetWhen;
-exports.retryN_Effect = retryN_Effect;
-exports.retryOrElse_Effect = retryOrElse_Effect;
-exports.retryUntilEffect_Effect = retryUntilEffect_Effect;
-exports.retryUntil_Effect = retryUntil_Effect;
-exports.retryWhileEffect_Effect = retryWhileEffect_Effect;
-exports.retryWhile_Effect = retryWhile_Effect;
-exports.retry_Effect = retry_Effect;
-exports.run = run;
-exports.scheduleFrom_Effect = scheduleFrom_Effect;
-exports.schedule_Effect = schedule_Effect;
-exports.secondOfMinute = secondOfMinute;
-exports.spaced = spaced;
-exports.stop = stop;
-exports.succeed = succeed;
-exports.sync = sync;
-exports.tapInput = tapInput;
-exports.tapOutput = tapOutput;
-exports.unfold = unfold;
-exports.union = union;
-exports.unionWith = unionWith;
-exports.untilInput = untilInput;
-exports.untilInputEffect = untilInputEffect;
-exports.untilOutput = untilOutput;
-exports.untilOutputEffect = untilOutputEffect;
-exports.upTo = upTo;
-exports.whileInput = whileInput;
-exports.whileInputEffect = whileInputEffect;
-exports.whileOutput = whileOutput;
-exports.whileOutputEffect = whileOutputEffect;
-exports.windowed = windowed;
-exports.zipLeft = zipLeft;
-exports.zipRight = zipRight;
-exports.zipWith = zipWith;