@attocash/commons-js 5.0.0

package/kotlinx-coroutines-core/kotlinx/coroutines/JobSupport.mjs

@@ -0,0 +1,1910 @@
+import {
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+} from '../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  LockFreeLinkedListHeaduwhs9comnpmn as LockFreeLinkedListHead,
+  LockFreeLinkedListNode18403qmazubk5 as LockFreeLinkedListNode,
+} from './internal/LinkedList.mjs';
+import { StringBuildermazzzhj6kkai as StringBuilder } from '../../../kotlin-kotlin-stdlib/kotlin/text/StringBuilderJs.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  equals2au1ep9vhcato as equals,
+  toString1pkumu07cwy4m as toString,
+  protoOf180f3jzyo7rfj as protoOf,
+  anyToString3ho3k49fc56mj as anyToString,
+} from '../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import {
+  get_DEBUG1a8uv2i5oid01 as get_DEBUG,
+  get_classSimpleName2jgk6lzg9ft1 as get_classSimpleName,
+  get_hexAddress1mxa7txdmiojm as get_hexAddress,
+} from './Debug.mjs';
+import {
+  throwUninitializedPropertyAccessExceptionyynx7gkm73wd as throwUninitializedPropertyAccessException,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+} from '../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { ArrayList3it5z8td81qkl as ArrayList } from '../../../kotlin-kotlin-stdlib/kotlin/collections/ArrayListJs.mjs';
+import { CompletedExceptionally3itrk74dxkv9s as CompletedExceptionally } from './CompletionState.mjs';
+import { JobCancellationException2g3wpni5v5fkt as JobCancellationException } from './Exceptions.mjs';
+import { CancellationException3b36o9qz53rgr as CancellationException } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/cancellation/CancellationException.mjs';
+import { TimeoutCancellationException198b5zwr3v3uw as TimeoutCancellationException } from './Timeout.mjs';
+import { identitySet1lu9dl60optk8 as identitySet } from './internal/Concurrent.mjs';
+import { unwrap34f7x4f5snsxt as unwrap } from './internal/StackTraceRecovery.mjs';
+import { addSuppressedu5jwjfvsc039 as addSuppressed } from '../../../kotlin-kotlin-stdlib/kotlin/throwableExtensions.mjs';
+import {
+  NonDisposableHandle_instance3k5b81ogrgecy as NonDisposableHandle_instance,
+  invokeOnCompletion3npqdfp2wzhn6 as invokeOnCompletion,
+  ParentJob1a3idoswyjefg as ParentJob,
+  Key_instance2tirv2rj82ml4 as Key_instance,
+  invokeOnCompletion$default6tc1ee8hzqwd as invokeOnCompletion$default,
+  ensureActive2yo7199srjlgl as ensureActive,
+  cancel$default2gzemzkga6aea as cancel$default,
+  Job29shfjfygy86k as Job,
+} from './Job.mjs';
+import { CompletionHandlerException1h8udyjlr1wky as CompletionHandlerException } from './Exceptions.common.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { intercepted2ogpsikxxj4u0 as intercepted } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import { CancellableContinuationImpl1cx201opicavg as CancellableContinuationImpl } from './CancellableContinuationImpl.mjs';
+import { disposeOnCancellation302lv5bib5mna as disposeOnCancellation } from './CancellableContinuation.mjs';
+import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { SynchronizedObject32xqzf15iiskd as SynchronizedObject } from './internal/Synchronized.mjs';
+import {
+  atomic$boolean$1iggki4z65a2h as atomic$boolean$1,
+  atomic$ref$130aurmcwdfdf1 as atomic$ref$1,
+} from '../../../kotlinx-atomicfu/kotlinx/atomicfu/AtomicFU.mjs';
+import { toString30pk9tzaqopn as toString_0 } from '../../../kotlin-kotlin-stdlib/kotlin/Library.mjs';
+import { CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineImpl.mjs';
+import {
+  SequenceScope1coiso86pqzq2 as SequenceScope,
+  sequence2vgswtrxvqoa7 as sequence,
+} from '../../../kotlin-kotlin-stdlib/kotlin/sequences/SequenceBuilder.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import {
+  plusolev77jfy5r9 as plus,
+  get6d5x931vk0s as get,
+  fold36i9psb7d5v48 as fold,
+  minusKeyyqanvso9aovh as minusKey,
+} from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineContext.mjs';
+import {
+  Companion_instance2oawqq9qiaris as Companion_instance,
+  _Result___init__impl__xyqfz83hut4nr3dfvi3 as _Result___init__impl__xyqfz8,
+  createFailure8paxfkfa5dc7 as createFailure,
+} from '../../../kotlin-kotlin-stdlib/kotlin/Result.mjs';
+import { CompletableJob1w6swnu15iclo as CompletableJob } from './CompletableJob.mjs';
+import { Symbol17xuwzgi5g8ve as Symbol } from './internal/Symbol.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function get_COMPLETING_ALREADY() {
+  _init_properties_JobSupport_kt__68f172();
+  return COMPLETING_ALREADY;
+}
+var COMPLETING_ALREADY;
+function get_COMPLETING_WAITING_CHILDREN() {
+  _init_properties_JobSupport_kt__68f172();
+  return COMPLETING_WAITING_CHILDREN;
+}
+var COMPLETING_WAITING_CHILDREN;
+function get_COMPLETING_RETRY() {
+  _init_properties_JobSupport_kt__68f172();
+  return COMPLETING_RETRY;
+}
+var COMPLETING_RETRY;
+function get_TOO_LATE_TO_CANCEL() {
+  _init_properties_JobSupport_kt__68f172();
+  return TOO_LATE_TO_CANCEL;
+}
+var TOO_LATE_TO_CANCEL;
+function get_SEALED() {
+  _init_properties_JobSupport_kt__68f172();
+  return SEALED;
+}
+var SEALED;
+function get_EMPTY_NEW() {
+  _init_properties_JobSupport_kt__68f172();
+  return EMPTY_NEW;
+}
+var EMPTY_NEW;
+function get_EMPTY_ACTIVE() {
+  _init_properties_JobSupport_kt__68f172();
+  return EMPTY_ACTIVE;
+}
+var EMPTY_ACTIVE;
+var EmptyClass;
+function Empty() {
+  if (EmptyClass === VOID) {
+    class $ {
+      constructor(isActive) {
+        this.q26_1 = isActive;
+      }
+      t1x() {
+        return this.q26_1;
+      }
+      j24() {
+        return null;
+      }
+      toString() {
+        return 'Empty{' + (this.q26_1 ? 'Active' : 'New') + '}';
+      }
+    }
+    initMetadataForClass($, 'Empty', VOID, VOID, [Incomplete()]);
+    EmptyClass = $;
+  }
+  return EmptyClass;
+}
+var IncompleteClass;
+function Incomplete() {
+  if (IncompleteClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'Incomplete');
+    IncompleteClass = $;
+  }
+  return IncompleteClass;
+}
+var NodeListClass;
+function NodeList() {
+  if (NodeListClass === VOID) {
+    class $ extends LockFreeLinkedListHead() {
+      t1x() {
+        return true;
+      }
+      j24() {
+        return this;
+      }
+      u26(state) {
+        // Inline function 'kotlin.text.buildString' call
+        // Inline function 'kotlin.apply' call
+        var this_0 = StringBuilder().a1();
+        this_0.jb('List{');
+        this_0.jb(state);
+        this_0.jb('}[');
+        var first = true;
+        // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListHead.forEach' call
+        var cur = this.k24_1;
+        while (!equals(cur, this)) {
+          var node = cur;
+          if (node instanceof JobNode()) {
+            if (first) {
+              first = false;
+            } else
+              this_0.jb(', ');
+            this_0.ib(node);
+          }
+          cur = cur.k24_1;
+        }
+        this_0.jb(']');
+        return this_0.toString();
+      }
+      toString() {
+        return get_DEBUG() ? this.u26('Active') : super.toString();
+      }
+    }
+    initMetadataForClass($, 'NodeList', NodeList, VOID, [LockFreeLinkedListHead(), Incomplete()]);
+    NodeListClass = $;
+  }
+  return NodeListClass;
+}
+var JobNodeClass;
+function JobNode() {
+  if (JobNodeClass === VOID) {
+    class $ extends LockFreeLinkedListNode() {
+      i24() {
+        var tmp = this.h24_1;
+        if (!(tmp == null))
+          return tmp;
+        else {
+          throwUninitializedPropertyAccessException('job');
+        }
+      }
+      t1x() {
+        return true;
+      }
+      j24() {
+        return null;
+      }
+      u21() {
+        return this.i24().a1z(this);
+      }
+      toString() {
+        return get_classSimpleName(this) + '@' + get_hexAddress(this) + '[job@' + get_hexAddress(this.i24()) + ']';
+      }
+    }
+    initMetadataForClass($, 'JobNode', VOID, VOID, [LockFreeLinkedListNode(), Incomplete()]);
+    JobNodeClass = $;
+  }
+  return JobNodeClass;
+}
+function _set_exceptionsHolder__tqm22h($this, value) {
+  $this.z26_1.kotlinx$atomicfu$value = value;
+}
+function _get_exceptionsHolder__nhszp($this) {
+  return $this.z26_1.kotlinx$atomicfu$value;
+}
+function allocateList($this) {
+  return ArrayList().c1(4);
+}
+function finalizeFinishingState($this, state, proposedUpdate) {
+  // Inline function 'kotlinx.coroutines.assert' call
+  // Inline function 'kotlinx.coroutines.assert' call
+  // Inline function 'kotlinx.coroutines.assert' call
+  var tmp0_safe_receiver = proposedUpdate instanceof CompletedExceptionally() ? proposedUpdate : null;
+  var proposedException = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.y1x_1;
+  var wasCancelling;
+  // Inline function 'kotlinx.coroutines.internal.synchronized' call
+  // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
+  wasCancelling = state.a27();
+  var exceptions = state.b27(proposedException);
+  var finalCause = getFinalRootCause($this, state, exceptions);
+  if (!(finalCause == null)) {
+    addSuppressedExceptions($this, finalCause, exceptions);
+  }
+  var finalException = finalCause;
+  var finalState = finalException == null ? proposedUpdate : finalException === proposedException ? proposedUpdate : new (CompletedExceptionally())(finalException);
+  if (!(finalException == null)) {
+    var handled = cancelParent($this, finalException) || $this.q1z(finalException);
+    if (handled) {
+      (finalState instanceof CompletedExceptionally() ? finalState : THROW_CCE()).x22();
+    }
+  }
+  if (!wasCancelling) {
+    $this.n1z(finalException);
+  }
+  $this.x1x(finalState);
+  var casSuccess = $this.m1x_1.atomicfu$compareAndSet(state, boxIncomplete(finalState));
+  // Inline function 'kotlinx.coroutines.assert' call
+  completeStateFinalization($this, state, finalState);
+  return finalState;
+}
+function getFinalRootCause($this, state, exceptions) {
+  if (exceptions.j()) {
+    if (state.a27()) {
+      // Inline function 'kotlinx.coroutines.JobSupport.defaultCancellationException' call
+      return JobCancellationException().i27(null == null ? $this.w1x() : null, null, $this);
+    }
+    return null;
+  }
+  var tmp$ret$2;
+  $l$block: {
+    // Inline function 'kotlin.collections.firstOrNull' call
+    var _iterator__ex2g4s = exceptions.d1();
+    while (_iterator__ex2g4s.e1()) {
+      var element = _iterator__ex2g4s.f1();
+      if (!(element instanceof CancellationException())) {
+        tmp$ret$2 = element;
+        break $l$block;
+      }
+    }
+    tmp$ret$2 = null;
+  }
+  var firstNonCancellation = tmp$ret$2;
+  if (!(firstNonCancellation == null))
+    return firstNonCancellation;
+  var first = exceptions.j1(0);
+  if (first instanceof TimeoutCancellationException()) {
+    var tmp$ret$4;
+    $l$block_0: {
+      // Inline function 'kotlin.collections.firstOrNull' call
+      var _iterator__ex2g4s_0 = exceptions.d1();
+      while (_iterator__ex2g4s_0.e1()) {
+        var element_0 = _iterator__ex2g4s_0.f1();
+        var tmp;
+        if (!(element_0 === first)) {
+          tmp = element_0 instanceof TimeoutCancellationException();
+        } else {
+          tmp = false;
+        }
+        if (tmp) {
+          tmp$ret$4 = element_0;
+          break $l$block_0;
+        }
+      }
+      tmp$ret$4 = null;
+    }
+    var detailedTimeoutException = tmp$ret$4;
+    if (!(detailedTimeoutException == null))
+      return detailedTimeoutException;
+  }
+  return first;
+}
+function addSuppressedExceptions($this, rootCause, exceptions) {
+  if (exceptions.i1() <= 1)
+    return Unit_instance;
+  var seenExceptions = identitySet(exceptions.i1());
+  var unwrappedCause = unwrap(rootCause);
+  var _iterator__ex2g4s = exceptions.d1();
+  while (_iterator__ex2g4s.e1()) {
+    var exception = _iterator__ex2g4s.f1();
+    var unwrapped = unwrap(exception);
+    var tmp;
+    var tmp_0;
+    if (!(unwrapped === rootCause) && !(unwrapped === unwrappedCause)) {
+      tmp_0 = !(unwrapped instanceof CancellationException());
+    } else {
+      tmp_0 = false;
+    }
+    if (tmp_0) {
+      tmp = seenExceptions.m(unwrapped);
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      addSuppressed(rootCause, unwrapped);
+    }
+  }
+}
+function tryFinalizeSimpleState($this, state, update) {
+  // Inline function 'kotlinx.coroutines.assert' call
+  // Inline function 'kotlinx.coroutines.assert' call
+  if (!$this.m1x_1.atomicfu$compareAndSet(state, boxIncomplete(update)))
+    return false;
+  $this.n1z(null);
+  $this.x1x(update);
+  completeStateFinalization($this, state, update);
+  return true;
+}
+function completeStateFinalization($this, state, update) {
+  var tmp0_safe_receiver = $this.l1y();
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    tmp0_safe_receiver.u21();
+    $this.k1y(NonDisposableHandle_instance);
+  }
+  var tmp1_safe_receiver = update instanceof CompletedExceptionally() ? update : null;
+  var cause = tmp1_safe_receiver == null ? null : tmp1_safe_receiver.y1x_1;
+  if (state instanceof JobNode()) {
+    try {
+      state.t21(cause);
+    } catch ($p) {
+      if ($p instanceof Error) {
+        var ex = $p;
+        $this.e1y(CompletionHandlerException().o22('Exception in completion handler ' + state.toString() + ' for ' + $this.toString(), ex));
+      } else {
+        throw $p;
+      }
+    }
+  } else {
+    var tmp2_safe_receiver = state.j24();
+    if (tmp2_safe_receiver == null)
+      null;
+    else {
+      notifyCompletion($this, tmp2_safe_receiver, cause);
+    }
+  }
+}
+function notifyCancelling($this, list, cause) {
+  $this.n1z(cause);
+  list.v26(4);
+  // Inline function 'kotlinx.coroutines.JobSupport.notifyHandlers' call
+  var exception = null;
+  // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListHead.forEach' call
+  var cur = list.k24_1;
+  while (!equals(cur, list)) {
+    var node = cur;
+    var tmp;
+    if (node instanceof JobNode()) {
+      tmp = node.d24();
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      try {
+        node.t21(cause);
+      } catch ($p) {
+        if ($p instanceof Error) {
+          var ex = $p;
+          var tmp0_safe_receiver = exception;
+          var tmp_0;
+          if (tmp0_safe_receiver == null) {
+            tmp_0 = null;
+          } else {
+            // Inline function 'kotlin.apply' call
+            addSuppressed(tmp0_safe_receiver, ex);
+            tmp_0 = tmp0_safe_receiver;
+          }
+          if (tmp_0 == null) {
+            // Inline function 'kotlin.run' call
+            exception = CompletionHandlerException().o22('Exception in completion handler ' + node.toString() + ' for ' + $this.toString(), ex);
+          }
+        } else {
+          throw $p;
+        }
+      }
+    }
+    cur = cur.k24_1;
+  }
+  var tmp0_safe_receiver_0 = exception;
+  if (tmp0_safe_receiver_0 == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    $this.e1y(tmp0_safe_receiver_0);
+  }
+  cancelParent($this, cause);
+}
+function cancelParent($this, cause) {
+  if ($this.o1z())
+    return true;
+  var isCancellation = cause instanceof CancellationException();
+  var parent = $this.l1y();
+  if (parent === null || parent === NonDisposableHandle_instance) {
+    return isCancellation;
+  }
+  return parent.g1z(cause) || isCancellation;
+}
+function notifyCompletion($this, _this__u8e3s4, cause) {
+  _this__u8e3s4.v26(1);
+  // Inline function 'kotlinx.coroutines.JobSupport.notifyHandlers' call
+  var exception = null;
+  // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListHead.forEach' call
+  var cur = _this__u8e3s4.k24_1;
+  while (!equals(cur, _this__u8e3s4)) {
+    var node = cur;
+    var tmp;
+    if (node instanceof JobNode()) {
+      tmp = true;
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      try {
+        node.t21(cause);
+      } catch ($p) {
+        if ($p instanceof Error) {
+          var ex = $p;
+          var tmp0_safe_receiver = exception;
+          var tmp_0;
+          if (tmp0_safe_receiver == null) {
+            tmp_0 = null;
+          } else {
+            // Inline function 'kotlin.apply' call
+            addSuppressed(tmp0_safe_receiver, ex);
+            tmp_0 = tmp0_safe_receiver;
+          }
+          if (tmp_0 == null) {
+            // Inline function 'kotlin.run' call
+            exception = CompletionHandlerException().o22('Exception in completion handler ' + node.toString() + ' for ' + $this.toString(), ex);
+          }
+        } else {
+          throw $p;
+        }
+      }
+    }
+    cur = cur.k24_1;
+  }
+  var tmp0_safe_receiver_0 = exception;
+  if (tmp0_safe_receiver_0 == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    $this.e1y(tmp0_safe_receiver_0);
+  }
+}
+function startInternal($this, state) {
+  if (state instanceof Empty()) {
+    if (state.q26_1)
+      return 0;
+    if (!$this.m1x_1.atomicfu$compareAndSet(state, get_EMPTY_ACTIVE()))
+      return -1;
+    $this.r1y();
+    return 1;
+  } else {
+    if (state instanceof InactiveNodeList()) {
+      if (!$this.m1x_1.atomicfu$compareAndSet(state, state.j27_1))
+        return -1;
+      $this.r1y();
+      return 1;
+    } else {
+      return 0;
+    }
+  }
+}
+function promoteEmptyToNodeList($this, state) {
+  var list = new (NodeList())();
+  var update = state.q26_1 ? list : new (InactiveNodeList())(list);
+  $this.m1x_1.atomicfu$compareAndSet(state, update);
+}
+function promoteSingleToNodeList($this, state) {
+  state.p24(new (NodeList())());
+  // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.nextNode' call
+  var list = state.k24_1;
+  $this.m1x_1.atomicfu$compareAndSet(state, list);
+}
+function joinInternal($this) {
+  // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+  while (true) {
+    var state = $this.n1y();
+    if (!(!(state == null) ? isInterface(state, Incomplete()) : false))
+      return false;
+    if (startInternal($this, state) >= 0)
+      return true;
+  }
+}
+function joinSuspend($this, $completion) {
+  var cancellable = new (CancellableContinuationImpl())(intercepted($completion), 1);
+  cancellable.a23();
+  disposeOnCancellation(cancellable, invokeOnCompletion($this, VOID, new (ResumeOnCompletion())(cancellable)));
+  return cancellable.b20();
+}
+function cancelMakeCompleting($this, cause) {
+  // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+  while (true) {
+    var state = $this.n1y();
+    var tmp;
+    if (!(!(state == null) ? isInterface(state, Incomplete()) : false)) {
+      tmp = true;
+    } else {
+      var tmp_0;
+      if (state instanceof Finishing()) {
+        tmp_0 = state.k27();
+      } else {
+        tmp_0 = false;
+      }
+      tmp = tmp_0;
+    }
+    if (tmp) {
+      return get_COMPLETING_ALREADY();
+    }
+    var proposedUpdate = new (CompletedExceptionally())(createCauseException($this, cause));
+    var finalState = tryMakeCompleting($this, state, proposedUpdate);
+    if (!(finalState === get_COMPLETING_RETRY()))
+      return finalState;
+  }
+}
+function createCauseException($this, cause) {
+  var tmp;
+  if (cause == null ? true : cause instanceof Error) {
+    var tmp_0;
+    if (cause == null) {
+      // Inline function 'kotlinx.coroutines.JobSupport.defaultCancellationException' call
+      tmp_0 = JobCancellationException().i27(null == null ? $this.w1x() : null, null, $this);
+    } else {
+      tmp_0 = cause;
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = ((!(cause == null) ? isInterface(cause, ParentJob()) : false) ? cause : THROW_CCE()).j1z();
+  }
+  return tmp;
+}
+function makeCancelling($this, cause) {
+  var causeExceptionCache = null;
+  // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+  while (true) {
+    var tmp0 = $this.n1y();
+    $l$block: {
+      if (tmp0 instanceof Finishing()) {
+        // Inline function 'kotlinx.coroutines.internal.synchronized' call
+        // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
+        if (tmp0.l27())
+          return get_TOO_LATE_TO_CANCEL();
+        var wasCancelling = tmp0.a27();
+        if (!(cause == null) || !wasCancelling) {
+          var tmp0_elvis_lhs = causeExceptionCache;
+          var tmp;
+          if (tmp0_elvis_lhs == null) {
+            // Inline function 'kotlin.also' call
+            var this_0 = createCauseException($this, cause);
+            causeExceptionCache = this_0;
+            tmp = this_0;
+          } else {
+            tmp = tmp0_elvis_lhs;
+          }
+          var causeException = tmp;
+          tmp0.m27(causeException);
+        }
+        // Inline function 'kotlin.takeIf' call
+        var this_1 = tmp0.n27();
+        var tmp_0;
+        if (!wasCancelling) {
+          tmp_0 = this_1;
+        } else {
+          tmp_0 = null;
+        }
+        var notifyRootCause = tmp_0;
+        if (notifyRootCause == null)
+          null;
+        else {
+          // Inline function 'kotlin.let' call
+          notifyCancelling($this, tmp0.w26_1, notifyRootCause);
+        }
+        return get_COMPLETING_ALREADY();
+      } else {
+        if (!(tmp0 == null) ? isInterface(tmp0, Incomplete()) : false) {
+          var tmp2_elvis_lhs = causeExceptionCache;
+          var tmp_1;
+          if (tmp2_elvis_lhs == null) {
+            // Inline function 'kotlin.also' call
+            var this_2 = createCauseException($this, cause);
+            causeExceptionCache = this_2;
+            tmp_1 = this_2;
+          } else {
+            tmp_1 = tmp2_elvis_lhs;
+          }
+          var causeException_0 = tmp_1;
+          if (tmp0.t1x()) {
+            if (tryMakeCancelling($this, tmp0, causeException_0))
+              return get_COMPLETING_ALREADY();
+          } else {
+            var finalState = tryMakeCompleting($this, tmp0, new (CompletedExceptionally())(causeException_0));
+            if (finalState === get_COMPLETING_ALREADY()) {
+              // Inline function 'kotlin.error' call
+              var message = 'Cannot happen in ' + toString(tmp0);
+              throw IllegalStateException().o4(toString(message));
+            } else if (finalState === get_COMPLETING_RETRY()) {
+              break $l$block;
+            } else
+              return finalState;
+          }
+        } else {
+          return get_TOO_LATE_TO_CANCEL();
+        }
+      }
+    }
+  }
+}
+function getOrPromoteCancellingList($this, state) {
+  var tmp0_elvis_lhs = state.j24();
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    var tmp_0;
+    if (state instanceof Empty()) {
+      tmp_0 = new (NodeList())();
+    } else {
+      if (state instanceof JobNode()) {
+        promoteSingleToNodeList($this, state);
+        tmp_0 = null;
+      } else {
+        var message = 'State should have list: ' + toString(state);
+        throw IllegalStateException().o4(toString(message));
+      }
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  return tmp;
+}
+function tryMakeCancelling($this, state, rootCause) {
+  // Inline function 'kotlinx.coroutines.assert' call
+  // Inline function 'kotlinx.coroutines.assert' call
+  var tmp0_elvis_lhs = getOrPromoteCancellingList($this, state);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    return false;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var list = tmp;
+  var cancelling = new (Finishing())(list, false, rootCause);
+  if (!$this.m1x_1.atomicfu$compareAndSet(state, cancelling))
+    return false;
+  notifyCancelling($this, list, rootCause);
+  return true;
+}
+function tryMakeCompleting($this, state, proposedUpdate) {
+  if (!(!(state == null) ? isInterface(state, Incomplete()) : false))
+    return get_COMPLETING_ALREADY();
+  var tmp;
+  var tmp_0;
+  var tmp_1;
+  if (state instanceof Empty()) {
+    tmp_1 = true;
+  } else {
+    tmp_1 = state instanceof JobNode();
+  }
+  if (tmp_1) {
+    tmp_0 = !(state instanceof ChildHandleNode());
+  } else {
+    tmp_0 = false;
+  }
+  if (tmp_0) {
+    tmp = !(proposedUpdate instanceof CompletedExceptionally());
+  } else {
+    tmp = false;
+  }
+  if (tmp) {
+    if (tryFinalizeSimpleState($this, state, proposedUpdate)) {
+      return proposedUpdate;
+    }
+    return get_COMPLETING_RETRY();
+  }
+  return tryMakeCompletingSlowPath($this, state, proposedUpdate);
+}
+function tryMakeCompletingSlowPath($this, state, proposedUpdate) {
+  var tmp0_elvis_lhs = getOrPromoteCancellingList($this, state);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    return get_COMPLETING_RETRY();
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var list = tmp;
+  var tmp1_elvis_lhs = state instanceof Finishing() ? state : null;
+  var finishing = tmp1_elvis_lhs == null ? new (Finishing())(list, false, null) : tmp1_elvis_lhs;
+  var notifyRootCause;
+  // Inline function 'kotlinx.coroutines.internal.synchronized' call
+  // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
+  if (finishing.k27())
+    return get_COMPLETING_ALREADY();
+  finishing.o27(true);
+  if (!(finishing === state)) {
+    if (!$this.m1x_1.atomicfu$compareAndSet(state, finishing))
+      return get_COMPLETING_RETRY();
+  }
+  // Inline function 'kotlinx.coroutines.assert' call
+  var wasCancelling = finishing.a27();
+  var tmp0_safe_receiver = proposedUpdate instanceof CompletedExceptionally() ? proposedUpdate : null;
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    finishing.m27(tmp0_safe_receiver.y1x_1);
+  }
+  // Inline function 'kotlin.takeIf' call
+  var this_0 = finishing.n27();
+  var tmp_0;
+  if (!wasCancelling) {
+    tmp_0 = this_0;
+  } else {
+    tmp_0 = null;
+  }
+  notifyRootCause = tmp_0;
+  if (notifyRootCause == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    notifyCancelling($this, list, notifyRootCause);
+  }
+  var child = nextChild($this, list);
+  if (!(child == null) && tryWaitForChild($this, finishing, child, proposedUpdate))
+    return get_COMPLETING_WAITING_CHILDREN();
+  list.v26(2);
+  var anotherChild = nextChild($this, list);
+  if (!(anotherChild == null) && tryWaitForChild($this, finishing, anotherChild, proposedUpdate))
+    return get_COMPLETING_WAITING_CHILDREN();
+  return finalizeFinishingState($this, finishing, proposedUpdate);
+}
+function _get_exceptionOrNull__b3j7js($this, _this__u8e3s4) {
+  var tmp0_safe_receiver = _this__u8e3s4 instanceof CompletedExceptionally() ? _this__u8e3s4 : null;
+  return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.y1x_1;
+}
+function tryWaitForChild($this, state, child, proposedUpdate) {
+  var $this_0 = $this;
+  var state_0 = state;
+  var child_0 = child;
+  var proposedUpdate_0 = proposedUpdate;
+  $l$1: do {
+    $l$0: do {
+      var handle = invokeOnCompletion(child_0.t27_1, false, new (ChildCompletion())($this_0, state_0, child_0, proposedUpdate_0));
+      if (!(handle === NonDisposableHandle_instance))
+        return true;
+      var tmp0_elvis_lhs = nextChild($this_0, child_0);
+      var tmp;
+      if (tmp0_elvis_lhs == null) {
+        return false;
+      } else {
+        tmp = tmp0_elvis_lhs;
+      }
+      var nextChild_0 = tmp;
+      var tmp0 = $this_0;
+      var tmp1 = state_0;
+      var tmp3 = proposedUpdate_0;
+      $this_0 = tmp0;
+      state_0 = tmp1;
+      child_0 = nextChild_0;
+      proposedUpdate_0 = tmp3;
+      continue $l$0;
+    }
+     while (false);
+  }
+   while (true);
+}
+function continueCompleting($this, state, lastChild, proposedUpdate) {
+  // Inline function 'kotlinx.coroutines.assert' call
+  var waitChild = nextChild($this, lastChild);
+  if (!(waitChild == null) && tryWaitForChild($this, state, waitChild, proposedUpdate))
+    return Unit_instance;
+  state.w26_1.v26(2);
+  var waitChildAgain = nextChild($this, lastChild);
+  if (!(waitChildAgain == null) && tryWaitForChild($this, state, waitChildAgain, proposedUpdate)) {
+    return Unit_instance;
+  }
+  var finalState = finalizeFinishingState($this, state, proposedUpdate);
+  $this.d1y(finalState);
+}
+function nextChild($this, _this__u8e3s4) {
+  var cur = _this__u8e3s4;
+  $l$loop: while (true) {
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.isRemoved' call
+    if (!cur.m24_1) {
+      break $l$loop;
+    }
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.prevNode' call
+    cur = cur.l24_1;
+  }
+  $l$loop_0: while (true) {
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.nextNode' call
+    cur = cur.k24_1;
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.isRemoved' call
+    if (cur.m24_1)
+      continue $l$loop_0;
+    if (cur instanceof ChildHandleNode())
+      return cur;
+    if (cur instanceof NodeList())
+      return null;
+  }
+}
+function stateString($this, state) {
+  var tmp;
+  if (state instanceof Finishing()) {
+    tmp = state.a27() ? 'Cancelling' : state.k27() ? 'Completing' : 'Active';
+  } else {
+    if (!(state == null) ? isInterface(state, Incomplete()) : false) {
+      tmp = state.t1x() ? 'Active' : 'New';
+    } else {
+      if (state instanceof CompletedExceptionally()) {
+        tmp = 'Cancelled';
+      } else {
+        tmp = 'Completed';
+      }
+    }
+  }
+  return tmp;
+}
+var FinishingClass;
+function Finishing() {
+  if (FinishingClass === VOID) {
+    class $ extends SynchronizedObject() {
+      constructor(list, isCompleting, rootCause) {
+        super();
+        this.w26_1 = list;
+        this.x26_1 = atomic$boolean$1(isCompleting);
+        this.y26_1 = atomic$ref$1(rootCause);
+        this.z26_1 = atomic$ref$1(null);
+      }
+      j24() {
+        return this.w26_1;
+      }
+      o27(value) {
+        this.x26_1.kotlinx$atomicfu$value = value;
+      }
+      k27() {
+        return this.x26_1.kotlinx$atomicfu$value;
+      }
+      u27(value) {
+        this.y26_1.kotlinx$atomicfu$value = value;
+      }
+      n27() {
+        return this.y26_1.kotlinx$atomicfu$value;
+      }
+      l27() {
+        return _get_exceptionsHolder__nhszp(this) === get_SEALED();
+      }
+      a27() {
+        return !(this.n27() == null);
+      }
+      t1x() {
+        return this.n27() == null;
+      }
+      b27(proposedException) {
+        var eh = _get_exceptionsHolder__nhszp(this);
+        var tmp;
+        if (eh == null) {
+          tmp = allocateList(this);
+        } else {
+          if (eh instanceof Error) {
+            // Inline function 'kotlin.also' call
+            var this_0 = allocateList(this);
+            this_0.m(eh);
+            tmp = this_0;
+          } else {
+            if (eh instanceof ArrayList()) {
+              tmp = eh instanceof ArrayList() ? eh : THROW_CCE();
+            } else {
+              var message = 'State is ' + toString_0(eh);
+              throw IllegalStateException().o4(toString(message));
+            }
+          }
+        }
+        var list = tmp;
+        var rootCause = this.n27();
+        if (rootCause == null)
+          null;
+        else {
+          // Inline function 'kotlin.let' call
+          list.b3(0, rootCause);
+        }
+        if (!(proposedException == null) && !equals(proposedException, rootCause)) {
+          list.m(proposedException);
+        }
+        _set_exceptionsHolder__tqm22h(this, get_SEALED());
+        return list;
+      }
+      m27(exception) {
+        var rootCause = this.n27();
+        if (rootCause == null) {
+          this.u27(exception);
+          return Unit_instance;
+        }
+        if (exception === rootCause)
+          return Unit_instance;
+        var eh = _get_exceptionsHolder__nhszp(this);
+        if (eh == null) {
+          _set_exceptionsHolder__tqm22h(this, exception);
+        } else {
+          if (eh instanceof Error) {
+            if (exception === eh)
+              return Unit_instance;
+            // Inline function 'kotlin.apply' call
+            var this_0 = allocateList(this);
+            this_0.m(eh);
+            this_0.m(exception);
+            _set_exceptionsHolder__tqm22h(this, this_0);
+          } else {
+            if (eh instanceof ArrayList()) {
+              (eh instanceof ArrayList() ? eh : THROW_CCE()).m(exception);
+            } else {
+              // Inline function 'kotlin.error' call
+              var message = 'State is ' + toString_0(eh);
+              throw IllegalStateException().o4(toString(message));
+            }
+          }
+        }
+      }
+      toString() {
+        return 'Finishing[cancelling=' + this.a27() + ', completing=' + this.k27() + ', rootCause=' + toString_0(this.n27()) + ', exceptions=' + toString_0(_get_exceptionsHolder__nhszp(this)) + ', list=' + this.w26_1.toString() + ']';
+      }
+    }
+    initMetadataForClass($, 'Finishing', VOID, VOID, [SynchronizedObject(), Incomplete()]);
+    FinishingClass = $;
+  }
+  return FinishingClass;
+}
+var ChildCompletionClass;
+function ChildCompletion() {
+  if (ChildCompletionClass === VOID) {
+    class $ extends JobNode() {
+      constructor(parent, state, child, proposedUpdate) {
+        super();
+        this.z27_1 = parent;
+        this.a28_1 = state;
+        this.b28_1 = child;
+        this.c28_1 = proposedUpdate;
+      }
+      d24() {
+        return false;
+      }
+      t21(cause) {
+        continueCompleting(this.z27_1, this.a28_1, this.b28_1, this.c28_1);
+      }
+    }
+    initMetadataForClass($, 'ChildCompletion');
+    ChildCompletionClass = $;
+  }
+  return ChildCompletionClass;
+}
+var AwaitContinuationClass;
+function AwaitContinuation() {
+  if (AwaitContinuationClass === VOID) {
+    class $ extends CancellableContinuationImpl() {
+      constructor(delegate, job) {
+        super(delegate, 1);
+        this.j28_1 = job;
+      }
+      h23(parent) {
+        var state = this.j28_1.n1y();
+        if (state instanceof Finishing()) {
+          var tmp0_safe_receiver = state.n27();
+          if (tmp0_safe_receiver == null)
+            null;
+          else {
+            // Inline function 'kotlin.let' call
+            return tmp0_safe_receiver;
+          }
+        }
+        if (state instanceof CompletedExceptionally())
+          return state.y1x_1;
+        return parent.s1y();
+      }
+      t23() {
+        return 'AwaitContinuation';
+      }
+    }
+    initMetadataForClass($, 'AwaitContinuation');
+    AwaitContinuationClass = $;
+  }
+  return AwaitContinuationClass;
+}
+function awaitSuspend($this, $completion) {
+  var cont = new (AwaitContinuation())(intercepted($completion), $this);
+  cont.a23();
+  disposeOnCancellation(cont, invokeOnCompletion($this, VOID, new (ResumeAwaitOnCompletion())(cont)));
+  return cont.b20();
+}
+var JobSupport$_get_children_$slambda_k839f8Class;
+function JobSupport$_get_children_$slambda_k839f8() {
+  if (JobSupport$_get_children_$slambda_k839f8Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(this$0, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.s28_1 = this$0;
+        super(resultContinuation, $box);
+      }
+      g29($this$sequence, $completion) {
+        var tmp = this.h29($this$sequence, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      kd(p1, $completion) {
+        return this.g29(p1 instanceof SequenceScope() ? p1 : THROW_CCE(), $completion);
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 8;
+                this.u28_1 = this.s28_1.n1y();
+                var tmp_0 = this.u28_1;
+                if (tmp_0 instanceof ChildHandleNode()) {
+                  this.ac_1 = 6;
+                  suspendResult = this.t28_1.ml(this.u28_1.t27_1, this);
+                  if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                    return suspendResult;
+                  }
+                  continue $sm;
+                } else {
+                  var tmp_1 = this.u28_1;
+                  if (!(tmp_1 == null) ? isInterface(tmp_1, Incomplete()) : false) {
+                    this.v28_1 = this.u28_1.j24();
+                    if (this.v28_1 == null) {
+                      this.w28_1 = null;
+                      this.ac_1 = 5;
+                      continue $sm;
+                    } else {
+                      var tmp_2 = this;
+                      tmp_2.x28_1 = this.v28_1;
+                      this.y28_1 = this.x28_1;
+                      var tmp_3 = this;
+                      tmp_3.z28_1 = this.y28_1;
+                      this.a29_1 = this.z28_1;
+                      var tmp_4 = this;
+                      tmp_4.b29_1 = this.a29_1;
+                      this.c29_1 = this.b29_1;
+                      this.d29_1 = this.c29_1.k24_1;
+                      this.ac_1 = 1;
+                      continue $sm;
+                    }
+                  } else {
+                    this.ac_1 = 7;
+                    continue $sm;
+                  }
+                }
+
+              case 1:
+                if (!!equals(this.d29_1, this.c29_1)) {
+                  this.ac_1 = 4;
+                  continue $sm;
+                }
+
+                var tmp_5 = this;
+                tmp_5.e29_1 = this.d29_1;
+                this.f29_1 = this.e29_1;
+                var tmp_6 = this.f29_1;
+                if (tmp_6 instanceof ChildHandleNode()) {
+                  this.ac_1 = 2;
+                  suspendResult = this.t28_1.ml(this.f29_1.t27_1, this);
+                  if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                    return suspendResult;
+                  }
+                  continue $sm;
+                } else {
+                  this.ac_1 = 3;
+                  continue $sm;
+                }
+
+              case 2:
+                this.ac_1 = 3;
+                continue $sm;
+              case 3:
+                this.d29_1 = this.d29_1.k24_1;
+                this.ac_1 = 1;
+                continue $sm;
+              case 4:
+                var tmp_7 = this;
+                tmp_7.w28_1 = Unit_instance;
+                this.ac_1 = 5;
+                continue $sm;
+              case 5:
+                this.ac_1 = 7;
+                continue $sm;
+              case 6:
+                this.ac_1 = 7;
+                continue $sm;
+              case 7:
+                return Unit_instance;
+              case 8:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 8) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+      h29($this$sequence, completion) {
+        var i = new (JobSupport$_get_children_$slambda_k839f8())(this.s28_1, completion);
+        i.t28_1 = $this$sequence;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    JobSupport$_get_children_$slambda_k839f8Class = $;
+  }
+  return JobSupport$_get_children_$slambda_k839f8Class;
+}
+function JobSupport$_get_children_$slambda_k839f8_0(this$0, resultContinuation) {
+  var i = new (JobSupport$_get_children_$slambda_k839f8())(this$0, resultContinuation);
+  var l = function ($this$sequence, $completion) {
+    return i.g29($this$sequence, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+var JobSupportClass;
+function JobSupport() {
+  if (JobSupportClass === VOID) {
+    class $ {
+      constructor(active) {
+        this.m1x_1 = atomic$ref$1(active ? get_EMPTY_ACTIVE() : get_EMPTY_NEW());
+        this.n1x_1 = atomic$ref$1(null);
+      }
+      r1() {
+        return Key_instance;
+      }
+      k1y(value) {
+        this.n1x_1.kotlinx$atomicfu$value = value;
+      }
+      l1y() {
+        return this.n1x_1.kotlinx$atomicfu$value;
+      }
+      m1y() {
+        var tmp0_safe_receiver = this.l1y();
+        return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.m1y();
+      }
+      o1x(parent) {
+        // Inline function 'kotlinx.coroutines.assert' call
+        if (parent == null) {
+          this.k1y(NonDisposableHandle_instance);
+          return Unit_instance;
+        }
+        parent.q1y();
+        var handle = parent.m1z(this);
+        this.k1y(handle);
+        if (this.o1y()) {
+          handle.u21();
+          this.k1y(NonDisposableHandle_instance);
+        }
+      }
+      n1y() {
+        return this.m1x_1.kotlinx$atomicfu$value;
+      }
+      t1x() {
+        var state = this.n1y();
+        var tmp;
+        if (!(state == null) ? isInterface(state, Incomplete()) : false) {
+          tmp = state.t1x();
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      o1y() {
+        var tmp = this.n1y();
+        return !(!(tmp == null) ? isInterface(tmp, Incomplete()) : false);
+      }
+      p1y() {
+        var state = this.n1y();
+        var tmp;
+        if (state instanceof CompletedExceptionally()) {
+          tmp = true;
+        } else {
+          var tmp_0;
+          if (state instanceof Finishing()) {
+            tmp_0 = state.a27();
+          } else {
+            tmp_0 = false;
+          }
+          tmp = tmp_0;
+        }
+        return tmp;
+      }
+      q1y() {
+        // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+        while (true) {
+          var state = this.n1y();
+          var tmp0_subject = startInternal(this, state);
+          if (tmp0_subject === 0)
+            return false;
+          else if (tmp0_subject === 1)
+            return true;
+        }
+      }
+      r1y() {
+      }
+      s1y() {
+        var state = this.n1y();
+        var tmp;
+        if (state instanceof Finishing()) {
+          var tmp0_safe_receiver = state.n27();
+          var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : this.t1y(tmp0_safe_receiver, get_classSimpleName(this) + ' is cancelling');
+          var tmp_0;
+          if (tmp1_elvis_lhs == null) {
+            var message = 'Job is still new or active: ' + this.toString();
+            throw IllegalStateException().o4(toString(message));
+          } else {
+            tmp_0 = tmp1_elvis_lhs;
+          }
+          tmp = tmp_0;
+        } else {
+          if (!(state == null) ? isInterface(state, Incomplete()) : false) {
+            var message_0 = 'Job is still new or active: ' + this.toString();
+            throw IllegalStateException().o4(toString(message_0));
+          } else {
+            if (state instanceof CompletedExceptionally()) {
+              tmp = this.u1y(state.y1x_1);
+            } else {
+              tmp = JobCancellationException().i27(get_classSimpleName(this) + ' has completed normally', null, this);
+            }
+          }
+        }
+        return tmp;
+      }
+      t1y(_this__u8e3s4, message) {
+        var tmp0_elvis_lhs = _this__u8e3s4 instanceof CancellationException() ? _this__u8e3s4 : null;
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          // Inline function 'kotlinx.coroutines.JobSupport.defaultCancellationException' call
+          tmp = JobCancellationException().i27(message == null ? this.w1x() : message, _this__u8e3s4, this);
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        return tmp;
+      }
+      u1y(_this__u8e3s4, message, $super) {
+        message = message === VOID ? null : message;
+        return $super === VOID ? this.t1y(_this__u8e3s4, message) : $super.t1y.call(this, _this__u8e3s4, message);
+      }
+      v1y(handler) {
+        return this.y1y(true, new (InvokeOnCompletion())(handler));
+      }
+      w1y(onCancelling, invokeImmediately, handler) {
+        var tmp;
+        if (onCancelling) {
+          tmp = new (InvokeOnCancelling())(handler);
+        } else {
+          tmp = new (InvokeOnCompletion())(handler);
+        }
+        return this.y1y(invokeImmediately, tmp);
+      }
+      y1y(invokeImmediately, node) {
+        node.h24_1 = this;
+        var tmp$ret$0;
+        $l$block_1: {
+          // Inline function 'kotlinx.coroutines.JobSupport.tryPutNodeIntoList' call
+          // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+          while (true) {
+            var state = this.n1y();
+            if (state instanceof Empty()) {
+              if (state.q26_1) {
+                if (this.m1x_1.atomicfu$compareAndSet(state, node)) {
+                  tmp$ret$0 = true;
+                  break $l$block_1;
+                }
+              } else {
+                promoteEmptyToNodeList(this, state);
+              }
+            } else {
+              if (!(state == null) ? isInterface(state, Incomplete()) : false) {
+                var list = state.j24();
+                if (list == null) {
+                  promoteSingleToNodeList(this, state instanceof JobNode() ? state : THROW_CCE());
+                } else {
+                  var tmp;
+                  if (node.d24()) {
+                    var tmp0_safe_receiver = state instanceof Finishing() ? state : null;
+                    var rootCause = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.n27();
+                    var tmp_0;
+                    if (rootCause == null) {
+                      tmp_0 = list.n24(node, 5);
+                    } else {
+                      if (invokeImmediately) {
+                        node.t21(rootCause);
+                      }
+                      return NonDisposableHandle_instance;
+                    }
+                    tmp = tmp_0;
+                  } else {
+                    tmp = list.n24(node, 1);
+                  }
+                  if (tmp) {
+                    tmp$ret$0 = true;
+                    break $l$block_1;
+                  }
+                }
+              } else {
+                tmp$ret$0 = false;
+                break $l$block_1;
+              }
+            }
+          }
+        }
+        var added = tmp$ret$0;
+        if (added)
+          return node;
+        else if (invokeImmediately) {
+          var tmp_1 = this.n1y();
+          var tmp0_safe_receiver_0 = tmp_1 instanceof CompletedExceptionally() ? tmp_1 : null;
+          node.t21(tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.y1x_1);
+        }
+        return NonDisposableHandle_instance;
+      }
+      z1y($completion) {
+        if (!joinInternal(this)) {
+          // Inline function 'kotlin.js.getCoroutineContext' call
+          var tmp$ret$0 = $completion.gc();
+          ensureActive(tmp$ret$0);
+          return Unit_instance;
+        }
+        return joinSuspend(this, $completion);
+      }
+      a1z(node) {
+        // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+        while (true) {
+          var state = this.n1y();
+          if (state instanceof JobNode()) {
+            if (!(state === node))
+              return Unit_instance;
+            if (this.m1x_1.atomicfu$compareAndSet(state, get_EMPTY_ACTIVE()))
+              return Unit_instance;
+          } else {
+            if (!(state == null) ? isInterface(state, Incomplete()) : false) {
+              if (!(state.j24() == null)) {
+                node.o24();
+              }
+              return Unit_instance;
+            } else {
+              return Unit_instance;
+            }
+          }
+        }
+      }
+      b1z() {
+        return false;
+      }
+      c1z(cause) {
+        var tmp;
+        if (cause == null) {
+          // Inline function 'kotlinx.coroutines.JobSupport.defaultCancellationException' call
+          tmp = JobCancellationException().i27(null == null ? this.w1x() : null, null, this);
+        } else {
+          tmp = cause;
+        }
+        this.e1z(tmp);
+      }
+      w1x() {
+        return 'Job was cancelled';
+      }
+      e1z(cause) {
+        this.i1z(cause);
+      }
+      f1z(parentJob) {
+        this.i1z(parentJob);
+      }
+      g1z(cause) {
+        if (cause instanceof CancellationException())
+          return true;
+        return this.i1z(cause) && this.p1z();
+      }
+      h1z(cause) {
+        return this.i1z(cause);
+      }
+      i1z(cause) {
+        var finalState = get_COMPLETING_ALREADY();
+        if (this.b1z()) {
+          finalState = cancelMakeCompleting(this, cause);
+          if (finalState === get_COMPLETING_WAITING_CHILDREN())
+            return true;
+        }
+        if (finalState === get_COMPLETING_ALREADY()) {
+          finalState = makeCancelling(this, cause);
+        }
+        var tmp;
+        if (finalState === get_COMPLETING_ALREADY()) {
+          tmp = true;
+        } else if (finalState === get_COMPLETING_WAITING_CHILDREN()) {
+          tmp = true;
+        } else if (finalState === get_TOO_LATE_TO_CANCEL()) {
+          tmp = false;
+        } else {
+          this.d1y(finalState);
+          tmp = true;
+        }
+        return tmp;
+      }
+      j1z() {
+        var state = this.n1y();
+        var tmp;
+        if (state instanceof Finishing()) {
+          tmp = state.n27();
+        } else {
+          if (state instanceof CompletedExceptionally()) {
+            tmp = state.y1x_1;
+          } else {
+            if (!(state == null) ? isInterface(state, Incomplete()) : false) {
+              var message = 'Cannot be cancelling child in this state: ' + toString(state);
+              throw IllegalStateException().o4(toString(message));
+            } else {
+              tmp = null;
+            }
+          }
+        }
+        var rootCause = tmp;
+        var tmp1_elvis_lhs = rootCause instanceof CancellationException() ? rootCause : null;
+        return tmp1_elvis_lhs == null ? JobCancellationException().i27('Parent job is ' + stateString(this, state), rootCause, this) : tmp1_elvis_lhs;
+      }
+      k1z(proposedUpdate) {
+        // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+        while (true) {
+          var tmp0 = this.n1y();
+          $l$block: {
+            var finalState = tryMakeCompleting(this, tmp0, proposedUpdate);
+            if (finalState === get_COMPLETING_ALREADY())
+              return false;
+            else if (finalState === get_COMPLETING_WAITING_CHILDREN())
+              return true;
+            else if (finalState === get_COMPLETING_RETRY()) {
+              break $l$block;
+            } else {
+              this.d1y(finalState);
+              return true;
+            }
+          }
+        }
+      }
+      b1y(proposedUpdate) {
+        // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+        while (true) {
+          var tmp0 = this.n1y();
+          $l$block: {
+            var finalState = tryMakeCompleting(this, tmp0, proposedUpdate);
+            if (finalState === get_COMPLETING_ALREADY())
+              throw IllegalStateException().ed('Job ' + this.toString() + ' is already complete or completing, ' + ('but is being completed with ' + toString_0(proposedUpdate)), _get_exceptionOrNull__b3j7js(this, proposedUpdate));
+            else if (finalState === get_COMPLETING_RETRY()) {
+              break $l$block;
+            } else
+              return finalState;
+          }
+        }
+      }
+      l1z() {
+        return sequence(JobSupport$_get_children_$slambda_k839f8_0(this, null));
+      }
+      m1z(child) {
+        // Inline function 'kotlin.also' call
+        var this_0 = new (ChildHandleNode())(child);
+        this_0.h24_1 = this;
+        var node = this_0;
+        var tmp$ret$2;
+        $l$block_1: {
+          // Inline function 'kotlinx.coroutines.JobSupport.tryPutNodeIntoList' call
+          // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+          while (true) {
+            var state = this.n1y();
+            if (state instanceof Empty()) {
+              if (state.q26_1) {
+                if (this.m1x_1.atomicfu$compareAndSet(state, node)) {
+                  tmp$ret$2 = true;
+                  break $l$block_1;
+                }
+              } else {
+                promoteEmptyToNodeList(this, state);
+              }
+            } else {
+              if (!(state == null) ? isInterface(state, Incomplete()) : false) {
+                var list = state.j24();
+                if (list == null) {
+                  promoteSingleToNodeList(this, state instanceof JobNode() ? state : THROW_CCE());
+                } else {
+                  var addedBeforeCancellation = list.n24(node, 7);
+                  var tmp;
+                  if (addedBeforeCancellation) {
+                    tmp = true;
+                  } else {
+                    var addedBeforeCompletion = list.n24(node, 3);
+                    var latestState = this.n1y();
+                    var tmp_0;
+                    if (latestState instanceof Finishing()) {
+                      tmp_0 = latestState.n27();
+                    } else {
+                      // Inline function 'kotlinx.coroutines.assert' call
+                      var tmp0_safe_receiver = latestState instanceof CompletedExceptionally() ? latestState : null;
+                      tmp_0 = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.y1x_1;
+                    }
+                    var rootCause = tmp_0;
+                    node.t21(rootCause);
+                    var tmp_1;
+                    if (addedBeforeCompletion) {
+                      // Inline function 'kotlinx.coroutines.assert' call
+                      tmp_1 = true;
+                    } else {
+                      return NonDisposableHandle_instance;
+                    }
+                    tmp = tmp_1;
+                  }
+                  if (tmp) {
+                    tmp$ret$2 = true;
+                    break $l$block_1;
+                  }
+                }
+              } else {
+                tmp$ret$2 = false;
+                break $l$block_1;
+              }
+            }
+          }
+        }
+        var added = tmp$ret$2;
+        if (added)
+          return node;
+        var tmp_2 = this.n1y();
+        var tmp0_safe_receiver_0 = tmp_2 instanceof CompletedExceptionally() ? tmp_2 : null;
+        node.t21(tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.y1x_1);
+        return NonDisposableHandle_instance;
+      }
+      e1y(exception) {
+        throw exception;
+      }
+      n1z(cause) {
+      }
+      o1z() {
+        return false;
+      }
+      p1z() {
+        return true;
+      }
+      q1z(exception) {
+        return false;
+      }
+      x1x(state) {
+      }
+      d1y(state) {
+      }
+      toString() {
+        return this.r1z() + '@' + get_hexAddress(this);
+      }
+      r1z() {
+        return this.f1y() + '{' + stateString(this, this.n1y()) + '}';
+      }
+      f1y() {
+        return get_classSimpleName(this);
+      }
+      s1z() {
+        var state = this.n1y();
+        // Inline function 'kotlin.check' call
+        if (!!(!(state == null) ? isInterface(state, Incomplete()) : false)) {
+          var message = 'This job has not completed yet';
+          throw IllegalStateException().o4(toString(message));
+        }
+        return _get_exceptionOrNull__b3j7js(this, state);
+      }
+      t1z() {
+        var state = this.n1y();
+        // Inline function 'kotlin.check' call
+        if (!!(!(state == null) ? isInterface(state, Incomplete()) : false)) {
+          var message = 'This job has not completed yet';
+          throw IllegalStateException().o4(toString(message));
+        }
+        if (state instanceof CompletedExceptionally())
+          throw state.y1x_1;
+        return unboxState(state);
+      }
+      u1z($completion) {
+        $l$loop: while (true) {
+          var state = this.n1y();
+          if (!(!(state == null) ? isInterface(state, Incomplete()) : false)) {
+            if (state instanceof CompletedExceptionally()) {
+              // Inline function 'kotlinx.coroutines.internal.recoverAndThrow' call
+              throw state.y1x_1;
+            }
+            return unboxState(state);
+          }
+          if (startInternal(this, state) >= 0)
+            break $l$loop;
+        }
+        return awaitSuspend(this, $completion);
+      }
+    }
+    protoOf($).x1y = invokeOnCompletion$default;
+    protoOf($).d1z = cancel$default;
+    protoOf($).lm = plus;
+    protoOf($).nc = get;
+    protoOf($).km = fold;
+    protoOf($).jm = minusKey;
+    initMetadataForClass($, 'JobSupport', VOID, VOID, [Job(), ParentJob()], [0]);
+    JobSupportClass = $;
+  }
+  return JobSupportClass;
+}
+function boxIncomplete(_this__u8e3s4) {
+  _init_properties_JobSupport_kt__68f172();
+  var tmp;
+  if (!(_this__u8e3s4 == null) ? isInterface(_this__u8e3s4, Incomplete()) : false) {
+    tmp = new (IncompleteStateBox())(_this__u8e3s4);
+  } else {
+    tmp = _this__u8e3s4;
+  }
+  return tmp;
+}
+var InactiveNodeListClass;
+function InactiveNodeList() {
+  if (InactiveNodeListClass === VOID) {
+    class $ {
+      constructor(list) {
+        this.j27_1 = list;
+      }
+      j24() {
+        return this.j27_1;
+      }
+      t1x() {
+        return false;
+      }
+      toString() {
+        return get_DEBUG() ? this.j27_1.u26('New') : anyToString(this);
+      }
+    }
+    initMetadataForClass($, 'InactiveNodeList', VOID, VOID, [Incomplete()]);
+    InactiveNodeListClass = $;
+  }
+  return InactiveNodeListClass;
+}
+var InvokeOnCompletionClass;
+function InvokeOnCompletion() {
+  if (InvokeOnCompletionClass === VOID) {
+    class $ extends JobNode() {
+      constructor(handler) {
+        super();
+        this.m29_1 = handler;
+      }
+      d24() {
+        return false;
+      }
+      t21(cause) {
+        return this.m29_1(cause);
+      }
+    }
+    initMetadataForClass($, 'InvokeOnCompletion');
+    InvokeOnCompletionClass = $;
+  }
+  return InvokeOnCompletionClass;
+}
+var InvokeOnCancellingClass;
+function InvokeOnCancelling() {
+  if (InvokeOnCancellingClass === VOID) {
+    class $ extends JobNode() {
+      constructor(handler) {
+        super();
+        this.r29_1 = handler;
+        this.s29_1 = atomic$boolean$1(false);
+      }
+      d24() {
+        return true;
+      }
+      t21(cause) {
+        if (this.s29_1.atomicfu$compareAndSet(false, true))
+          this.r29_1(cause);
+      }
+    }
+    initMetadataForClass($, 'InvokeOnCancelling');
+    InvokeOnCancellingClass = $;
+  }
+  return InvokeOnCancellingClass;
+}
+var ResumeOnCompletionClass;
+function ResumeOnCompletion() {
+  if (ResumeOnCompletionClass === VOID) {
+    class $ extends JobNode() {
+      constructor(continuation) {
+        super();
+        this.x29_1 = continuation;
+      }
+      d24() {
+        return false;
+      }
+      t21(cause) {
+        // Inline function 'kotlin.coroutines.resume' call
+        var this_0 = this.x29_1;
+        // Inline function 'kotlin.Companion.success' call
+        var tmp$ret$0 = _Result___init__impl__xyqfz8(Unit_instance);
+        this_0.lc(tmp$ret$0);
+        return Unit_instance;
+      }
+    }
+    initMetadataForClass($, 'ResumeOnCompletion');
+    ResumeOnCompletionClass = $;
+  }
+  return ResumeOnCompletionClass;
+}
+var ChildHandleNodeClass;
+function ChildHandleNode() {
+  if (ChildHandleNodeClass === VOID) {
+    class $ extends JobNode() {
+      constructor(childJob) {
+        super();
+        this.t27_1 = childJob;
+      }
+      m1y() {
+        return this.i24();
+      }
+      d24() {
+        return true;
+      }
+      t21(cause) {
+        return this.t27_1.f1z(this.i24());
+      }
+      g1z(cause) {
+        return this.i24().g1z(cause);
+      }
+    }
+    initMetadataForClass($, 'ChildHandleNode');
+    ChildHandleNodeClass = $;
+  }
+  return ChildHandleNodeClass;
+}
+function unboxState(_this__u8e3s4) {
+  _init_properties_JobSupport_kt__68f172();
+  var tmp0_safe_receiver = _this__u8e3s4 instanceof IncompleteStateBox() ? _this__u8e3s4 : null;
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.y29_1;
+  return tmp1_elvis_lhs == null ? _this__u8e3s4 : tmp1_elvis_lhs;
+}
+var ResumeAwaitOnCompletionClass;
+function ResumeAwaitOnCompletion() {
+  if (ResumeAwaitOnCompletionClass === VOID) {
+    class $ extends JobNode() {
+      constructor(continuation) {
+        super();
+        this.d2a_1 = continuation;
+      }
+      d24() {
+        return false;
+      }
+      t21(cause) {
+        var state = this.i24().n1y();
+        // Inline function 'kotlinx.coroutines.assert' call
+        if (state instanceof CompletedExceptionally()) {
+          var tmp0 = this.d2a_1;
+          // Inline function 'kotlin.coroutines.resumeWithException' call
+          // Inline function 'kotlin.Companion.failure' call
+          var exception = state.y1x_1;
+          var tmp$ret$1 = _Result___init__impl__xyqfz8(createFailure(exception));
+          tmp0.lc(tmp$ret$1);
+        } else {
+          var tmp0_0 = this.d2a_1;
+          var tmp = unboxState(state);
+          // Inline function 'kotlin.coroutines.resume' call
+          // Inline function 'kotlin.Companion.success' call
+          var value = (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+          var tmp$ret$3 = _Result___init__impl__xyqfz8(value);
+          tmp0_0.lc(tmp$ret$3);
+        }
+      }
+    }
+    initMetadataForClass($, 'ResumeAwaitOnCompletion');
+    ResumeAwaitOnCompletionClass = $;
+  }
+  return ResumeAwaitOnCompletionClass;
+}
+var IncompleteStateBoxClass;
+function IncompleteStateBox() {
+  if (IncompleteStateBoxClass === VOID) {
+    class $ {
+      constructor(state) {
+        this.y29_1 = state;
+      }
+    }
+    initMetadataForClass($, 'IncompleteStateBox');
+    IncompleteStateBoxClass = $;
+  }
+  return IncompleteStateBoxClass;
+}
+function handlesExceptionF($this) {
+  var tmp = $this.l1y();
+  var tmp0_safe_receiver = tmp instanceof ChildHandleNode() ? tmp : null;
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.i24();
+  var tmp_0;
+  if (tmp1_elvis_lhs == null) {
+    return false;
+  } else {
+    tmp_0 = tmp1_elvis_lhs;
+  }
+  var parentJob = tmp_0;
+  while (true) {
+    if (parentJob.p1z())
+      return true;
+    var tmp_1 = parentJob.l1y();
+    var tmp2_safe_receiver = tmp_1 instanceof ChildHandleNode() ? tmp_1 : null;
+    var tmp3_elvis_lhs = tmp2_safe_receiver == null ? null : tmp2_safe_receiver.i24();
+    var tmp_2;
+    if (tmp3_elvis_lhs == null) {
+      return false;
+    } else {
+      tmp_2 = tmp3_elvis_lhs;
+    }
+    parentJob = tmp_2;
+  }
+}
+var JobImplClass;
+function JobImpl() {
+  if (JobImplClass === VOID) {
+    class $ extends JobSupport() {
+      constructor(parent) {
+        super(true);
+        this.o1x(parent);
+        this.g2a_1 = handlesExceptionF(this);
+      }
+      b1z() {
+        return true;
+      }
+      p1z() {
+        return this.g2a_1;
+      }
+      d25() {
+        return this.k1z(Unit_instance);
+      }
+      c25(exception) {
+        return this.k1z(new (CompletedExceptionally())(exception));
+      }
+    }
+    initMetadataForClass($, 'JobImpl', VOID, VOID, [JobSupport(), CompletableJob()], [0]);
+    JobImplClass = $;
+  }
+  return JobImplClass;
+}
+var properties_initialized_JobSupport_kt_5iq8a4;
+function _init_properties_JobSupport_kt__68f172() {
+  if (!properties_initialized_JobSupport_kt_5iq8a4) {
+    properties_initialized_JobSupport_kt_5iq8a4 = true;
+    COMPLETING_ALREADY = new (Symbol())('COMPLETING_ALREADY');
+    COMPLETING_WAITING_CHILDREN = new (Symbol())('COMPLETING_WAITING_CHILDREN');
+    COMPLETING_RETRY = new (Symbol())('COMPLETING_RETRY');
+    TOO_LATE_TO_CANCEL = new (Symbol())('TOO_LATE_TO_CANCEL');
+    SEALED = new (Symbol())('SEALED');
+    EMPTY_NEW = new (Empty())(false);
+    EMPTY_ACTIVE = new (Empty())(true);
+  }
+}
+//region block: exports
+export {
+  get_COMPLETING_WAITING_CHILDREN as get_COMPLETING_WAITING_CHILDREN3nnjgv5wv89p1,
+  JobImpl as JobImpl2fbttqo93wxua,
+  JobNode as JobNode2tu3g3s3xsko1,
+  JobSupport as JobSupport3fdjh0rbee4be,
+  unboxState as unboxStateze7t12boxn2m,
+};
+//endregion
+
+//# sourceMappingURL=JobSupport.mjs.map