@attocash/commons-test 6.0.0

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

@@ -0,0 +1,868 @@
+import {
+  get_classSimpleName2jgk6lzg9ft1 as get_classSimpleName,
+  get_hexAddress1mxa7txdmiojm as get_hexAddress,
+} from './Debug.mjs';
+import {
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+} from '../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  CancelledContinuation2f46cx697kdhx as CancelledContinuation,
+  CompletedExceptionally3itrk74dxkv9s as CompletedExceptionally,
+  toState1u6l586qexaz7 as toState,
+} from './CompletionState.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { DispatchedContinuation8kf77e5g2ha2 as DispatchedContinuation } from './internal/DispatchedContinuation.mjs';
+import {
+  get_isReusableMode36u17a15bfmkj as get_isReusableMode,
+  dispatch2sf9j0r16c3zo as dispatch,
+  get_isCancellableMode2kisg4oawmpb2 as get_isCancellableMode,
+  DispatchedTask39ez3ayqqzt3m as DispatchedTask,
+} from './DispatchedTask.mjs';
+import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import {
+  toString1pkumu07cwy4m as toString,
+  hashCodeq5arwsb9dgti as hashCode,
+  equals2au1ep9vhcato as equals,
+} from '../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { CompletionHandlerException1h8udyjlr1wky as CompletionHandlerException } from './Exceptions.common.mjs';
+import { handleCoroutineExceptionv1m1bdk4j2te as handleCoroutineException } from './CoroutineExceptionHandler.mjs';
+import {
+  Key_instance2tirv2rj82ml4 as Key_instance,
+  invokeOnCompletion3npqdfp2wzhn6 as invokeOnCompletion,
+  NonDisposableHandle_instance3k5b81ogrgecy as NonDisposableHandle_instance,
+} from './Job.mjs';
+import { Segmentqmq1glevgieu as Segment } from './internal/ConcurrentLinkedList.mjs';
+import { toString30pk9tzaqopn as toString_0 } from '../../../kotlin-kotlin-stdlib/kotlin/Library.mjs';
+import {
+  atomic$int$11d5swdyn6j0pu as atomic$int$1,
+  atomic$ref$130aurmcwdfdf1 as atomic$ref$1,
+} from '../../../kotlinx-atomicfu/kotlinx/atomicfu/AtomicFU.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { recoverStackTrace2i3si2i8nvw1k as recoverStackTrace } from './internal/StackTraceRecovery.mjs';
+import {
+  invokeOnCancellationb68niwbjdmgy as invokeOnCancellation,
+  CancellableContinuationpb2x00mxmcbt as CancellableContinuation,
+} from './CancellableContinuation.mjs';
+import { toDebugString2sjrkc0z7k0mx as toDebugString } from './CoroutineContext.mjs';
+import { Waiter3lxa2a79zyo0g as Waiter } from './Waiter.mjs';
+import { JobNode2tu3g3s3xsko1 as JobNode } from './JobSupport.mjs';
+import { Symbol17xuwzgi5g8ve as Symbol } from './internal/Symbol.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+//endregion
+function get_RESUME_TOKEN() {
+  _init_properties_CancellableContinuationImpl_kt__6rrtdd();
+  return RESUME_TOKEN;
+}
+var RESUME_TOKEN;
+var UserSuppliedClass;
+function UserSupplied() {
+  if (UserSuppliedClass === VOID) {
+    class $ {
+      constructor(handler) {
+        this.rw_1 = handler;
+      }
+      hw(cause) {
+        this.rw_1(cause);
+      }
+      toString() {
+        return 'CancelHandler.UserSupplied[' + get_classSimpleName(this.rw_1) + '@' + get_hexAddress(this) + ']';
+      }
+    }
+    initMetadataForClass($, 'UserSupplied', VOID, VOID, [CancelHandler()]);
+    UserSuppliedClass = $;
+  }
+  return UserSuppliedClass;
+}
+var CancelHandlerClass;
+function CancelHandler() {
+  if (CancelHandlerClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'CancelHandler', VOID, VOID, [NotCompleted()]);
+    CancelHandlerClass = $;
+  }
+  return CancelHandlerClass;
+}
+function _get_parentHandle__f8dcex($this) {
+  return $this.ew_1.kotlinx$atomicfu$value;
+}
+function _get_stateDebugRepresentation__bf18u4($this) {
+  var tmp0_subject = $this.wt();
+  var tmp;
+  if (!(tmp0_subject == null) ? isInterface(tmp0_subject, NotCompleted()) : false) {
+    tmp = 'Active';
+  } else {
+    if (tmp0_subject instanceof CancelledContinuation()) {
+      tmp = 'Cancelled';
+    } else {
+      tmp = 'Completed';
+    }
+  }
+  return tmp;
+}
+function isReusable($this) {
+  var tmp;
+  if (get_isReusableMode($this.tw_1)) {
+    var tmp_0 = $this.aw_1;
+    tmp = (tmp_0 instanceof DispatchedContinuation() ? tmp_0 : THROW_CCE()).sw();
+  } else {
+    tmp = false;
+  }
+  return tmp;
+}
+function cancelLater($this, cause) {
+  if (!isReusable($this))
+    return false;
+  var tmp = $this.aw_1;
+  var dispatched = tmp instanceof DispatchedContinuation() ? tmp : THROW_CCE();
+  return dispatched.uw(cause);
+}
+function callSegmentOnCancellation($this, segment, cause) {
+  // Inline function 'kotlinx.coroutines.index' call
+  var index = $this.cw_1.kotlinx$atomicfu$value & 536870911;
+  // Inline function 'kotlin.check' call
+  if (!!(index === 536870911)) {
+    var message = 'The index for Segment.onCancellation(..) is broken';
+    throw IllegalStateException().w4(toString(message));
+  }
+  // Inline function 'kotlinx.coroutines.CancellableContinuationImpl.callCancelHandlerSafely' call
+  try {
+    segment.zw(index, cause, $this.tb());
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var ex = $p;
+      handleCoroutineException($this.tb(), CompletionHandlerException().dx('Exception in invokeOnCancellation handler for ' + $this.toString(), ex));
+    } else {
+      throw $p;
+    }
+  }
+}
+function trySuspend($this) {
+  // Inline function 'kotlinx.atomicfu.loop' call
+  var this_0 = $this.cw_1;
+  while (true) {
+    var cur = this_0.kotlinx$atomicfu$value;
+    // Inline function 'kotlinx.coroutines.decision' call
+    switch (cur >> 29) {
+      case 0:
+        // Inline function 'kotlinx.coroutines.index' call
+
+        // Inline function 'kotlinx.coroutines.decisionAndIndex' call
+
+        var tmp$ret$2 = (1 << 29) + (cur & 536870911) | 0;
+        if ($this.cw_1.atomicfu$compareAndSet(cur, tmp$ret$2))
+          return true;
+        break;
+      case 2:
+        return false;
+      default:
+        // Inline function 'kotlin.error' call
+
+        var message = 'Already suspended';
+        throw IllegalStateException().w4(toString(message));
+    }
+  }
+}
+function tryResume($this) {
+  // Inline function 'kotlinx.atomicfu.loop' call
+  var this_0 = $this.cw_1;
+  while (true) {
+    var cur = this_0.kotlinx$atomicfu$value;
+    // Inline function 'kotlinx.coroutines.decision' call
+    switch (cur >> 29) {
+      case 0:
+        // Inline function 'kotlinx.coroutines.index' call
+
+        // Inline function 'kotlinx.coroutines.decisionAndIndex' call
+
+        var tmp$ret$2 = (2 << 29) + (cur & 536870911) | 0;
+        if ($this.cw_1.atomicfu$compareAndSet(cur, tmp$ret$2))
+          return true;
+        break;
+      case 1:
+        return false;
+      default:
+        // Inline function 'kotlin.error' call
+
+        var message = 'Already resumed';
+        throw IllegalStateException().w4(toString(message));
+    }
+  }
+}
+function installParentHandle($this) {
+  var tmp0_elvis_lhs = $this.tb().gc(Key_instance);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    return null;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var parent = tmp;
+  var handle = invokeOnCompletion(parent, VOID, new (ChildContinuation())($this));
+  $this.ew_1.atomicfu$compareAndSet(null, handle);
+  return handle;
+}
+function invokeOnCancellationImpl($this, handler) {
+  // Inline function 'kotlinx.coroutines.assert' call
+  // Inline function 'kotlinx.atomicfu.loop' call
+  var this_0 = $this.dw_1;
+  while (true) {
+    var state = this_0.kotlinx$atomicfu$value;
+    if (state instanceof Active()) {
+      if ($this.dw_1.atomicfu$compareAndSet(state, handler))
+        return Unit_instance;
+    } else {
+      var tmp;
+      if (!(state == null) ? isInterface(state, CancelHandler()) : false) {
+        tmp = true;
+      } else {
+        tmp = state instanceof Segment();
+      }
+      if (tmp) {
+        multipleHandlersError($this, handler, state);
+      } else {
+        if (state instanceof CompletedExceptionally()) {
+          if (!state.mx()) {
+            multipleHandlersError($this, handler, state);
+          }
+          if (state instanceof CancelledContinuation()) {
+            var tmp1_safe_receiver = state instanceof CompletedExceptionally() ? state : null;
+            var cause = tmp1_safe_receiver == null ? null : tmp1_safe_receiver.ht_1;
+            if (isInterface(handler, CancelHandler())) {
+              $this.jx(handler, cause);
+            } else {
+              var segment = handler instanceof Segment() ? handler : THROW_CCE();
+              callSegmentOnCancellation($this, segment, cause);
+            }
+          }
+          return Unit_instance;
+        } else {
+          if (state instanceof CompletedContinuation()) {
+            if (!(state.fx_1 == null)) {
+              multipleHandlersError($this, handler, state);
+            }
+            if (handler instanceof Segment())
+              return Unit_instance;
+            if (!isInterface(handler, CancelHandler()))
+              THROW_CCE();
+            if (state.kx()) {
+              $this.jx(handler, state.ix_1);
+              return Unit_instance;
+            }
+            var update = state.lx(VOID, handler);
+            if ($this.dw_1.atomicfu$compareAndSet(state, update))
+              return Unit_instance;
+          } else {
+            if (handler instanceof Segment())
+              return Unit_instance;
+            if (!isInterface(handler, CancelHandler()))
+              THROW_CCE();
+            var update_0 = new (CompletedContinuation())(state, handler);
+            if ($this.dw_1.atomicfu$compareAndSet(state, update_0))
+              return Unit_instance;
+          }
+        }
+      }
+    }
+  }
+}
+function multipleHandlersError($this, handler, state) {
+  // Inline function 'kotlin.error' call
+  var message = "It's prohibited to register multiple handlers, tried to register " + toString(handler) + ', already has ' + toString_0(state);
+  throw IllegalStateException().w4(toString(message));
+}
+function dispatchResume($this, mode) {
+  if (tryResume($this))
+    return Unit_instance;
+  dispatch($this, mode);
+}
+function resumedState($this, state, proposedUpdate, resumeMode, onCancellation, idempotent) {
+  var tmp;
+  if (proposedUpdate instanceof CompletedExceptionally()) {
+    // Inline function 'kotlinx.coroutines.assert' call
+    // Inline function 'kotlinx.coroutines.assert' call
+    tmp = proposedUpdate;
+  } else {
+    if (!get_isCancellableMode(resumeMode) && idempotent == null) {
+      tmp = proposedUpdate;
+    } else {
+      var tmp_0;
+      var tmp_1;
+      if (!(onCancellation == null)) {
+        tmp_1 = true;
+      } else {
+        tmp_1 = isInterface(state, CancelHandler());
+      }
+      if (tmp_1) {
+        tmp_0 = true;
+      } else {
+        tmp_0 = !(idempotent == null);
+      }
+      if (tmp_0) {
+        tmp = new (CompletedContinuation())(proposedUpdate, isInterface(state, CancelHandler()) ? state : null, onCancellation, idempotent);
+      } else {
+        tmp = proposedUpdate;
+      }
+    }
+  }
+  return tmp;
+}
+function tryResumeImpl($this, proposedUpdate, idempotent, onCancellation) {
+  // Inline function 'kotlinx.atomicfu.loop' call
+  var this_0 = $this.dw_1;
+  while (true) {
+    var tmp0 = this_0.kotlinx$atomicfu$value;
+    $l$block: {
+      if (!(tmp0 == null) ? isInterface(tmp0, NotCompleted()) : false) {
+        var update = resumedState($this, tmp0, proposedUpdate, $this.tw_1, onCancellation, idempotent);
+        if (!$this.dw_1.atomicfu$compareAndSet(tmp0, update)) {
+          break $l$block;
+        }
+        detachChildIfNonReusable($this);
+        return get_RESUME_TOKEN();
+      } else {
+        if (tmp0 instanceof CompletedContinuation()) {
+          var tmp;
+          if (!(idempotent == null) && tmp0.hx_1 === idempotent) {
+            // Inline function 'kotlinx.coroutines.assert' call
+            tmp = get_RESUME_TOKEN();
+          } else {
+            tmp = null;
+          }
+          return tmp;
+        } else {
+          return null;
+        }
+      }
+    }
+  }
+}
+function alreadyResumedError($this, proposedUpdate) {
+  // Inline function 'kotlin.error' call
+  var message = 'Already resumed, but proposed with update ' + toString_0(proposedUpdate);
+  throw IllegalStateException().w4(toString(message));
+}
+function detachChildIfNonReusable($this) {
+  if (!isReusable($this)) {
+    $this.nx();
+  }
+}
+function CancellableContinuationImpl$resume$lambda($onCancellation) {
+  return (cause, _unused_var__etf5q3, _unused_var__etf5q3_0) => {
+    $onCancellation(cause);
+    return Unit_instance;
+  };
+}
+var CancellableContinuationImplClass;
+function CancellableContinuationImpl() {
+  if (CancellableContinuationImplClass === VOID) {
+    class $ extends DispatchedTask() {
+      constructor(delegate, resumeMode) {
+        super(resumeMode);
+        this.aw_1 = delegate;
+        // Inline function 'kotlinx.coroutines.assert' call
+        this.bw_1 = this.aw_1.tb();
+        var tmp = this;
+        // Inline function 'kotlinx.coroutines.decisionAndIndex' call
+        var tmp$ret$1 = (0 << 29) + 536870911 | 0;
+        tmp.cw_1 = atomic$int$1(tmp$ret$1);
+        this.dw_1 = atomic$ref$1(Active_instance);
+        this.ew_1 = atomic$ref$1(null);
+      }
+      ox() {
+        return this.aw_1;
+      }
+      tb() {
+        return this.bw_1;
+      }
+      wt() {
+        return this.dw_1.kotlinx$atomicfu$value;
+      }
+      xt() {
+        var tmp = this.wt();
+        return !(!(tmp == null) ? isInterface(tmp, NotCompleted()) : false);
+      }
+      yt() {
+        var tmp = this.wt();
+        return tmp instanceof CancelledContinuation();
+      }
+      px() {
+        var tmp0_elvis_lhs = installParentHandle(this);
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          return Unit_instance;
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        var handle = tmp;
+        if (this.xt()) {
+          handle.iw();
+          this.ew_1.kotlinx$atomicfu$value = NonDisposableHandle_instance;
+        }
+      }
+      qw() {
+        // Inline function 'kotlinx.coroutines.assert' call
+        // Inline function 'kotlinx.coroutines.assert' call
+        var state = this.dw_1.kotlinx$atomicfu$value;
+        // Inline function 'kotlinx.coroutines.assert' call
+        var tmp;
+        if (state instanceof CompletedContinuation()) {
+          tmp = !(state.hx_1 == null);
+        } else {
+          tmp = false;
+        }
+        if (tmp) {
+          this.nx();
+          return false;
+        }
+        var tmp_0 = this.cw_1;
+        // Inline function 'kotlinx.coroutines.decisionAndIndex' call
+        tmp_0.kotlinx$atomicfu$value = (0 << 29) + 536870911 | 0;
+        this.dw_1.kotlinx$atomicfu$value = Active_instance;
+        return true;
+      }
+      qx() {
+        return this.wt();
+      }
+      rx(takenState, cause) {
+        var this_0 = this.dw_1;
+        while (true) {
+          var state = this_0.kotlinx$atomicfu$value;
+          if (!(state == null) ? isInterface(state, NotCompleted()) : false) {
+            // Inline function 'kotlin.error' call
+            var message = 'Not completed';
+            throw IllegalStateException().w4(toString(message));
+          } else {
+            if (state instanceof CompletedExceptionally())
+              return Unit_instance;
+            else {
+              if (state instanceof CompletedContinuation()) {
+                // Inline function 'kotlin.check' call
+                if (!!state.kx()) {
+                  var message_0 = 'Must be called at most once';
+                  throw IllegalStateException().w4(toString(message_0));
+                }
+                var update = state.lx(VOID, VOID, VOID, VOID, cause);
+                if (this.dw_1.atomicfu$compareAndSet(state, update)) {
+                  state.sx(this, cause);
+                  return Unit_instance;
+                }
+              } else {
+                if (this.dw_1.atomicfu$compareAndSet(state, new (CompletedContinuation())(state, VOID, VOID, VOID, cause))) {
+                  return Unit_instance;
+                }
+              }
+            }
+          }
+        }
+        return Unit_instance;
+      }
+      tx(cause) {
+        // Inline function 'kotlinx.atomicfu.loop' call
+        var this_0 = this.dw_1;
+        while (true) {
+          var tmp0 = this_0.kotlinx$atomicfu$value;
+          $l$block: {
+            if (!(!(tmp0 == null) ? isInterface(tmp0, NotCompleted()) : false))
+              return false;
+            var tmp;
+            if (isInterface(tmp0, CancelHandler())) {
+              tmp = true;
+            } else {
+              tmp = tmp0 instanceof Segment();
+            }
+            var update = new (CancelledContinuation())(this, cause, tmp);
+            if (!this.dw_1.atomicfu$compareAndSet(tmp0, update)) {
+              break $l$block;
+            }
+            if (isInterface(tmp0, CancelHandler())) {
+              this.jx(tmp0, cause);
+            } else {
+              if (tmp0 instanceof Segment()) {
+                callSegmentOnCancellation(this, tmp0, cause);
+              }
+            }
+            detachChildIfNonReusable(this);
+            dispatchResume(this, this.tw_1);
+            return true;
+          }
+        }
+      }
+      ux(cause) {
+        if (cancelLater(this, cause))
+          return Unit_instance;
+        this.tx(cause);
+        detachChildIfNonReusable(this);
+      }
+      jx(handler, cause) {
+        // Inline function 'kotlinx.coroutines.CancellableContinuationImpl.callCancelHandlerSafely' call
+        try {
+          handler.hw(cause);
+        } catch ($p) {
+          if ($p instanceof Error) {
+            var ex = $p;
+            handleCoroutineException(this.tb(), CompletionHandlerException().dx('Exception in invokeOnCancellation handler for ' + this.toString(), ex));
+          } else {
+            throw $p;
+          }
+        }
+        return Unit_instance;
+      }
+      vx(onCancellation, cause, value) {
+        try {
+          onCancellation(cause, value, this.tb());
+        } catch ($p) {
+          if ($p instanceof Error) {
+            var ex = $p;
+            handleCoroutineException(this.tb(), CompletionHandlerException().dx('Exception in resume onCancellation handler for ' + this.toString(), ex));
+          } else {
+            throw $p;
+          }
+        }
+      }
+      wx(parent) {
+        return parent.bu();
+      }
+      xx() {
+        var isReusable_0 = isReusable(this);
+        if (trySuspend(this)) {
+          if (_get_parentHandle__f8dcex(this) == null) {
+            installParentHandle(this);
+          }
+          if (isReusable_0) {
+            this.yx();
+          }
+          return get_COROUTINE_SUSPENDED();
+        }
+        if (isReusable_0) {
+          this.yx();
+        }
+        var state = this.wt();
+        if (state instanceof CompletedExceptionally())
+          throw recoverStackTrace(state.ht_1, this);
+        if (get_isCancellableMode(this.tw_1)) {
+          var job = this.tb().gc(Key_instance);
+          if (!(job == null) && !job.ct()) {
+            var cause = job.bu();
+            this.rx(state, cause);
+            throw recoverStackTrace(cause, this);
+          }
+        }
+        return this.zx(state);
+      }
+      yx() {
+        var tmp = this.aw_1;
+        var tmp0_safe_receiver = tmp instanceof DispatchedContinuation() ? tmp : null;
+        var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.ay(this);
+        var tmp_0;
+        if (tmp1_elvis_lhs == null) {
+          return Unit_instance;
+        } else {
+          tmp_0 = tmp1_elvis_lhs;
+        }
+        var cancellationCause = tmp_0;
+        this.nx();
+        this.tx(cancellationCause);
+      }
+      vb(result) {
+        return this.by(toState(result, this), this.tw_1);
+      }
+      cy(value, onCancellation) {
+        var tmp = this.tw_1;
+        var tmp_0;
+        if (onCancellation == null) {
+          tmp_0 = null;
+        } else {
+          // Inline function 'kotlin.let' call
+          tmp_0 = CancellableContinuationImpl$resume$lambda(onCancellation);
+        }
+        return this.dy(value, tmp, tmp_0);
+      }
+      yv(value, onCancellation) {
+        return this.dy(value, this.tw_1, onCancellation);
+      }
+      ey(segment, index) {
+        var tmp0 = this.cw_1;
+        $l$block: {
+          // Inline function 'kotlinx.atomicfu.update' call
+          while (true) {
+            var cur = tmp0.kotlinx$atomicfu$value;
+            // Inline function 'kotlinx.coroutines.index' call
+            // Inline function 'kotlin.check' call
+            if (!((cur & 536870911) === 536870911)) {
+              var message = 'invokeOnCancellation should be called at most once';
+              throw IllegalStateException().w4(toString(message));
+            }
+            // Inline function 'kotlinx.coroutines.decision' call
+            // Inline function 'kotlinx.coroutines.decisionAndIndex' call
+            var upd = (cur >> 29 << 29) + index | 0;
+            if (tmp0.atomicfu$compareAndSet(cur, upd)) {
+              break $l$block;
+            }
+          }
+        }
+        invokeOnCancellationImpl(this, segment);
+      }
+      wv(handler) {
+        return invokeOnCancellation(this, new (UserSupplied())(handler));
+      }
+      fw(handler) {
+        return invokeOnCancellationImpl(this, handler);
+      }
+      dy(proposedUpdate, resumeMode, onCancellation) {
+        // Inline function 'kotlinx.atomicfu.loop' call
+        var this_0 = this.dw_1;
+        while (true) {
+          var tmp0 = this_0.kotlinx$atomicfu$value;
+          $l$block: {
+            if (!(tmp0 == null) ? isInterface(tmp0, NotCompleted()) : false) {
+              var update = resumedState(this, tmp0, proposedUpdate, resumeMode, onCancellation, null);
+              if (!this.dw_1.atomicfu$compareAndSet(tmp0, update)) {
+                break $l$block;
+              }
+              detachChildIfNonReusable(this);
+              dispatchResume(this, resumeMode);
+              return Unit_instance;
+            } else {
+              if (tmp0 instanceof CancelledContinuation()) {
+                if (tmp0.iy()) {
+                  if (onCancellation == null)
+                    null;
+                  else {
+                    // Inline function 'kotlin.let' call
+                    this.vx(onCancellation, tmp0.ht_1, proposedUpdate);
+                  }
+                  return Unit_instance;
+                }
+              }
+            }
+            alreadyResumedError(this, proposedUpdate);
+          }
+        }
+      }
+      by(proposedUpdate, resumeMode, onCancellation, $super) {
+        onCancellation = onCancellation === VOID ? null : onCancellation;
+        var tmp;
+        if ($super === VOID) {
+          this.dy(proposedUpdate, resumeMode, onCancellation);
+          tmp = Unit_instance;
+        } else {
+          tmp = $super.dy.call(this, proposedUpdate, resumeMode, onCancellation);
+        }
+        return tmp;
+      }
+      nx() {
+        var tmp0_elvis_lhs = _get_parentHandle__f8dcex(this);
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          return Unit_instance;
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        var handle = tmp;
+        handle.iw();
+        this.ew_1.kotlinx$atomicfu$value = NonDisposableHandle_instance;
+      }
+      uv(value, idempotent, onCancellation) {
+        return tryResumeImpl(this, value, idempotent, onCancellation);
+      }
+      vv(token) {
+        // Inline function 'kotlinx.coroutines.assert' call
+        dispatchResume(this, this.tw_1);
+      }
+      xv(_this__u8e3s4, value) {
+        var tmp = this.aw_1;
+        var dc = tmp instanceof DispatchedContinuation() ? tmp : null;
+        var tmp_0;
+        if ((dc == null ? null : dc.kw_1) === _this__u8e3s4) {
+          tmp_0 = 4;
+        } else {
+          tmp_0 = this.tw_1;
+        }
+        this.by(value, tmp_0);
+      }
+      zx(state) {
+        var tmp;
+        if (state instanceof CompletedContinuation()) {
+          var tmp_0 = state.ex_1;
+          tmp = (tmp_0 == null ? true : !(tmp_0 == null)) ? tmp_0 : THROW_CCE();
+        } else {
+          tmp = (state == null ? true : !(state == null)) ? state : THROW_CCE();
+        }
+        return tmp;
+      }
+      jy(state) {
+        var tmp0_safe_receiver = super.jy(state);
+        var tmp;
+        if (tmp0_safe_receiver == null) {
+          tmp = null;
+        } else {
+          // Inline function 'kotlin.let' call
+          tmp = recoverStackTrace(tmp0_safe_receiver, this.aw_1);
+        }
+        return tmp;
+      }
+      toString() {
+        return this.ky() + '(' + toDebugString(this.aw_1) + '){' + _get_stateDebugRepresentation__bf18u4(this) + '}@' + get_hexAddress(this);
+      }
+      ky() {
+        return 'CancellableContinuation';
+      }
+    }
+    initMetadataForClass($, 'CancellableContinuationImpl', VOID, VOID, [DispatchedTask(), CancellableContinuation(), Waiter()]);
+    CancellableContinuationImplClass = $;
+  }
+  return CancellableContinuationImplClass;
+}
+var NotCompletedClass;
+function NotCompleted() {
+  if (NotCompletedClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'NotCompleted');
+    NotCompletedClass = $;
+  }
+  return NotCompletedClass;
+}
+var ActiveClass;
+function Active() {
+  if (ActiveClass === VOID) {
+    class $ {
+      toString() {
+        return 'Active';
+      }
+    }
+    initMetadataForObject($, 'Active', VOID, VOID, [NotCompleted()]);
+    ActiveClass = $;
+  }
+  return ActiveClass;
+}
+var Active_instance;
+function Active_getInstance() {
+  return Active_instance;
+}
+var CompletedContinuationClass;
+function CompletedContinuation() {
+  if (CompletedContinuationClass === VOID) {
+    class $ {
+      constructor(result, cancelHandler, onCancellation, idempotentResume, cancelCause) {
+        cancelHandler = cancelHandler === VOID ? null : cancelHandler;
+        onCancellation = onCancellation === VOID ? null : onCancellation;
+        idempotentResume = idempotentResume === VOID ? null : idempotentResume;
+        cancelCause = cancelCause === VOID ? null : cancelCause;
+        this.ex_1 = result;
+        this.fx_1 = cancelHandler;
+        this.gx_1 = onCancellation;
+        this.hx_1 = idempotentResume;
+        this.ix_1 = cancelCause;
+      }
+      kx() {
+        return !(this.ix_1 == null);
+      }
+      sx(cont, cause) {
+        var tmp0_safe_receiver = this.fx_1;
+        if (tmp0_safe_receiver == null)
+          null;
+        else {
+          // Inline function 'kotlin.let' call
+          cont.jx(tmp0_safe_receiver, cause);
+        }
+        var tmp1_safe_receiver = this.gx_1;
+        if (tmp1_safe_receiver == null)
+          null;
+        else {
+          // Inline function 'kotlin.let' call
+          cont.vx(tmp1_safe_receiver, cause, this.ex_1);
+        }
+      }
+      ny(result, cancelHandler, onCancellation, idempotentResume, cancelCause) {
+        return new (CompletedContinuation())(result, cancelHandler, onCancellation, idempotentResume, cancelCause);
+      }
+      lx(result, cancelHandler, onCancellation, idempotentResume, cancelCause, $super) {
+        result = result === VOID ? this.ex_1 : result;
+        cancelHandler = cancelHandler === VOID ? this.fx_1 : cancelHandler;
+        onCancellation = onCancellation === VOID ? this.gx_1 : onCancellation;
+        idempotentResume = idempotentResume === VOID ? this.hx_1 : idempotentResume;
+        cancelCause = cancelCause === VOID ? this.ix_1 : cancelCause;
+        return $super === VOID ? this.ny(result, cancelHandler, onCancellation, idempotentResume, cancelCause) : $super.ny.call(this, result, cancelHandler, onCancellation, idempotentResume, cancelCause);
+      }
+      toString() {
+        return 'CompletedContinuation(result=' + toString_0(this.ex_1) + ', cancelHandler=' + toString_0(this.fx_1) + ', onCancellation=' + toString_0(this.gx_1) + ', idempotentResume=' + toString_0(this.hx_1) + ', cancelCause=' + toString_0(this.ix_1) + ')';
+      }
+      hashCode() {
+        var result = this.ex_1 == null ? 0 : hashCode(this.ex_1);
+        result = imul(result, 31) + (this.fx_1 == null ? 0 : hashCode(this.fx_1)) | 0;
+        result = imul(result, 31) + (this.gx_1 == null ? 0 : hashCode(this.gx_1)) | 0;
+        result = imul(result, 31) + (this.hx_1 == null ? 0 : hashCode(this.hx_1)) | 0;
+        result = imul(result, 31) + (this.ix_1 == null ? 0 : hashCode(this.ix_1)) | 0;
+        return result;
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof CompletedContinuation()))
+          return false;
+        var tmp0_other_with_cast = other instanceof CompletedContinuation() ? other : THROW_CCE();
+        if (!equals(this.ex_1, tmp0_other_with_cast.ex_1))
+          return false;
+        if (!equals(this.fx_1, tmp0_other_with_cast.fx_1))
+          return false;
+        if (!equals(this.gx_1, tmp0_other_with_cast.gx_1))
+          return false;
+        if (!equals(this.hx_1, tmp0_other_with_cast.hx_1))
+          return false;
+        if (!equals(this.ix_1, tmp0_other_with_cast.ix_1))
+          return false;
+        return true;
+      }
+    }
+    initMetadataForClass($, 'CompletedContinuation');
+    CompletedContinuationClass = $;
+  }
+  return CompletedContinuationClass;
+}
+var ChildContinuationClass;
+function ChildContinuation() {
+  if (ChildContinuationClass === VOID) {
+    class $ extends JobNode() {
+      constructor(child) {
+        super();
+        this.sy_1 = child;
+      }
+      ty() {
+        return true;
+      }
+      hw(cause) {
+        this.sy_1.ux(this.sy_1.wx(this.yy()));
+      }
+    }
+    initMetadataForClass($, 'ChildContinuation');
+    ChildContinuationClass = $;
+  }
+  return ChildContinuationClass;
+}
+var properties_initialized_CancellableContinuationImpl_kt_xtzb03;
+function _init_properties_CancellableContinuationImpl_kt__6rrtdd() {
+  if (!properties_initialized_CancellableContinuationImpl_kt_xtzb03) {
+    properties_initialized_CancellableContinuationImpl_kt_xtzb03 = true;
+    RESUME_TOKEN = new (Symbol())('RESUME_TOKEN');
+  }
+}
+//region block: init
+Active_instance = new (Active())();
+//endregion
+//region block: exports
+export {
+  CancelHandler as CancelHandler3ic7xysezxbm5,
+  CancellableContinuationImpl as CancellableContinuationImpl1cx201opicavg,
+  NotCompleted as NotCompleted1jonr7fgu2l3n,
+};
+//endregion
+
+//# sourceMappingURL=CancellableContinuationImpl.mjs.map