@continuous-excellence/coupling-cli 0.0.0

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

@@ -0,0 +1,217 @@
+import { copyToArray2j022khrow2yi as copyToArray } from '../../../kotlin-kotlin-stdlib/kotlin/collections/collectionJs.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { emptyList1g2z5xcrvp2zy as emptyList } from '../../../kotlin-kotlin-stdlib/kotlin/collections/CollectionsKt.mjs';
+import {
+  suspendOrReturn49pspzlx5djv as suspendOrReturn,
+  intercepted2ogpsikxxj4u0 as intercepted,
+} from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { toString1pkumu07cwy4m as toString } from '../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import {
+  CancelHandler3ic7xysezxbm5 as CancelHandler,
+  CancellableContinuationImpl1cx201opicavg as CancellableContinuationImpl,
+} from './CancellableContinuationImpl.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { JobNode2tu3g3s3xsko1 as JobNode } from './JobSupport.mjs';
+import {
+  atomic$ref$130aurmcwdfdf1 as atomic$ref$1,
+  atomic$int$11d5swdyn6j0pu as atomic$int$1,
+} from '../../../kotlinx-atomicfu/kotlinx/atomicfu/AtomicFU.mjs';
+import { throwUninitializedPropertyAccessException14fok093f3k3t as throwUninitializedPropertyAccessException } from '../../../kotlin-kotlin-stdlib/kotlin/internal/ThrowHelpers.mjs';
+import { ArrayList3it5z8td81qkl as ArrayList } from '../../../kotlin-kotlin-stdlib/kotlin/collections/ArrayListJs.mjs';
+import {
+  Companion_instance25ullnynvxd0w as Companion_instance,
+  _Result___init__impl__xyqfz83a5421h46yeyh as _Result___init__impl__xyqfz8,
+} from '../../../kotlin-kotlin-stdlib/kotlin/Result.mjs';
+import { invokeOnCompletion3npqdfp2wzhn6 as invokeOnCompletion } from './Job.mjs';
+import { invokeOnCancellationb68niwbjdmgy as invokeOnCancellation } from './CancellableContinuation.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function *_generator_awaitAll__ivbqpv(_this__u8e3s4, $completion) {
+  var tmp;
+  if (_this__u8e3s4.o1()) {
+    tmp = emptyList();
+  } else {
+    // Inline function 'kotlin.collections.toTypedArray' call
+    var tmp$ret$0 = copyToArray(_this__u8e3s4);
+    var tmp_0 = (new (AwaitAll())(tmp$ret$0)).my($completion);
+    if (tmp_0 === get_COROUTINE_SUSPENDED())
+      tmp_0 = yield tmp_0;
+    tmp = tmp_0;
+  }
+  return tmp;
+}
+function awaitAll(_this__u8e3s4, $completion) {
+  return suspendOrReturn(/*#__NOINLINE__*/_generator_awaitAll__ivbqpv.bind(VOID, _this__u8e3s4), $completion);
+}
+var DisposeHandlersOnCancelClass;
+function DisposeHandlersOnCancel() {
+  if (DisposeHandlersOnCancelClass === VOID) {
+    class $ {
+      constructor($outer, nodes) {
+        this.oy_1 = $outer;
+        this.ny_1 = nodes;
+      }
+      py() {
+        // Inline function 'kotlin.collections.forEach' call
+        var indexedObject = this.ny_1;
+        var inductionVariable = 0;
+        var last = indexedObject.length;
+        while (inductionVariable < last) {
+          var element = indexedObject[inductionVariable];
+          inductionVariable = inductionVariable + 1 | 0;
+          element.yy().zy();
+        }
+      }
+      az(cause) {
+        this.py();
+      }
+      toString() {
+        return 'DisposeHandlersOnCancel[' + toString(this.ny_1) + ']';
+      }
+    }
+    initMetadataForClass($, 'DisposeHandlersOnCancel', VOID, VOID, [CancelHandler()]);
+    DisposeHandlersOnCancelClass = $;
+  }
+  return DisposeHandlersOnCancelClass;
+}
+var AwaitAllNodeClass;
+function AwaitAllNode() {
+  if (AwaitAllNodeClass === VOID) {
+    class $ extends JobNode() {
+      constructor($outer, continuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.xy_1 = $outer;
+        super($box);
+        this.uy_1 = continuation;
+        this.wy_1 = atomic$ref$1(null);
+      }
+      yy() {
+        var tmp = this.vy_1;
+        if (!(tmp == null))
+          return tmp;
+        else {
+          throwUninitializedPropertyAccessException('handle');
+        }
+      }
+      bz(value) {
+        this.wy_1.kotlinx$atomicfu$value = value;
+      }
+      cz() {
+        return this.wy_1.kotlinx$atomicfu$value;
+      }
+      dz() {
+        return false;
+      }
+      az(cause) {
+        if (!(cause == null)) {
+          var token = this.uy_1.fz(cause);
+          if (!(token == null)) {
+            this.uy_1.gz(token);
+            var tmp0_safe_receiver = this.cz();
+            if (tmp0_safe_receiver == null)
+              null;
+            else {
+              tmp0_safe_receiver.py();
+            }
+          }
+        } else if (this.xy_1.ly_1.atomicfu$decrementAndGet() === 0) {
+          var tmp0 = this.uy_1;
+          // Inline function 'kotlin.collections.map' call
+          var this_0 = this.xy_1.ky_1;
+          // Inline function 'kotlin.collections.mapTo' call
+          var destination = ArrayList().w2(this_0.length);
+          var inductionVariable = 0;
+          var last = this_0.length;
+          while (inductionVariable < last) {
+            var item = this_0[inductionVariable];
+            inductionVariable = inductionVariable + 1 | 0;
+            var tmp$ret$0 = item.ez();
+            destination.t2(tmp$ret$0);
+          }
+          // Inline function 'kotlin.coroutines.resume' call
+          // Inline function 'kotlin.Companion.success' call
+          var tmp$ret$3 = _Result___init__impl__xyqfz8(destination);
+          tmp0.dd(tmp$ret$3);
+        }
+      }
+    }
+    initMetadataForClass($, 'AwaitAllNode');
+    AwaitAllNodeClass = $;
+  }
+  return AwaitAllNodeClass;
+}
+var AwaitAllClass;
+function AwaitAll() {
+  if (AwaitAllClass === VOID) {
+    class $ {
+      constructor(deferreds) {
+        this.ky_1 = deferreds;
+        this.ly_1 = atomic$int$1(this.ky_1.length);
+      }
+      my($completion) {
+        var cancellable = new (CancellableContinuationImpl())(intercepted($completion), 1);
+        cancellable.zz();
+        var tmp = 0;
+        var tmp_0 = this.ky_1.length;
+        // Inline function 'kotlin.arrayOfNulls' call
+        var tmp_1 = Array(tmp_0);
+        while (tmp < tmp_0) {
+          var tmp_2 = tmp;
+          var deferred = this.ky_1[tmp_2];
+          deferred.gx();
+          // Inline function 'kotlin.apply' call
+          var this_0 = new (AwaitAllNode())(this, cancellable);
+          this_0.vy_1 = invokeOnCompletion(deferred, VOID, this_0);
+          tmp_1[tmp_2] = this_0;
+          tmp = tmp + 1 | 0;
+        }
+        var nodes = tmp_1;
+        var disposer = new (DisposeHandlersOnCancel())(this, nodes);
+        // Inline function 'kotlin.collections.forEach' call
+        var inductionVariable = 0;
+        var last = nodes.length;
+        while (inductionVariable < last) {
+          var element = nodes[inductionVariable];
+          inductionVariable = inductionVariable + 1 | 0;
+          element.bz(disposer);
+        }
+        if (cancellable.ex()) {
+          disposer.py();
+        } else {
+          invokeOnCancellation(cancellable, disposer);
+        }
+        return cancellable.a10();
+      }
+    }
+    initMetadataForClass($, 'AwaitAll', VOID, VOID, VOID, [0]);
+    AwaitAllClass = $;
+  }
+  return AwaitAllClass;
+}
+function *_generator_joinAll__v1pfh(_this__u8e3s4, $completion) {
+  // Inline function 'kotlin.collections.forEach' call
+  var _iterator__ex2g4s = _this__u8e3s4.q1();
+  while (_iterator__ex2g4s.r1()) {
+    var element = _iterator__ex2g4s.s1();
+    var tmp = element.px($completion);
+    if (tmp === get_COROUTINE_SUSPENDED())
+      tmp = yield tmp;
+  }
+  return Unit_instance;
+}
+function joinAll(_this__u8e3s4, $completion) {
+  return suspendOrReturn(/*#__NOINLINE__*/_generator_joinAll__v1pfh.bind(VOID, _this__u8e3s4), $completion);
+}
+//region block: exports
+export {
+  awaitAll as awaitAll1yjaae5fre68u,
+  joinAll as joinAll2rzjwreoc01qe,
+};
+//endregion
+
+//# sourceMappingURL=Await.mjs.map

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/Await.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/Await.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/js/src/kotlin/collectionJs.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/common/src/generated/_Arrays.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/src/kotlin/util/Result.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/src/kotlin/coroutines/Continuation.kt","../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/CancellableContinuation.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/js/builtins/Library.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/src/kotlin/util/Standard.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/common/src/generated/_Collections.kt"],"sourcesContent":[null,null,null,null,null,null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<generator-awaitAll>","<this>","$completion","awaitAll","nodes","disposeAll","element","invoke","cause","toString","continuation","<get-handle>","<set-disposer>","value","<get-disposer>","<get-onCancelling>","token","item","deferreds","await","cancellable","deferred","disposer","<generator-joinAll>","joinAll"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAkCAA,CAAuBC,a,EAAvBC,WAAAF,EACI;A;EAAI,uB;UAAW,W;;;QCToE,YAAjB,YDSzB,aCTyB,C;QDST,0BAAhB,SAAgB,kB;;;;;EAAO,U;AAAD,C;iBADnEG,CAAuBF,a,EAAvBC,WAAAC,E;;C;;;;;0BAmDgDC,K;QAAD,kB;QAAC,iB;;QACxCC,CAAAA,EAAiB;A;YEqpbL,gBFppbR,IEopbQ,CFppbR,I;YEopbQ,qB;YAAA,2B;eAAhB,oBAAgB,I,EAAhB;A,cAAKC,UAAW,gC;UAAA,6C;UAAa,OFppbF,KAAO,K;;MAC9B,C;QAEAC,CAAoBC,KAApBD,EAAuC;A,QAAE,S;MAAa,C;cACtDE,CAAAA,EAAkC;A,QAAiC,OAAhC,0BAAgC,YAAP,IAAO,CAAP,IAAO,IAAF,G;MAAC,C;;;;;;;;;;;0BAGrCC,Y;;;QAAD,kB;;QAAC,wB;QAGL,yBAAiC,IAAjC,C;;QAFxBC,CAAAA,EAAA;A,YAAA,e;QAAA,mB;UAAA,U;aAAA;A,UAAA,mD;QAAoC,C;MAAA,C;QAKhCC,CAAIC,KAAJD,EAAW;A,QAAE,IAAU,CAAV,IAAU,0BAAQ,K;MAAM,C;QADrCE,CAAAA,EAAQ;A,QAAe,OAAf,IAAe,CAAf,IAAe,CAAL,sB;MAAI,C;QAGAC,CAAAA,EAAQ;A,QAAK,OAAL,K;MAAI,C;QAEtCR,CAAoBC,KAApBD,EAAuC;A,QAC/B,eAAS,IAAT,E,CAAe;A,cACfS,QAAY,IAAa,CAAb,IAAa,IAAuB,KAAvB,C;UACrB,eAAS,IAAT,E,CAAe;A,YACf,IAAa,CAAb,IAAa,IAAe,KAAf,C;gBAGb,8B;YAAU,+B;cAAA,I;;cAAV,kBAAU,K;;;QAElB,C,MAAW,IAAA,IAAkB,CAAlB,IAAkB,CAAlB,IAAkB,2BAAlB,KAAuC,CAAvC,C,CAA0C;A,qBACjD,I,CAAA,I;;uBAAoB,I,CAAA,I,CAAA,I;;4BEs0WnB,eAAa,MAAb,CAAa,MAAb,C;cA2VA,qB;cAAA,OA3VN,MA2VM,O;iBAAb,oBAAa,I,EAAb;A,gBAAKC,OA3VE,MA2VM,mB;YAAA,6C;gBFjqXoD,YEkqXnC,IFlqXqB,K;YEkqX/C,WAAY,IAAI,SAAJ,C;;;;cCxrXK,YAAb,6BDyrXD,WCzrXC,C;UChDR,QAAkB,SAAlB,C;QJwEQ,C;MACJ,C;;;;;;;;;;;kBA1DkBC,S;QAAA,qB;QACU,yBAAO,IAAP,CAAO,IAAP,CAAiB,MAAjB,C;;QAEhCC,CAAAjB,WAAAiB,EAA+B;A,YK4W3BC,kDAAoD,YLpZN,WKoZM,CAApDA,EAAgF,CAAhFA,C;QAMA,WAAY,K;YL/WA,O;YAAgB,QAAV,IAAU,CAAV,IAAU,O;;YAAhB,QMrC8C,MNqC9C,KMrC8C,C;eNqC9C,W,EAAA;A,cAAA,W;cACRC,WAAe,UAAU,KAAV,C;UACf,QAAS,K;;uBACT,2BK6WE,WL7WF,C;UACI,cAAkB,mBAAT,QAAS,e;UAJd,eOsBT,M;UPtBS,iB;QAMZ,C;YANAjB,QAAY,K;YAOZkB,2CAAe,IAAfA,EAAuC,KAAvCA,C;;YEmqbY,qB;YAAA,OFjqbZ,KEiqbY,O;eAAhB,oBAAgB,I,EAAhB;A,cAAKhB,UFjqbD,KEiqbY,mB;UAAA,6C;UAAa,OFjqbN,IAAW,QAAX,C;;QAGf,IKoWE,WLpWG,KAAL,C,CAAkB;A,UAElB,QAAS,K;QACb,C,MAAO;A,UACE,qBKgWH,WLhWG,EAA+B,QAA/B,C;QACT,C;QACJ,OK+VI,WAAY,M;ML/VhB,C;;;;;;;mCA1BJiB,CAAmBtB,a,EAAnBC,WAAAqB,EAAqD;A;MQi0DjC,oBRj0DiC,aQi0DjC,K;SAAA,sB,EAAM;A,QAAjBjB,UAAW,sB;QRj0D8C,MQi0DjC,ORj0DiC,gB;;;EQi0D1B,C;ERj0DkC,oB;AAAD,C;gBAAzEkB,CAAmBvB,a,EAAnBC,WAAAsB,E;;C;;;;;"}

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/Builders.common.mjs

