effect 2.0.0-next.4 → 2.0.0-next.41

package/dist/schedule-7e30db2d.cjs.prod.js

@@ -0,0 +1,956 @@
+'use strict';
+
+var Chunk_dist_effectChunk = require('./Chunk-6cf5a8e6.cjs.prod.js');
+var Clock_dist_effectClock = require('./Clock-09ecce0a.cjs.prod.js');
+var Context_dist_effectContext = require('./Context-25a49952.cjs.prod.js');
+var Duration_dist_effectDuration = require('./Duration-0bc08d03.cjs.prod.js');
+var Either_dist_effectEither = require('./Either-3fab3796.cjs.prod.js');
+var Equal_dist_effectEqual = require('./Equal-ce9977a8.cjs.prod.js');
+var Function_dist_effectFunction = require('./Function-2e6b0cda.cjs.prod.js');
+var core = require('./core-c2eb171a.cjs.prod.js');
+var Ref_dist_effectRef = require('./Ref-30e5ee58.cjs.prod.js');
+var Option_dist_effectOption = require('./Option-02025c86.cjs.prod.js');
+var Pipeable_dist_effectPipeable = require('./Pipeable-d3ec6711.cjs.prod.js');
+var Random_dist_effectRandom = require('./Random-b4709b6a.cjs.prod.js');
+var ScheduleDecision_dist_effectScheduleDecision = require('./ScheduleDecision-369f2d2b.cjs.prod.js');
+var ScheduleInterval_dist_effectScheduleInterval = require('./ScheduleInterval-78037484.cjs.prod.js');
+var ScheduleIntervals_dist_effectScheduleIntervals = require('./ScheduleIntervals-db13140c.cjs.prod.js');
+var coreEffect = require('./core-effect-bf806dd9.cjs.prod.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;