@attocash/commons-test 6.0.0

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

@@ -0,0 +1,1761 @@
+import {
+  LockFreeLinkedListNode18403qmazubk5 as LockFreeLinkedListNode,
+  LockFreeLinkedListHeaduwhs9comnpmn as LockFreeLinkedListHead,
+} from './internal/LinkedList.mjs';
+import {
+  throwUninitializedPropertyAccessExceptionyynx7gkm73wd as throwUninitializedPropertyAccessException,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+} from '../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import {
+  get_classSimpleName2jgk6lzg9ft1 as get_classSimpleName,
+  get_hexAddress1mxa7txdmiojm as get_hexAddress,
+  get_DEBUG1a8uv2i5oid01 as get_DEBUG,
+} from './Debug.mjs';
+import {
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+} from '../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { ArrayList3it5z8td81qkl as ArrayList } from '../../../kotlin-kotlin-stdlib/kotlin/collections/ArrayListJs.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../kotlin-kotlin-stdlib/kotlin/Unit.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 {
+  equals2au1ep9vhcato as equals,
+  toString1pkumu07cwy4m as toString,
+  protoOf180f3jzyo7rfj as protoOf,
+  anyToString3ho3k49fc56mj as anyToString,
+} from '../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.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 {
+  plusolev77jfy5r9 as plus,
+  get6d5x931vk0s as get,
+  fold36i9psb7d5v48 as fold,
+  minusKeyyqanvso9aovh as minusKey,
+} from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineContext.mjs';
+import { CompletableJob1w6swnu15iclo as CompletableJob } from './CompletableJob.mjs';
+import { StringBuildermazzzhj6kkai as StringBuilder } from '../../../kotlin-kotlin-stdlib/kotlin/text/StringBuilderJs.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 { 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 JobNodeClass;
+function JobNode() {
+  if (JobNodeClass === VOID) {
+    class $ extends LockFreeLinkedListNode() {
+      yy() {
+        var tmp = this.xy_1;
+        if (!(tmp == null))
+          return tmp;
+        else {
+          throwUninitializedPropertyAccessException('job');
+        }
+      }
+      ct() {
+        return true;
+      }
+      zy() {
+        return null;
+      }
+      iw() {
+        return this.yy().ju(this);
+      }
+      toString() {
+        return get_classSimpleName(this) + '@' + get_hexAddress(this) + '[job@' + get_hexAddress(this.yy()) + ']';
+      }
+    }
+    initMetadataForClass($, 'JobNode', VOID, VOID, [LockFreeLinkedListNode(), Incomplete()]);
+    JobNodeClass = $;
+  }
+  return JobNodeClass;
+}
+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.s10_1;
+  return tmp1_elvis_lhs == null ? _this__u8e3s4 : tmp1_elvis_lhs;
+}
+function _set_exceptionsHolder__tqm22h($this, value) {
+  $this.w10_1.kotlinx$atomicfu$value = value;
+}
+function _get_exceptionsHolder__nhszp($this) {
+  return $this.w10_1.kotlinx$atomicfu$value;
+}
+function allocateList($this) {
+  return ArrayList().u(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.ht_1;
+  var wasCancelling;
+  // Inline function 'kotlinx.coroutines.internal.synchronized' call
+  // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
+  wasCancelling = state.x10();
+  var exceptions = state.y10(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.yu(finalException);
+    if (handled) {
+      (finalState instanceof CompletedExceptionally() ? finalState : THROW_CCE()).mx();
+    }
+  }
+  if (!wasCancelling) {
+    $this.vu(finalException);
+  }
+  $this.gt(finalState);
+  var casSuccess = $this.vs_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.o()) {
+    if (state.x10()) {
+      // Inline function 'kotlinx.coroutines.JobSupport.defaultCancellationException' call
+      return JobCancellationException().f11(null == null ? $this.ft() : null, null, $this);
+    }
+    return null;
+  }
+  var tmp$ret$2;
+  $l$block: {
+    // Inline function 'kotlin.collections.firstOrNull' call
+    var _iterator__ex2g4s = exceptions.k1();
+    while (_iterator__ex2g4s.l1()) {
+      var element = _iterator__ex2g4s.m1();
+      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.o1(0);
+  if (first instanceof TimeoutCancellationException()) {
+    var tmp$ret$4;
+    $l$block_0: {
+      // Inline function 'kotlin.collections.firstOrNull' call
+      var _iterator__ex2g4s_0 = exceptions.k1();
+      while (_iterator__ex2g4s_0.l1()) {
+        var element_0 = _iterator__ex2g4s_0.m1();
+        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.n1() <= 1)
+    return Unit_instance;
+  var seenExceptions = identitySet(exceptions.n1());
+  var unwrappedCause = unwrap(rootCause);
+  var _iterator__ex2g4s = exceptions.k1();
+  while (_iterator__ex2g4s.l1()) {
+    var exception = _iterator__ex2g4s.m1();
+    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.v(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.vs_1.atomicfu$compareAndSet(state, boxIncomplete(update)))
+    return false;
+  $this.vu(null);
+  $this.gt(update);
+  completeStateFinalization($this, state, update);
+  return true;
+}
+function completeStateFinalization($this, state, update) {
+  var tmp0_safe_receiver = $this.ut();
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    tmp0_safe_receiver.iw();
+    $this.tt(NonDisposableHandle_instance);
+  }
+  var tmp1_safe_receiver = update instanceof CompletedExceptionally() ? update : null;
+  var cause = tmp1_safe_receiver == null ? null : tmp1_safe_receiver.ht_1;
+  if (state instanceof JobNode()) {
+    try {
+      state.hw(cause);
+    } catch ($p) {
+      if ($p instanceof Error) {
+        var ex = $p;
+        $this.nt(CompletionHandlerException().dx('Exception in completion handler ' + state.toString() + ' for ' + $this.toString(), ex));
+      } else {
+        throw $p;
+      }
+    }
+  } else {
+    var tmp2_safe_receiver = state.zy();
+    if (tmp2_safe_receiver == null)
+      null;
+    else {
+      notifyCompletion($this, tmp2_safe_receiver, cause);
+    }
+  }
+}
+function notifyCancelling($this, list, cause) {
+  $this.vu(cause);
+  list.g11(4);
+  // Inline function 'kotlinx.coroutines.JobSupport.notifyHandlers' call
+  var exception = null;
+  // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListHead.forEach' call
+  var cur = list.az_1;
+  while (!equals(cur, list)) {
+    var node = cur;
+    var tmp;
+    if (node instanceof JobNode()) {
+      tmp = node.ty();
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      try {
+        node.hw(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().dx('Exception in completion handler ' + node.toString() + ' for ' + $this.toString(), ex);
+          }
+        } else {
+          throw $p;
+        }
+      }
+    }
+    cur = cur.az_1;
+  }
+  var tmp0_safe_receiver_0 = exception;
+  if (tmp0_safe_receiver_0 == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    $this.nt(tmp0_safe_receiver_0);
+  }
+  cancelParent($this, cause);
+}
+function cancelParent($this, cause) {
+  if ($this.wu())
+    return true;
+  var isCancellation = cause instanceof CancellationException();
+  var parent = $this.ut();
+  if (parent === null || parent === NonDisposableHandle_instance) {
+    return isCancellation;
+  }
+  return parent.pu(cause) || isCancellation;
+}
+function notifyCompletion($this, _this__u8e3s4, cause) {
+  _this__u8e3s4.g11(1);
+  // Inline function 'kotlinx.coroutines.JobSupport.notifyHandlers' call
+  var exception = null;
+  // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListHead.forEach' call
+  var cur = _this__u8e3s4.az_1;
+  while (!equals(cur, _this__u8e3s4)) {
+    var node = cur;
+    var tmp;
+    if (node instanceof JobNode()) {
+      tmp = true;
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      try {
+        node.hw(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().dx('Exception in completion handler ' + node.toString() + ' for ' + $this.toString(), ex);
+          }
+        } else {
+          throw $p;
+        }
+      }
+    }
+    cur = cur.az_1;
+  }
+  var tmp0_safe_receiver_0 = exception;
+  if (tmp0_safe_receiver_0 == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    $this.nt(tmp0_safe_receiver_0);
+  }
+}
+function startInternal($this, state) {
+  if (state instanceof Empty()) {
+    if (state.i11_1)
+      return 0;
+    if (!$this.vs_1.atomicfu$compareAndSet(state, get_EMPTY_ACTIVE()))
+      return -1;
+    $this.au();
+    return 1;
+  } else {
+    if (state instanceof InactiveNodeList()) {
+      if (!$this.vs_1.atomicfu$compareAndSet(state, state.h11_1))
+        return -1;
+      $this.au();
+      return 1;
+    } else {
+      return 0;
+    }
+  }
+}
+function promoteEmptyToNodeList($this, state) {
+  var list = new (NodeList())();
+  var update = state.i11_1 ? list : new (InactiveNodeList())(list);
+  $this.vs_1.atomicfu$compareAndSet(state, update);
+}
+function promoteSingleToNodeList($this, state) {
+  state.fz(new (NodeList())());
+  // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.nextNode' call
+  var list = state.az_1;
+  $this.vs_1.atomicfu$compareAndSet(state, list);
+}
+function joinInternal($this) {
+  // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+  while (true) {
+    var state = $this.wt();
+    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.px();
+  disposeOnCancellation(cancellable, invokeOnCompletion($this, VOID, new (ResumeOnCompletion())(cancellable)));
+  return cancellable.xx();
+}
+function cancelMakeCompleting($this, cause) {
+  // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+  while (true) {
+    var state = $this.wt();
+    var tmp;
+    if (!(!(state == null) ? isInterface(state, Incomplete()) : false)) {
+      tmp = true;
+    } else {
+      var tmp_0;
+      if (state instanceof Finishing()) {
+        tmp_0 = state.j11();
+      } 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().f11(null == null ? $this.ft() : null, null, $this);
+    } else {
+      tmp_0 = cause;
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = ((!(cause == null) ? isInterface(cause, ParentJob()) : false) ? cause : THROW_CCE()).su();
+  }
+  return tmp;
+}
+function makeCancelling($this, cause) {
+  var causeExceptionCache = null;
+  // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+  while (true) {
+    var tmp0 = $this.wt();
+    $l$block: {
+      if (tmp0 instanceof Finishing()) {
+        // Inline function 'kotlinx.coroutines.internal.synchronized' call
+        // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
+        if (tmp0.k11())
+          return get_TOO_LATE_TO_CANCEL();
+        var wasCancelling = tmp0.x10();
+        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.l11(causeException);
+        }
+        // Inline function 'kotlin.takeIf' call
+        var this_1 = tmp0.m11();
+        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.t10_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.ct()) {
+            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().w4(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.zy();
+  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().w4(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.vs_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.j11())
+    return get_COMPLETING_ALREADY();
+  finishing.n11(true);
+  if (!(finishing === state)) {
+    if (!$this.vs_1.atomicfu$compareAndSet(state, finishing))
+      return get_COMPLETING_RETRY();
+  }
+  // Inline function 'kotlinx.coroutines.assert' call
+  var wasCancelling = finishing.x10();
+  var tmp0_safe_receiver = proposedUpdate instanceof CompletedExceptionally() ? proposedUpdate : null;
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    finishing.l11(tmp0_safe_receiver.ht_1);
+  }
+  // Inline function 'kotlin.takeIf' call
+  var this_0 = finishing.m11();
+  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.g11(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.ht_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.s11_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.t10_1.g11(2);
+  var waitChildAgain = nextChild($this, lastChild);
+  if (!(waitChildAgain == null) && tryWaitForChild($this, state, waitChildAgain, proposedUpdate)) {
+    return Unit_instance;
+  }
+  var finalState = finalizeFinishingState($this, state, proposedUpdate);
+  $this.mt(finalState);
+}
+function nextChild($this, _this__u8e3s4) {
+  var cur = _this__u8e3s4;
+  $l$loop: while (true) {
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.isRemoved' call
+    if (!cur.cz_1) {
+      break $l$loop;
+    }
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.prevNode' call
+    cur = cur.bz_1;
+  }
+  $l$loop_0: while (true) {
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.nextNode' call
+    cur = cur.az_1;
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.isRemoved' call
+    if (cur.cz_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.x10() ? 'Cancelling' : state.j11() ? 'Completing' : 'Active';
+  } else {
+    if (!(state == null) ? isInterface(state, Incomplete()) : false) {
+      tmp = state.ct() ? '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.t10_1 = list;
+        this.u10_1 = atomic$boolean$1(isCompleting);
+        this.v10_1 = atomic$ref$1(rootCause);
+        this.w10_1 = atomic$ref$1(null);
+      }
+      zy() {
+        return this.t10_1;
+      }
+      n11(value) {
+        this.u10_1.kotlinx$atomicfu$value = value;
+      }
+      j11() {
+        return this.u10_1.kotlinx$atomicfu$value;
+      }
+      t11(value) {
+        this.v10_1.kotlinx$atomicfu$value = value;
+      }
+      m11() {
+        return this.v10_1.kotlinx$atomicfu$value;
+      }
+      k11() {
+        return _get_exceptionsHolder__nhszp(this) === get_SEALED();
+      }
+      x10() {
+        return !(this.m11() == null);
+      }
+      ct() {
+        return this.m11() == null;
+      }
+      y10(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.v(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().w4(toString(message));
+            }
+          }
+        }
+        var list = tmp;
+        var rootCause = this.m11();
+        if (rootCause == null)
+          null;
+        else {
+          // Inline function 'kotlin.let' call
+          list.s3(0, rootCause);
+        }
+        if (!(proposedException == null) && !equals(proposedException, rootCause)) {
+          list.v(proposedException);
+        }
+        _set_exceptionsHolder__tqm22h(this, get_SEALED());
+        return list;
+      }
+      l11(exception) {
+        var rootCause = this.m11();
+        if (rootCause == null) {
+          this.t11(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.v(eh);
+            this_0.v(exception);
+            _set_exceptionsHolder__tqm22h(this, this_0);
+          } else {
+            if (eh instanceof ArrayList()) {
+              (eh instanceof ArrayList() ? eh : THROW_CCE()).v(exception);
+            } else {
+              // Inline function 'kotlin.error' call
+              var message = 'State is ' + toString_0(eh);
+              throw IllegalStateException().w4(toString(message));
+            }
+          }
+        }
+      }
+      toString() {
+        return 'Finishing[cancelling=' + this.x10() + ', completing=' + this.j11() + ', rootCause=' + toString_0(this.m11()) + ', exceptions=' + toString_0(_get_exceptionsHolder__nhszp(this)) + ', list=' + this.t10_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.y11_1 = parent;
+        this.z11_1 = state;
+        this.a12_1 = child;
+        this.b12_1 = proposedUpdate;
+      }
+      ty() {
+        return false;
+      }
+      hw(cause) {
+        continueCompleting(this.y11_1, this.z11_1, this.a12_1, this.b12_1);
+      }
+    }
+    initMetadataForClass($, 'ChildCompletion');
+    ChildCompletionClass = $;
+  }
+  return ChildCompletionClass;
+}
+var AwaitContinuationClass;
+function AwaitContinuation() {
+  if (AwaitContinuationClass === VOID) {
+    class $ extends CancellableContinuationImpl() {
+      constructor(delegate, job) {
+        super(delegate, 1);
+        this.i12_1 = job;
+      }
+      wx(parent) {
+        var state = this.i12_1.wt();
+        if (state instanceof Finishing()) {
+          var tmp0_safe_receiver = state.m11();
+          if (tmp0_safe_receiver == null)
+            null;
+          else {
+            // Inline function 'kotlin.let' call
+            return tmp0_safe_receiver;
+          }
+        }
+        if (state instanceof CompletedExceptionally())
+          return state.ht_1;
+        return parent.bu();
+      }
+      ky() {
+        return 'AwaitContinuation';
+      }
+    }
+    initMetadataForClass($, 'AwaitContinuation');
+    AwaitContinuationClass = $;
+  }
+  return AwaitContinuationClass;
+}
+function awaitSuspend($this, $completion) {
+  var cont = new (AwaitContinuation())(intercepted($completion), $this);
+  cont.px();
+  disposeOnCancellation(cont, invokeOnCompletion($this, VOID, new (ResumeAwaitOnCompletion())(cont)));
+  return cont.xx();
+}
+var JobSupportClass;
+function JobSupport() {
+  if (JobSupportClass === VOID) {
+    class $ {
+      constructor(active) {
+        this.vs_1 = atomic$ref$1(active ? get_EMPTY_ACTIVE() : get_EMPTY_NEW());
+        this.ws_1 = atomic$ref$1(null);
+      }
+      y1() {
+        return Key_instance;
+      }
+      tt(value) {
+        this.ws_1.kotlinx$atomicfu$value = value;
+      }
+      ut() {
+        return this.ws_1.kotlinx$atomicfu$value;
+      }
+      vt() {
+        var tmp0_safe_receiver = this.ut();
+        return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.vt();
+      }
+      xs(parent) {
+        // Inline function 'kotlinx.coroutines.assert' call
+        if (parent == null) {
+          this.tt(NonDisposableHandle_instance);
+          return Unit_instance;
+        }
+        parent.zt();
+        var handle = parent.uu(this);
+        this.tt(handle);
+        if (this.xt()) {
+          handle.iw();
+          this.tt(NonDisposableHandle_instance);
+        }
+      }
+      wt() {
+        return this.vs_1.kotlinx$atomicfu$value;
+      }
+      ct() {
+        var state = this.wt();
+        var tmp;
+        if (!(state == null) ? isInterface(state, Incomplete()) : false) {
+          tmp = state.ct();
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      xt() {
+        var tmp = this.wt();
+        return !(!(tmp == null) ? isInterface(tmp, Incomplete()) : false);
+      }
+      yt() {
+        var state = this.wt();
+        var tmp;
+        if (state instanceof CompletedExceptionally()) {
+          tmp = true;
+        } else {
+          var tmp_0;
+          if (state instanceof Finishing()) {
+            tmp_0 = state.x10();
+          } else {
+            tmp_0 = false;
+          }
+          tmp = tmp_0;
+        }
+        return tmp;
+      }
+      zt() {
+        // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+        while (true) {
+          var state = this.wt();
+          var tmp0_subject = startInternal(this, state);
+          if (tmp0_subject === 0)
+            return false;
+          else if (tmp0_subject === 1)
+            return true;
+        }
+      }
+      au() {
+      }
+      bu() {
+        var state = this.wt();
+        var tmp;
+        if (state instanceof Finishing()) {
+          var tmp0_safe_receiver = state.m11();
+          var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : this.cu(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().w4(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().w4(toString(message_0));
+          } else {
+            if (state instanceof CompletedExceptionally()) {
+              tmp = this.du(state.ht_1);
+            } else {
+              tmp = JobCancellationException().f11(get_classSimpleName(this) + ' has completed normally', null, this);
+            }
+          }
+        }
+        return tmp;
+      }
+      cu(_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().f11(message == null ? this.ft() : message, _this__u8e3s4, this);
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        return tmp;
+      }
+      du(_this__u8e3s4, message, $super) {
+        message = message === VOID ? null : message;
+        return $super === VOID ? this.cu(_this__u8e3s4, message) : $super.cu.call(this, _this__u8e3s4, message);
+      }
+      eu(handler) {
+        return this.hu(true, new (InvokeOnCompletion())(handler));
+      }
+      fu(onCancelling, invokeImmediately, handler) {
+        var tmp;
+        if (onCancelling) {
+          tmp = new (InvokeOnCancelling())(handler);
+        } else {
+          tmp = new (InvokeOnCompletion())(handler);
+        }
+        return this.hu(invokeImmediately, tmp);
+      }
+      hu(invokeImmediately, node) {
+        node.xy_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.wt();
+            if (state instanceof Empty()) {
+              if (state.i11_1) {
+                if (this.vs_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.zy();
+                if (list == null) {
+                  promoteSingleToNodeList(this, state instanceof JobNode() ? state : THROW_CCE());
+                } else {
+                  var tmp;
+                  if (node.ty()) {
+                    var tmp0_safe_receiver = state instanceof Finishing() ? state : null;
+                    var rootCause = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.m11();
+                    var tmp_0;
+                    if (rootCause == null) {
+                      tmp_0 = list.dz(node, 5);
+                    } else {
+                      if (invokeImmediately) {
+                        node.hw(rootCause);
+                      }
+                      return NonDisposableHandle_instance;
+                    }
+                    tmp = tmp_0;
+                  } else {
+                    tmp = list.dz(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.wt();
+          var tmp0_safe_receiver_0 = tmp_1 instanceof CompletedExceptionally() ? tmp_1 : null;
+          node.hw(tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.ht_1);
+        }
+        return NonDisposableHandle_instance;
+      }
+      iu($completion) {
+        if (!joinInternal(this)) {
+          // Inline function 'kotlin.js.getCoroutineContext' call
+          var tmp$ret$0 = $completion.tb();
+          ensureActive(tmp$ret$0);
+          return Unit_instance;
+        }
+        return joinSuspend(this, $completion);
+      }
+      ju(node) {
+        // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+        while (true) {
+          var state = this.wt();
+          if (state instanceof JobNode()) {
+            if (!(state === node))
+              return Unit_instance;
+            if (this.vs_1.atomicfu$compareAndSet(state, get_EMPTY_ACTIVE()))
+              return Unit_instance;
+          } else {
+            if (!(state == null) ? isInterface(state, Incomplete()) : false) {
+              if (!(state.zy() == null)) {
+                node.ez();
+              }
+              return Unit_instance;
+            } else {
+              return Unit_instance;
+            }
+          }
+        }
+      }
+      ku() {
+        return false;
+      }
+      lu(cause) {
+        var tmp;
+        if (cause == null) {
+          // Inline function 'kotlinx.coroutines.JobSupport.defaultCancellationException' call
+          tmp = JobCancellationException().f11(null == null ? this.ft() : null, null, this);
+        } else {
+          tmp = cause;
+        }
+        this.nu(tmp);
+      }
+      ft() {
+        return 'Job was cancelled';
+      }
+      nu(cause) {
+        this.ru(cause);
+      }
+      ou(parentJob) {
+        this.ru(parentJob);
+      }
+      pu(cause) {
+        if (cause instanceof CancellationException())
+          return true;
+        return this.ru(cause) && this.xu();
+      }
+      qu(cause) {
+        return this.ru(cause);
+      }
+      ru(cause) {
+        var finalState = get_COMPLETING_ALREADY();
+        if (this.ku()) {
+          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.mt(finalState);
+          tmp = true;
+        }
+        return tmp;
+      }
+      su() {
+        var state = this.wt();
+        var tmp;
+        if (state instanceof Finishing()) {
+          tmp = state.m11();
+        } else {
+          if (state instanceof CompletedExceptionally()) {
+            tmp = state.ht_1;
+          } else {
+            if (!(state == null) ? isInterface(state, Incomplete()) : false) {
+              var message = 'Cannot be cancelling child in this state: ' + toString(state);
+              throw IllegalStateException().w4(toString(message));
+            } else {
+              tmp = null;
+            }
+          }
+        }
+        var rootCause = tmp;
+        var tmp1_elvis_lhs = rootCause instanceof CancellationException() ? rootCause : null;
+        return tmp1_elvis_lhs == null ? JobCancellationException().f11('Parent job is ' + stateString(this, state), rootCause, this) : tmp1_elvis_lhs;
+      }
+      tu(proposedUpdate) {
+        // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+        while (true) {
+          var tmp0 = this.wt();
+          $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.mt(finalState);
+              return true;
+            }
+          }
+        }
+      }
+      kt(proposedUpdate) {
+        // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+        while (true) {
+          var tmp0 = this.wt();
+          $l$block: {
+            var finalState = tryMakeCompleting(this, tmp0, proposedUpdate);
+            if (finalState === get_COMPLETING_ALREADY())
+              throw IllegalStateException().xc('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;
+          }
+        }
+      }
+      uu(child) {
+        // Inline function 'kotlin.also' call
+        var this_0 = new (ChildHandleNode())(child);
+        this_0.xy_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.wt();
+            if (state instanceof Empty()) {
+              if (state.i11_1) {
+                if (this.vs_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.zy();
+                if (list == null) {
+                  promoteSingleToNodeList(this, state instanceof JobNode() ? state : THROW_CCE());
+                } else {
+                  var addedBeforeCancellation = list.dz(node, 7);
+                  var tmp;
+                  if (addedBeforeCancellation) {
+                    tmp = true;
+                  } else {
+                    var addedBeforeCompletion = list.dz(node, 3);
+                    var latestState = this.wt();
+                    var tmp_0;
+                    if (latestState instanceof Finishing()) {
+                      tmp_0 = latestState.m11();
+                    } 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.ht_1;
+                    }
+                    var rootCause = tmp_0;
+                    node.hw(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.wt();
+        var tmp0_safe_receiver_0 = tmp_2 instanceof CompletedExceptionally() ? tmp_2 : null;
+        node.hw(tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.ht_1);
+        return NonDisposableHandle_instance;
+      }
+      nt(exception) {
+        throw exception;
+      }
+      vu(cause) {
+      }
+      wu() {
+        return false;
+      }
+      xu() {
+        return true;
+      }
+      yu(exception) {
+        return false;
+      }
+      gt(state) {
+      }
+      mt(state) {
+      }
+      toString() {
+        return this.zu() + '@' + get_hexAddress(this);
+      }
+      zu() {
+        return this.ot() + '{' + stateString(this, this.wt()) + '}';
+      }
+      ot() {
+        return get_classSimpleName(this);
+      }
+      av() {
+        var state = this.wt();
+        // Inline function 'kotlin.check' call
+        if (!!(!(state == null) ? isInterface(state, Incomplete()) : false)) {
+          var message = 'This job has not completed yet';
+          throw IllegalStateException().w4(toString(message));
+        }
+        return _get_exceptionOrNull__b3j7js(this, state);
+      }
+      bv() {
+        var state = this.wt();
+        // Inline function 'kotlin.check' call
+        if (!!(!(state == null) ? isInterface(state, Incomplete()) : false)) {
+          var message = 'This job has not completed yet';
+          throw IllegalStateException().w4(toString(message));
+        }
+        if (state instanceof CompletedExceptionally())
+          throw state.ht_1;
+        return unboxState(state);
+      }
+      cv($completion) {
+        $l$loop: while (true) {
+          var state = this.wt();
+          if (!(!(state == null) ? isInterface(state, Incomplete()) : false)) {
+            if (state instanceof CompletedExceptionally()) {
+              // Inline function 'kotlinx.coroutines.internal.recoverAndThrow' call
+              throw state.ht_1;
+            }
+            return unboxState(state);
+          }
+          if (startInternal(this, state) >= 0)
+            break $l$loop;
+        }
+        return awaitSuspend(this, $completion);
+      }
+    }
+    protoOf($).gu = invokeOnCompletion$default;
+    protoOf($).mu = cancel$default;
+    protoOf($).cl = plus;
+    protoOf($).gc = get;
+    protoOf($).bl = fold;
+    protoOf($).al = minusKey;
+    initMetadataForClass($, 'JobSupport', VOID, VOID, [Job(), ParentJob()], [0]);
+    JobSupportClass = $;
+  }
+  return JobSupportClass;
+}
+function handlesExceptionF($this) {
+  var tmp = $this.ut();
+  var tmp0_safe_receiver = tmp instanceof ChildHandleNode() ? tmp : null;
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.yy();
+  var tmp_0;
+  if (tmp1_elvis_lhs == null) {
+    return false;
+  } else {
+    tmp_0 = tmp1_elvis_lhs;
+  }
+  var parentJob = tmp_0;
+  while (true) {
+    if (parentJob.xu())
+      return true;
+    var tmp_1 = parentJob.ut();
+    var tmp2_safe_receiver = tmp_1 instanceof ChildHandleNode() ? tmp_1 : null;
+    var tmp3_elvis_lhs = tmp2_safe_receiver == null ? null : tmp2_safe_receiver.yy();
+    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.xs(parent);
+        this.l12_1 = handlesExceptionF(this);
+      }
+      ku() {
+        return true;
+      }
+      xu() {
+        return this.l12_1;
+      }
+      kz() {
+        return this.tu(Unit_instance);
+      }
+      jz(exception) {
+        return this.tu(new (CompletedExceptionally())(exception));
+      }
+    }
+    initMetadataForClass($, 'JobImpl', VOID, VOID, [JobSupport(), CompletableJob()], [0]);
+    JobImplClass = $;
+  }
+  return JobImplClass;
+}
+var EmptyClass;
+function Empty() {
+  if (EmptyClass === VOID) {
+    class $ {
+      constructor(isActive) {
+        this.i11_1 = isActive;
+      }
+      ct() {
+        return this.i11_1;
+      }
+      zy() {
+        return null;
+      }
+      toString() {
+        return 'Empty{' + (this.i11_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() {
+      ct() {
+        return true;
+      }
+      zy() {
+        return this;
+      }
+      p12(state) {
+        // Inline function 'kotlin.text.buildString' call
+        // Inline function 'kotlin.apply' call
+        var this_0 = StringBuilder().a1();
+        this_0.ib('List{');
+        this_0.ib(state);
+        this_0.ib('}[');
+        var first = true;
+        // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListHead.forEach' call
+        var cur = this.az_1;
+        while (!equals(cur, this)) {
+          var node = cur;
+          if (node instanceof JobNode()) {
+            if (first) {
+              first = false;
+            } else
+              this_0.ib(', ');
+            this_0.hb(node);
+          }
+          cur = cur.az_1;
+        }
+        this_0.ib(']');
+        return this_0.toString();
+      }
+      toString() {
+        return get_DEBUG() ? this.p12('Active') : super.toString();
+      }
+    }
+    initMetadataForClass($, 'NodeList', NodeList, VOID, [LockFreeLinkedListHead(), Incomplete()]);
+    NodeListClass = $;
+  }
+  return NodeListClass;
+}
+var IncompleteStateBoxClass;
+function IncompleteStateBox() {
+  if (IncompleteStateBoxClass === VOID) {
+    class $ {
+      constructor(state) {
+        this.s10_1 = state;
+      }
+    }
+    initMetadataForClass($, 'IncompleteStateBox');
+    IncompleteStateBoxClass = $;
+  }
+  return IncompleteStateBoxClass;
+}
+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.h11_1 = list;
+      }
+      zy() {
+        return this.h11_1;
+      }
+      ct() {
+        return false;
+      }
+      toString() {
+        return get_DEBUG() ? this.h11_1.p12('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.u12_1 = handler;
+      }
+      ty() {
+        return false;
+      }
+      hw(cause) {
+        return this.u12_1(cause);
+      }
+    }
+    initMetadataForClass($, 'InvokeOnCompletion');
+    InvokeOnCompletionClass = $;
+  }
+  return InvokeOnCompletionClass;
+}
+var InvokeOnCancellingClass;
+function InvokeOnCancelling() {
+  if (InvokeOnCancellingClass === VOID) {
+    class $ extends JobNode() {
+      constructor(handler) {
+        super();
+        this.z12_1 = handler;
+        this.a13_1 = atomic$boolean$1(false);
+      }
+      ty() {
+        return true;
+      }
+      hw(cause) {
+        if (this.a13_1.atomicfu$compareAndSet(false, true))
+          this.z12_1(cause);
+      }
+    }
+    initMetadataForClass($, 'InvokeOnCancelling');
+    InvokeOnCancellingClass = $;
+  }
+  return InvokeOnCancellingClass;
+}
+var ResumeOnCompletionClass;
+function ResumeOnCompletion() {
+  if (ResumeOnCompletionClass === VOID) {
+    class $ extends JobNode() {
+      constructor(continuation) {
+        super();
+        this.f13_1 = continuation;
+      }
+      ty() {
+        return false;
+      }
+      hw(cause) {
+        // Inline function 'kotlin.coroutines.resume' call
+        var this_0 = this.f13_1;
+        // Inline function 'kotlin.Companion.success' call
+        var tmp$ret$0 = _Result___init__impl__xyqfz8(Unit_instance);
+        this_0.vb(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.s11_1 = childJob;
+      }
+      vt() {
+        return this.yy();
+      }
+      ty() {
+        return true;
+      }
+      hw(cause) {
+        return this.s11_1.ou(this.yy());
+      }
+      pu(cause) {
+        return this.yy().pu(cause);
+      }
+    }
+    initMetadataForClass($, 'ChildHandleNode');
+    ChildHandleNodeClass = $;
+  }
+  return ChildHandleNodeClass;
+}
+var ResumeAwaitOnCompletionClass;
+function ResumeAwaitOnCompletion() {
+  if (ResumeAwaitOnCompletionClass === VOID) {
+    class $ extends JobNode() {
+      constructor(continuation) {
+        super();
+        this.k13_1 = continuation;
+      }
+      ty() {
+        return false;
+      }
+      hw(cause) {
+        var state = this.yy().wt();
+        // Inline function 'kotlinx.coroutines.assert' call
+        if (state instanceof CompletedExceptionally()) {
+          var tmp0 = this.k13_1;
+          // Inline function 'kotlin.coroutines.resumeWithException' call
+          // Inline function 'kotlin.Companion.failure' call
+          var exception = state.ht_1;
+          var tmp$ret$1 = _Result___init__impl__xyqfz8(createFailure(exception));
+          tmp0.vb(tmp$ret$1);
+        } else {
+          var tmp0_0 = this.k13_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.vb(tmp$ret$3);
+        }
+      }
+    }
+    initMetadataForClass($, 'ResumeAwaitOnCompletion');
+    ResumeAwaitOnCompletionClass = $;
+  }
+  return ResumeAwaitOnCompletionClass;
+}
+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