effect 2.0.0-next.41 → 2.0.0-next.43

package/dist/STM-243df414.cjs.prod.js

@@ -1,1447 +0,0 @@
-'use strict';
-
-var Cause_dist_effectCause = require('./Cause-384e2165.cjs.prod.js');
-var Chunk_dist_effectChunk = require('./Chunk-6cf5a8e6.cjs.prod.js');
-var core = require('./core-bce61cfc.cjs.prod.js');
-var stm = require('./stm-8e837f76.cjs.prod.js');
-
-/**
- * @since 2.0.0
- */
-/**
- * @since 2.0.0
- * @category symbols
- */
-const STMTypeId = core.STMTypeId;
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-
-/**
- * `STM<R, E, A>` represents an effect that can be performed transactionally,
- *  resulting in a failure `E` or a value `A` that may require an environment
- *  `R` to execute.
- *
- * Software Transactional Memory is a technique which allows composition of
- * arbitrary atomic operations.  It is the software analog of transactions in
- * database systems.
- *
- * The API is lifted directly from the Haskell package Control.Concurrent.STM
- * although the implementation does not resemble the Haskell one at all.
- *
- * See http://hackage.haskell.org/package/stm-2.5.0.0/docs/Control-Concurrent-STM.html
- *
- * STM in Haskell was introduced in:
- *
- * Composable memory transactions, by Tim Harris, Simon Marlow, Simon Peyton
- * Jones, and Maurice Herlihy, in ACM Conference on Principles and Practice of
- * Parallel Programming 2005.
- *
- * See https://www.microsoft.com/en-us/research/publication/composable-memory-transactions/
- *
- * See also:
- *  Lock Free Data Structures using STMs in Haskell, by Anthony Discolo, Tim
- *  Harris, Simon Marlow, Simon Peyton Jones, Satnam Singh) FLOPS 2006: Eighth
- *  International Symposium on Functional and Logic Programming, Fuji Susono,
- *  JAPAN, April 2006
- *
- *  https://www.microsoft.com/en-us/research/publication/lock-free-data-structures-using-stms-in-haskell/
- *
- * The implemtation is based on the ZIO STM module, while JS environments have
- * no race conditions from multiple threads STM provides greater benefits for
- * synchronization of Fibers and transactional data-types can be quite useful.
- *
- * @since 2.0.0
- * @category models
- */
-
-/**
- * @since 2.0.0
- * @category models
- */
-
-/**
- * @category models
- * @since 2.0.0
- */
-
-/**
- * @category type lambdas
- * @since 2.0.0
- */
-
-/**
- * @since 2.0.0
- * @category models
- */
-
-/**
- * @since 2.0.0
- * @category models
- */
-
-/**
- * @since 2.0.0
- * @category models
- */
-
-/**
- * @since 2.0.0
- */
-
-/**
- * @category models
- * @since 2.0.0
- */
-
-/**
- * Returns `true` if the provided value is an `STM`, `false` otherwise.
- *
- * @since 2.0.0
- * @category refinements
- */
-const isSTM = core.isSTM;
-
-/**
- * Treats the specified `acquire` transaction as the acquisition of a
- * resource. The `acquire` transaction will be executed interruptibly. If it
- * is a success and is committed the specified `release` workflow will be
- * executed uninterruptibly as soon as the `use` workflow completes execution.
- *
- * @since 2.0.0
- * @category constructors
- */
-const acquireUseRelease = stm.acquireUseRelease;
-
-/**
- * @since 2.0.0
- * @category utils
- */
-
-/**
- * Runs all the provided transactional effects in sequence respecting the
- * structure provided in input.
- *
- * Supports multiple arguments, a single argument tuple / array or record /
- * struct.
- *
- * @since 2.0.0
- * @category constructors
- */
-const all = stm.all;
-
-/**
- * Maps the success value of this effect to the specified constant value.
- *
- * @since 2.0.0
- * @category mapping
- */
-const as = stm.as;
-
-/**
- * Maps the success value of this effect to an optional value.
- *
- * @since 2.0.0
- * @category mapping
- */
-const asSome = stm.asSome;
-
-/**
- * Maps the error value of this effect to an optional value.
- *
- * @since 2.0.0
- * @category mapping
- */
-const asSomeError = stm.asSomeError;
-
-/**
- * This function maps the success value of an `STM` to `void`. If the original
- * `STM` succeeds, the returned `STM` will also succeed. If the original `STM`
- * fails, the returned `STM` will fail with the same error.
- *
- * @since 2.0.0
- * @category mapping
- */
-const asUnit = stm.asUnit;
-
-/**
- * Creates an `STM` value from a partial (but pure) function.
- *
- * @since 2.0.0
- * @category constructors
- */
-const attempt = stm.attempt;
-
-/**
- * Recovers from all errors.
- *
- * @since 2.0.0
- * @category error handling
- */
-const catchAll = core.catchAll;
-
-/**
- * Recovers from some or all of the error cases.
- *
- * @since 2.0.0
- * @category error handling
- */
-const catchSome = stm.catchSome;
-
-/**
- * Recovers from the specified tagged error.
- *
- * @since 2.0.0
- * @category error handling
- */
-const catchTag = stm.catchTag;
-
-/**
- * Recovers from multiple tagged errors.
- *
- * @since 2.0.0
- * @category error handling
- */
-const catchTags = stm.catchTags;
-
-/**
- * Checks the condition, and if it's true, returns unit, otherwise, retries.
- *
- * @since 2.0.0
- * @category constructors
- */
-const check = stm.check;
-
-/**
- * Simultaneously filters and maps the value produced by this effect.
- *
- * @since 2.0.0
- * @category mutations
- */
-const collect = stm.collect;
-
-/**
- * Simultaneously filters and maps the value produced by this effect.
- *
- * @since 2.0.0
- * @category mutations
- */
-const collectSTM = stm.collectSTM;
-
-/**
- * Commits this transaction atomically.
- *
- * @since 2.0.0
- * @category destructors
- */
-const commit = core.commit;
-
-/**
- * Commits this transaction atomically, regardless of whether the transaction
- * is a success or a failure.
- *
- * @since 2.0.0
- * @category destructors
- */
-const commitEither = stm.commitEither;
-
-/**
- * Similar to Either.cond, evaluate the predicate, return the given A as
- * success if predicate returns true, and the given E as error otherwise
- *
- * @since 2.0.0
- * @category constructors
- */
-const cond = stm.cond;
-
-/**
- * Retrieves the environment inside an stm.
- *
- * @since 2.0.0
- * @category constructors
- */
-const context = core.context;
-
-/**
- * Accesses the environment of the transaction to perform a transaction.
- *
- * @since 2.0.0
- * @category constructors
- */
-const contextWith = core.contextWith;
-
-/**
- * Accesses the environment of the transaction to perform a transaction.
- *
- * @since 2.0.0
- * @category constructors
- */
-const contextWithSTM = core.contextWithSTM;
-
-/**
- * Transforms the environment being provided to this effect with the specified
- * function.
- *
- * @since 2.0.0
- * @category context
- */
-const mapInputContext = core.mapInputContext;
-
-/**
- * Fails the transactional effect with the specified defect.
- *
- * @since 2.0.0
- * @category constructors
- */
-const die = core.die;
-
-/**
- * Kills the fiber running the effect with a `Cause.RuntimeException` that
- * contains the specified message.
- *
- * @since 2.0.0
- * @category constructors
- */
-const dieMessage = core.dieMessage;
-
-/**
- * Fails the transactional effect with the specified lazily evaluated defect.
- *
- * @since 2.0.0
- * @category constructors
- */
-const dieSync = core.dieSync;
-
-/**
- * Converts the failure channel into an `Either`.
- *
- * @since 2.0.0
- * @category mutations
- */
-const either = stm.either;
-
-/**
- * Executes the specified finalization transaction whether or not this effect
- * succeeds. Note that as with all STM transactions, if the full transaction
- * fails, everything will be rolled back.
- *
- * @since 2.0.0
- * @category finalization
- */
-const ensuring = core.ensuring;
-
-/**
- * Returns an effect that ignores errors and runs repeatedly until it
- * eventually succeeds.
- *
- * @since 2.0.0
- * @category mutations
- */
-const eventually = stm.eventually;
-
-/**
- * Determines whether all elements of the `Iterable<A>` satisfy the effectual
- * predicate.
- *
- * @since 2.0.0
- * @category constructors
- */
-const every = stm.every;
-
-/**
- * Determines whether any element of the `Iterable[A]` satisfies the effectual
- * predicate `f`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const exists = stm.exists;
-
-/**
- * Fails the transactional effect with the specified error.
- *
- * @since 2.0.0
- * @category constructors
- */
-const fail = core.fail;
-
-/**
- * Fails the transactional effect with the specified lazily evaluated error.
- *
- * @since 2.0.0
- * @category constructors
- */
-const failSync = core.failSync;
-
-/**
- * Returns the fiber id of the fiber committing the transaction.
- *
- * @since 2.0.0
- * @category constructors
- */
-const fiberId = stm.fiberId;
-
-/**
- * Filters the collection using the specified effectual predicate.
- *
- * @since 2.0.0
- * @category constructors
- */
-const filter = stm.filter;
-
-/**
- * Filters the collection using the specified effectual predicate, removing
- * all elements that satisfy the predicate.
- *
- * @since 2.0.0
- * @category constructors
- */
-const filterNot = stm.filterNot;
-
-/**
- * Dies with specified defect if the predicate fails.
- *
- * @since 2.0.0
- * @category filtering
- */
-const filterOrDie = stm.filterOrDie;
-
-/**
- * Dies with a `Cause.RuntimeException` having the specified  message if the
- * predicate fails.
- *
- * @since 2.0.0
- * @category filtering
- */
-const filterOrDieMessage = stm.filterOrDieMessage;
-
-/**
- * Supplies `orElse` if the predicate fails.
- *
- * @since 2.0.0
- * @category filtering
- */
-const filterOrElse = stm.filterOrElse;
-
-/**
- * Fails with the specified error if the predicate fails.
- *
- * @since 2.0.0
- * @category filtering
- */
-const filterOrFail = stm.filterOrFail;
-
-/**
- * Feeds the value produced by this effect to the specified function, and then
- * runs the returned effect as well to produce its results.
- *
- * @since 2.0.0
- * @category sequencing
- */
-const flatMap = core.flatMap;
-
-/**
- * Flattens out a nested `STM` effect.
- *
- * @since 2.0.0
- * @category sequencing
- */
-const flatten = stm.flatten;
-
-/**
- * Flips the success and failure channels of this transactional effect. This
- * allows you to use all methods on the error channel, possibly before
- * flipping back.
- *
- * @since 2.0.0
- * @category mutations
- */
-const flip = stm.flip;
-
-/**
- * Swaps the error/value parameters, applies the function `f` and flips the
- * parameters back
- *
- * @since 2.0.0
- * @category mutations
- */
-const flipWith = stm.flipWith;
-
-/**
- * Folds over the `STM` effect, handling both failure and success, but not
- * retry.
- *
- * @since 2.0.0
- * @category folding
- */
-const match = stm.match;
-
-/**
- * Effectfully folds over the `STM` effect, handling both failure and success.
- *
- * @since 2.0.0
- * @category folding
- */
-const matchSTM = core.matchSTM;
-
-/**
- * Applies the function `f` to each element of the `Iterable<A>` and returns
- * a transactional effect that produces a new `Chunk<A2>`.
- *
- * @since 2.0.0
- * @category traversing
- */
-const forEach = stm.forEach;
-
-/**
- * Lifts an `Either` into a `STM`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const fromEither = stm.fromEither;
-
-/**
- * Lifts an `Option` into a `STM`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const fromOption = stm.fromOption;
-
-/**
- * @since 2.0.0
- * @category models
- */
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-const gen = stm.gen;
-
-/**
- * Returns a successful effect with the head of the list if the list is
- * non-empty or fails with the error `None` if the list is empty.
- *
- * @since 2.0.0
- * @category getters
- */
-const head = stm.head;
-const if_ = stm.if_;
-
-/**
- * Returns a new effect that ignores the success or failure of this effect.
- *
- * @since 2.0.0
- * @category mutations
- */
-const ignore = stm.ignore;
-
-/**
- * Interrupts the fiber running the effect.
- *
- * @since 2.0.0
- * @category constructors
- */
-const interrupt = core.interrupt;
-
-/**
- * Interrupts the fiber running the effect with the specified `FiberId`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const interruptAs = core.interruptAs;
-
-/**
- * Returns whether this transactional effect is a failure.
- *
- * @since 2.0.0
- * @category getters
- */
-const isFailure = stm.isFailure;
-
-/**
- * Returns whether this transactional effect is a success.
- *
- * @since 2.0.0
- * @category getters
- */
-const isSuccess = stm.isSuccess;
-
-/**
- * Iterates with the specified transactional function. The moral equivalent
- * of:
- *
- * ```ts
- * const s = initial
- *
- * while (cont(s)) {
- *   s = body(s)
- * }
- *
- * return s
- * ```
- *
- * @since 2.0.0
- * @category constructors
- */
-const iterate = stm.iterate;
-
-/**
- * Loops with the specified transactional function, collecting the results
- * into a list. The moral equivalent of:
- *
- * ```ts
- * const as = []
- * let s  = initial
- *
- * while (cont(s)) {
- *   as.push(body(s))
- *   s  = inc(s)
- * }
- *
- * return as
- * ```
- *
- * @since 2.0.0
- * @category constructors
- */
-const loop = stm.loop;
-
-/**
- * Maps the value produced by the effect.
- *
- * @since 2.0.0
- * @category mapping
- */
-const map = core.map;
-
-/**
- * Maps the value produced by the effect with the specified function that may
- * throw exceptions but is otherwise pure, translating any thrown exceptions
- * into typed failed effects.
- *
- * @since 2.0.0
- * @category mapping
- */
-const mapAttempt = stm.mapAttempt;
-
-/**
- * Returns an `STM` effect whose failure and success channels have been mapped
- * by the specified pair of functions, `f` and `g`.
- *
- * @since 2.0.0
- * @category mapping
- */
-const mapBoth = stm.mapBoth;
-
-/**
- * Maps from one error type to another.
- *
- * @since 2.0.0
- * @category mapping
- */
-const mapError = stm.mapError;
-
-/**
- * Returns a new effect where the error channel has been merged into the
- * success channel to their common combined type.
- *
- * @since 2.0.0
- * @category mutations
- */
-const merge = stm.merge;
-
-/**
- * Merges an `Iterable<STM>` to a single `STM`, working sequentially.
- *
- * @since 2.0.0
- * @category constructors
- */
-const mergeAll = stm.mergeAll;
-
-/**
- * Returns a new effect where boolean value of this effect is negated.
- *
- * @since 2.0.0
- * @category mutations
- */
-const negate = stm.negate;
-
-/**
- * Requires the option produced by this value to be `None`.
- *
- * @since 2.0.0
- * @category mutations
- */
-const none = stm.none;
-
-/**
- * Converts the failure channel into an `Option`.
- *
- * @since 2.0.0
- * @category mutations
- */
-const option = stm.option;
-
-/**
- * Translates `STM` effect failure into death of the fiber, making all
- * failures unchecked and not a part of the type of the effect.
- *
- * @since 2.0.0
- * @category error handling
- */
-const orDie = stm.orDie;
-
-/**
- * Keeps none of the errors, and terminates the fiber running the `STM` effect
- * with them, using the specified function to convert the `E` into a defect.
- *
- * @since 2.0.0
- * @category error handling
- */
-const orDieWith = stm.orDieWith;
-
-/**
- * Tries this effect first, and if it fails or retries, tries the other
- * effect.
- *
- * @since 2.0.0
- * @category error handling
- */
-const orElse = stm.orElse;
-
-/**
- * Returns a transactional effect that will produce the value of this effect
- * in left side, unless it fails or retries, in which case, it will produce
- * the value of the specified effect in right side.
- *
- * @since 2.0.0
- * @category error handling
- */
-const orElseEither = stm.orElseEither;
-
-/**
- * Tries this effect first, and if it fails or retries, fails with the
- * specified error.
- *
- * @since 2.0.0
- * @category error handling
- */
-const orElseFail = stm.orElseFail;
-
-/**
- * Returns an effect that will produce the value of this effect, unless it
- * fails with the `None` value, in which case it will produce the value of the
- * specified effect.
- *
- * @since 2.0.0
- * @category error handling
- */
-const orElseOptional = stm.orElseOptional;
-
-/**
- * Tries this effect first, and if it fails or retries, succeeds with the
- * specified value.
- *
- * @since 2.0.0
- * @category error handling
- */
-const orElseSucceed = stm.orElseSucceed;
-
-/**
- * Tries this effect first, and if it enters retry, then it tries the other
- * effect. This is an equivalent of Haskell's orElse.
- *
- * @since 2.0.0
- * @category error handling
- */
-const orTry = core.orTry;
-
-/**
- * Feeds elements of type `A` to a function `f` that returns an effect.
- * Collects all successes and failures in a tupled fashion.
- *
- * @since 2.0.0
- * @category traversing
- */
-const partition = stm.partition;
-
-/**
- * Provides the transaction its required environment, which eliminates its
- * dependency on `R`.
- *
- * @since 2.0.0
- * @category context
- */
-const provideContext = stm.provideContext;
-
-/**
- * Splits the context into two parts, providing one part using the
- * specified layer and leaving the remainder `R0`.
- *
- * @since 2.0.0
- * @category context
- */
-const provideSomeContext = stm.provideSomeContext;
-
-/**
- * Provides the effect with the single service it requires. If the transactional
- * effect requires more than one service use `provideEnvironment` instead.
- *
- * @since 2.0.0
- * @category context
- */
-const provideService = stm.provideService;
-
-/**
- * Provides the effect with the single service it requires. If the transactional
- * effect requires more than one service use `provideEnvironment` instead.
- *
- * @since 2.0.0
- * @category context
- */
-const provideServiceSTM = stm.provideServiceSTM;
-
-/**
- * Folds an `Iterable<A>` using an effectual function f, working sequentially
- * from left to right.
- *
- * @since 2.0.0
- * @category constructors
- */
-const reduce = stm.reduce;
-
-/**
- * Reduces an `Iterable<STM>` to a single `STM`, working sequentially.
- *
- * @since 2.0.0
- * @category constructors
- */
-const reduceAll = stm.reduceAll;
-
-/**
- * Folds an `Iterable<A>` using an effectual function f, working sequentially
- * from right to left.
- *
- * @since 2.0.0
- * @category constructors
- */
-const reduceRight = stm.reduceRight;
-
-/**
- * Keeps some of the errors, and terminates the fiber with the rest.
- *
- * @since 2.0.0
- * @category mutations
- */
-const refineOrDie = stm.refineOrDie;
-
-/**
- * Keeps some of the errors, and terminates the fiber with the rest, using the
- * specified function to convert the `E` into a `Throwable`.
- *
- * @since 2.0.0
- * @category mutations
- */
-const refineOrDieWith = stm.refineOrDieWith;
-
-/**
- * Fail with the returned value if the `PartialFunction` matches, otherwise
- * continue with our held value.
- *
- * @since 2.0.0
- * @category mutations
- */
-const reject = stm.reject;
-
-/**
- * Continue with the returned computation if the specified partial function
- * matches, translating the successful match into a failure, otherwise continue
- * with our held value.
- *
- * @since 2.0.0
- * @category mutations
- */
-const rejectSTM = stm.rejectSTM;
-
-/**
- * Repeats this `STM` effect until its result satisfies the specified
- * predicate.
- *
- * **WARNING**: `repeatUntil` uses a busy loop to repeat the effect and will
- * consume a thread until it completes (it cannot yield). This is because STM
- * describes a single atomic transaction which must either complete, retry or
- * fail a transaction before yielding back to the Effect runtime.
- *   - Use `retryUntil` instead if you don't need to maintain transaction
- *     state for repeats.
- *   - Ensure repeating the STM effect will eventually satisfy the predicate.
- *
- * @since 2.0.0
- * @category mutations
- */
-const repeatUntil = stm.repeatUntil;
-
-/**
- * Repeats this `STM` effect while its result satisfies the specified
- * predicate.
- *
- * **WARNING**: `repeatWhile` uses a busy loop to repeat the effect and will
- * consume a thread until it completes (it cannot yield). This is because STM
- * describes a single atomic transaction which must either complete, retry or
- * fail a transaction before yielding back to the Effect runtime.
- *   - Use `retryWhile` instead if you don't need to maintain transaction
- *     state for repeats.
- *   - Ensure repeating the STM effect will eventually not satisfy the
- *     predicate.
- *
- * @since 2.0.0
- * @category mutations
- */
-const repeatWhile = stm.repeatWhile;
-
-/**
- * Replicates the given effect n times. If 0 or negative numbers are given, an
- * empty `Chunk` will be returned.
- *
- * @since 2.0.0
- * @category constructors
- */
-const replicate = stm.replicate;
-
-/**
- * Performs this transaction the specified number of times and collects the
- * results.
- *
- * @since 2.0.0
- * @category constructors
- */
-const replicateSTM = stm.replicateSTM;
-
-/**
- * Performs this transaction the specified number of times, discarding the
- * results.
- *
- * @since 2.0.0
- * @category constructors
- */
-const replicateSTMDiscard = stm.replicateSTMDiscard;
-
-/**
- * Abort and retry the whole transaction when any of the underlying
- * transactional variables have changed.
- *
- * @since 2.0.0
- * @category error handling
- */
-const retry = core.retry;
-
-/**
- * Filters the value produced by this effect, retrying the transaction until
- * the predicate returns `true` for the value.
- *
- * @since 2.0.0
- * @category mutations
- */
-const retryUntil = stm.retryUntil;
-
-/**
- * Filters the value produced by this effect, retrying the transaction while
- * the predicate returns `true` for the value.
- *
- * @since 2.0.0
- * @category mutations
- */
-const retryWhile = stm.retryWhile;
-
-/**
- * Converts an option on values into an option on errors.
- *
- * @since 2.0.0
- * @category getters
- */
-const some = stm.some;
-
-/**
- * Returns an `STM` effect that succeeds with the specified value.
- *
- * @since 2.0.0
- * @category constructors
- */
-const succeed = core.succeed;
-
-/**
- * Returns an effect with the empty value.
- *
- * @since 2.0.0
- * @category constructors
- */
-const succeedNone = stm.succeedNone;
-
-/**
- * Returns an effect with the optional value.
- *
- * @since 2.0.0
- * @category constructors
- */
-const succeedSome = stm.succeedSome;
-
-/**
- * Summarizes a `STM` effect by computing a provided value before and after
- * execution, and then combining the values to produce a summary, together
- * with the result of execution.
- *
- * @since 2.0.0
- * @category mutations
- */
-const summarized = stm.summarized;
-
-/**
- * Suspends creation of the specified transaction lazily.
- *
- * @since 2.0.0
- * @category constructors
- */
-const suspend = stm.suspend;
-
-/**
- * Returns an `STM` effect that succeeds with the specified lazily evaluated
- * value.
- *
- * @since 2.0.0
- * @category constructors
- */
-const sync = core.sync;
-
-/**
- * "Peeks" at the success of transactional effect.
- *
- * @since 2.0.0
- * @category sequencing
- */
-const tap = stm.tap;
-
-/**
- * "Peeks" at both sides of an transactional effect.
- *
- * @since 2.0.0
- * @category sequencing
- */
-const tapBoth = stm.tapBoth;
-
-/**
- * "Peeks" at the error of the transactional effect.
- *
- * @since 2.0.0
- * @category sequencing
- */
-const tapError = stm.tapError;
-const try_ = stm.try_;
-
-/**
- * The moral equivalent of `if (!p) exp`
- *
- * @since 2.0.0
- * @category mutations
- */
-const unless = stm.unless;
-
-/**
- * The moral equivalent of `if (!p) exp` when `p` has side-effects
- *
- * @since 2.0.0
- * @category mutations
- */
-const unlessSTM = stm.unlessSTM;
-
-/**
- * Converts an option on errors into an option on values.
- *
- * @since 2.0.0
- * @category getters
- */
-const unsome = stm.unsome;
-
-/**
- * Returns an `STM` effect that succeeds with `Unit`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const unit = stm.unit;
-
-/**
- * Feeds elements of type `A` to `f` and accumulates all errors in error
- * channel or successes in success channel.
- *
- * This combinator is lossy meaning that if there are errors all successes
- * will be lost. To retain all information please use `STM.partition`.
- *
- * @since 2.0.0
- * @category mutations
- */
-const validateAll = stm.validateAll;
-
-/**
- * Feeds elements of type `A` to `f` until it succeeds. Returns first success
- * or the accumulation of all errors.
- *
- * @since 2.0.0
- * @category mutations
- */
-const validateFirst = stm.validateFirst;
-
-/**
- * The moral equivalent of `if (p) exp`.
- *
- * @since 2.0.0
- * @category mutations
- */
-const when = stm.when;
-
-/**
- * The moral equivalent of `if (p) exp` when `p` has side-effects.
- *
- * @since 2.0.0
- * @category mutations
- */
-const whenSTM = stm.whenSTM;
-
-/**
- * Sequentially zips this value with the specified one.
- *
- * @since 2.0.0
- * @category zipping
- */
-const zip = core.zip;
-
-/**
- * Sequentially zips this value with the specified one, discarding the second
- * element of the tuple.
- *
- * @since 2.0.0
- * @category zipping
- */
-const zipLeft = core.zipLeft;
-
-/**
- * Sequentially zips this value with the specified one, discarding the first
- * element of the tuple.
- *
- * @since 2.0.0
- * @category zipping
- */
-const zipRight = core.zipRight;
-
-/**
- * Sequentially zips this value with the specified one, combining the values
- * using the specified combiner function.
- *
- * @since 2.0.0
- * @category zipping
- */
-const zipWith = core.zipWith;
-
-/**
- * This function takes an iterable of `STM` values and returns a new
- * `STM` value that represents the first `STM` value in the iterable
- * that succeeds. If all of the `Effect` values in the iterable fail, then
- * the resulting `STM` value will fail as well.
- *
- * This function is sequential, meaning that the `STM` values in the
- * iterable will be executed in sequence, and the first one that succeeds
- * will determine the outcome of the resulting `STM` value.
- *
- * @param effects - The iterable of `STM` values to evaluate.
- *
- * @returns A new `STM` value that represents the first successful
- * `STM` value in the iterable, or a failed `STM` value if all of the
- * `STM` values in the iterable fail.
- *
- * @since 2.0.0
- * @category elements
- */
-const firstSuccessOf = effects => suspend(() => {
-  const list = Chunk_dist_effectChunk.fromIterable(effects);
-  if (!Chunk_dist_effectChunk.isNonEmpty(list)) {
-    return dieSync(() => Cause_dist_effectCause.IllegalArgumentException(`Received an empty collection of effects`));
-  }
-  return Chunk_dist_effectChunk.reduce(Chunk_dist_effectChunk.tailNonEmpty(list), Chunk_dist_effectChunk.headNonEmpty(list), (left, right) => orElse(left, () => right));
-});
-
-/**
- * @category do notation
- * @since 2.0.0
- */
-const Do = /*#__PURE__*/succeed({});
-
-/**
- * @category do notation
- * @since 2.0.0
- */
-const bind = stm.bind;
-const let_ = stm.let_;
-
-/**
- * @category do notation
- * @since 2.0.0
- */
-const bindTo = stm.bindTo;
-
-var STM = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  STMTypeId: STMTypeId,
-  isSTM: isSTM,
-  acquireUseRelease: acquireUseRelease,
-  all: all,
-  as: as,
-  asSome: asSome,
-  asSomeError: asSomeError,
-  asUnit: asUnit,
-  attempt: attempt,
-  catchAll: catchAll,
-  catchSome: catchSome,
-  catchTag: catchTag,
-  catchTags: catchTags,
-  check: check,
-  collect: collect,
-  collectSTM: collectSTM,
-  commit: commit,
-  commitEither: commitEither,
-  cond: cond,
-  context: context,
-  contextWith: contextWith,
-  contextWithSTM: contextWithSTM,
-  mapInputContext: mapInputContext,
-  die: die,
-  dieMessage: dieMessage,
-  dieSync: dieSync,
-  either: either,
-  ensuring: ensuring,
-  eventually: eventually,
-  every: every,
-  exists: exists,
-  fail: fail,
-  failSync: failSync,
-  fiberId: fiberId,
-  filter: filter,
-  filterNot: filterNot,
-  filterOrDie: filterOrDie,
-  filterOrDieMessage: filterOrDieMessage,
-  filterOrElse: filterOrElse,
-  filterOrFail: filterOrFail,
-  flatMap: flatMap,
-  flatten: flatten,
-  flip: flip,
-  flipWith: flipWith,
-  match: match,
-  matchSTM: matchSTM,
-  forEach: forEach,
-  fromEither: fromEither,
-  fromOption: fromOption,
-  gen: gen,
-  head: head,
-  'if': if_,
-  ignore: ignore,
-  interrupt: interrupt,
-  interruptAs: interruptAs,
-  isFailure: isFailure,
-  isSuccess: isSuccess,
-  iterate: iterate,
-  loop: loop,
-  map: map,
-  mapAttempt: mapAttempt,
-  mapBoth: mapBoth,
-  mapError: mapError,
-  merge: merge,
-  mergeAll: mergeAll,
-  negate: negate,
-  none: none,
-  option: option,
-  orDie: orDie,
-  orDieWith: orDieWith,
-  orElse: orElse,
-  orElseEither: orElseEither,
-  orElseFail: orElseFail,
-  orElseOptional: orElseOptional,
-  orElseSucceed: orElseSucceed,
-  orTry: orTry,
-  partition: partition,
-  provideContext: provideContext,
-  provideSomeContext: provideSomeContext,
-  provideService: provideService,
-  provideServiceSTM: provideServiceSTM,
-  reduce: reduce,
-  reduceAll: reduceAll,
-  reduceRight: reduceRight,
-  refineOrDie: refineOrDie,
-  refineOrDieWith: refineOrDieWith,
-  reject: reject,
-  rejectSTM: rejectSTM,
-  repeatUntil: repeatUntil,
-  repeatWhile: repeatWhile,
-  replicate: replicate,
-  replicateSTM: replicateSTM,
-  replicateSTMDiscard: replicateSTMDiscard,
-  retry: retry,
-  retryUntil: retryUntil,
-  retryWhile: retryWhile,
-  some: some,
-  succeed: succeed,
-  succeedNone: succeedNone,
-  succeedSome: succeedSome,
-  summarized: summarized,
-  suspend: suspend,
-  sync: sync,
-  tap: tap,
-  tapBoth: tapBoth,
-  tapError: tapError,
-  'try': try_,
-  unless: unless,
-  unlessSTM: unlessSTM,
-  unsome: unsome,
-  unit: unit,
-  validateAll: validateAll,
-  validateFirst: validateFirst,
-  when: when,
-  whenSTM: whenSTM,
-  zip: zip,
-  zipLeft: zipLeft,
-  zipRight: zipRight,
-  zipWith: zipWith,
-  firstSuccessOf: firstSuccessOf,
-  Do: Do,
-  bind: bind,
-  'let': let_,
-  bindTo: bindTo
-});
-
-exports.Do = Do;
-exports.STM = STM;
-exports.STMTypeId = STMTypeId;
-exports.acquireUseRelease = acquireUseRelease;
-exports.all = all;
-exports.as = as;
-exports.asSome = asSome;
-exports.asSomeError = asSomeError;
-exports.asUnit = asUnit;
-exports.attempt = attempt;
-exports.bind = bind;
-exports.bindTo = bindTo;
-exports.catchAll = catchAll;
-exports.catchSome = catchSome;
-exports.catchTag = catchTag;
-exports.catchTags = catchTags;
-exports.check = check;
-exports.collect = collect;
-exports.collectSTM = collectSTM;
-exports.commit = commit;
-exports.commitEither = commitEither;
-exports.cond = cond;
-exports.context = context;
-exports.contextWith = contextWith;
-exports.contextWithSTM = contextWithSTM;
-exports.die = die;
-exports.dieMessage = dieMessage;
-exports.dieSync = dieSync;
-exports.either = either;
-exports.ensuring = ensuring;
-exports.eventually = eventually;
-exports.every = every;
-exports.exists = exists;
-exports.fail = fail;
-exports.failSync = failSync;
-exports.fiberId = fiberId;
-exports.filter = filter;
-exports.filterNot = filterNot;
-exports.filterOrDie = filterOrDie;
-exports.filterOrDieMessage = filterOrDieMessage;
-exports.filterOrElse = filterOrElse;
-exports.filterOrFail = filterOrFail;
-exports.firstSuccessOf = firstSuccessOf;
-exports.flatMap = flatMap;
-exports.flatten = flatten;
-exports.flip = flip;
-exports.flipWith = flipWith;
-exports.forEach = forEach;
-exports.fromEither = fromEither;
-exports.fromOption = fromOption;
-exports.gen = gen;
-exports.head = head;
-exports.if_ = if_;
-exports.ignore = ignore;
-exports.interrupt = interrupt;
-exports.interruptAs = interruptAs;
-exports.isFailure = isFailure;
-exports.isSTM = isSTM;
-exports.isSuccess = isSuccess;
-exports.iterate = iterate;
-exports.let_ = let_;
-exports.loop = loop;
-exports.map = map;
-exports.mapAttempt = mapAttempt;
-exports.mapBoth = mapBoth;
-exports.mapError = mapError;
-exports.mapInputContext = mapInputContext;
-exports.match = match;
-exports.matchSTM = matchSTM;
-exports.merge = merge;
-exports.mergeAll = mergeAll;
-exports.negate = negate;
-exports.none = none;
-exports.option = option;
-exports.orDie = orDie;
-exports.orDieWith = orDieWith;
-exports.orElse = orElse;
-exports.orElseEither = orElseEither;
-exports.orElseFail = orElseFail;
-exports.orElseOptional = orElseOptional;
-exports.orElseSucceed = orElseSucceed;
-exports.orTry = orTry;
-exports.partition = partition;
-exports.provideContext = provideContext;
-exports.provideService = provideService;
-exports.provideServiceSTM = provideServiceSTM;
-exports.provideSomeContext = provideSomeContext;
-exports.reduce = reduce;
-exports.reduceAll = reduceAll;
-exports.reduceRight = reduceRight;
-exports.refineOrDie = refineOrDie;
-exports.refineOrDieWith = refineOrDieWith;
-exports.reject = reject;
-exports.rejectSTM = rejectSTM;
-exports.repeatUntil = repeatUntil;
-exports.repeatWhile = repeatWhile;
-exports.replicate = replicate;
-exports.replicateSTM = replicateSTM;
-exports.replicateSTMDiscard = replicateSTMDiscard;
-exports.retry = retry;
-exports.retryUntil = retryUntil;
-exports.retryWhile = retryWhile;
-exports.some = some;
-exports.succeed = succeed;
-exports.succeedNone = succeedNone;
-exports.succeedSome = succeedSome;
-exports.summarized = summarized;
-exports.suspend = suspend;
-exports.sync = sync;
-exports.tap = tap;
-exports.tapBoth = tapBoth;
-exports.tapError = tapError;
-exports.try_ = try_;
-exports.unit = unit;
-exports.unless = unless;
-exports.unlessSTM = unlessSTM;
-exports.unsome = unsome;
-exports.validateAll = validateAll;
-exports.validateFirst = validateFirst;
-exports.when = when;
-exports.whenSTM = whenSTM;
-exports.zip = zip;
-exports.zipLeft = zipLeft;
-exports.zipRight = zipRight;
-exports.zipWith = zipWith;