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

package/dist/STM-55e91604.esm.js

@@ -1,1321 +0,0 @@
-import { I as IllegalArgumentException } from './Cause-8be0b9a6.esm.js';
-import { f as fromIterable, h as isNonEmpty, y as reduce$2, t as tailNonEmpty, j as headNonEmpty } from './Chunk-98371336.esm.js';
-import { S as STMTypeId$1, i as isSTM$1, c as catchAll$1, a as commit$1, b as context$1, d as contextWith$1, e as contextWithSTM$1, m as mapInputContext$1, f as die$1, g as dieMessage$1, h as dieSync$1, j as ensuring$1, k as fail$1, l as failSync$1, n as flatMap$1, o as matchSTM$1, p as interrupt$1, q as interruptAs$1, r as map$1, s as orTry$1, t as retry$1, u as succeed$1, v as sync$1, z as zip$1, w as zipLeft$1, x as zipRight$1, y as zipWith$1 } from './core-9276b625.esm.js';
-import { a as acquireUseRelease$1, b as all$1, c as as$1, d as asSome$1, e as asSomeError$1, f as asUnit$1, g as attempt$1, h as catchSome$1, i as catchTag$1, j as catchTags$1, k as check$1, l as collect$1, m as collectSTM$1, n as commitEither$1, o as cond$1, p as either$1, q as eventually$1, r as every$1, s as exists$1, t as fiberId$1, u as filter$1, v as filterNot$1, w as filterOrDie$1, x as filterOrDieMessage$1, y as filterOrElse$1, z as filterOrFail$1, A as flatten$1, B as flip$1, C as flipWith$1, D as match$1, E as forEach$1, F as fromEither$1, G as fromOption$1, H as gen$1, I as head$1, J as if_$1, K as ignore$1, L as isFailure$1, M as isSuccess$1, N as iterate$1, O as loop$1, P as mapAttempt$1, Q as mapBoth$1, R as mapError$1, S as merge$1, T as mergeAll$1, U as negate$1, V as none$1, W as option$1, X as orDie$1, Y as orDieWith$1, Z as orElse$1, _ as orElseEither$1, $ as orElseFail$1, a0 as orElseOptional$1, a1 as orElseSucceed$1, a2 as partition$1, a3 as provideContext$1, a4 as provideSomeContext$1, a5 as provideService$1, a6 as provideServiceSTM$1, a7 as reduce$1, a8 as reduceAll$1, a9 as reduceRight$1, aa as refineOrDie$1, ab as refineOrDieWith$1, ac as reject$1, ad as rejectSTM$1, ae as repeatUntil$1, af as repeatWhile$1, ag as replicate$1, ah as replicateSTM$1, ai as replicateSTMDiscard$1, aj as retryUntil$1, ak as retryWhile$1, al as some$1, am as succeedNone$1, an as succeedSome$1, ao as summarized$1, ap as suspend$1, aq as tap$1, ar as tapBoth$1, as as tapError$1, at as try_$1, au as unless$1, av as unlessSTM$1, aw as unsome$1, ax as unit$1, ay as validateAll$1, az as validateFirst$1, aA as when$1, aB as whenSTM$1, aC as bind$1, aD as let_$1, aE as bindTo$1 } from './stm-d01a804c.esm.js';
-
-/**
- * @since 1.0.0
- */
-/**
- * @since 1.0.0
- * @category symbols
- */
-const STMTypeId = STMTypeId$1;
-
-/**
- * @since 1.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 1.0.0
- * @category models
- */
-
-/**
- * @since 1.0.0
- * @category models
- */
-
-/**
- * @category models
- * @since 1.0.0
- */
-
-/**
- * @category type lambdas
- * @since 1.0.0
- */
-
-/**
- * @since 1.0.0
- * @category models
- */
-
-/**
- * @since 1.0.0
- * @category models
- */
-
-/**
- * @since 1.0.0
- * @category models
- */
-
-/**
- * @since 1.0.0
- */
-
-/**
- * @category models
- * @since 1.0.0
- */
-
-/**
- * Returns `true` if the provided value is an `STM`, `false` otherwise.
- *
- * @since 1.0.0
- * @category refinements
- */
-const isSTM = isSTM$1;
-
-/**
- * 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 1.0.0
- * @category constructors
- */
-const acquireUseRelease = acquireUseRelease$1;
-
-/**
- * @since 1.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 1.0.0
- * @category constructors
- */
-const all = all$1;
-
-/**
- * Maps the success value of this effect to the specified constant value.
- *
- * @since 1.0.0
- * @category mapping
- */
-const as = as$1;
-
-/**
- * Maps the success value of this effect to an optional value.
- *
- * @since 1.0.0
- * @category mapping
- */
-const asSome = asSome$1;
-
-/**
- * Maps the error value of this effect to an optional value.
- *
- * @since 1.0.0
- * @category mapping
- */
-const asSomeError = asSomeError$1;
-
-/**
- * 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 1.0.0
- * @category mapping
- */
-const asUnit = asUnit$1;
-
-/**
- * Creates an `STM` value from a partial (but pure) function.
- *
- * @since 1.0.0
- * @category constructors
- */
-const attempt = attempt$1;
-
-/**
- * Recovers from all errors.
- *
- * @since 1.0.0
- * @category error handling
- */
-const catchAll = catchAll$1;
-
-/**
- * Recovers from some or all of the error cases.
- *
- * @since 1.0.0
- * @category error handling
- */
-const catchSome = catchSome$1;
-
-/**
- * Recovers from the specified tagged error.
- *
- * @since 1.0.0
- * @category error handling
- */
-const catchTag = catchTag$1;
-
-/**
- * Recovers from multiple tagged errors.
- *
- * @since 1.0.0
- * @category error handling
- */
-const catchTags = catchTags$1;
-
-/**
- * Checks the condition, and if it's true, returns unit, otherwise, retries.
- *
- * @since 1.0.0
- * @category constructors
- */
-const check = check$1;
-
-/**
- * Simultaneously filters and maps the value produced by this effect.
- *
- * @since 1.0.0
- * @category mutations
- */
-const collect = collect$1;
-
-/**
- * Simultaneously filters and maps the value produced by this effect.
- *
- * @since 1.0.0
- * @category mutations
- */
-const collectSTM = collectSTM$1;
-
-/**
- * Commits this transaction atomically.
- *
- * @since 1.0.0
- * @category destructors
- */
-const commit = commit$1;
-
-/**
- * Commits this transaction atomically, regardless of whether the transaction
- * is a success or a failure.
- *
- * @since 1.0.0
- * @category destructors
- */
-const commitEither = commitEither$1;
-
-/**
- * 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 1.0.0
- * @category constructors
- */
-const cond = cond$1;
-
-/**
- * Retrieves the environment inside an stm.
- *
- * @since 1.0.0
- * @category constructors
- */
-const context = context$1;
-
-/**
- * Accesses the environment of the transaction to perform a transaction.
- *
- * @since 1.0.0
- * @category constructors
- */
-const contextWith = contextWith$1;
-
-/**
- * Accesses the environment of the transaction to perform a transaction.
- *
- * @since 1.0.0
- * @category constructors
- */
-const contextWithSTM = contextWithSTM$1;
-
-/**
- * Transforms the environment being provided to this effect with the specified
- * function.
- *
- * @since 1.0.0
- * @category context
- */
-const mapInputContext = mapInputContext$1;
-
-/**
- * Fails the transactional effect with the specified defect.
- *
- * @since 1.0.0
- * @category constructors
- */
-const die = die$1;
-
-/**
- * Kills the fiber running the effect with a `Cause.RuntimeException` that
- * contains the specified message.
- *
- * @since 1.0.0
- * @category constructors
- */
-const dieMessage = dieMessage$1;
-
-/**
- * Fails the transactional effect with the specified lazily evaluated defect.
- *
- * @since 1.0.0
- * @category constructors
- */
-const dieSync = dieSync$1;
-
-/**
- * Converts the failure channel into an `Either`.
- *
- * @since 1.0.0
- * @category mutations
- */
-const either = either$1;
-
-/**
- * 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 1.0.0
- * @category finalization
- */
-const ensuring = ensuring$1;
-
-/**
- * Returns an effect that ignores errors and runs repeatedly until it
- * eventually succeeds.
- *
- * @since 1.0.0
- * @category mutations
- */
-const eventually = eventually$1;
-
-/**
- * Determines whether all elements of the `Iterable<A>` satisfy the effectual
- * predicate.
- *
- * @since 1.0.0
- * @category constructors
- */
-const every = every$1;
-
-/**
- * Determines whether any element of the `Iterable[A]` satisfies the effectual
- * predicate `f`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const exists = exists$1;
-
-/**
- * Fails the transactional effect with the specified error.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fail = fail$1;
-
-/**
- * Fails the transactional effect with the specified lazily evaluated error.
- *
- * @since 1.0.0
- * @category constructors
- */
-const failSync = failSync$1;
-
-/**
- * Returns the fiber id of the fiber committing the transaction.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fiberId = fiberId$1;
-
-/**
- * Filters the collection using the specified effectual predicate.
- *
- * @since 1.0.0
- * @category constructors
- */
-const filter = filter$1;
-
-/**
- * Filters the collection using the specified effectual predicate, removing
- * all elements that satisfy the predicate.
- *
- * @since 1.0.0
- * @category constructors
- */
-const filterNot = filterNot$1;
-
-/**
- * Dies with specified defect if the predicate fails.
- *
- * @since 1.0.0
- * @category filtering
- */
-const filterOrDie = filterOrDie$1;
-
-/**
- * Dies with a `Cause.RuntimeException` having the specified  message if the
- * predicate fails.
- *
- * @since 1.0.0
- * @category filtering
- */
-const filterOrDieMessage = filterOrDieMessage$1;
-
-/**
- * Supplies `orElse` if the predicate fails.
- *
- * @since 1.0.0
- * @category filtering
- */
-const filterOrElse = filterOrElse$1;
-
-/**
- * Fails with the specified error if the predicate fails.
- *
- * @since 1.0.0
- * @category filtering
- */
-const filterOrFail = filterOrFail$1;
-
-/**
- * Feeds the value produced by this effect to the specified function, and then
- * runs the returned effect as well to produce its results.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const flatMap = flatMap$1;
-
-/**
- * Flattens out a nested `STM` effect.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const flatten = flatten$1;
-
-/**
- * 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 1.0.0
- * @category mutations
- */
-const flip = flip$1;
-
-/**
- * Swaps the error/value parameters, applies the function `f` and flips the
- * parameters back
- *
- * @since 1.0.0
- * @category mutations
- */
-const flipWith = flipWith$1;
-
-/**
- * Folds over the `STM` effect, handling both failure and success, but not
- * retry.
- *
- * @since 1.0.0
- * @category folding
- */
-const match = match$1;
-
-/**
- * Effectfully folds over the `STM` effect, handling both failure and success.
- *
- * @since 1.0.0
- * @category folding
- */
-const matchSTM = matchSTM$1;
-
-/**
- * Applies the function `f` to each element of the `Iterable<A>` and returns
- * a transactional effect that produces a new `Chunk<A2>`.
- *
- * @since 1.0.0
- * @category traversing
- */
-const forEach = forEach$1;
-
-/**
- * Lifts an `Either` into a `STM`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fromEither = fromEither$1;
-
-/**
- * Lifts an `Option` into a `STM`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fromOption = fromOption$1;
-
-/**
- * @since 1.0.0
- * @category models
- */
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-const gen = gen$1;
-
-/**
- * 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 1.0.0
- * @category getters
- */
-const head = head$1;
-const if_ = if_$1;
-
-/**
- * Returns a new effect that ignores the success or failure of this effect.
- *
- * @since 1.0.0
- * @category mutations
- */
-const ignore = ignore$1;
-
-/**
- * Interrupts the fiber running the effect.
- *
- * @since 1.0.0
- * @category constructors
- */
-const interrupt = interrupt$1;
-
-/**
- * Interrupts the fiber running the effect with the specified `FiberId`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const interruptAs = interruptAs$1;
-
-/**
- * Returns whether this transactional effect is a failure.
- *
- * @since 1.0.0
- * @category getters
- */
-const isFailure = isFailure$1;
-
-/**
- * Returns whether this transactional effect is a success.
- *
- * @since 1.0.0
- * @category getters
- */
-const isSuccess = isSuccess$1;
-
-/**
- * Iterates with the specified transactional function. The moral equivalent
- * of:
- *
- * ```ts
- * const s = initial
- *
- * while (cont(s)) {
- *   s = body(s)
- * }
- *
- * return s
- * ```
- *
- * @since 1.0.0
- * @category constructors
- */
-const iterate = iterate$1;
-
-/**
- * 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 1.0.0
- * @category constructors
- */
-const loop = loop$1;
-
-/**
- * Maps the value produced by the effect.
- *
- * @since 1.0.0
- * @category mapping
- */
-const map = map$1;
-
-/**
- * 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 1.0.0
- * @category mapping
- */
-const mapAttempt = mapAttempt$1;
-
-/**
- * Returns an `STM` effect whose failure and success channels have been mapped
- * by the specified pair of functions, `f` and `g`.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapBoth = mapBoth$1;
-
-/**
- * Maps from one error type to another.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapError = mapError$1;
-
-/**
- * Returns a new effect where the error channel has been merged into the
- * success channel to their common combined type.
- *
- * @since 1.0.0
- * @category mutations
- */
-const merge = merge$1;
-
-/**
- * Merges an `Iterable<STM>` to a single `STM`, working sequentially.
- *
- * @since 1.0.0
- * @category constructors
- */
-const mergeAll = mergeAll$1;
-
-/**
- * Returns a new effect where boolean value of this effect is negated.
- *
- * @since 1.0.0
- * @category mutations
- */
-const negate = negate$1;
-
-/**
- * Requires the option produced by this value to be `None`.
- *
- * @since 1.0.0
- * @category mutations
- */
-const none = none$1;
-
-/**
- * Converts the failure channel into an `Option`.
- *
- * @since 1.0.0
- * @category mutations
- */
-const option = option$1;
-
-/**
- * Translates `STM` effect failure into death of the fiber, making all
- * failures unchecked and not a part of the type of the effect.
- *
- * @since 1.0.0
- * @category error handling
- */
-const orDie = orDie$1;
-
-/**
- * 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 1.0.0
- * @category error handling
- */
-const orDieWith = orDieWith$1;
-
-/**
- * Tries this effect first, and if it fails or retries, tries the other
- * effect.
- *
- * @since 1.0.0
- * @category error handling
- */
-const orElse = orElse$1;
-
-/**
- * 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 1.0.0
- * @category error handling
- */
-const orElseEither = orElseEither$1;
-
-/**
- * Tries this effect first, and if it fails or retries, fails with the
- * specified error.
- *
- * @since 1.0.0
- * @category error handling
- */
-const orElseFail = orElseFail$1;
-
-/**
- * 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 1.0.0
- * @category error handling
- */
-const orElseOptional = orElseOptional$1;
-
-/**
- * Tries this effect first, and if it fails or retries, succeeds with the
- * specified value.
- *
- * @since 1.0.0
- * @category error handling
- */
-const orElseSucceed = orElseSucceed$1;
-
-/**
- * Tries this effect first, and if it enters retry, then it tries the other
- * effect. This is an equivalent of Haskell's orElse.
- *
- * @since 1.0.0
- * @category error handling
- */
-const orTry = orTry$1;
-
-/**
- * Feeds elements of type `A` to a function `f` that returns an effect.
- * Collects all successes and failures in a tupled fashion.
- *
- * @since 1.0.0
- * @category traversing
- */
-const partition = partition$1;
-
-/**
- * Provides the transaction its required environment, which eliminates its
- * dependency on `R`.
- *
- * @since 1.0.0
- * @category context
- */
-const provideContext = provideContext$1;
-
-/**
- * Splits the context into two parts, providing one part using the
- * specified layer and leaving the remainder `R0`.
- *
- * @since 1.0.0
- * @category context
- */
-const provideSomeContext = provideSomeContext$1;
-
-/**
- * Provides the effect with the single service it requires. If the transactional
- * effect requires more than one service use `provideEnvironment` instead.
- *
- * @since 1.0.0
- * @category context
- */
-const provideService = provideService$1;
-
-/**
- * Provides the effect with the single service it requires. If the transactional
- * effect requires more than one service use `provideEnvironment` instead.
- *
- * @since 1.0.0
- * @category context
- */
-const provideServiceSTM = provideServiceSTM$1;
-
-/**
- * Folds an `Iterable<A>` using an effectual function f, working sequentially
- * from left to right.
- *
- * @since 1.0.0
- * @category constructors
- */
-const reduce = reduce$1;
-
-/**
- * Reduces an `Iterable<STM>` to a single `STM`, working sequentially.
- *
- * @since 1.0.0
- * @category constructors
- */
-const reduceAll = reduceAll$1;
-
-/**
- * Folds an `Iterable<A>` using an effectual function f, working sequentially
- * from right to left.
- *
- * @since 1.0.0
- * @category constructors
- */
-const reduceRight = reduceRight$1;
-
-/**
- * Keeps some of the errors, and terminates the fiber with the rest.
- *
- * @since 1.0.0
- * @category mutations
- */
-const refineOrDie = refineOrDie$1;
-
-/**
- * Keeps some of the errors, and terminates the fiber with the rest, using the
- * specified function to convert the `E` into a `Throwable`.
- *
- * @since 1.0.0
- * @category mutations
- */
-const refineOrDieWith = refineOrDieWith$1;
-
-/**
- * Fail with the returned value if the `PartialFunction` matches, otherwise
- * continue with our held value.
- *
- * @since 1.0.0
- * @category mutations
- */
-const reject = reject$1;
-
-/**
- * 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 1.0.0
- * @category mutations
- */
-const rejectSTM = rejectSTM$1;
-
-/**
- * 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 1.0.0
- * @category mutations
- */
-const repeatUntil = repeatUntil$1;
-
-/**
- * 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 1.0.0
- * @category mutations
- */
-const repeatWhile = repeatWhile$1;
-
-/**
- * Replicates the given effect n times. If 0 or negative numbers are given, an
- * empty `Chunk` will be returned.
- *
- * @since 1.0.0
- * @category constructors
- */
-const replicate = replicate$1;
-
-/**
- * Performs this transaction the specified number of times and collects the
- * results.
- *
- * @since 1.0.0
- * @category constructors
- */
-const replicateSTM = replicateSTM$1;
-
-/**
- * Performs this transaction the specified number of times, discarding the
- * results.
- *
- * @since 1.0.0
- * @category constructors
- */
-const replicateSTMDiscard = replicateSTMDiscard$1;
-
-/**
- * Abort and retry the whole transaction when any of the underlying
- * transactional variables have changed.
- *
- * @since 1.0.0
- * @category error handling
- */
-const retry = retry$1;
-
-/**
- * Filters the value produced by this effect, retrying the transaction until
- * the predicate returns `true` for the value.
- *
- * @since 1.0.0
- * @category mutations
- */
-const retryUntil = retryUntil$1;
-
-/**
- * Filters the value produced by this effect, retrying the transaction while
- * the predicate returns `true` for the value.
- *
- * @since 1.0.0
- * @category mutations
- */
-const retryWhile = retryWhile$1;
-
-/**
- * Converts an option on values into an option on errors.
- *
- * @since 1.0.0
- * @category getters
- */
-const some = some$1;
-
-/**
- * Returns an `STM` effect that succeeds with the specified value.
- *
- * @since 1.0.0
- * @category constructors
- */
-const succeed = succeed$1;
-
-/**
- * Returns an effect with the empty value.
- *
- * @since 1.0.0
- * @category constructors
- */
-const succeedNone = succeedNone$1;
-
-/**
- * Returns an effect with the optional value.
- *
- * @since 1.0.0
- * @category constructors
- */
-const succeedSome = succeedSome$1;
-
-/**
- * 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 1.0.0
- * @category mutations
- */
-const summarized = summarized$1;
-
-/**
- * Suspends creation of the specified transaction lazily.
- *
- * @since 1.0.0
- * @category constructors
- */
-const suspend = suspend$1;
-
-/**
- * Returns an `STM` effect that succeeds with the specified lazily evaluated
- * value.
- *
- * @since 1.0.0
- * @category constructors
- */
-const sync = sync$1;
-
-/**
- * "Peeks" at the success of transactional effect.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const tap = tap$1;
-
-/**
- * "Peeks" at both sides of an transactional effect.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const tapBoth = tapBoth$1;
-
-/**
- * "Peeks" at the error of the transactional effect.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const tapError = tapError$1;
-const try_ = try_$1;
-
-/**
- * The moral equivalent of `if (!p) exp`
- *
- * @since 1.0.0
- * @category mutations
- */
-const unless = unless$1;
-
-/**
- * The moral equivalent of `if (!p) exp` when `p` has side-effects
- *
- * @since 1.0.0
- * @category mutations
- */
-const unlessSTM = unlessSTM$1;
-
-/**
- * Converts an option on errors into an option on values.
- *
- * @since 1.0.0
- * @category getters
- */
-const unsome = unsome$1;
-
-/**
- * Returns an `STM` effect that succeeds with `Unit`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const unit = unit$1;
-
-/**
- * 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 1.0.0
- * @category mutations
- */
-const validateAll = validateAll$1;
-
-/**
- * Feeds elements of type `A` to `f` until it succeeds. Returns first success
- * or the accumulation of all errors.
- *
- * @since 1.0.0
- * @category mutations
- */
-const validateFirst = validateFirst$1;
-
-/**
- * The moral equivalent of `if (p) exp`.
- *
- * @since 1.0.0
- * @category mutations
- */
-const when = when$1;
-
-/**
- * The moral equivalent of `if (p) exp` when `p` has side-effects.
- *
- * @since 1.0.0
- * @category mutations
- */
-const whenSTM = whenSTM$1;
-
-/**
- * Sequentially zips this value with the specified one.
- *
- * @since 1.0.0
- * @category zipping
- */
-const zip = zip$1;
-
-/**
- * Sequentially zips this value with the specified one, discarding the second
- * element of the tuple.
- *
- * @since 1.0.0
- * @category zipping
- */
-const zipLeft = zipLeft$1;
-
-/**
- * Sequentially zips this value with the specified one, discarding the first
- * element of the tuple.
- *
- * @since 1.0.0
- * @category zipping
- */
-const zipRight = zipRight$1;
-
-/**
- * Sequentially zips this value with the specified one, combining the values
- * using the specified combiner function.
- *
- * @since 1.0.0
- * @category zipping
- */
-const zipWith = zipWith$1;
-
-/**
- * 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 1.0.0
- * @category elements
- */
-const firstSuccessOf = effects => suspend(() => {
-  const list = fromIterable(effects);
-  if (!isNonEmpty(list)) {
-    return dieSync(() => IllegalArgumentException(`Received an empty collection of effects`));
-  }
-  return reduce$2(tailNonEmpty(list), headNonEmpty(list), (left, right) => orElse(left, () => right));
-});
-
-/**
- * @category do notation
- * @since 1.0.0
- */
-const Do = /*#__PURE__*/succeed({});
-
-/**
- * @category do notation
- * @since 1.0.0
- */
-const bind = bind$1;
-const let_ = let_$1;
-
-/**
- * @category do notation
- * @since 1.0.0
- */
-const bindTo = bindTo$1;
-
-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
-});
-
-export { fromOption as $, mapInputContext as A, die as B, dieMessage as C, dieSync as D, either as E, ensuring as F, eventually as G, every as H, exists as I, fail as J, failSync as K, fiberId as L, filter as M, filterNot as N, filterOrDie as O, filterOrDieMessage as P, filterOrElse as Q, filterOrFail as R, STM as S, flatMap as T, flatten as U, flip as V, flipWith as W, match as X, matchSTM as Y, forEach as Z, fromEither as _, STMTypeId as a, zipLeft as a$, gen as a0, head as a1, if_ as a2, ignore as a3, interrupt as a4, isFailure as a5, isSuccess as a6, iterate as a7, loop as a8, mapAttempt as a9, rejectSTM as aA, repeatUntil as aB, repeatWhile as aC, replicate as aD, replicateSTM as aE, replicateSTMDiscard as aF, retryUntil as aG, retryWhile as aH, some as aI, succeedNone as aJ, succeedSome as aK, summarized as aL, suspend as aM, sync as aN, tap as aO, tapBoth as aP, tapError as aQ, try_ as aR, unless as aS, unlessSTM as aT, unsome as aU, unit as aV, validateAll as aW, validateFirst as aX, when as aY, whenSTM as aZ, zip as a_, mapBoth as aa, mapError as ab, merge as ac, mergeAll as ad, negate as ae, none as af, option as ag, orDie as ah, orDieWith as ai, orElse as aj, orElseEither as ak, orElseFail as al, orElseOptional as am, orElseSucceed as an, orTry as ao, partition as ap, provideContext as aq, provideSomeContext as ar, provideService as as, provideServiceSTM as at, reduce as au, reduceAll as av, reduceRight as aw, refineOrDie as ax, refineOrDieWith as ay, reject as az, isSTM as b, zipRight as b0, zipWith as b1, firstSuccessOf as b2, Do as b3, bind as b4, let_ as b5, bindTo as b6, acquireUseRelease as c, all as d, as as e, asSome as f, asSomeError as g, asUnit as h, interruptAs as i, attempt as j, catchAll as k, catchSome as l, map as m, catchTag as n, catchTags as o, check as p, collect as q, retry as r, succeed as s, collectSTM as t, commit as u, commitEither as v, cond as w, context as x, contextWith as y, contextWithSTM as z };