@@ -0,0 +1,241 @@
+import { EmptyCoroutineContext_getInstance10e98b8bnsvr1 as EmptyCoroutineContext_getInstance } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineContextImpl.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { CoroutineStart_DEFAULT_getInstancem736nlr0ekl as CoroutineStart_DEFAULT_getInstance } from './CoroutineStart.mjs';
+import {
+  newCoroutineContext2tdpc8c02iv5t as newCoroutineContext,
+  newCoroutineContext1x74axajiiptk as newCoroutineContext_0,
+  UndispatchedCoroutine1g5upie8aljdz as UndispatchedCoroutine,
+} from './CoroutineContext.mjs';
+import {
+  ensureActive2yo7199srjlgl as ensureActive,
+  Job29shfjfygy86k as Job,
+} from './Job.mjs';
+import { ScopeCoroutine2c07fgm3ekmnx as ScopeCoroutine } from './internal/Scopes.mjs';
+import { startUndispatchedOrReturn1od7ryhr362dr as startUndispatchedOrReturn } from './intrinsics/Undispatched.mjs';
+import { Key_instance1cmljiecd0y8y as Key_instance } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/ContinuationInterceptor.mjs';
+import {
+  equals2au1ep9vhcato as equals,
+  toString1pkumu07cwy4m as toString,
+} from '../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import {
+  startCoroutineCancellable3v5el961z6rj8 as startCoroutineCancellable,
+  startCoroutineCancellable1tb4wrxetke45 as startCoroutineCancellable_0,
+} from './intrinsics/Cancellable.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { AbstractCoroutine2jzyhqo91sb0o as AbstractCoroutine } from './AbstractCoroutine.mjs';
+import {
+  suspendOrReturn49pspzlx5djv as suspendOrReturn,
+  createCoroutineUninterceptedGeneratorVersion2gduom218i9ay as createCoroutineUninterceptedGeneratorVersion,
+  intercepted2ogpsikxxj4u0 as intercepted,
+} from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { handleCoroutineExceptionv1m1bdk4j2te as handleCoroutineException } from './CoroutineExceptionHandler.mjs';
+import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { atomic$int$11d5swdyn6j0pu as atomic$int$1 } from '../../../kotlinx-atomicfu/kotlinx/atomicfu/AtomicFU.mjs';
+import {
+  recoverResult92pymwoef8np as recoverResult,
+  CompletedExceptionally3itrk74dxkv9s as CompletedExceptionally,
+} from './CompletionState.mjs';
+import { resumeCancellableWith2mw849xp548hg as resumeCancellableWith } from './internal/DispatchedContinuation.mjs';
+import { unboxStateze7t12boxn2m as unboxState } from './JobSupport.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function async(_this__u8e3s4, context, start, block) {
+  context = context === VOID ? EmptyCoroutineContext_getInstance() : context;
+  start = start === VOID ? CoroutineStart_DEFAULT_getInstance() : start;
+  var newContext = newCoroutineContext(_this__u8e3s4, context);
+  var coroutine = start.b10() ? new (LazyDeferredCoroutine())(newContext, block) : new (DeferredCoroutine())(newContext, true);
+  coroutine.ww(start, coroutine, block);
+  return coroutine;
+}
+function launch(_this__u8e3s4, context, start, block) {
+  context = context === VOID ? EmptyCoroutineContext_getInstance() : context;
+  start = start === VOID ? CoroutineStart_DEFAULT_getInstance() : start;
+  var newContext = newCoroutineContext(_this__u8e3s4, context);
+  var coroutine = start.b10() ? new (LazyStandaloneCoroutine())(newContext, block) : new (StandaloneCoroutine())(newContext, true);
+  coroutine.ww(start, coroutine, block);
+  return coroutine;
+}
+function withContext(context, block, $completion) {
+  var tmp$ret$0;
+  $l$block_0: {
+    var oldContext = $completion.bd();
+    var newContext = newCoroutineContext_0(oldContext, context);
+    ensureActive(newContext);
+    if (newContext === oldContext) {
+      var coroutine = new (ScopeCoroutine())(newContext, $completion);
+      tmp$ret$0 = startUndispatchedOrReturn(coroutine, coroutine, block);
+      break $l$block_0;
+    }
+    if (equals(newContext.rd(Key_instance), oldContext.rd(Key_instance))) {
+      var coroutine_0 = new (UndispatchedCoroutine())(newContext, $completion);
+      // Inline function 'kotlinx.coroutines.withCoroutineContext' call
+      coroutine_0.hw_1;
+      tmp$ret$0 = startUndispatchedOrReturn(coroutine_0, coroutine_0, block);
+      break $l$block_0;
+    }
+    var coroutine_1 = new (DispatchedCoroutine())(newContext, $completion);
+    startCoroutineCancellable(block, coroutine_1, coroutine_1);
+    tmp$ret$0 = coroutine_1.a10();
+  }
+  return tmp$ret$0;
+}
+function *_generator_await__mos7q6($this, $completion) {
+  var tmp = $this.jy($completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var tmp_0 = tmp;
+  return (tmp_0 == null ? true : !(tmp_0 == null)) ? tmp_0 : THROW_CCE();
+}
+var DeferredCoroutineClass;
+function DeferredCoroutine() {
+  if (DeferredCoroutineClass === VOID) {
+    class $ extends AbstractCoroutine() {
+      constructor(parentContext, active) {
+        super(parentContext, true, active);
+      }
+      ez() {
+        var tmp = this.iy();
+        return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+      }
+      my($completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_await__mos7q6.bind(VOID, this), $completion);
+      }
+    }
+    initMetadataForClass($, 'DeferredCoroutine', VOID, VOID, [AbstractCoroutine(), Job()], [0]);
+    DeferredCoroutineClass = $;
+  }
+  return DeferredCoroutineClass;
+}
+var LazyDeferredCoroutineClass;
+function LazyDeferredCoroutine() {
+  if (LazyDeferredCoroutineClass === VOID) {
+    class $ extends DeferredCoroutine() {
+      constructor(parentContext, block) {
+        super(parentContext, false);
+        this.n10_1 = createCoroutineUninterceptedGeneratorVersion(block, this, this);
+      }
+      hx() {
+        startCoroutineCancellable_0(this.n10_1, this);
+      }
+    }
+    initMetadataForClass($, 'LazyDeferredCoroutine', VOID, VOID, VOID, [0]);
+    LazyDeferredCoroutineClass = $;
+  }
+  return LazyDeferredCoroutineClass;
+}
+var StandaloneCoroutineClass;
+function StandaloneCoroutine() {
+  if (StandaloneCoroutineClass === VOID) {
+    class $ extends AbstractCoroutine() {
+      constructor(parentContext, active) {
+        super(parentContext, true, active);
+      }
+      gy(exception) {
+        handleCoroutineException(this.hw_1, exception);
+        return true;
+      }
+    }
+    initMetadataForClass($, 'StandaloneCoroutine', VOID, VOID, VOID, [0]);
+    StandaloneCoroutineClass = $;
+  }
+  return StandaloneCoroutineClass;
+}
+var LazyStandaloneCoroutineClass;
+function LazyStandaloneCoroutine() {
+  if (LazyStandaloneCoroutineClass === VOID) {
+    class $ extends StandaloneCoroutine() {
+      constructor(parentContext, block) {
+        super(parentContext, false);
+        this.u10_1 = createCoroutineUninterceptedGeneratorVersion(block, this, this);
+      }
+      hx() {
+        startCoroutineCancellable_0(this.u10_1, this);
+      }
+    }
+    initMetadataForClass($, 'LazyStandaloneCoroutine', VOID, VOID, VOID, [0]);
+    LazyStandaloneCoroutineClass = $;
+  }
+  return LazyStandaloneCoroutineClass;
+}
+function trySuspend($this) {
+  // Inline function 'kotlinx.atomicfu.loop' call
+  var this_0 = $this.g10_1;
+  while (true) {
+    switch (this_0.kotlinx$atomicfu$value) {
+      case 0:
+        if ($this.g10_1.atomicfu$compareAndSet(0, 1))
+          return true;
+        break;
+      case 2:
+        return false;
+      default:
+        // Inline function 'kotlin.error' call
+
+        var message = 'Already suspended';
+        throw IllegalStateException().o(toString(message));
+    }
+  }
+}
+function tryResume($this) {
+  // Inline function 'kotlinx.atomicfu.loop' call
+  var this_0 = $this.g10_1;
+  while (true) {
+    switch (this_0.kotlinx$atomicfu$value) {
+      case 0:
+        if ($this.g10_1.atomicfu$compareAndSet(0, 2))
+          return true;
+        break;
+      case 1:
+        return false;
+      default:
+        // Inline function 'kotlin.error' call
+
+        var message = 'Already resumed';
+        throw IllegalStateException().o(toString(message));
+    }
+  }
+}
+var DispatchedCoroutineClass;
+function DispatchedCoroutine() {
+  if (DispatchedCoroutineClass === VOID) {
+    class $ extends ScopeCoroutine() {
+      constructor(context, uCont) {
+        super(context, uCont);
+        this.g10_1 = atomic$int$1(0);
+      }
+      tw(state) {
+        this.sw(state);
+      }
+      sw(state) {
+        if (tryResume(this))
+          return Unit_instance;
+        resumeCancellableWith(intercepted(this.y10_1), recoverResult(state, this.y10_1));
+      }
+      a10() {
+        if (trySuspend(this))
+          return get_COROUTINE_SUSPENDED();
+        var state = unboxState(this.dx());
+        if (state instanceof CompletedExceptionally())
+          throw state.ow_1;
+        return (state == null ? true : !(state == null)) ? state : THROW_CCE();
+      }
+    }
+    initMetadataForClass($, 'DispatchedCoroutine', VOID, VOID, VOID, [0]);
+    DispatchedCoroutineClass = $;
+  }
+  return DispatchedCoroutineClass;
+}
+//region block: exports
+export {
+  withContext as withContext3dkm8s4upl4ld,
+  async as asyncz02dsa2nb2zt,
+  launch as launch1c91vkjzdi9sd,
+};
+//endregion
+
+//# sourceMappingURL=Builders.common.mjs.map

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/Builders.common.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/Builders.common.kt","../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/jsAndWasmShared/src/CoroutineContext.kt","../../../../../../../.gradle/daemon/9.3.0/Z:/BuildAgent/work/711ef0d9c7c28b00/atomicfu/src/commonMain/kotlin/kotlinx/atomicfu/AtomicFU.common.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/src/kotlin/util/Preconditions.kt"],"sourcesContent":[null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["async","<this>","context","start","block","newContext","coroutine","launch","withContext","$completion","oldContext","<generator-await>","parentContext","active","getCompleted","await","onStart","handleJobException","exception","trySuspend","tryResume","uCont","afterCompletion","state","afterResume","getResult"],"mappings":"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"}

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

