effect 2.0.0-next.37 → 2.0.0-next.38

package/dist/Schedule-da001b13.esm.js

@@ -1,1059 +0,0 @@
-import { S as ScheduleTypeId$1, n as ScheduleDriverTypeId$1, o as makeWithState$1, p as addDelay$1, q as addDelayEffect$1, t as andThen$1, u as andThenEither$1, v as as$1, w as asUnit$1, x as bothInOut$1, y as check$1, z as checkEffect$1, A as collectAllInputs$1, B as collectAllOutputs$1, C as collectUntil$1, D as collectUntilEffect$1, E as collectWhile$1, F as collectWhileEffect$1, G as compose$1, H as mapInput$1, I as mapInputContext$1, J as mapInputEffect$1, K as count$1, L as dayOfMonth$1, M as dayOfWeek$1, N as delayed$1, O as delayedEffect$1, P as delayedSchedule$1, Q as delays$1, R as mapBoth$1, T as mapBothEffect$1, U as driver$1, V as duration$1, W as either$1, X as eitherWith$1, Y as elapsed$1, Z as ensuring$1, _ as exponential$1, $ as fibonacci$1, a0 as fixed$1, a1 as forever$1, a2 as fromDelay$1, a3 as fromDelays$1, a4 as fromFunction$1, a5 as hourOfDay$1, a6 as identity$1, a7 as intersect$1, a8 as intersectWith$1, a9 as jittered$1, aa as jitteredWith$1, ab as linear$1, ac as map$1, ad as mapEffect$1, ae as minuteOfHour$1, af as modifyDelay$1, ag as modifyDelayEffect$1, ah as onDecision$1, ai as once$1, aj as passthrough$1, ak as provideContext$1, al as provideService$1, am as recurUntil$1, an as recurUntilEffect$1, ao as recurUntilOption$1, ap as recurUpTo$1, aq as recurWhile$1, ar as recurWhileEffect$1, as as recurs$1, at as reduce$1, au as reduceEffect$1, av as repetitions$1, aw as resetAfter$1, ax as resetWhen$1, ay as run$1, az as secondOfMinute$1, aA as spaced$1, aB as stop$1, aC as succeed$1, aD as sync$1, aE as tapInput$1, aF as tapOutput$1, aG as unfold$1, aH as union$1, aI as unionWith$1, aJ as untilInput$1, aK as untilInputEffect$1, aL as untilOutput$1, aM as untilOutputEffect$1, aN as upTo$1, aO as whileInput$1, aP as whileInputEffect$1, aQ as whileOutput$1, aR as whileOutputEffect$1, aS as windowed$1, aT as zipLeft$1, aU as zipRight$1, aV as zipWith$1 } from './schedule-0d31f4cc.esm.js';
-
-/**
- * @since 1.0.0
- */
-/**
- * @since 1.0.0
- * @category symbols
- */
-const ScheduleTypeId = ScheduleTypeId$1;
-
-/**
- * @since 1.0.0
- * @category symbols
- */
-
-/**
- * @since 1.0.0
- * @category symbols
- */
-const ScheduleDriverTypeId = ScheduleDriverTypeId$1;
-
-/**
- * @since 1.0.0
- * @category symbols
- */
-
-/**
- * A `Schedule<Env, In, Out>` defines a recurring schedule, which consumes
- * values of type `In`, and which returns values of type `Out`.
- *
- * Schedules are defined as a possibly infinite set of intervals spread out over
- * time. Each interval defines a window in which recurrence is possible.
- *
- * When schedules are used to repeat or retry effects, the starting boundary of
- * each interval produced by a schedule is used as the moment when the effect
- * will be executed again.
- *
- * Schedules compose in the following primary ways:
- *
- * - Union: performs the union of the intervals of two schedules
- * - Intersection: performs the intersection of the intervals of two schedules
- * - Sequence: concatenates the intervals of one schedule onto another
- *
- * In addition, schedule inputs and outputs can be transformed, filtered (to
- * terminate a schedule early in response to some input or output), and so
- * forth.
- *
- * A variety of other operators exist for transforming and combining schedules,
- * and the companion object for `Schedule` contains all common types of
- * schedules, both for performing retrying, as well as performing repetition.
- *
- * @category model
- * @since 1.0.0
- */
-
-/**
- * @since 1.0.0
- */
-
-/**
- * @since 1.0.0
- * @category models
- */
-
-/**
- * Constructs a new `Schedule` with the specified `initial` state and the
- * specified `step` function.
- *
- * @since 1.0.0
- * @category constructors
- */
-const makeWithState = makeWithState$1;
-
-/**
- * Returns a new schedule with the given delay added to every interval defined
- * by this schedule.
- *
- * @since 1.0.0
- * @category utils
- */
-const addDelay = addDelay$1;
-
-/**
- * Returns a new schedule with the given effectfully computed delay added to
- * every interval defined by this schedule.
- *
- * @since 1.0.0
- * @category utils
- */
-const addDelayEffect = addDelayEffect$1;
-
-/**
- * The same as `andThenEither`, but merges the output.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const andThen = andThen$1;
-
-/**
- * Returns a new schedule that first executes this schedule to completion, and
- * then executes the specified schedule to completion.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const andThenEither = andThenEither$1;
-
-/**
- * Returns a new schedule that maps this schedule to a constant output.
- *
- * @since 1.0.0
- * @category mapping
- */
-const as = as$1;
-
-/**
- * Returns a new schedule that maps the output of this schedule to unit.
- *
- * @since 1.0.0
- * @category constructors
- */
-const asUnit = asUnit$1;
-
-/**
- * Returns a new schedule that has both the inputs and outputs of this and the
- * specified schedule.
- *
- * @since 1.0.0
- * @category utils
- */
-const bothInOut = bothInOut$1;
-
-/**
- * Returns a new schedule that passes each input and output of this schedule
- * to the specified function, and then determines whether or not to continue
- * based on the return value of the function.
- *
- * @since 1.0.0
- * @category utils
- */
-const check = check$1;
-
-/**
- * Returns a new schedule that passes each input and output of this schedule
- * to the specified function, and then determines whether or not to continue
- * based on the return value of the function.
- *
- * @since 1.0.0
- * @category utils
- */
-const checkEffect = checkEffect$1;
-
-/**
- * A schedule that recurs anywhere, collecting all inputs into a `Chunk`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const collectAllInputs = collectAllInputs$1;
-
-/**
- * Returns a new schedule that collects the outputs of this one into a chunk.
- *
- * @since 1.0.0
- * @category utils
- */
-const collectAllOutputs = collectAllOutputs$1;
-
-/**
- * A schedule that recurs until the condition f fails, collecting all inputs
- * into a list.
- *
- * @since 1.0.0
- * @category utils
- */
-const collectUntil = collectUntil$1;
-
-/**
- * A schedule that recurs until the effectful condition f fails, collecting
- * all inputs into a list.
- *
- * @since 1.0.0
- * @category utils
- */
-const collectUntilEffect = collectUntilEffect$1;
-
-/**
- * A schedule that recurs as long as the condition f holds, collecting all
- * inputs into a list.
- *
- * @since 1.0.0
- * @category utils
- */
-const collectWhile = collectWhile$1;
-
-/**
- * A schedule that recurs as long as the effectful condition holds, collecting
- * all inputs into a list.
- *
- * @category utils
- * @since 1.0.0
- */
-const collectWhileEffect = collectWhileEffect$1;
-
-/**
- * Returns the composition of this schedule and the specified schedule, by
- * piping the output of this one into the input of the other. Effects
- * described by this schedule will always be executed before the effects
- * described by the second schedule.
- *
- * @since 1.0.0
- * @category utils
- */
-const compose = compose$1;
-
-/**
- * Returns a new schedule that deals with a narrower class of inputs than this
- * schedule.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapInput = mapInput$1;
-
-/**
- * Transforms the context being provided to this schedule with the
- * specified function.
- *
- * @since 1.0.0
- * @category context
- */
-const mapInputContext = mapInputContext$1;
-
-/**
- * Returns a new schedule that deals with a narrower class of inputs than this
- * schedule.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapInputEffect = mapInputEffect$1;
-
-/**
- * A schedule that always recurs, which counts the number of recurrences.
- *
- * @since 1.0.0
- * @category constructors
- */
-const count = count$1;
-
-/**
- * Cron-like schedule that recurs every specified `day` of month. Won't recur
- * on months containing less days than specified in `day` param.
- *
- * It triggers at zero hour of the day. Producing a count of repeats: 0, 1, 2.
- *
- * NOTE: `day` parameter is validated lazily. Must be in range 1...31.
- *
- * @since 1.0.0
- * @category constructors
- */
-const dayOfMonth = dayOfMonth$1;
-
-/**
- * Cron-like schedule that recurs every specified `day` of each week. It
- * triggers at zero hour of the week. Producing a count of repeats: 0, 1, 2.
- *
- * NOTE: `day` parameter is validated lazily. Must be in range 1 (Monday)...7
- * (Sunday).
- *
- * @since 1.0.0
- * @category constructors
- */
-const dayOfWeek = dayOfWeek$1;
-
-/**
- * Returns a new schedule with the specified effectfully computed delay added
- * before the start of each interval produced by this schedule.
- *
- * @since 1.0.0
- * @category utils
- */
-const delayed = delayed$1;
-
-/**
- * Returns a new schedule with the specified effectfully computed delay added
- * before the start of each interval produced by this schedule.
- *
- * @since 1.0.0
- * @category constructors
- */
-const delayedEffect = delayedEffect$1;
-
-/**
- * Takes a schedule that produces a delay, and returns a new schedule that
- * uses this delay to further delay intervals in the resulting schedule.
- *
- * @since 1.0.0
- * @category constructors
- */
-const delayedSchedule = delayedSchedule$1;
-
-/**
- * Returns a new schedule that outputs the delay between each occurence.
- *
- * @since 1.0.0
- * @category constructors
- */
-const delays = delays$1;
-
-/**
- * Returns a new schedule that maps both the input and output.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapBoth = mapBoth$1;
-
-/**
- * Returns a new schedule that maps both the input and output.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapBothEffect = mapBothEffect$1;
-
-/**
- * Returns a driver that can be used to step the schedule, appropriately
- * handling sleeping.
- *
- * @since 1.0.0
- * @category getter
- */
-const driver = driver$1;
-
-/**
- * A schedule that can recur one time, the specified amount of time into the
- * future.
- *
- * @since 1.0.0
- * @category constructors
- */
-const duration = duration$1;
-
-/**
- * Returns a new schedule that performs a geometric union on the intervals
- * defined by both schedules.
- *
- * @since 1.0.0
- * @category alternatives
- */
-const either = either$1;
-
-/**
- * The same as `either` followed by `map`.
- *
- * @since 1.0.0
- * @category alternatives
- */
-const eitherWith = eitherWith$1;
-
-/**
- * A schedule that occurs everywhere, which returns the total elapsed duration
- * since the first step.
- *
- * @since 1.0.0
- * @category constructors
- */
-const elapsed = elapsed$1;
-
-/**
- * Returns a new schedule that will run the specified finalizer as soon as the
- * schedule is complete. Note that unlike `Effect.ensuring`, this method does not
- * guarantee the finalizer will be run. The `Schedule` may not initialize or
- * the driver of the schedule may not run to completion. However, if the
- * `Schedule` ever decides not to continue, then the finalizer will be run.
- *
- * @since 1.0.0
- * @category finalization
- */
-const ensuring = ensuring$1;
-
-/**
- * A schedule that always recurs, but will wait a certain amount between
- * repetitions, given by `base * factor.pow(n)`, where `n` is the number of
- * repetitions so far. Returns the current duration between recurrences.
- *
- * @since 1.0.0
- * @category constructors
- */
-const exponential = exponential$1;
-
-/**
- * A schedule that always recurs, increasing delays by summing the preceding
- * two delays (similar to the fibonacci sequence). Returns the current
- * duration between recurrences.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fibonacci = fibonacci$1;
-
-/**
- * A schedule that recurs on a fixed interval. Returns the number of
- * repetitions of the schedule so far.
- *
- * If the action run between updates takes longer than the interval, then the
- * action will be run immediately, but re-runs will not "pile up".
- *
- * ```
- * |-----interval-----|-----interval-----|-----interval-----|
- * |---------action--------||action|-----|action|-----------|
- * ```
- *
- * @since 1.0.0
- * @category constructors
- */
-const fixed = fixed$1;
-
-/**
- * A schedule that always recurs, producing a count of repeats: 0, 1, 2.
- *
- * @since 1.0.0
- * @category constructors
- */
-const forever = forever$1;
-
-/**
- * A schedule that recurs once with the specified delay.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fromDelay = fromDelay$1;
-
-/**
- * A schedule that recurs once for each of the specified durations, delaying
- * each time for the length of the specified duration. Returns the length of
- * the current duration between recurrences.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fromDelays = fromDelays$1;
-
-/**
- * A schedule that always recurs, mapping input values through the specified
- * function.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fromFunction = fromFunction$1;
-
-/**
- * Cron-like schedule that recurs every specified `hour` of each day. It
- * triggers at zero minute of the hour. Producing a count of repeats: 0, 1, 2.
- *
- * NOTE: `hour` parameter is validated lazily. Must be in range 0...23.
- *
- * @since 1.0.0
- * @category constructors
- */
-const hourOfDay = hourOfDay$1;
-
-/**
- * A schedule that always recurs, which returns inputs as outputs.
- *
- * @since 1.0.0
- * @category constructors
- */
-const identity = identity$1;
-
-/**
- * Returns a new schedule that performs a geometric intersection on the
- * intervals defined by both schedules.
- *
- * @since 1.0.0
- * @category utils
- */
-const intersect = intersect$1;
-
-/**
- * Returns a new schedule that combines this schedule with the specified
- * schedule, continuing as long as both schedules want to continue and merging
- * the next intervals according to the specified merge function.
- *
- * @since 1.0.0
- * @category utils
- */
-const intersectWith = intersectWith$1;
-
-/**
- * Returns a new schedule that randomly modifies the size of the intervals of
- * this schedule.
- *
- * Defaults `min` to `0.8` and `max` to `1.2`.
- *
- * The new interval size is between `min * old interval size` and `max * old
- * interval size`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const jittered = jittered$1;
-
-/**
- * Returns a new schedule that randomly modifies the size of the intervals of
- * this schedule.
- *
- * The new interval size is between `min * old interval size` and `max * old
- * interval size`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const jitteredWith = jitteredWith$1;
-
-/**
- * A schedule that always recurs, but will repeat on a linear time interval,
- * given by `base * n` where `n` is the number of repetitions so far. Returns
- * the current duration between recurrences.
- *
- * @since 1.0.0
- * @category constructors
- */
-const linear = linear$1;
-
-/**
- * Returns a new schedule that maps the output of this schedule through the
- * specified function.
- *
- * @since 1.0.0
- * @category mapping
- */
-const map = map$1;
-
-/**
- * Returns a new schedule that maps the output of this schedule through the
- * specified effectful function.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapEffect = mapEffect$1;
-
-/**
- * Cron-like schedule that recurs every specified `minute` of each hour. It
- * triggers at zero second of the minute. Producing a count of repeats: 0, 1,
- * 2.
- *
- * NOTE: `minute` parameter is validated lazily. Must be in range 0...59.
- *
- * @since 1.0.0
- * @category constructors
- */
-const minuteOfHour = minuteOfHour$1;
-
-/**
- * Returns a new schedule that modifies the delay using the specified
- * function.
- *
- * @since 1.0.0
- * @category utils
- */
-const modifyDelay = modifyDelay$1;
-
-/**
- * Returns a new schedule that modifies the delay using the specified
- * effectual function.
- *
- * @since 1.0.0
- * @category utils
- */
-const modifyDelayEffect = modifyDelayEffect$1;
-
-/**
- * Returns a new schedule that applies the current one but runs the specified
- * effect for every decision of this schedule. This can be used to create
- * schedules that log failures, decisions, or computed values.
- *
- * @since 1.0.0
- * @category utils
- */
-const onDecision = onDecision$1;
-
-/**
- * A schedule that recurs one time.
- *
- * @since 1.0.0
- * @category constructors
- */
-const once = once$1;
-
-/**
- * Returns a new schedule that passes through the inputs of this schedule.
- *
- * @since 1.0.0
- * @category utils
- */
-const passthrough = passthrough$1;
-
-/**
- * Returns a new schedule with its context provided to it, so the
- * resulting schedule does not require any context.
- *
- * @since 1.0.0
- * @category context
- */
-const provideContext = provideContext$1;
-
-/**
- * Returns a new schedule with the single service it requires provided to it.
- * If the schedule requires multiple services use `provideContext`
- * instead.
- *
- * @since 1.0.0
- * @category context
- */
-const provideService = provideService$1;
-
-/**
- * A schedule that recurs for until the predicate evaluates to true.
- *
- * @since 1.0.0
- * @category utils
- */
-const recurUntil = recurUntil$1;
-
-/**
- * A schedule that recurs for until the predicate evaluates to true.
- *
- * @since 1.0.0
- * @category utils
- */
-const recurUntilEffect = recurUntilEffect$1;
-
-/**
- * A schedule that recurs for until the input value becomes applicable to
- * partial function and then map that value with given function.
- *
- * @since 1.0.0
- * @category utils
- */
-const recurUntilOption = recurUntilOption$1;
-
-/**
- * A schedule that recurs during the given duration.
- *
- * @since 1.0.0
- * @category utils
- */
-const recurUpTo = recurUpTo$1;
-
-/**
- * A schedule that recurs for as long as the predicate evaluates to true.
- *
- * @since 1.0.0
- * @category utils
- */
-const recurWhile = recurWhile$1;
-
-/**
- * A schedule that recurs for as long as the effectful predicate evaluates to
- * true.
- *
- * @since 1.0.0
- * @category utils
- */
-const recurWhileEffect = recurWhileEffect$1;
-
-/**
- * A schedule spanning all time, which can be stepped only the specified
- * number of times before it terminates.
- *
- * @category constructors
- * @since 1.0.0
- */
-const recurs = recurs$1;
-
-/**
- * Returns a new schedule that folds over the outputs of this one.
- *
- * @since 1.0.0
- * @category folding
- */
-const reduce = reduce$1;
-
-/**
- * Returns a new schedule that effectfully folds over the outputs of this one.
- *
- * @since 1.0.0
- * @category folding
- */
-const reduceEffect = reduceEffect$1;
-
-/**
- * Returns a new schedule that loops this one continuously, resetting the
- * state when this schedule is done.
- *
- * @since 1.0.0
- * @category constructors
- */
-const repeatForever = forever$1;
-
-/**
- * Returns a new schedule that outputs the number of repetitions of this one.
- *
- * @since 1.0.0
- * @category utils
- */
-const repetitions = repetitions$1;
-
-/**
- * Return a new schedule that automatically resets the schedule to its initial
- * state after some time of inactivity defined by `duration`.
- *
- * @since 1.0.0
- * @category utils
- */
-const resetAfter = resetAfter$1;
-
-/**
- * Resets the schedule when the specified predicate on the schedule output
- * evaluates to true.
- *
- * @since 1.0.0
- * @category utils
- */
-const resetWhen = resetWhen$1;
-
-/**
- * Runs a schedule using the provided inputs, and collects all outputs.
- *
- * @since 1.0.0
- * @category destructors
- */
-const run = run$1;
-
-/**
- * Cron-like schedule that recurs every specified `second` of each minute. It
- * triggers at zero nanosecond of the second. Producing a count of repeats: 0,
- * 1, 2.
- *
- * NOTE: `second` parameter is validated lazily. Must be in range 0...59.
- *
- * @since 1.0.0
- * @category constructors
- */
-const secondOfMinute = secondOfMinute$1;
-
-/**
- * Returns a schedule that recurs continuously, each repetition spaced the
- * specified duration from the last run.
- *
- * @since 1.0.0
- * @category constructors
- */
-const spaced = spaced$1;
-
-/**
- * A schedule that does not recur, it just stops.
- *
- * @since 1.0.0
- * @category constructors
- */
-const stop = stop$1;
-
-/**
- * Returns a schedule that repeats one time, producing the specified constant
- * value.
- *
- * @since 1.0.0
- * @category constructors
- */
-const succeed = succeed$1;
-
-/**
- * Returns a schedule that repeats one time, producing the specified constant
- * value.
- *
- * @category constructors
- * @since 1.0.0
- */
-const sync = sync$1;
-
-/**
- * Returns a new schedule that effectfully processes every input to this
- * schedule.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const tapInput = tapInput$1;
-
-/**
- * Returns a new schedule that effectfully processes every output from this
- * schedule.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const tapOutput = tapOutput$1;
-
-/**
- * Unfolds a schedule that repeats one time from the specified state and
- * iterator.
- *
- * @since 1.0.0
- * @category constructors
- */
-const unfold = unfold$1;
-
-/**
- * Returns a new schedule that performs a geometric union on the intervals
- * defined by both schedules.
- *
- * @since 1.0.0
- * @category utils
- */
-const union = union$1;
-
-/**
- * Returns a new schedule that combines this schedule with the specified
- * schedule, continuing as long as either schedule wants to continue and
- * merging the next intervals according to the specified merge function.
- *
- * @since 1.0.0
- * @category utils
- */
-const unionWith = unionWith$1;
-
-/**
- * Returns a new schedule that continues until the specified predicate on the
- * input evaluates to true.
- *
- * @since 1.0.0
- * @category utils
- */
-const untilInput = untilInput$1;
-
-/**
- * Returns a new schedule that continues until the specified effectful
- * predicate on the input evaluates to true.
- *
- * @since 1.0.0
- * @category utils
- */
-const untilInputEffect = untilInputEffect$1;
-
-/**
- * Returns a new schedule that continues until the specified predicate on the
- * output evaluates to true.
- *
- * @since 1.0.0
- * @category utils
- */
-const untilOutput = untilOutput$1;
-
-/**
- * Returns a new schedule that continues until the specified effectful
- * predicate on the output evaluates to true.
- *
- * @since 1.0.0
- * @category utils
- */
-const untilOutputEffect = untilOutputEffect$1;
-
-/**
- * A schedule that recurs during the given duration.
- *
- * @since 1.0.0
- * @category utils
- */
-const upTo = upTo$1;
-
-/**
- * Returns a new schedule that continues for as long the specified predicate
- * on the input evaluates to true.
- *
- * @since 1.0.0
- * @category utils
- */
-const whileInput = whileInput$1;
-
-/**
- * Returns a new schedule that continues for as long the specified effectful
- * predicate on the input evaluates to true.
- *
- * @since 1.0.0
- * @category utils
- */
-const whileInputEffect = whileInputEffect$1;
-
-/**
- * Returns a new schedule that continues for as long the specified predicate
- * on the output evaluates to true.
- *
- * @since 1.0.0
- * @category utils
- */
-const whileOutput = whileOutput$1;
-
-/**
- * Returns a new schedule that continues for as long the specified effectful
- * predicate on the output evaluates to true.
- *
- * @since 1.0.0
- * @category utils
- */
-const whileOutputEffect = whileOutputEffect$1;
-
-/**
- * A schedule that divides the timeline to `interval`-long windows, and sleeps
- * until the nearest window boundary every time it recurs.
- *
- * For example, `windowed(Duration.seconds(10))` would produce a schedule as
- * follows:
- *
- * ```
- *      10s        10s        10s       10s
- * |----------|----------|----------|----------|
- * |action------|sleep---|act|-sleep|action----|
- * ```
- *
- * @since 1.0.0
- * @category constructors
- */
-const windowed = windowed$1;
-
-/**
- * The same as `intersect` but ignores the right output.
- *
- * @since 1.0.0
- * @category zipping
- */
-const zipLeft = zipLeft$1;
-
-/**
- * The same as `intersect` but ignores the left output.
- *
- * @since 1.0.0
- * @category zipping
- */
-const zipRight = zipRight$1;
-
-/**
- * Equivalent to `intersect` followed by `map`.
- *
- * @since 1.0.0
- * @category zipping
- */
-const zipWith = zipWith$1;
-
-var Schedule = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  ScheduleTypeId: ScheduleTypeId,
-  ScheduleDriverTypeId: ScheduleDriverTypeId,
-  makeWithState: makeWithState,
-  addDelay: addDelay,
-  addDelayEffect: addDelayEffect,
-  andThen: andThen,
-  andThenEither: andThenEither,
-  as: as,
-  asUnit: asUnit,
-  bothInOut: bothInOut,
-  check: check,
-  checkEffect: checkEffect,
-  collectAllInputs: collectAllInputs,
-  collectAllOutputs: collectAllOutputs,
-  collectUntil: collectUntil,
-  collectUntilEffect: collectUntilEffect,
-  collectWhile: collectWhile,
-  collectWhileEffect: collectWhileEffect,
-  compose: compose,
-  mapInput: mapInput,
-  mapInputContext: mapInputContext,
-  mapInputEffect: mapInputEffect,
-  count: count,
-  dayOfMonth: dayOfMonth,
-  dayOfWeek: dayOfWeek,
-  delayed: delayed,
-  delayedEffect: delayedEffect,
-  delayedSchedule: delayedSchedule,
-  delays: delays,
-  mapBoth: mapBoth,
-  mapBothEffect: mapBothEffect,
-  driver: driver,
-  duration: duration,
-  either: either,
-  eitherWith: eitherWith,
-  elapsed: elapsed,
-  ensuring: ensuring,
-  exponential: exponential,
-  fibonacci: fibonacci,
-  fixed: fixed,
-  forever: forever,
-  fromDelay: fromDelay,
-  fromDelays: fromDelays,
-  fromFunction: fromFunction,
-  hourOfDay: hourOfDay,
-  identity: identity,
-  intersect: intersect,
-  intersectWith: intersectWith,
-  jittered: jittered,
-  jitteredWith: jitteredWith,
-  linear: linear,
-  map: map,
-  mapEffect: mapEffect,
-  minuteOfHour: minuteOfHour,
-  modifyDelay: modifyDelay,
-  modifyDelayEffect: modifyDelayEffect,
-  onDecision: onDecision,
-  once: once,
-  passthrough: passthrough,
-  provideContext: provideContext,
-  provideService: provideService,
-  recurUntil: recurUntil,
-  recurUntilEffect: recurUntilEffect,
-  recurUntilOption: recurUntilOption,
-  recurUpTo: recurUpTo,
-  recurWhile: recurWhile,
-  recurWhileEffect: recurWhileEffect,
-  recurs: recurs,
-  reduce: reduce,
-  reduceEffect: reduceEffect,
-  repeatForever: repeatForever,
-  repetitions: repetitions,
-  resetAfter: resetAfter,
-  resetWhen: resetWhen,
-  run: run,
-  secondOfMinute: secondOfMinute,
-  spaced: spaced,
-  stop: stop,
-  succeed: succeed,
-  sync: sync,
-  tapInput: tapInput,
-  tapOutput: tapOutput,
-  unfold: unfold,
-  union: union,
-  unionWith: unionWith,
-  untilInput: untilInput,
-  untilInputEffect: untilInputEffect,
-  untilOutput: untilOutput,
-  untilOutputEffect: untilOutputEffect,
-  upTo: upTo,
-  whileInput: whileInput,
-  whileInputEffect: whileInputEffect,
-  whileOutput: whileOutput,
-  whileOutputEffect: whileOutputEffect,
-  windowed: windowed,
-  zipLeft: zipLeft,
-  zipRight: zipRight,
-  zipWith: zipWith
-});
-
-export { map as $, dayOfMonth as A, dayOfWeek as B, delayed as C, delayedEffect as D, delayedSchedule as E, delays as F, mapBoth as G, mapBothEffect as H, duration as I, either as J, eitherWith as K, elapsed as L, ensuring as M, exponential as N, fibonacci as O, fixed as P, fromDelay as Q, fromDelays as R, Schedule as S, fromFunction as T, hourOfDay as U, identity as V, intersect as W, intersectWith as X, jittered as Y, jitteredWith as Z, linear as _, ScheduleTypeId as a, mapEffect as a0, minuteOfHour as a1, modifyDelay as a2, modifyDelayEffect as a3, onDecision as a4, once as a5, passthrough as a6, provideContext as a7, provideService as a8, recurUntil as a9, upTo as aA, whileInput as aB, whileInputEffect as aC, whileOutput as aD, whileOutputEffect as aE, windowed as aF, zipLeft as aG, zipRight as aH, zipWith as aI, recurUntilEffect as aa, recurUntilOption as ab, recurUpTo as ac, recurWhile as ad, recurWhileEffect as ae, recurs as af, reduce as ag, reduceEffect as ah, repeatForever as ai, repetitions as aj, resetAfter as ak, resetWhen as al, run as am, secondOfMinute as an, stop as ao, succeed as ap, sync as aq, tapInput as ar, tapOutput as as, unfold as at, union as au, unionWith as av, untilInput as aw, untilInputEffect as ax, untilOutput as ay, untilOutputEffect as az, ScheduleDriverTypeId as b, addDelay as c, driver as d, addDelayEffect as e, forever as f, andThen as g, andThenEither as h, as as i, asUnit as j, bothInOut as k, check as l, makeWithState as m, checkEffect as n, collectAllInputs as o, collectAllOutputs as p, collectUntil as q, collectUntilEffect as r, spaced as s, collectWhile as t, collectWhileEffect as u, compose as v, mapInput as w, mapInputContext as x, mapInputEffect as y, count as z };