@continuous-excellence/coupling-cli 0.0.0

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

@@ -0,0 +1,1816 @@
+import {
+  LockFreeLinkedListNode18403qmazubk5 as LockFreeLinkedListNode,
+  LockFreeLinkedListHeaduwhs9comnpmn as LockFreeLinkedListHead,
+} from './internal/LinkedList.mjs';
+import { throwUninitializedPropertyAccessException14fok093f3k3t as throwUninitializedPropertyAccessException } from '../../../kotlin-kotlin-stdlib/kotlin/internal/ThrowHelpers.mjs';
+import {
+  get_classSimpleName2jgk6lzg9ft1 as get_classSimpleName,
+  get_hexAddress1mxa7txdmiojm as get_hexAddress,
+  get_DEBUG1a8uv2i5oid01 as get_DEBUG,
+} from './Debug.mjs';
+import {
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+  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 {
+  equals2au1ep9vhcato as equals,
+  toString1pkumu07cwy4m as toString,
+  protoOf180f3jzyo7rfj as protoOf,
+  anyToString3ho3k49fc56mj as anyToString,
+} from '../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { CompletedExceptionally3itrk74dxkv9s as CompletedExceptionally } from './CompletionState.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../kotlin-kotlin-stdlib/kotlin/hacks.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_instance24m7p1dk8gx40 as NonDisposableHandle_instance,
+  invokeOnCompletion3npqdfp2wzhn6 as invokeOnCompletion,
+  ParentJob1a3idoswyjefg as ParentJob,
+  Key_instance17dpgmdbeabno as Key_instance,
+  invokeOnCompletion$defaultev9m7gf4tqep as invokeOnCompletion$default,
+  ensureActive2yo7199srjlgl as ensureActive,
+  cancel$default3jli2aaano5py as cancel$default,
+  Job29shfjfygy86k as Job,
+} from './Job.mjs';
+import { CompletionHandlerException1h8udyjlr1wky as CompletionHandlerException } from './Exceptions.common.mjs';
+import {
+  intercepted2ogpsikxxj4u0 as intercepted,
+  suspendOrReturn49pspzlx5djv as suspendOrReturn,
+} 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 {
+  SequenceScope1coiso86pqzq2 as SequenceScope,
+  sequence2vgswtrxvqoa7 as sequence,
+} from '../../../kotlin-kotlin-stdlib/kotlin/sequences/SequenceBuilder.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_instance25ullnynvxd0w as Companion_instance,
+  _Result___init__impl__xyqfz83a5421h46yeyh 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() {
+      lz() {
+        var tmp = this.kz_1;
+        if (!(tmp == null))
+          return tmp;
+        else {
+          throwUninitializedPropertyAccessException('job');
+        }
+      }
+      jw() {
+        return true;
+      }
+      mz() {
+        return null;
+      }
+      zy() {
+        return this.lz().qx(this);
+      }
+      toString() {
+        return get_classSimpleName(this) + '@' + get_hexAddress(this) + '[job@' + get_hexAddress(this.lz()) + ']';
+      }
+    }
+    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.g15_1;
+  return tmp1_elvis_lhs == null ? _this__u8e3s4 : tmp1_elvis_lhs;
+}
+function _set_exceptionsHolder__tqm22h($this, value) {
+  $this.k15_1.kotlinx$atomicfu$value = value;
+}
+function _get_exceptionsHolder__nhszp($this) {
+  return $this.k15_1.kotlinx$atomicfu$value;
+}
+function allocateList($this) {
+  return ArrayList().w2(4);
+}
+function *_generator_invoke__zhh2q8($this, $this$sequence, $completion) {
+  var state = $this.l15_1.dx();
+  if (state instanceof ChildHandleNode()) {
+    var tmp = $this$sequence.um(state.q15_1, $completion);
+    if (tmp === get_COROUTINE_SUSPENDED())
+      tmp = yield tmp;
+  } else {
+    if (!(state == null) ? isInterface(state, Incomplete()) : false) {
+      var tmp0_safe_receiver = state.mz();
+      if (tmp0_safe_receiver == null)
+        null;
+      else {
+        // Inline function 'kotlin.let' call
+        // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListHead.forEach' call
+        var cur = tmp0_safe_receiver.nz_1;
+        while (!equals(cur, tmp0_safe_receiver)) {
+          var it = cur;
+          if (it instanceof ChildHandleNode()) {
+            var tmp_0 = $this$sequence.um(it.q15_1, $completion);
+            if (tmp_0 === get_COROUTINE_SUSPENDED())
+              tmp_0 = yield tmp_0;
+          }
+          cur = cur.nz_1;
+        }
+      }
+    }
+  }
+  return Unit_instance;
+}
+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.ow_1;
+  var wasCancelling;
+  // Inline function 'kotlinx.coroutines.internal.synchronized' call
+  // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
+  wasCancelling = state.r15();
+  var exceptions = state.s15(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.gy(finalException);
+    if (handled) {
+      (finalState instanceof CompletedExceptionally() ? finalState : THROW_CCE()).i12();
+    }
+  }
+  if (!wasCancelling) {
+    $this.dy(finalException);
+  }
+  $this.nw(finalState);
+  var casSuccess = $this.cw_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.o1()) {
+    if (state.r15()) {
+      // Inline function 'kotlinx.coroutines.JobSupport.defaultCancellationException' call
+      return JobCancellationException().z15(null == null ? $this.mw() : null, null, $this);
+    }
+    return null;
+  }
+  var tmp$ret$2;
+  $l$block: {
+    // Inline function 'kotlin.collections.firstOrNull' call
+    var _iterator__ex2g4s = exceptions.q1();
+    while (_iterator__ex2g4s.r1()) {
+      var element = _iterator__ex2g4s.s1();
+      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.u2(0);
+  if (first instanceof TimeoutCancellationException()) {
+    var tmp$ret$4;
+    $l$block_0: {
+      // Inline function 'kotlin.collections.firstOrNull' call
+      var _iterator__ex2g4s_0 = exceptions.q1();
+      while (_iterator__ex2g4s_0.r1()) {
+        var element_0 = _iterator__ex2g4s_0.s1();
+        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.v2() <= 1)
+    return Unit_instance;
+  var seenExceptions = identitySet(exceptions.v2());
+  var unwrappedCause = unwrap(rootCause);
+  var _iterator__ex2g4s = exceptions.q1();
+  while (_iterator__ex2g4s.r1()) {
+    var exception = _iterator__ex2g4s.s1();
+    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.t2(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.cw_1.atomicfu$compareAndSet(state, boxIncomplete(update)))
+    return false;
+  $this.dy(null);
+  $this.nw(update);
+  completeStateFinalization($this, state, update);
+  return true;
+}
+function completeStateFinalization($this, state, update) {
+  var tmp0_safe_receiver = $this.bx();
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    tmp0_safe_receiver.zy();
+    $this.ax(NonDisposableHandle_instance);
+  }
+  var tmp1_safe_receiver = update instanceof CompletedExceptionally() ? update : null;
+  var cause = tmp1_safe_receiver == null ? null : tmp1_safe_receiver.ow_1;
+  if (state instanceof JobNode()) {
+    try {
+      state.az(cause);
+    } catch ($p) {
+      if ($p instanceof Error) {
+        var ex = $p;
+        $this.uw(CompletionHandlerException().z11('Exception in completion handler ' + state.toString() + ' for ' + $this.toString(), ex));
+      } else {
+        throw $p;
+      }
+    }
+  } else {
+    var tmp2_safe_receiver = state.mz();
+    if (tmp2_safe_receiver == null)
+      null;
+    else {
+      notifyCompletion($this, tmp2_safe_receiver, cause);
+    }
+  }
+}
+function notifyCancelling($this, list, cause) {
+  $this.dy(cause);
+  list.a16(4);
+  // Inline function 'kotlinx.coroutines.JobSupport.notifyHandlers' call
+  var exception = null;
+  // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListHead.forEach' call
+  var cur = list.nz_1;
+  while (!equals(cur, list)) {
+    var node = cur;
+    var tmp;
+    if (node instanceof JobNode()) {
+      tmp = node.dz();
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      try {
+        node.az(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().z11('Exception in completion handler ' + node.toString() + ' for ' + $this.toString(), ex);
+          }
+        } else {
+          throw $p;
+        }
+      }
+    }
+    cur = cur.nz_1;
+  }
+  var tmp0_safe_receiver_0 = exception;
+  if (tmp0_safe_receiver_0 == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    $this.uw(tmp0_safe_receiver_0);
+  }
+  cancelParent($this, cause);
+}
+function cancelParent($this, cause) {
+  if ($this.ey())
+    return true;
+  var isCancellation = cause instanceof CancellationException();
+  var parent = $this.bx();
+  if (parent === null || parent === NonDisposableHandle_instance) {
+    return isCancellation;
+  }
+  return parent.wx(cause) || isCancellation;
+}
+function notifyCompletion($this, _this__u8e3s4, cause) {
+  _this__u8e3s4.a16(1);
+  // Inline function 'kotlinx.coroutines.JobSupport.notifyHandlers' call
+  var exception = null;
+  // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListHead.forEach' call
+  var cur = _this__u8e3s4.nz_1;
+  while (!equals(cur, _this__u8e3s4)) {
+    var node = cur;
+    var tmp;
+    if (node instanceof JobNode()) {
+      tmp = true;
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      try {
+        node.az(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().z11('Exception in completion handler ' + node.toString() + ' for ' + $this.toString(), ex);
+          }
+        } else {
+          throw $p;
+        }
+      }
+    }
+    cur = cur.nz_1;
+  }
+  var tmp0_safe_receiver_0 = exception;
+  if (tmp0_safe_receiver_0 == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    $this.uw(tmp0_safe_receiver_0);
+  }
+}
+function startInternal($this, state) {
+  if (state instanceof Empty()) {
+    if (state.c16_1)
+      return 0;
+    if (!$this.cw_1.atomicfu$compareAndSet(state, get_EMPTY_ACTIVE()))
+      return -1;
+    $this.hx();
+    return 1;
+  } else {
+    if (state instanceof InactiveNodeList()) {
+      if (!$this.cw_1.atomicfu$compareAndSet(state, state.b16_1))
+        return -1;
+      $this.hx();
+      return 1;
+    } else {
+      return 0;
+    }
+  }
+}
+function promoteEmptyToNodeList($this, state) {
+  var list = new (NodeList())();
+  var update = state.c16_1 ? list : new (InactiveNodeList())(list);
+  $this.cw_1.atomicfu$compareAndSet(state, update);
+}
+function promoteSingleToNodeList($this, state) {
+  state.sz(new (NodeList())());
+  // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.nextNode' call
+  var list = state.nz_1;
+  $this.cw_1.atomicfu$compareAndSet(state, list);
+}
+function joinInternal($this) {
+  // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+  while (true) {
+    var state = $this.dx();
+    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.zz();
+  disposeOnCancellation(cancellable, invokeOnCompletion($this, VOID, new (ResumeOnCompletion())(cancellable)));
+  return cancellable.a10();
+}
+function cancelMakeCompleting($this, cause) {
+  // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+  while (true) {
+    var state = $this.dx();
+    var tmp;
+    if (!(!(state == null) ? isInterface(state, Incomplete()) : false)) {
+      tmp = true;
+    } else {
+      var tmp_0;
+      if (state instanceof Finishing()) {
+        tmp_0 = state.d16();
+      } 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().z15(null == null ? $this.mw() : null, null, $this);
+    } else {
+      tmp_0 = cause;
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = ((!(cause == null) ? isInterface(cause, ParentJob()) : false) ? cause : THROW_CCE()).zx();
+  }
+  return tmp;
+}
+function makeCancelling($this, cause) {
+  var causeExceptionCache = null;
+  // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+  while (true) {
+    var tmp0 = $this.dx();
+    $l$block: {
+      if (tmp0 instanceof Finishing()) {
+        // Inline function 'kotlinx.coroutines.internal.synchronized' call
+        // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
+        if (tmp0.e16())
+          return get_TOO_LATE_TO_CANCEL();
+        var wasCancelling = tmp0.r15();
+        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.f16(causeException);
+        }
+        // Inline function 'kotlin.takeIf' call
+        var this_1 = tmp0.g16();
+        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.h15_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.jw()) {
+            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().o(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.mz();
+  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().o(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.cw_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.d16())
+    return get_COMPLETING_ALREADY();
+  finishing.h16(true);
+  if (!(finishing === state)) {
+    if (!$this.cw_1.atomicfu$compareAndSet(state, finishing))
+      return get_COMPLETING_RETRY();
+  }
+  // Inline function 'kotlinx.coroutines.assert' call
+  var wasCancelling = finishing.r15();
+  var tmp0_safe_receiver = proposedUpdate instanceof CompletedExceptionally() ? proposedUpdate : null;
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    finishing.f16(tmp0_safe_receiver.ow_1);
+  }
+  // Inline function 'kotlin.takeIf' call
+  var this_0 = finishing.g16();
+  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.a16(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.ow_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.q15_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.h15_1.a16(2);
+  var waitChildAgain = nextChild($this, lastChild);
+  if (!(waitChildAgain == null) && tryWaitForChild($this, state, waitChildAgain, proposedUpdate)) {
+    return Unit_instance;
+  }
+  var finalState = finalizeFinishingState($this, state, proposedUpdate);
+  $this.tw(finalState);
+}
+function nextChild($this, _this__u8e3s4) {
+  var cur = _this__u8e3s4;
+  $l$loop: while (true) {
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.isRemoved' call
+    if (!cur.pz_1) {
+      break $l$loop;
+    }
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.prevNode' call
+    cur = cur.oz_1;
+  }
+  $l$loop_0: while (true) {
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.nextNode' call
+    cur = cur.nz_1;
+    // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListNode.isRemoved' call
+    if (cur.pz_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.r15() ? 'Cancelling' : state.d16() ? 'Completing' : 'Active';
+  } else {
+    if (!(state == null) ? isInterface(state, Incomplete()) : false) {
+      tmp = state.jw() ? '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.h15_1 = list;
+        this.i15_1 = atomic$boolean$1(isCompleting);
+        this.j15_1 = atomic$ref$1(rootCause);
+        this.k15_1 = atomic$ref$1(null);
+      }
+      mz() {
+        return this.h15_1;
+      }
+      h16(value) {
+        this.i15_1.kotlinx$atomicfu$value = value;
+      }
+      d16() {
+        return this.i15_1.kotlinx$atomicfu$value;
+      }
+      i16(value) {
+        this.j15_1.kotlinx$atomicfu$value = value;
+      }
+      g16() {
+        return this.j15_1.kotlinx$atomicfu$value;
+      }
+      e16() {
+        return _get_exceptionsHolder__nhszp(this) === get_SEALED();
+      }
+      r15() {
+        return !(this.g16() == null);
+      }
+      jw() {
+        return this.g16() == null;
+      }
+      s15(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.t2(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().o(toString(message));
+            }
+          }
+        }
+        var list = tmp;
+        var rootCause = this.g16();
+        if (rootCause == null)
+          null;
+        else {
+          // Inline function 'kotlin.let' call
+          list.t4(0, rootCause);
+        }
+        if (!(proposedException == null) && !equals(proposedException, rootCause)) {
+          list.t2(proposedException);
+        }
+        _set_exceptionsHolder__tqm22h(this, get_SEALED());
+        return list;
+      }
+      f16(exception) {
+        var rootCause = this.g16();
+        if (rootCause == null) {
+          this.i16(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.t2(eh);
+            this_0.t2(exception);
+            _set_exceptionsHolder__tqm22h(this, this_0);
+          } else {
+            if (eh instanceof ArrayList()) {
+              (eh instanceof ArrayList() ? eh : THROW_CCE()).t2(exception);
+            } else {
+              // Inline function 'kotlin.error' call
+              var message = 'State is ' + toString_0(eh);
+              throw IllegalStateException().o(toString(message));
+            }
+          }
+        }
+      }
+      toString() {
+        return 'Finishing[cancelling=' + this.r15() + ', completing=' + this.d16() + ', rootCause=' + toString_0(this.g16()) + ', exceptions=' + toString_0(_get_exceptionsHolder__nhszp(this)) + ', list=' + this.h15_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.n16_1 = parent;
+        this.o16_1 = state;
+        this.p16_1 = child;
+        this.q16_1 = proposedUpdate;
+      }
+      dz() {
+        return false;
+      }
+      az(cause) {
+        continueCompleting(this.n16_1, this.o16_1, this.p16_1, this.q16_1);
+      }
+    }
+    initMetadataForClass($, 'ChildCompletion');
+    ChildCompletionClass = $;
+  }
+  return ChildCompletionClass;
+}
+var AwaitContinuationClass;
+function AwaitContinuation() {
+  if (AwaitContinuationClass === VOID) {
+    class $ extends CancellableContinuationImpl() {
+      constructor(delegate, job) {
+        super(delegate, 1);
+        this.x16_1 = job;
+      }
+      r12(parent) {
+        var state = this.x16_1.dx();
+        if (state instanceof Finishing()) {
+          var tmp0_safe_receiver = state.g16();
+          if (tmp0_safe_receiver == null)
+            null;
+          else {
+            // Inline function 'kotlin.let' call
+            return tmp0_safe_receiver;
+          }
+        }
+        if (state instanceof CompletedExceptionally())
+          return state.ow_1;
+        return parent.ix();
+      }
+      e13() {
+        return 'AwaitContinuation';
+      }
+    }
+    initMetadataForClass($, 'AwaitContinuation');
+    AwaitContinuationClass = $;
+  }
+  return AwaitContinuationClass;
+}
+function awaitSuspend($this, $completion) {
+  var cont = new (AwaitContinuation())(intercepted($completion), $this);
+  cont.zz();
+  disposeOnCancellation(cont, invokeOnCompletion($this, VOID, new (ResumeAwaitOnCompletion())(cont)));
+  return cont.a10();
+}
+var JobSupport$_get_children_$slambda_k839f8Class;
+function JobSupport$_get_children_$slambda_k839f8() {
+  if (JobSupport$_get_children_$slambda_k839f8Class === VOID) {
+    class $ {
+      constructor(this$0) {
+        this.l15_1 = this$0;
+      }
+      y16($this$sequence, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8.bind(VOID, this, $this$sequence), $completion);
+      }
+      de(p1, $completion) {
+        return this.y16(p1 instanceof SequenceScope() ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    JobSupport$_get_children_$slambda_k839f8Class = $;
+  }
+  return JobSupport$_get_children_$slambda_k839f8Class;
+}
+function JobSupport$_get_children_$slambda_k839f8_0(this$0) {
+  var i = new (JobSupport$_get_children_$slambda_k839f8())(this$0);
+  var l = ($this$sequence, $completion) => i.y16($this$sequence, $completion);
+  l.$arity = 1;
+  return l;
+}
+var JobSupportClass;
+function JobSupport() {
+  if (JobSupportClass === VOID) {
+    class $ {
+      constructor(active) {
+        this.cw_1 = atomic$ref$1(active ? get_EMPTY_ACTIVE() : get_EMPTY_NEW());
+        this.dw_1 = atomic$ref$1(null);
+      }
+      f3() {
+        return Key_instance;
+      }
+      ax(value) {
+        this.dw_1.kotlinx$atomicfu$value = value;
+      }
+      bx() {
+        return this.dw_1.kotlinx$atomicfu$value;
+      }
+      cx() {
+        var tmp0_safe_receiver = this.bx();
+        return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.cx();
+      }
+      ew(parent) {
+        // Inline function 'kotlinx.coroutines.assert' call
+        if (parent == null) {
+          this.ax(NonDisposableHandle_instance);
+          return Unit_instance;
+        }
+        parent.gx();
+        var handle = parent.cy(this);
+        this.ax(handle);
+        if (this.ex()) {
+          handle.zy();
+          this.ax(NonDisposableHandle_instance);
+        }
+      }
+      dx() {
+        return this.cw_1.kotlinx$atomicfu$value;
+      }
+      jw() {
+        var state = this.dx();
+        var tmp;
+        if (!(state == null) ? isInterface(state, Incomplete()) : false) {
+          tmp = state.jw();
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      ex() {
+        var tmp = this.dx();
+        return !(!(tmp == null) ? isInterface(tmp, Incomplete()) : false);
+      }
+      fx() {
+        var state = this.dx();
+        var tmp;
+        if (state instanceof CompletedExceptionally()) {
+          tmp = true;
+        } else {
+          var tmp_0;
+          if (state instanceof Finishing()) {
+            tmp_0 = state.r15();
+          } else {
+            tmp_0 = false;
+          }
+          tmp = tmp_0;
+        }
+        return tmp;
+      }
+      gx() {
+        // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+        while (true) {
+          var state = this.dx();
+          var tmp0_subject = startInternal(this, state);
+          if (tmp0_subject === 0)
+            return false;
+          else if (tmp0_subject === 1)
+            return true;
+        }
+      }
+      hx() {
+      }
+      ix() {
+        var state = this.dx();
+        var tmp;
+        if (state instanceof Finishing()) {
+          var tmp0_safe_receiver = state.g16();
+          var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : this.jx(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().o(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().o(toString(message_0));
+          } else {
+            if (state instanceof CompletedExceptionally()) {
+              tmp = this.kx(state.ow_1);
+            } else {
+              tmp = JobCancellationException().z15(get_classSimpleName(this) + ' has completed normally', null, this);
+            }
+          }
+        }
+        return tmp;
+      }
+      jx(_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().z15(message == null ? this.mw() : message, _this__u8e3s4, this);
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        return tmp;
+      }
+      kx(_this__u8e3s4, message, $super) {
+        message = message === VOID ? null : message;
+        return $super === VOID ? this.jx(_this__u8e3s4, message) : $super.jx.call(this, _this__u8e3s4, message);
+      }
+      lx(handler) {
+        return this.ox(true, new (InvokeOnCompletion())(handler));
+      }
+      mx(onCancelling, invokeImmediately, handler) {
+        var tmp;
+        if (onCancelling) {
+          tmp = new (InvokeOnCancelling())(handler);
+        } else {
+          tmp = new (InvokeOnCompletion())(handler);
+        }
+        return this.ox(invokeImmediately, tmp);
+      }
+      ox(invokeImmediately, node) {
+        node.kz_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.dx();
+            if (state instanceof Empty()) {
+              if (state.c16_1) {
+                if (this.cw_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.mz();
+                if (list == null) {
+                  promoteSingleToNodeList(this, state instanceof JobNode() ? state : THROW_CCE());
+                } else {
+                  var tmp;
+                  if (node.dz()) {
+                    var tmp0_safe_receiver = state instanceof Finishing() ? state : null;
+                    var rootCause = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.g16();
+                    var tmp_0;
+                    if (rootCause == null) {
+                      tmp_0 = list.qz(node, 5);
+                    } else {
+                      if (invokeImmediately) {
+                        node.az(rootCause);
+                      }
+                      return NonDisposableHandle_instance;
+                    }
+                    tmp = tmp_0;
+                  } else {
+                    tmp = list.qz(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.dx();
+          var tmp0_safe_receiver_0 = tmp_1 instanceof CompletedExceptionally() ? tmp_1 : null;
+          node.az(tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.ow_1);
+        }
+        return NonDisposableHandle_instance;
+      }
+      px($completion) {
+        if (!joinInternal(this)) {
+          // Inline function 'kotlin.js.getCoroutineContext' call
+          var tmp$ret$0 = $completion.bd();
+          ensureActive(tmp$ret$0);
+          return Unit_instance;
+        }
+        return joinSuspend(this, $completion);
+      }
+      qx(node) {
+        // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+        while (true) {
+          var state = this.dx();
+          if (state instanceof JobNode()) {
+            if (!(state === node))
+              return Unit_instance;
+            if (this.cw_1.atomicfu$compareAndSet(state, get_EMPTY_ACTIVE()))
+              return Unit_instance;
+          } else {
+            if (!(state == null) ? isInterface(state, Incomplete()) : false) {
+              if (!(state.mz() == null)) {
+                node.rz();
+              }
+              return Unit_instance;
+            } else {
+              return Unit_instance;
+            }
+          }
+        }
+      }
+      rx() {
+        return false;
+      }
+      sx(cause) {
+        var tmp;
+        if (cause == null) {
+          // Inline function 'kotlinx.coroutines.JobSupport.defaultCancellationException' call
+          tmp = JobCancellationException().z15(null == null ? this.mw() : null, null, this);
+        } else {
+          tmp = cause;
+        }
+        this.ux(tmp);
+      }
+      mw() {
+        return 'Job was cancelled';
+      }
+      ux(cause) {
+        this.yx(cause);
+      }
+      vx(parentJob) {
+        this.yx(parentJob);
+      }
+      wx(cause) {
+        if (cause instanceof CancellationException())
+          return true;
+        return this.yx(cause) && this.fy();
+      }
+      xx(cause) {
+        return this.yx(cause);
+      }
+      yx(cause) {
+        var finalState = get_COMPLETING_ALREADY();
+        if (this.rx()) {
+          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.tw(finalState);
+          tmp = true;
+        }
+        return tmp;
+      }
+      zx() {
+        var state = this.dx();
+        var tmp;
+        if (state instanceof Finishing()) {
+          tmp = state.g16();
+        } else {
+          if (state instanceof CompletedExceptionally()) {
+            tmp = state.ow_1;
+          } else {
+            if (!(state == null) ? isInterface(state, Incomplete()) : false) {
+              var message = 'Cannot be cancelling child in this state: ' + toString(state);
+              throw IllegalStateException().o(toString(message));
+            } else {
+              tmp = null;
+            }
+          }
+        }
+        var rootCause = tmp;
+        var tmp1_elvis_lhs = rootCause instanceof CancellationException() ? rootCause : null;
+        return tmp1_elvis_lhs == null ? JobCancellationException().z15('Parent job is ' + stateString(this, state), rootCause, this) : tmp1_elvis_lhs;
+      }
+      ay(proposedUpdate) {
+        // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+        while (true) {
+          var tmp0 = this.dx();
+          $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.tw(finalState);
+              return true;
+            }
+          }
+        }
+      }
+      rw(proposedUpdate) {
+        // Inline function 'kotlinx.coroutines.JobSupport.loopOnState' call
+        while (true) {
+          var tmp0 = this.dx();
+          $l$block: {
+            var finalState = tryMakeCompleting(this, tmp0, proposedUpdate);
+            if (finalState === get_COMPLETING_ALREADY())
+              throw IllegalStateException().q('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;
+          }
+        }
+      }
+      by() {
+        return sequence(JobSupport$_get_children_$slambda_k839f8_0(this));
+      }
+      cy(child) {
+        // Inline function 'kotlin.also' call
+        var this_0 = new (ChildHandleNode())(child);
+        this_0.kz_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.dx();
+            if (state instanceof Empty()) {
+              if (state.c16_1) {
+                if (this.cw_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.mz();
+                if (list == null) {
+                  promoteSingleToNodeList(this, state instanceof JobNode() ? state : THROW_CCE());
+                } else {
+                  var addedBeforeCancellation = list.qz(node, 7);
+                  var tmp;
+                  if (addedBeforeCancellation) {
+                    tmp = true;
+                  } else {
+                    var addedBeforeCompletion = list.qz(node, 3);
+                    var latestState = this.dx();
+                    var tmp_0;
+                    if (latestState instanceof Finishing()) {
+                      tmp_0 = latestState.g16();
+                    } 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.ow_1;
+                    }
+                    var rootCause = tmp_0;
+                    node.az(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.dx();
+        var tmp0_safe_receiver_0 = tmp_2 instanceof CompletedExceptionally() ? tmp_2 : null;
+        node.az(tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.ow_1);
+        return NonDisposableHandle_instance;
+      }
+      uw(exception) {
+        throw exception;
+      }
+      dy(cause) {
+      }
+      ey() {
+        return false;
+      }
+      fy() {
+        return true;
+      }
+      gy(exception) {
+        return false;
+      }
+      nw(state) {
+      }
+      tw(state) {
+      }
+      toString() {
+        return this.hy() + '@' + get_hexAddress(this);
+      }
+      hy() {
+        return this.vw() + '{' + stateString(this, this.dx()) + '}';
+      }
+      vw() {
+        return get_classSimpleName(this);
+      }
+      iy() {
+        var state = this.dx();
+        // Inline function 'kotlin.check' call
+        if (!!(!(state == null) ? isInterface(state, Incomplete()) : false)) {
+          var message = 'This job has not completed yet';
+          throw IllegalStateException().o(toString(message));
+        }
+        if (state instanceof CompletedExceptionally())
+          throw state.ow_1;
+        return unboxState(state);
+      }
+      jy($completion) {
+        $l$loop: while (true) {
+          var state = this.dx();
+          if (!(!(state == null) ? isInterface(state, Incomplete()) : false)) {
+            if (state instanceof CompletedExceptionally()) {
+              // Inline function 'kotlinx.coroutines.internal.recoverAndThrow' call
+              throw state.ow_1;
+            }
+            return unboxState(state);
+          }
+          if (startInternal(this, state) >= 0)
+            break $l$loop;
+        }
+        return awaitSuspend(this, $completion);
+      }
+    }
+    protoOf($).nx = invokeOnCompletion$default;
+    protoOf($).tx = cancel$default;
+    protoOf($).wo = plus;
+    protoOf($).rd = get;
+    protoOf($).vo = fold;
+    protoOf($).uo = minusKey;
+    initMetadataForClass($, 'JobSupport', VOID, VOID, [Job(), ParentJob()], [0]);
+    JobSupportClass = $;
+  }
+  return JobSupportClass;
+}
+function handlesExceptionF($this) {
+  var tmp = $this.bx();
+  var tmp0_safe_receiver = tmp instanceof ChildHandleNode() ? tmp : null;
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.lz();
+  var tmp_0;
+  if (tmp1_elvis_lhs == null) {
+    return false;
+  } else {
+    tmp_0 = tmp1_elvis_lhs;
+  }
+  var parentJob = tmp_0;
+  while (true) {
+    if (parentJob.fy())
+      return true;
+    var tmp_1 = parentJob.bx();
+    var tmp2_safe_receiver = tmp_1 instanceof ChildHandleNode() ? tmp_1 : null;
+    var tmp3_elvis_lhs = tmp2_safe_receiver == null ? null : tmp2_safe_receiver.lz();
+    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.ew(parent);
+        this.b17_1 = handlesExceptionF(this);
+      }
+      rx() {
+        return true;
+      }
+      fy() {
+        return this.b17_1;
+      }
+      r13() {
+        return this.ay(Unit_instance);
+      }
+      q13(exception) {
+        return this.ay(new (CompletedExceptionally())(exception));
+      }
+    }
+    initMetadataForClass($, 'JobImpl', VOID, VOID, [JobSupport(), CompletableJob()], [0]);
+    JobImplClass = $;
+  }
+  return JobImplClass;
+}
+var EmptyClass;
+function Empty() {
+  if (EmptyClass === VOID) {
+    class $ {
+      constructor(isActive) {
+        this.c16_1 = isActive;
+      }
+      jw() {
+        return this.c16_1;
+      }
+      mz() {
+        return null;
+      }
+      toString() {
+        return 'Empty{' + (this.c16_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() {
+      jw() {
+        return true;
+      }
+      mz() {
+        return this;
+      }
+      f17(state) {
+        // Inline function 'kotlin.text.buildString' call
+        // Inline function 'kotlin.apply' call
+        var this_0 = StringBuilder().m1();
+        this_0.n1('List{');
+        this_0.n1(state);
+        this_0.n1('}[');
+        var first = true;
+        // Inline function 'kotlinx.coroutines.internal.LockFreeLinkedListHead.forEach' call
+        var cur = this.nz_1;
+        while (!equals(cur, this)) {
+          var node = cur;
+          if (node instanceof JobNode()) {
+            if (first) {
+              first = false;
+            } else
+              this_0.n1(', ');
+            this_0.t1(node);
+          }
+          cur = cur.nz_1;
+        }
+        this_0.n1(']');
+        return this_0.toString();
+      }
+      toString() {
+        return get_DEBUG() ? this.f17('Active') : super.toString();
+      }
+    }
+    initMetadataForClass($, 'NodeList', NodeList, VOID, [LockFreeLinkedListHead(), Incomplete()]);
+    NodeListClass = $;
+  }
+  return NodeListClass;
+}
+var IncompleteStateBoxClass;
+function IncompleteStateBox() {
+  if (IncompleteStateBoxClass === VOID) {
+    class $ {
+      constructor(state) {
+        this.g15_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.b16_1 = list;
+      }
+      mz() {
+        return this.b16_1;
+      }
+      jw() {
+        return false;
+      }
+      toString() {
+        return get_DEBUG() ? this.b16_1.f17('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.k17_1 = handler;
+      }
+      dz() {
+        return false;
+      }
+      az(cause) {
+        return this.k17_1(cause);
+      }
+    }
+    initMetadataForClass($, 'InvokeOnCompletion');
+    InvokeOnCompletionClass = $;
+  }
+  return InvokeOnCompletionClass;
+}
+var InvokeOnCancellingClass;
+function InvokeOnCancelling() {
+  if (InvokeOnCancellingClass === VOID) {
+    class $ extends JobNode() {
+      constructor(handler) {
+        super();
+        this.p17_1 = handler;
+        this.q17_1 = atomic$boolean$1(false);
+      }
+      dz() {
+        return true;
+      }
+      az(cause) {
+        if (this.q17_1.atomicfu$compareAndSet(false, true))
+          this.p17_1(cause);
+      }
+    }
+    initMetadataForClass($, 'InvokeOnCancelling');
+    InvokeOnCancellingClass = $;
+  }
+  return InvokeOnCancellingClass;
+}
+var ResumeOnCompletionClass;
+function ResumeOnCompletion() {
+  if (ResumeOnCompletionClass === VOID) {
+    class $ extends JobNode() {
+      constructor(continuation) {
+        super();
+        this.v17_1 = continuation;
+      }
+      dz() {
+        return false;
+      }
+      az(cause) {
+        // Inline function 'kotlin.coroutines.resume' call
+        var this_0 = this.v17_1;
+        // Inline function 'kotlin.Companion.success' call
+        var tmp$ret$0 = _Result___init__impl__xyqfz8(Unit_instance);
+        this_0.dd(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.q15_1 = childJob;
+      }
+      cx() {
+        return this.lz();
+      }
+      dz() {
+        return true;
+      }
+      az(cause) {
+        return this.q15_1.vx(this.lz());
+      }
+      wx(cause) {
+        return this.lz().wx(cause);
+      }
+    }
+    initMetadataForClass($, 'ChildHandleNode');
+    ChildHandleNodeClass = $;
+  }
+  return ChildHandleNodeClass;
+}
+var ResumeAwaitOnCompletionClass;
+function ResumeAwaitOnCompletion() {
+  if (ResumeAwaitOnCompletionClass === VOID) {
+    class $ extends JobNode() {
+      constructor(continuation) {
+        super();
+        this.a18_1 = continuation;
+      }
+      dz() {
+        return false;
+      }
+      az(cause) {
+        var state = this.lz().dx();
+        // Inline function 'kotlinx.coroutines.assert' call
+        if (state instanceof CompletedExceptionally()) {
+          var tmp0 = this.a18_1;
+          // Inline function 'kotlin.coroutines.resumeWithException' call
+          // Inline function 'kotlin.Companion.failure' call
+          var exception = state.ow_1;
+          var tmp$ret$1 = _Result___init__impl__xyqfz8(createFailure(exception));
+          tmp0.dd(tmp$ret$1);
+        } else {
+          var tmp0_0 = this.a18_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.dd(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