@@ -0,0 +1,96 @@
+import { Continuation1aa2oekvx7jm7 as Continuation } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/Continuation.mjs';
+import {
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { UnsupportedOperationException2tkumpmhredt3 as UnsupportedOperationException } from '../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  CancellableContinuationImpl1cx201opicavg as CancellableContinuationImpl,
+  CancelHandler3ic7xysezxbm5 as CancelHandler,
+} from './CancellableContinuationImpl.mjs';
+import { toString1pkumu07cwy4m as toString } from '../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { DispatchedContinuation8kf77e5g2ha2 as DispatchedContinuation } from './internal/DispatchedContinuation.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var CancellableContinuationClass;
+function CancellableContinuation() {
+  if (CancellableContinuationClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'CancellableContinuation', VOID, VOID, [Continuation()]);
+    CancellableContinuationClass = $;
+  }
+  return CancellableContinuationClass;
+}
+function invokeOnCancellation(_this__u8e3s4, handler) {
+  var tmp;
+  if (_this__u8e3s4 instanceof CancellableContinuationImpl()) {
+    _this__u8e3s4.d11(handler);
+    tmp = Unit_instance;
+  } else {
+    throw UnsupportedOperationException().pa('third-party implementation of CancellableContinuation is not supported');
+  }
+  return tmp;
+}
+function disposeOnCancellation(_this__u8e3s4, handle) {
+  return invokeOnCancellation(_this__u8e3s4, new (DisposeOnCancel())(handle));
+}
+var DisposeOnCancelClass;
+function DisposeOnCancel() {
+  if (DisposeOnCancelClass === VOID) {
+    class $ {
+      constructor(handle) {
+        this.e11_1 = handle;
+      }
+      az(cause) {
+        return this.e11_1.zy();
+      }
+      toString() {
+        return 'DisposeOnCancel[' + toString(this.e11_1) + ']';
+      }
+    }
+    initMetadataForClass($, 'DisposeOnCancel', VOID, VOID, [CancelHandler()]);
+    DisposeOnCancelClass = $;
+  }
+  return DisposeOnCancelClass;
+}
+function getOrCreateCancellableContinuation(delegate) {
+  if (!(delegate instanceof DispatchedContinuation())) {
+    return new (CancellableContinuationImpl())(delegate, 1);
+  }
+  var tmp0_safe_receiver = delegate.l11();
+  var tmp;
+  if (tmp0_safe_receiver == null) {
+    tmp = null;
+  } else {
+    // Inline function 'kotlin.takeIf' call
+    var tmp_0;
+    if (tmp0_safe_receiver.m11()) {
+      tmp_0 = tmp0_safe_receiver;
+    } else {
+      tmp_0 = null;
+    }
+    tmp = tmp_0;
+  }
+  var tmp1_elvis_lhs = tmp;
+  var tmp_1;
+  if (tmp1_elvis_lhs == null) {
+    return new (CancellableContinuationImpl())(delegate, 2);
+  } else {
+    tmp_1 = tmp1_elvis_lhs;
+  }
+  return tmp_1;
+}
+//region block: exports
+export {
+  CancellableContinuation as CancellableContinuationpb2x00mxmcbt,
+  disposeOnCancellation as disposeOnCancellation302lv5bib5mna,
+  getOrCreateCancellableContinuation as getOrCreateCancellableContinuation2t1o0dr9l9i36,
+  invokeOnCancellation as invokeOnCancellationb68niwbjdmgy,
+};
+//endregion
+
+//# sourceMappingURL=CancellableContinuation.mjs.map

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/CancellableContinuation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/CancellableContinuation.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/src/kotlin/util/Standard.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["invokeOnCancellation","<this>","handler","disposeOnCancellation","handle","invoke","cause","toString","getOrCreateCancellableContinuation","delegate"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;6BAwTAA,CAAiBC,a,EAAgDC,OAAjEF,EAA2F;A;EACvF,IAD6F,aAC7F,0C;IAAkC,kBAA6B,OAA7B,C;;;IAC1B,yCAAoC,wEAApC,C;;EACX,U;AAAD,C;8BA8KAG,CACWF,a,EAAiDG,MAD5DD,EAEI;A,EAAuD,OAAvD,4DAA+C,MAA/C,E;AAAsD,C;;;;;kBAE5BC,M;QAAA,mB;;QAC1BC,CAAoBC,KAApBD,EAAyC;A,QAAgB,OAAhB,IAAO,CAAP,KAAO,K;MAAQ,C;cACxDE,CAAAA,EAAkC;A,QAA0B,OAAzB,kBAAyB,YAAR,IAAQ,CAAR,KAAQ,IAAF,G;MAAC,C;;;;;;;2CAvC/DC,CAAoDC,QAApDD,EAA+G;A,EAEvG,oD,CAAwC;A,IACxC,2CAAmC,QAAnC,EAA6C,CAA7C,C;EACJ,C;MAegB,qBAAT,QAAS,M;;EAAwC,+B;UAAA,I;;;;ICxV7C,IDwVJ,kBAA6D,MCxVzD,C;cDwVJ,kB;;cCxV+B,I;;UAA/B,K;;MDwVA,oB;;EAAA,2B;IACA,2CAAmC,QAAnC,EAA6C,CAA7C,C;;YADA,c;;EAAP,Y;AAEJ,C;;;;;"}