effect 2.0.0-next.35 → 2.0.0-next.37

package/dist/core-9276b625.esm.js

@@ -0,0 +1,1032 @@
+import { i as interrupt$3, d as die$3, f as fail$3, N as NoSuchElementException, R as RuntimeException } from './Cause-8be0b9a6.esm.js';
+import { u as unsafeGet$1 } from './Context-48179faa.esm.js';
+import { E as EffectTypeId, a as async, u as uninterruptibleMask, c as catchAllCause, f as failCause } from './Effect-d5910dae.esm.js';
+import { l as left, r as right } from './Either-09270bbc.esm.js';
+import { s as symbol$1, e as equals } from './Equal-7d4ae7e7.esm.js';
+import { s as succeed$2, i as interrupt$2, d as die$2, f as fail$2, a as failCause$1 } from './Exit-e31718e3.esm.js';
+import { c as currentContext, a as currentScheduler, b as currentSchedulingPriority } from './FiberRef-b81d5a7e.esm.js';
+import { p as pipe, d as dual, b as constVoid } from './Function-52fb7d21.esm.js';
+import { s as symbol, c as combine, h as hash, r as random } from './Hash-039222d1.esm.js';
+import { w as withFiberRuntime } from './core-9f5f0dc2.esm.js';
+import { m as OP_COMMIT } from './Effectable-a76b6aa1.esm.js';
+import { p as pipeArguments } from './Pipeable-fe51dc02.esm.js';
+import { S as StreamTypeId } from './Stream-1d51d0be.esm.js';
+import { S as SinkTypeId, C as ChannelTypeId } from './sink-3f26fc31.esm.js';
+
+/** @internal */
+const OP_WITH_STM_RUNTIME = "WithSTMRuntime";
+
+/** @internal */
+
+/** @internal */
+const OP_ON_FAILURE = "OnFailure";
+
+/** @internal */
+
+/** @internal */
+const OP_ON_RETRY = "OnRetry";
+
+/** @internal */
+
+/** @internal */
+const OP_ON_SUCCESS = "OnSuccess";
+
+/** @internal */
+
+/** @internal */
+const OP_PROVIDE = "Provide";
+
+/** @internal */
+
+/** @internal */
+const OP_SYNC = "Sync";
+
+/** @internal */
+
+/** @internal */
+const OP_SUCCEED$1 = "Succeed";
+
+/** @internal */
+
+/** @internal */
+const OP_RETRY$1 = "Retry";
+
+/** @internal */
+
+/** @internal */
+const OP_FAIL$1 = "Fail";
+
+/** @internal */
+
+/** @internal */
+const OP_DIE$1 = "Die";
+
+/** @internal */
+
+/** @internal */
+const OP_INTERRUPT$1 = "Interrupt";
+
+/** @internal */
+
+/** @internal */
+const OP_FAIL = "Fail";
+
+/** @internal */
+
+/** @internal */
+const OP_DIE = "Die";
+
+/** @internal */
+
+/** @internal */
+const OP_INTERRUPT = "Interrupt";
+
+/** @internal */
+
+/** @internal */
+const OP_SUCCEED = "Succeed";
+
+/** @internal */
+
+/** @internal */
+const OP_RETRY = "Retry";
+
+/** @internal */
+
+/** @internal */
+const OP_DONE$1 = "Done";
+
+/** @internal */
+
+/** @internal */
+const OP_SUSPEND = "Suspend";
+
+/** @internal */
+
+/** @internal */
+class Versioned {
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+/** @internal */
+
+/** @internal */
+const make$1 = (ref, isNew) => ({
+  ref,
+  isNew,
+  isChanged: false,
+  expected: ref.versioned,
+  newValue: ref.versioned.value
+});
+const unsafeGet = self => {
+  return self.newValue;
+};
+
+/** @internal */
+const unsafeSet = (self, value) => {
+  self.isChanged = true;
+  self.newValue = value;
+};
+
+/** @internal */
+const commit$1 = self => {
+  self.ref.versioned = new Versioned(self.newValue);
+};
+
+/** @internal */
+const copy = self => ({
+  ref: self.ref,
+  isNew: self.isNew,
+  isChanged: self.isChanged,
+  expected: self.expected,
+  newValue: self.newValue
+});
+
+/** @internal */
+const isInvalid = self => {
+  return self.ref.versioned !== self.expected;
+};
+
+/** @internal */
+const isChanged = self => {
+  return self.isChanged;
+};
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const JournalAnalysisInvalid = "Invalid";
+
+/** @internal */
+
+/** @internal */
+const JournalAnalysisReadWrite = "ReadWrite";
+
+/** @internal */
+
+/** @internal */
+const JournalAnalysisReadOnly = "ReadOnly";
+
+/** @internal */
+
+/** @internal */
+const commitJournal = journal => {
+  for (const entry of journal) {
+    commit$1(entry[1]);
+  }
+};
+
+/**
+ * Analyzes the journal, determining whether it is valid and whether it is
+ * read only in a single pass. Note that information on whether the
+ * journal is read only will only be accurate if the journal is valid, due
+ * to short-circuiting that occurs on an invalid journal.
+ *
+ * @internal
+ */
+const analyzeJournal = journal => {
+  let val = JournalAnalysisReadOnly;
+  for (const [, entry] of journal) {
+    val = isInvalid(entry) ? JournalAnalysisInvalid : isChanged(entry) ? JournalAnalysisReadWrite : val;
+    if (val === JournalAnalysisInvalid) {
+      return val;
+    }
+  }
+  return val;
+};
+
+/** @internal */
+const prepareResetJournal = journal => {
+  const saved = new Map();
+  for (const entry of journal) {
+    saved.set(entry[0], copy(entry[1]));
+  }
+  return () => {
+    journal.clear();
+    for (const entry of saved) {
+      journal.set(entry[0], entry[1]);
+    }
+  };
+};
+
+/** @internal */
+const collectTodos = journal => {
+  const allTodos = new Map();
+  for (const [, entry] of journal) {
+    for (const todo of entry.ref.todos) {
+      allTodos.set(todo[0], todo[1]);
+    }
+    entry.ref.todos = new Map();
+  }
+  return allTodos;
+};
+
+/** @internal */
+const execTodos = todos => {
+  const todosSorted = Array.from(todos.entries()).sort((x, y) => x[0] - y[0]);
+  for (const [_, todo] of todosSorted) {
+    todo();
+  }
+};
+
+/** @internal */
+const addTodo = (txnId, journal, todoEffect) => {
+  let added = false;
+  for (const [, entry] of journal) {
+    if (!entry.ref.todos.has(txnId)) {
+      entry.ref.todos.set(txnId, todoEffect);
+      added = true;
+    }
+  }
+  return added;
+};
+
+/** @internal */
+const OP_DONE = "Done";
+
+/** @internal */
+
+/** @internal */
+const OP_INTERRUPTED = "Interrupted";
+
+/** @internal */
+
+/** @internal */
+const OP_RUNNING = "Running";
+
+/** @internal */
+
+/** @internal */
+const STMStateSymbolKey = "effect/STM/State";
+
+/** @internal */
+const STMStateTypeId = /*#__PURE__*/Symbol.for(STMStateSymbolKey);
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const isSTMState = u => {
+  return typeof u === "object" && u != null && STMStateTypeId in u;
+};
+
+/** @internal */
+const isRunning = self => {
+  return self._tag === OP_RUNNING;
+};
+
+/** @internal */
+const isDone = self => {
+  return self._tag === OP_DONE;
+};
+
+/** @internal */
+const done$1 = exit => {
+  return {
+    [STMStateTypeId]: STMStateTypeId,
+    _tag: OP_DONE,
+    exit,
+    [symbol]() {
+      return pipe(hash(STMStateSymbolKey), combine(hash(OP_DONE)), combine(hash(exit)));
+    },
+    [symbol$1](that) {
+      return isSTMState(that) && that._tag === OP_DONE && equals(exit, that.exit);
+    }
+  };
+};
+
+/** @internal */
+const interrupted = {
+  [STMStateTypeId]: STMStateTypeId,
+  _tag: OP_INTERRUPTED,
+  [symbol]() {
+    return pipe(hash(STMStateSymbolKey), combine(hash(OP_INTERRUPTED)), combine(hash("interrupted")));
+  },
+  [symbol$1](that) {
+    return isSTMState(that) && that._tag === OP_INTERRUPTED;
+  }
+};
+
+/** @internal */
+const running = {
+  [STMStateTypeId]: STMStateTypeId,
+  _tag: OP_RUNNING,
+  [symbol]() {
+    return pipe(hash(STMStateSymbolKey), combine(hash(OP_RUNNING)), combine(hash("running")));
+  },
+  [symbol$1](that) {
+    return isSTMState(that) && that._tag === OP_RUNNING;
+  }
+};
+
+/** @internal */
+const fromTExit = tExit => {
+  switch (tExit._tag) {
+    case OP_FAIL:
+      {
+        return done$1(fail$2(tExit.error));
+      }
+    case OP_DIE:
+      {
+        return done$1(die$2(tExit.defect));
+      }
+    case OP_INTERRUPT:
+      {
+        return done$1(interrupt$2(tExit.fiberId));
+      }
+    case OP_SUCCEED:
+      {
+        return done$1(succeed$2(tExit.value));
+      }
+    case OP_RETRY:
+      {
+        throw new Error("BUG: STM.STMState.fromTExit - please report an issue at https://github.com/Effect-TS/io/issues");
+      }
+  }
+};
+
+/** @internal */
+const TExitSymbolKey = "effect/TExit";
+
+/** @internal */
+const TExitTypeId = /*#__PURE__*/Symbol.for(TExitSymbolKey);
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const variance = {
+  _E: _ => _,
+  _A: _ => _
+};
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const isExit = u => {
+  return typeof u === "object" && u != null && TExitTypeId in u;
+};
+
+/** @internal */
+const isSuccess = self => {
+  return self._tag === OP_SUCCEED;
+};
+
+/** @internal */
+const isRetry = self => {
+  return self._tag === OP_RETRY;
+};
+
+/** @internal */
+const fail$1 = error => ({
+  [TExitTypeId]: variance,
+  _tag: OP_FAIL,
+  error,
+  [symbol]() {
+    return pipe(hash(TExitSymbolKey), combine(hash(OP_FAIL)), combine(hash(error)));
+  },
+  [symbol$1](that) {
+    return isExit(that) && that._tag === OP_FAIL && equals(error, that.error);
+  }
+});
+
+/** @internal */
+const die$1 = defect => ({
+  [TExitTypeId]: variance,
+  _tag: OP_DIE,
+  defect,
+  [symbol]() {
+    return pipe(hash(TExitSymbolKey), combine(hash(OP_DIE)), combine(hash(defect)));
+  },
+  [symbol$1](that) {
+    return isExit(that) && that._tag === OP_DIE && equals(defect, that.defect);
+  }
+});
+
+/** @internal */
+const interrupt$1 = fiberId => ({
+  [TExitTypeId]: variance,
+  _tag: OP_INTERRUPT,
+  fiberId,
+  [symbol]() {
+    return pipe(hash(TExitSymbolKey), combine(hash(OP_INTERRUPT)), combine(hash(fiberId)));
+  },
+  [symbol$1](that) {
+    return isExit(that) && that._tag === OP_INTERRUPT && equals(fiberId, that.fiberId);
+  }
+});
+
+/** @internal */
+const succeed$1 = value => ({
+  [TExitTypeId]: variance,
+  _tag: OP_SUCCEED,
+  value,
+  [symbol]() {
+    return pipe(hash(TExitSymbolKey), combine(hash(OP_SUCCEED)), combine(hash(value)));
+  },
+  [symbol$1](that) {
+    return isExit(that) && that._tag === OP_SUCCEED && equals(value, that.value);
+  }
+});
+
+/** @internal */
+const retry$1 = {
+  [TExitTypeId]: variance,
+  _tag: OP_RETRY,
+  [symbol]() {
+    return pipe(hash(TExitSymbolKey), combine(hash(OP_RETRY)), combine(hash("retry")));
+  },
+  [symbol$1](that) {
+    return isExit(that) && isRetry(that);
+  }
+};
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const done = exit => {
+  return {
+    _tag: OP_DONE$1,
+    exit
+  };
+};
+
+/** @internal */
+const suspend = journal => {
+  return {
+    _tag: OP_SUSPEND,
+    journal
+  };
+};
+
+/** @internal */
+
+/** @internal */
+const txnCounter = {
+  ref: 0
+};
+
+/** @internal */
+const make = () => {
+  const newId = txnCounter.ref + 1;
+  txnCounter.ref = newId;
+  return newId;
+};
+
+/** @internal */
+const STMSymbolKey = "effect/STM";
+
+/** @internal */
+const STMTypeId = /*#__PURE__*/Symbol.for(STMSymbolKey);
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const stmVariance = {
+  _R: _ => _,
+  _E: _ => _,
+  _A: _ => _
+};
+
+/** @internal */
+class STMPrimitive {
+  _tag = OP_COMMIT;
+  _op = OP_COMMIT;
+  i1 = undefined;
+  i2 = undefined;
+  get [STMTypeId]() {
+    return stmVariance;
+  }
+  constructor(i0) {
+    this.i0 = i0;
+    this[EffectTypeId] = stmVariance;
+    this[StreamTypeId] = stmVariance;
+    this[SinkTypeId] = stmVariance;
+    this[ChannelTypeId] = stmVariance;
+  }
+  [symbol$1](that) {
+    return this === that;
+  }
+  [symbol]() {
+    return random(this);
+  }
+  commit() {
+    return unsafeAtomically(this, constVoid, constVoid);
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+}
+
+/** @internal */
+const isSTM = u => typeof u === "object" && u != null && STMTypeId in u;
+
+/** @internal */
+const commit = self => unsafeAtomically(self, constVoid, constVoid);
+
+/** @internal */
+const unsafeAtomically = (self, onDone, onInterrupt) => withFiberRuntime(state => {
+  const fiberId = state.id();
+  const env = state.getFiberRef(currentContext);
+  const scheduler = state.getFiberRef(currentScheduler);
+  const priority = state.getFiberRef(currentSchedulingPriority);
+  const commitResult = tryCommitSync(fiberId, self, env, scheduler, priority);
+  switch (commitResult._tag) {
+    case OP_DONE$1:
+      {
+        onDone(commitResult.exit);
+        return commitResult.exit;
+      }
+    case OP_SUSPEND:
+      {
+        const txnId = make();
+        const state = {
+          value: running
+        };
+        const effect = async(k => tryCommitAsync(fiberId, self, txnId, state, env, scheduler, priority, k));
+        return uninterruptibleMask(restore => pipe(restore(effect), catchAllCause(cause => {
+          let currentState = state.value;
+          if (isRunning(currentState)) {
+            state.value = interrupted;
+          }
+          currentState = state.value;
+          if (isDone(currentState)) {
+            onDone(currentState.exit);
+            return currentState.exit;
+          }
+          onInterrupt();
+          return failCause(cause);
+        })));
+      }
+  }
+});
+
+/** @internal */
+const tryCommit = (fiberId, stm, state, env, scheduler, priority) => {
+  const journal = new Map();
+  const tExit = new STMDriver(stm, journal, fiberId, env).run();
+  const analysis = analyzeJournal(journal);
+  if (analysis === JournalAnalysisReadWrite) {
+    commitJournal(journal);
+  } else if (analysis === JournalAnalysisInvalid) {
+    throw new Error("BUG: STM.TryCommit.tryCommit - please report an issue at https://github.com/Effect-TS/io/issues");
+  }
+  switch (tExit._tag) {
+    case OP_SUCCEED:
+      {
+        state.value = fromTExit(tExit);
+        return completeTodos(succeed$2(tExit.value), journal, scheduler, priority);
+      }
+    case OP_FAIL:
+      {
+        state.value = fromTExit(tExit);
+        const cause = fail$3(tExit.error);
+        return completeTodos(failCause$1(cause), journal, scheduler, priority);
+      }
+    case OP_DIE:
+      {
+        state.value = fromTExit(tExit);
+        const cause = die$3(tExit.defect);
+        return completeTodos(failCause$1(cause), journal, scheduler, priority);
+      }
+    case OP_INTERRUPT:
+      {
+        state.value = fromTExit(tExit);
+        const cause = interrupt$3(fiberId);
+        return completeTodos(failCause$1(cause), journal, scheduler, priority);
+      }
+    case OP_RETRY:
+      {
+        return suspend(journal);
+      }
+  }
+};
+
+/** @internal */
+const tryCommitSync = (fiberId, stm, env, scheduler, priority) => {
+  const journal = new Map();
+  const tExit = new STMDriver(stm, journal, fiberId, env).run();
+  const analysis = analyzeJournal(journal);
+  if (analysis === JournalAnalysisReadWrite && isSuccess(tExit)) {
+    commitJournal(journal);
+  } else if (analysis === JournalAnalysisInvalid) {
+    throw new Error("BUG: STM.TryCommit.tryCommitSync - please report an issue at https://github.com/Effect-TS/io/issues");
+  }
+  switch (tExit._tag) {
+    case OP_SUCCEED:
+      {
+        return completeTodos(succeed$2(tExit.value), journal, scheduler, priority);
+      }
+    case OP_FAIL:
+      {
+        const cause = fail$3(tExit.error);
+        return completeTodos(failCause$1(cause), journal, scheduler, priority);
+      }
+    case OP_DIE:
+      {
+        const cause = die$3(tExit.defect);
+        return completeTodos(failCause$1(cause), journal, scheduler, priority);
+      }
+    case OP_INTERRUPT:
+      {
+        const cause = interrupt$3(fiberId);
+        return completeTodos(failCause$1(cause), journal, scheduler, priority);
+      }
+    case OP_RETRY:
+      {
+        return suspend(journal);
+      }
+  }
+};
+
+/** @internal */
+const tryCommitAsync = (fiberId, self, txnId, state, context, scheduler, priority, k) => {
+  if (isRunning(state.value)) {
+    const result = tryCommit(fiberId, self, state, context, scheduler, priority);
+    switch (result._tag) {
+      case OP_DONE$1:
+        {
+          completeTryCommit(result.exit, k);
+          break;
+        }
+      case OP_SUSPEND:
+        {
+          addTodo(txnId, result.journal, () => tryCommitAsync(fiberId, self, txnId, state, context, scheduler, priority, k));
+          break;
+        }
+    }
+  }
+};
+
+/** @internal */
+const completeTodos = (exit, journal, scheduler, priority) => {
+  const todos = collectTodos(journal);
+  if (todos.size > 0) {
+    scheduler.scheduleTask(() => execTodos(todos), priority);
+  }
+  return done(exit);
+};
+
+/** @internal */
+const completeTryCommit = (exit, k) => {
+  k(exit);
+};
+
+/** @internal */
+
+/** @internal */
+const context = () => effect((_, __, env) => env);
+
+/** @internal */
+const contextWith = f => map(context(), f);
+
+/** @internal */
+const contextWithSTM = f => flatMap(context(), f);
+
+/** @internal */
+class STMDriver {
+  contStack = [];
+  constructor(self, journal, fiberId, r0) {
+    this.self = self;
+    this.journal = journal;
+    this.fiberId = fiberId;
+    this.env = r0;
+  }
+  getEnv() {
+    return this.env;
+  }
+  pushStack(cont) {
+    this.contStack.push(cont);
+  }
+  popStack() {
+    return this.contStack.pop();
+  }
+  nextSuccess() {
+    let current = this.popStack();
+    while (current !== undefined && current.i0 !== OP_ON_SUCCESS) {
+      current = this.popStack();
+    }
+    return current;
+  }
+  nextFailure() {
+    let current = this.popStack();
+    while (current !== undefined && current.i0 !== OP_ON_FAILURE) {
+      current = this.popStack();
+    }
+    return current;
+  }
+  nextRetry() {
+    let current = this.popStack();
+    while (current !== undefined && current.i0 !== OP_ON_RETRY) {
+      current = this.popStack();
+    }
+    return current;
+  }
+  run() {
+    let curr = this.self;
+    let exit = undefined;
+    while (exit === undefined && curr !== undefined) {
+      try {
+        const current = curr;
+        if (current) {
+          switch (current._tag) {
+            case "Tag":
+              {
+                curr = effect((_, __, env) => unsafeGet$1(env, current));
+                break;
+              }
+            case "Left":
+              {
+                curr = fail(current.left);
+                break;
+              }
+            case "None":
+              {
+                curr = fail(NoSuchElementException());
+                break;
+              }
+            case "Right":
+              {
+                curr = succeed(current.right);
+                break;
+              }
+            case "Some":
+              {
+                curr = succeed(current.value);
+                break;
+              }
+            case "Commit":
+              {
+                switch (current.i0) {
+                  case OP_DIE$1:
+                    {
+                      exit = die$1(current.i1());
+                      break;
+                    }
+                  case OP_FAIL$1:
+                    {
+                      const cont = this.nextFailure();
+                      if (cont === undefined) {
+                        exit = fail$1(current.i1());
+                      } else {
+                        curr = cont.i2(current.i1());
+                      }
+                      break;
+                    }
+                  case OP_RETRY$1:
+                    {
+                      const cont = this.nextRetry();
+                      if (cont === undefined) {
+                        exit = retry$1;
+                      } else {
+                        curr = cont.i2();
+                      }
+                      break;
+                    }
+                  case OP_INTERRUPT$1:
+                    {
+                      exit = interrupt$1(this.fiberId);
+                      break;
+                    }
+                  case OP_WITH_STM_RUNTIME:
+                    {
+                      curr = current.i1(this);
+                      break;
+                    }
+                  case OP_ON_SUCCESS:
+                  case OP_ON_FAILURE:
+                  case OP_ON_RETRY:
+                    {
+                      this.pushStack(current);
+                      curr = current.i1;
+                      break;
+                    }
+                  case OP_PROVIDE:
+                    {
+                      const env = this.env;
+                      this.env = current.i2(env);
+                      curr = pipe(current.i1, ensuring(sync(() => this.env = env)));
+                      break;
+                    }
+                  case OP_SUCCEED$1:
+                    {
+                      const value = current.i1;
+                      const cont = this.nextSuccess();
+                      if (cont === undefined) {
+                        exit = succeed$1(value);
+                      } else {
+                        curr = cont.i2(value);
+                      }
+                      break;
+                    }
+                  case OP_SYNC:
+                    {
+                      const value = current.i1();
+                      const cont = this.nextSuccess();
+                      if (cont === undefined) {
+                        exit = succeed$1(value);
+                      } else {
+                        curr = cont.i2(value);
+                      }
+                      break;
+                    }
+                }
+                break;
+              }
+          }
+        }
+      } catch (e) {
+        curr = die(e);
+      }
+    }
+    return exit;
+  }
+}
+
+/** @internal */
+const catchAll = /*#__PURE__*/dual(2, (self, f) => {
+  const stm = new STMPrimitive(OP_ON_FAILURE);
+  stm.i1 = self;
+  stm.i2 = f;
+  return stm;
+});
+
+/** @internal */
+const mapInputContext = /*#__PURE__*/dual(2, (self, f) => {
+  const stm = new STMPrimitive(OP_PROVIDE);
+  stm.i1 = self;
+  stm.i2 = f;
+  return stm;
+});
+
+/** @internal */
+const die = defect => dieSync(() => defect);
+
+/** @internal */
+const dieMessage = message => dieSync(() => RuntimeException(message));
+
+/** @internal */
+const dieSync = evaluate => {
+  const stm = new STMPrimitive(OP_DIE$1);
+  stm.i1 = evaluate;
+  return stm;
+};
+
+/** @internal */
+const effect = f => withSTMRuntime(_ => succeed(f(_.journal, _.fiberId, _.getEnv())));
+
+/** @internal */
+const ensuring = /*#__PURE__*/dual(2, (self, finalizer) => matchSTM(self, {
+  onFailure: e => zipRight(finalizer, fail(e)),
+  onSuccess: a => zipRight(finalizer, succeed(a))
+}));
+
+/** @internal */
+const fail = error => failSync(() => error);
+
+/** @internal */
+const failSync = evaluate => {
+  const stm = new STMPrimitive(OP_FAIL$1);
+  stm.i1 = evaluate;
+  return stm;
+};
+
+/** @internal */
+const flatMap = /*#__PURE__*/dual(2, (self, f) => {
+  const stm = new STMPrimitive(OP_ON_SUCCESS);
+  stm.i1 = self;
+  stm.i2 = f;
+  return stm;
+});
+
+/** @internal */
+const matchSTM = /*#__PURE__*/dual(2, (self, {
+  onFailure,
+  onSuccess
+}) => pipe(self, map(right), catchAll(e => pipe(onFailure(e), map(left))), flatMap(either => {
+  switch (either._tag) {
+    case "Left":
+      {
+        return succeed(either.left);
+      }
+    case "Right":
+      {
+        return onSuccess(either.right);
+      }
+  }
+})));
+
+/** @internal */
+const withSTMRuntime = f => {
+  const stm = new STMPrimitive(OP_WITH_STM_RUNTIME);
+  stm.i1 = f;
+  return stm;
+};
+
+/** @internal */
+const interrupt = /*#__PURE__*/withSTMRuntime(_ => {
+  const stm = new STMPrimitive(OP_INTERRUPT$1);
+  stm.i1 = _.fiberId;
+  return stm;
+});
+
+/** @internal */
+const interruptAs = fiberId => {
+  const stm = new STMPrimitive(OP_INTERRUPT$1);
+  stm.i1 = fiberId;
+  return stm;
+};
+
+/** @internal */
+const map = /*#__PURE__*/dual(2, (self, f) => pipe(self, flatMap(a => sync(() => f(a)))));
+
+/** @internal */
+const orTry = /*#__PURE__*/dual(2, (self, that) => {
+  const stm = new STMPrimitive(OP_ON_RETRY);
+  stm.i1 = self;
+  stm.i2 = that;
+  return stm;
+});
+
+/** @internal */
+const retry = /*#__PURE__*/new STMPrimitive(OP_RETRY$1);
+
+/** @internal */
+const succeed = value => {
+  const stm = new STMPrimitive(OP_SUCCEED$1);
+  stm.i1 = value;
+  return stm;
+};
+
+/** @internal */
+const sync = evaluate => {
+  const stm = new STMPrimitive(OP_SYNC);
+  stm.i1 = evaluate;
+  return stm;
+};
+
+/** @internal */
+const zip = /*#__PURE__*/dual(2, (self, that) => pipe(self, zipWith(that, (a, a1) => [a, a1])));
+
+/** @internal */
+const zipLeft = /*#__PURE__*/dual(2, (self, that) => pipe(self, flatMap(a => pipe(that, map(() => a)))));
+
+/** @internal */
+const zipRight = /*#__PURE__*/dual(2, (self, that) => pipe(self, flatMap(() => that)));
+
+/** @internal */
+const zipWith = /*#__PURE__*/dual(3, (self, that, f) => pipe(self, flatMap(a => pipe(that, map(b => f(a, b))))));
+
+export { isDone as A, unsafeAtomically as B, effect as C, running as D, interrupted as E, done$1 as F, prepareResetJournal as G, withSTMRuntime as H, unsafeGet as I, unsafeSet as J, make$1 as K, STMTypeId as S, Versioned as V, commit as a, context as b, catchAll as c, contextWith as d, contextWithSTM as e, die as f, dieMessage as g, dieSync as h, isSTM as i, ensuring as j, fail as k, failSync as l, mapInputContext as m, flatMap as n, matchSTM as o, interrupt as p, interruptAs as q, map as r, orTry as s, retry as t, succeed as u, sync as v, zipLeft as w, zipRight as x, zipWith as y, zip as z };