@continuous-excellence/coupling-cli 0.0.0

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

@@ -0,0 +1,87 @@
+import {
+  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 { EmptyCoroutineContext_getInstance10e98b8bnsvr1 as EmptyCoroutineContext_getInstance } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineContextImpl.mjs';
+import {
+  Key_instance17dpgmdbeabno as Key_instance,
+  Job13y4jkazwjho0 as Job,
+} from './Job.mjs';
+import { toString1pkumu07cwy4m as toString } from '../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { CancellationExceptionjngvjj221x3v as CancellationException } from './Exceptions.mjs';
+import {
+  ContextScoper0znlsj7ufhq as ContextScope,
+  ScopeCoroutine2c07fgm3ekmnx as ScopeCoroutine,
+} from './internal/Scopes.mjs';
+import { startUndispatchedOrReturn1od7ryhr362dr as startUndispatchedOrReturn } from './intrinsics/Undispatched.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var CoroutineScopeClass;
+function CoroutineScope() {
+  if (CoroutineScopeClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'CoroutineScope');
+    CoroutineScopeClass = $;
+  }
+  return CoroutineScopeClass;
+}
+var GlobalScopeClass;
+function GlobalScope() {
+  if (GlobalScopeClass === VOID) {
+    class $ {
+      iw() {
+        return EmptyCoroutineContext_getInstance();
+      }
+    }
+    initMetadataForObject($, 'GlobalScope', VOID, VOID, [CoroutineScope()]);
+    GlobalScopeClass = $;
+  }
+  return GlobalScopeClass;
+}
+var GlobalScope_instance;
+function GlobalScope_getInstance() {
+  return GlobalScope_instance;
+}
+function cancel(_this__u8e3s4, cause) {
+  cause = cause === VOID ? null : cause;
+  var tmp0_elvis_lhs = _this__u8e3s4.iw().rd(Key_instance);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    var message = 'Scope cannot be cancelled because it does not have a job: ' + toString(_this__u8e3s4);
+    throw IllegalStateException().o(toString(message));
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var job = tmp;
+  job.sx(cause);
+}
+function cancel_0(_this__u8e3s4, message, cause) {
+  cause = cause === VOID ? null : cause;
+  return cancel(_this__u8e3s4, CancellationException(message, cause));
+}
+function CoroutineScope_0(context) {
+  return new (ContextScope())(!(context.rd(Key_instance) == null) ? context : context.wo(Job()));
+}
+function coroutineScope(block, $completion) {
+  var coroutine = new (ScopeCoroutine())($completion.bd(), $completion);
+  return startUndispatchedOrReturn(coroutine, coroutine, block);
+}
+//region block: init
+GlobalScope_instance = new (GlobalScope())();
+//endregion
+//region block: exports
+export {
+  coroutineScope as coroutineScope16v8y7h9n9146,
+  GlobalScope_instance as GlobalScope_instance1goye8260az8c,
+  CoroutineScope_0 as CoroutineScopelux7s7zphw7e,
+  CoroutineScope as CoroutineScopefcb5f5dwqcas,
+  cancel as cancel36mj9lv3a0whl,
+  cancel_0 as cancel2ztysw4v4hav6,
+};
+//endregion
+
+//# sourceMappingURL=CoroutineScope.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/CoroutineScope.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-coroutineContext>","cancel","<this>","cause","job","message","CoroutineScope","context","coroutineScope","block","$completion","coroutine"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkPQA,CAAAA,EAAQ;A,QAAqB,0C;MAAD,C;;;;;;;;;;;eAgEpCC,CAAWC,a,EAAsBC,KAAjCF,EAAuE;A,2BAAN,I;MACnD,oD;;EAAA,2B;kBAAgC,4DAAD,YAA4D,aAA5D,C;IAlOhC,gCAAoC,SAAR,OAAQ,CAApC,C;;UAkOC,c;;MAAVG,S;EACA,GAAI,IAAO,KAAP,C;AACR,C;iBAOAH,CAAWC,a,EAAsBG,O,EAAiBF,KAAlDF,EAAoF;A,2BAAd,I;EAA2D,OAA7C,sBAAO,sBAAsB,OAAtB,EAA+B,KAA/B,CAAP,C;AAA4C,C;yBApBhIK,CAC0BC,OAD1BD,EAEI;A,EAAoE,4BAAnD,8BAAgB,IAAhB,IAAsB,OAAtB,GAAmC,WAAU,KAAV,CAAgB,C;AAAD,C;uBAnBvEE,CAAsCC,K,EAAtCC,WAAAF,EAAgF;A,MAKxEG,mCAlQK,WAkQgC,KAArCA,EAlQK,WAkQLA,C;EAGR,OAFkB,0BAAV,SAAU,EAA0B,SAA1B,EAAqC,KAArC,C;AAElB,C;;;;;;;;"}

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

@@ -0,0 +1,88 @@
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { Enum3alwj03lh1n41 as Enum } from '../../../kotlin-kotlin-stdlib/kotlin/Enum.mjs';
+import { startCoroutineCancellable3v5el961z6rj8 as startCoroutineCancellable } from './intrinsics/Cancellable.mjs';
+import { startCoroutine327fwvtqvedik as startCoroutine } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/Continuation.mjs';
+import { startCoroutineUndispatched23kmsh8s0p6h5 as startCoroutineUndispatched } from './intrinsics/Undispatched.mjs';
+import { noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException } from '../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var CoroutineStart_DEFAULT_instance;
+var CoroutineStart_LAZY_instance;
+var CoroutineStart_ATOMIC_instance;
+var CoroutineStart_UNDISPATCHED_instance;
+var CoroutineStart_entriesInitialized;
+function CoroutineStart_initEntries() {
+  if (CoroutineStart_entriesInitialized)
+    return Unit_instance;
+  CoroutineStart_entriesInitialized = true;
+  CoroutineStart_DEFAULT_instance = new (CoroutineStart())('DEFAULT', 0);
+  CoroutineStart_LAZY_instance = new (CoroutineStart())('LAZY', 1);
+  CoroutineStart_ATOMIC_instance = new (CoroutineStart())('ATOMIC', 2);
+  CoroutineStart_UNDISPATCHED_instance = new (CoroutineStart())('UNDISPATCHED', 3);
+}
+var CoroutineStartClass;
+function CoroutineStart() {
+  if (CoroutineStartClass === VOID) {
+    class $ extends Enum() {
+      zw(block, receiver, completion) {
+        var tmp;
+        switch (this.x1_1) {
+          case 0:
+            startCoroutineCancellable(block, receiver, completion);
+            tmp = Unit_instance;
+            break;
+          case 2:
+            startCoroutine(block, receiver, completion);
+            tmp = Unit_instance;
+            break;
+          case 3:
+            startCoroutineUndispatched(block, receiver, completion);
+            tmp = Unit_instance;
+            break;
+          case 1:
+            tmp = Unit_instance;
+            break;
+          default:
+            noWhenBranchMatchedException();
+            break;
+        }
+        return tmp;
+      }
+      b10() {
+        return this === CoroutineStart_LAZY_getInstance();
+      }
+    }
+    initMetadataForClass($, 'CoroutineStart');
+    CoroutineStartClass = $;
+  }
+  return CoroutineStartClass;
+}
+function CoroutineStart_DEFAULT_getInstance() {
+  CoroutineStart_initEntries();
+  return CoroutineStart_DEFAULT_instance;
+}
+function CoroutineStart_LAZY_getInstance() {
+  CoroutineStart_initEntries();
+  return CoroutineStart_LAZY_instance;
+}
+function CoroutineStart_ATOMIC_getInstance() {
+  CoroutineStart_initEntries();
+  return CoroutineStart_ATOMIC_instance;
+}
+function CoroutineStart_UNDISPATCHED_getInstance() {
+  CoroutineStart_initEntries();
+  return CoroutineStart_UNDISPATCHED_instance;
+}
+//region block: exports
+export {
+  CoroutineStart_ATOMIC_getInstance as CoroutineStart_ATOMIC_getInstance1bb1yqu2k5wg1,
+  CoroutineStart_DEFAULT_getInstance as CoroutineStart_DEFAULT_getInstancem736nlr0ekl,
+  CoroutineStart_UNDISPATCHED_getInstance as CoroutineStart_UNDISPATCHED_getInstanceldihd7d5m0an,
+};
+//endregion
+
+//# sourceMappingURL=CoroutineStart.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/CoroutineStart.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["invoke","block","receiver","completion","<get-isLazy>"],"mappings":";;;;;;;;;;;;;;;;;;;;;2DAAA,S,EAAA,C;wDAAA,M,EAAA,C;0DAAA,Q,EAAA,C;gEAAA,c,EAAA,C;;;;;;QAkWIA,CACkCC,K,EAA0BC,Q,EAAaC,UADzEH,EAEI;A;QAAA,QAAM,IAAN,CAAM,IAAN,C;eACI,C;YAAiB,0BAAN,KAAM,EAA0B,QAA1B,EAAoC,UAApC,C;;;eACjB,C;YAAgB,eAAN,KAAM,EAAe,QAAf,EAAyB,UAAzB,C;;;eAChB,C;YAAsB,2BAAN,KAAM,EAA2B,QAA3B,EAAqC,UAArC,C;;;eACtB,C;;;;YAJJ,8B;;;QAKC,U;MAAD,C;SAQuBI,CAAAA,EAAQ;A,QAAa,OAAb,SAAS,iC;MAAG,C;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,22 @@
+import { initMetadataForInterface1egvbzx539z91 as initMetadataForInterface } from '../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var CopyableThrowableClass;
+function CopyableThrowable() {
+  if (CopyableThrowableClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'CopyableThrowable');
+    CopyableThrowableClass = $;
+  }
+  return CopyableThrowableClass;
+}
+//region block: exports
+export {
+  CopyableThrowable as CopyableThrowable1mvc99jcyvivf,
+};
+//endregion
+
+//# sourceMappingURL=Debug.common.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,39 @@
+import { getKClassFromExpression348iqjl4fnx2f as getKClassFromExpression } from '../../../kotlin-kotlin-stdlib/kotlin/reflect/js/internal/reflection.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var counter;
+function get_DEBUG() {
+  return DEBUG;
+}
+var DEBUG;
+function get_classSimpleName(_this__u8e3s4) {
+  var tmp0_elvis_lhs = getKClassFromExpression(_this__u8e3s4).k1();
+  return tmp0_elvis_lhs == null ? 'Unknown' : tmp0_elvis_lhs;
+}
+function get_hexAddress(_this__u8e3s4) {
+  // Inline function 'kotlin.js.asDynamic' call
+  var result = _this__u8e3s4.__debug_counter;
+  if (!(typeof result === 'number')) {
+    counter = counter + 1 | 0;
+    result = counter;
+    // Inline function 'kotlin.js.asDynamic' call
+    _this__u8e3s4.__debug_counter = result;
+  }
+  return ((!(result == null) ? typeof result === 'number' : false) ? result : THROW_CCE()).toString();
+}
+//region block: init
+counter = 0;
+DEBUG = false;
+//endregion
+//region block: exports
+export {
+  get_DEBUG as get_DEBUG1a8uv2i5oid01,
+  get_classSimpleName as get_classSimpleName2jgk6lzg9ft1,
+  get_hexAddress as get_hexAddress1mxa7txdmiojm,
+};
+//endregion
+
+//# sourceMappingURL=Debug.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/js/src/Debug.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-DEBUG>","<get-classSimpleName>","<this>","<get-hexAddress>","result"],"mappings":";;;;;;;kBAIAA,CAAAA,EAAA;A,EAAA,Y;AAAiC,C;;4BAaeC,CAA5BC,aAA4BD,EAAQ;A,MAAA,iBAAY,wBAAZ,aAAY,M;EAAuB,OAAnC,yBAA0B,SAA1B,iB;AAAkC,C;uBAVtFE,CADgBD,aAChBC,EAAM;A;MACFC,SAAa,aAAbA,CAA8B,e;EAC1B,aAAS,MAAT,KAAqB,QAArB,E,CAA+B;A,IACpB,UAAA,OAAF,IAAE,I;IAAX,SAAW,O;;IACX,gCAAmC,M;EAEvC,C;EACA,OAAuB,IAAf,MAAe,mBAAf,MAAe,yBAAf,MAAe,0B;AAC3B,C;;UAbkB,C;QAEe,K;;;;;;"}

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

@@ -0,0 +1,93 @@
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { Long2qws0ah9gnpki as Long } from '../../../kotlin-kotlin-stdlib/kotlin/Primitives.mjs';
+import { compare2uud5j30pw5xc as compare } from '../../../kotlin-kotlin-stdlib/kotlin/js/internal/boxedLong/boxedLong.mjs';
+import { intercepted2ogpsikxxj4u0 as intercepted } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import { CancellableContinuationImpl1cx201opicavg as CancellableContinuationImpl } from './CancellableContinuationImpl.mjs';
+import { get_DefaultDelay3q9fawcutqbnw as get_DefaultDelay } from './CoroutineContext.mjs';
+import { initMetadataForInterface1egvbzx539z91 as initMetadataForInterface } from '../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { Key_instance1cmljiecd0y8y as Key_instance } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/ContinuationInterceptor.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import {
+  Duration__isPositive_impl_tvkkt231l760fgzz420 as Duration__isPositive_impl_tvkkt2,
+  Companion_getInstance1ji65oeucwbu1 as Companion_getInstance,
+  toDurationba1nlt78o6vu as toDuration,
+  Duration__plus_impl_yu9v8f3u0ccraw6vska as Duration__plus_impl_yu9v8f,
+  _Duration___get_inWholeMilliseconds__impl__msfiryatkl295bksdl as _Duration___get_inWholeMilliseconds__impl__msfiry,
+} from '../../../kotlin-kotlin-stdlib/kotlin/time/Duration.mjs';
+import { DurationUnit_NANOSECONDS_getInstance21q7hkfzg8ym5 as DurationUnit_NANOSECONDS_getInstance } from '../../../kotlin-kotlin-stdlib/kotlin/time/DurationUnitJs.mjs';
+import { noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException } from '../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function delay(timeMillis, $completion) {
+  if (compare(timeMillis, new (Long())(0, 0)) <= 0)
+    return Unit_instance;
+  var cancellable = new (CancellableContinuationImpl())(intercepted($completion), 1);
+  cancellable.zz();
+  if (compare(timeMillis, new (Long())(-1, 2147483647)) < 0) {
+    get_delay(cancellable.bd()).f14(timeMillis, cancellable);
+  }
+  return cancellable.a10();
+}
+function invokeOnTimeout(timeMillis, block, context) {
+  return get_DefaultDelay().g14(timeMillis, block, context);
+}
+var DelayClass;
+function Delay() {
+  if (DelayClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'Delay', VOID, VOID, VOID, [1]);
+    DelayClass = $;
+  }
+  return DelayClass;
+}
+function get_delay(_this__u8e3s4) {
+  var tmp = _this__u8e3s4.rd(Key_instance);
+  var tmp0_elvis_lhs = (!(tmp == null) ? isInterface(tmp, Delay()) : false) ? tmp : null;
+  return tmp0_elvis_lhs == null ? get_DefaultDelay() : tmp0_elvis_lhs;
+}
+var DelayWithTimeoutDiagnosticsClass;
+function DelayWithTimeoutDiagnostics() {
+  if (DelayWithTimeoutDiagnosticsClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'DelayWithTimeoutDiagnostics', VOID, VOID, [Delay()], [1]);
+    DelayWithTimeoutDiagnosticsClass = $;
+  }
+  return DelayWithTimeoutDiagnosticsClass;
+}
+function delay_0(duration, $completion) {
+  return delay(toDelayMillis(duration), $completion);
+}
+function toDelayMillis(_this__u8e3s4) {
+  var tmp;
+  switch (Duration__isPositive_impl_tvkkt2(_this__u8e3s4)) {
+    case true:
+      Companion_getInstance();
+      // Inline function 'kotlin.time.Companion.nanoseconds' call
+
+      var this_0 = new (Long())(999999, 0);
+      var tmp$ret$0 = toDuration(this_0, DurationUnit_NANOSECONDS_getInstance());
+      tmp = _Duration___get_inWholeMilliseconds__impl__msfiry(Duration__plus_impl_yu9v8f(_this__u8e3s4, tmp$ret$0));
+      break;
+    case false:
+      tmp = new (Long())(0, 0);
+      break;
+    default:
+      noWhenBranchMatchedException();
+      break;
+  }
+  return tmp;
+}
+//region block: exports
+export {
+  delay as delay2673xnmlkmidc,
+  delay_0 as delayko55i6ibvfeo,
+  DelayWithTimeoutDiagnostics as DelayWithTimeoutDiagnostics19ibxwhhgbjz0,
+  Delay as Delay9umexudtwyie,
+  get_delay as get_delaynv5kl66dta33,
+};
+//endregion
+
+//# sourceMappingURL=Delay.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/Delay.kt","../../../../../../../../../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/time/Duration.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["delay","timeMillis","$completion","cancellable","invokeOnTimeout","block","context","<get-delay>","<this>","duration","toDelayMillis"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cAwHAA,CAAyBC,U,EAAzBC,WAAAF,EAA2C;A,EACnC,qCAAc,CAAd,EAAc,CAAd,Q;IAAiB,oB;MCiTjBG,kDAAoD,YDzYsB,WCyYtB,CAApDA,EAAgF,CAAhFA,C;EAMA,WAAY,K;EDpTR,qCAAkB,EAAlB,EAAkB,UAAlB,O,CAA6B;A,IAChB,UCoTX,WDpTG,KAAQ,CAAM,KAAyB,UAAzB,ECoTjB,WDpTiB,C;EACvB,C;EAER,OCkTQ,WAAY,M;ADlTpB,C;wBA7EIC,CAA2BH,U,EAAkBI,K,EAAiBC,OAA9DF,EACI;A,EAAwD,OAAxD,kBAAa,KAAgB,UAAhB,EAA4B,KAA5B,EAAmC,OAAnC,C;AAA0C,C;;;;;;;;;;kBAgGpBG,CAA9BC,aAA8BD,EAAQ;A,YAAA,8B;MAAA,kF;EAAsD,OAAtD,yBAA0C,kBAA1C,iB;AAAqD,C;;;;;;;;;;gBAHxGP,CAAyBS,Q,EAAzBP,WAAAF,EAAqD;A,EAA8B,OAA9B,MAAe,cAAT,QAAS,CAAf,c;AAA8B,C;sBASnFU,CAAaF,aAAbE,EAA8C;A;EAAA,QAAM,+CAAN,C;SAC1C,I;;;;gCAAa,M,EAAA,C;UEhEgF,YAApC,mBAAwB,sCAAxB,C;YFgEtB,kDAA3B,0CAAc,SAAd,CAA2B,C;;SACnC,K;yBAAS,C,EAAA,C;;;MAFiC,8B;;;EAG7C,U;AAAD,C;;;;;"}

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

@@ -0,0 +1,221 @@
+import { SchedulerTaskrk35h6752rti as SchedulerTask } from './SchedulerTask.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { CompletedExceptionally3itrk74dxkv9s as CompletedExceptionally } from './CompletionState.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  DispatchedContinuation8kf77e5g2ha2 as DispatchedContinuation,
+  safeDispatch2vco9v5u7w5xs as safeDispatch,
+  safeIsDispatchNeeded2sl03dqd165wc as safeIsDispatchNeeded,
+} from './internal/DispatchedContinuation.mjs';
+import { Key_instance17dpgmdbeabno as Key_instance } from './Job.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 { recoverStackTrace2i3si2i8nvw1k as recoverStackTrace } from './internal/StackTraceRecovery.mjs';
+import { handleCoroutineExceptionv1m1bdk4j2te as handleCoroutineException } from './CoroutineExceptionHandler.mjs';
+import { CoroutinesInternalError3t354dypw0kr6 as CoroutinesInternalError } from './Exceptions.common.mjs';
+import {
+  toString1pkumu07cwy4m as toString,
+  captureStack1fzi4aczwc4hg as captureStack,
+} from '../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { Exceptiondt2hlxn7j7vw as Exception } from '../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { ThreadLocalEventLoop_getInstance2db7vbnjf6n0j as ThreadLocalEventLoop_getInstance } from './EventLoop.common.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var DispatchedTaskClass;
+function DispatchedTask() {
+  if (DispatchedTaskClass === VOID) {
+    class $ extends SchedulerTask() {
+      constructor(resumeMode) {
+        super();
+        this.p11_1 = resumeMode;
+      }
+      m12(takenState, cause) {
+      }
+      t12(state) {
+        return (state == null ? true : !(state == null)) ? state : THROW_CCE();
+      }
+      d13(state) {
+        var tmp0_safe_receiver = state instanceof CompletedExceptionally() ? state : null;
+        return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.ow_1;
+      }
+      f13() {
+        // Inline function 'kotlinx.coroutines.assert' call
+        try {
+          var tmp = this.k12();
+          var delegate = tmp instanceof DispatchedContinuation() ? tmp : THROW_CCE();
+          var continuation = delegate.h11_1;
+          // Inline function 'kotlinx.coroutines.withContinuationContext' call
+          delegate.j11_1;
+          var context = continuation.bd();
+          var state = this.l12();
+          var exception = this.d13(state);
+          var job = exception == null && get_isCancellableMode(this.p11_1) ? context.rd(Key_instance) : null;
+          if (!(job == null) && !job.jw()) {
+            var cause = job.ix();
+            this.m12(state, cause);
+            // Inline function 'kotlinx.coroutines.resumeWithStackTrace' call
+            // Inline function 'kotlin.Companion.failure' call
+            var exception_0 = recoverStackTrace(cause, continuation);
+            var tmp$ret$1 = _Result___init__impl__xyqfz8(createFailure(exception_0));
+            continuation.dd(tmp$ret$1);
+          } else {
+            if (!(exception == null)) {
+              // Inline function 'kotlin.coroutines.resumeWithException' call
+              // Inline function 'kotlin.Companion.failure' call
+              var tmp$ret$3 = _Result___init__impl__xyqfz8(createFailure(exception));
+              continuation.dd(tmp$ret$3);
+            } else {
+              // Inline function 'kotlin.coroutines.resume' call
+              // Inline function 'kotlin.Companion.success' call
+              var value = this.t12(state);
+              var tmp$ret$5 = _Result___init__impl__xyqfz8(value);
+              continuation.dd(tmp$ret$5);
+            }
+          }
+        } catch ($p) {
+          if ($p instanceof DispatchException()) {
+            var e = $p;
+            handleCoroutineException(this.k12().bd(), e.z13_1);
+          } else {
+            if ($p instanceof Error) {
+              var e_0 = $p;
+              this.g13(e_0);
+            } else {
+              throw $p;
+            }
+          }
+        }
+      }
+      g13(exception) {
+        var reason = CoroutinesInternalError().a15('Fatal exception in coroutines machinery for ' + toString(this) + '. ' + "Please read KDoc to 'handleFatalException' method and report this incident to maintainers", exception);
+        handleCoroutineException(this.k12().bd(), reason);
+      }
+    }
+    initMetadataForClass($, 'DispatchedTask');
+    DispatchedTaskClass = $;
+  }
+  return DispatchedTaskClass;
+}
+function get_isReusableMode(_this__u8e3s4) {
+  return _this__u8e3s4 === 2;
+}
+function get_isCancellableMode(_this__u8e3s4) {
+  return _this__u8e3s4 === 1 || _this__u8e3s4 === 2;
+}
+function dispatch(_this__u8e3s4, mode) {
+  // Inline function 'kotlinx.coroutines.assert' call
+  var delegate = _this__u8e3s4.k12();
+  var undispatched = mode === 4;
+  var tmp;
+  var tmp_0;
+  if (!undispatched) {
+    tmp_0 = delegate instanceof DispatchedContinuation();
+  } else {
+    tmp_0 = false;
+  }
+  if (tmp_0) {
+    tmp = get_isCancellableMode(mode) === get_isCancellableMode(_this__u8e3s4.p11_1);
+  } else {
+    tmp = false;
+  }
+  if (tmp) {
+    var dispatcher = delegate.g11_1;
+    var context = delegate.bd();
+    if (safeIsDispatchNeeded(dispatcher, context)) {
+      safeDispatch(dispatcher, context, _this__u8e3s4);
+    } else {
+      resumeUnconfined(_this__u8e3s4);
+    }
+  } else {
+    resume(_this__u8e3s4, delegate, undispatched);
+  }
+}
+var DispatchExceptionClass;
+function DispatchException() {
+  if (DispatchExceptionClass === VOID) {
+    class $ extends Exception() {
+      static i1j(cause, dispatcher, context) {
+        var $this = this.le('Coroutine dispatcher ' + dispatcher.toString() + ' threw an exception, context = ' + toString(context), cause);
+        captureStack($this, $this.a14_1);
+        $this.z13_1 = cause;
+        delete $this.cause;
+        return $this;
+      }
+      s() {
+        return this.z13_1;
+      }
+      get cause() {
+        return this.s();
+      }
+    }
+    initMetadataForClass($, 'DispatchException');
+    DispatchExceptionClass = $;
+  }
+  return DispatchExceptionClass;
+}
+function resumeUnconfined(_this__u8e3s4) {
+  var eventLoop = ThreadLocalEventLoop_getInstance().u14();
+  if (eventLoop.o14()) {
+    eventLoop.n14(_this__u8e3s4);
+  } else {
+    // Inline function 'kotlinx.coroutines.runUnconfinedEventLoop' call
+    eventLoop.q14(true);
+    try {
+      resume(_this__u8e3s4, _this__u8e3s4.k12(), true);
+      $l$loop: while (eventLoop.m14()) {
+      }
+    } catch ($p) {
+      if ($p instanceof Error) {
+        var e = $p;
+        _this__u8e3s4.g13(e);
+      } else {
+        throw $p;
+      }
+    }
+    finally {
+      eventLoop.r14(true);
+    }
+  }
+}
+function resume(_this__u8e3s4, delegate, undispatched) {
+  var state = _this__u8e3s4.l12();
+  var exception = _this__u8e3s4.d13(state);
+  var tmp;
+  if (!(exception == null)) {
+    // Inline function 'kotlin.Companion.failure' call
+    tmp = _Result___init__impl__xyqfz8(createFailure(exception));
+  } else {
+    // Inline function 'kotlin.Companion.success' call
+    var value = _this__u8e3s4.t12(state);
+    tmp = _Result___init__impl__xyqfz8(value);
+  }
+  var result = tmp;
+  if (undispatched) {
+    // Inline function 'kotlinx.coroutines.internal.DispatchedContinuation.resumeUndispatchedWith' call
+    var this_0 = delegate instanceof DispatchedContinuation() ? delegate : THROW_CCE();
+    this_0.h11_1;
+    // Inline function 'kotlinx.coroutines.withContinuationContext' call
+    this_0.j11_1;
+    this_0.h11_1.dd(result);
+  } else {
+    delegate.dd(result);
+  }
+}
+//region block: exports
+export {
+  DispatchException as DispatchException248dwsudeuh1h,
+  DispatchedTask as DispatchedTask39ez3ayqqzt3m,
+  dispatch as dispatch2sf9j0r16c3zo,
+  get_isCancellableMode as get_isCancellableMode2kisg4oawmpb2,
+  get_isReusableMode as get_isReusableMode36u17a15bfmkj,
+};
+//endregion
+
+//# sourceMappingURL=DispatchedTask.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/internal/DispatchedTask.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/internal/DispatchedContinuation.kt"],"sourcesContent":[null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["resumeMode","cancelCompletedResult","takenState","cause","getSuccessfulResult","state","getExceptionalResult","run","delegate","continuation","context","exception","job","e","handleFatalException","reason","<get-isReusableMode>","<this>","<get-isCancellableMode>","dispatch","mode","undispatched","dispatcher","<get-cause>","resumeUnconfined","eventLoop","resume","result"],"mappings":"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"}

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

@@ -0,0 +1,75 @@
+import { createDefaultDispatcher34z5li45gie67 as createDefaultDispatcher } from './CoroutineContext.mjs';
+import { Unconfined_getInstance17f2s8ko18ri2 as Unconfined_getInstance } from './Unconfined.mjs';
+import {
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { MainCoroutineDispatcher158x49bd8e9gp as MainCoroutineDispatcher } from './MainCoroutineDispatcher.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var DispatchersClass;
+function Dispatchers() {
+  if (DispatchersClass === VOID) {
+    class $ {
+      constructor() {
+        Dispatchers_instance = this;
+        this.e18_1 = createDefaultDispatcher();
+        this.f18_1 = Unconfined_getInstance();
+        this.g18_1 = new (JsMainDispatcher())(this.e18_1, false);
+        this.h18_1 = null;
+      }
+      i18() {
+        var tmp0_elvis_lhs = this.h18_1;
+        return tmp0_elvis_lhs == null ? this.g18_1 : tmp0_elvis_lhs;
+      }
+    }
+    initMetadataForObject($, 'Dispatchers');
+    DispatchersClass = $;
+  }
+  return DispatchersClass;
+}
+var Dispatchers_instance;
+function Dispatchers_getInstance() {
+  if (Dispatchers_instance === VOID)
+    new (Dispatchers())();
+  return Dispatchers_instance;
+}
+var JsMainDispatcherClass;
+function JsMainDispatcher() {
+  if (JsMainDispatcherClass === VOID) {
+    class $ extends MainCoroutineDispatcher() {
+      constructor(delegate, invokeImmediately) {
+        super();
+        this.f1n_1 = delegate;
+        this.g1n_1 = invokeImmediately;
+        this.h1n_1 = this.g1n_1 ? this : new (JsMainDispatcher())(this.f1n_1, true);
+      }
+      c18() {
+        return this.h1n_1;
+      }
+      t13(context) {
+        return !this.g1n_1;
+      }
+      w13(context, block) {
+        return this.f1n_1.w13(context, block);
+      }
+      toString() {
+        var tmp0_elvis_lhs = this.d18();
+        return tmp0_elvis_lhs == null ? this.f1n_1.toString() : tmp0_elvis_lhs;
+      }
+    }
+    initMetadataForClass($, 'JsMainDispatcher');
+    JsMainDispatcherClass = $;
+  }
+  return JsMainDispatcherClass;
+}
+//region block: exports
+export {
+  Dispatchers_getInstance as Dispatchers_getInstancewbokwrm9sosb,
+};
+//endregion
+
+//# sourceMappingURL=Dispatchers.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/jsAndWasmShared/src/Dispatchers.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-Main>","delegate","invokeImmediately","<get-immediate>","isDispatchNeeded","context","dispatch","block","toString"],"mappings":";;;;;;;;;;;;;;;;;;QAOqD,sC;QAGG,qC;QAEvB,sCAAiB,IAAjB,CAAiB,KAAjB,EAA0B,KAA1B,C;QACkC,iB;;SAJ3DA,CAAAA,EAAQ;A,YAAA,2B;QAAwC,OAAxC,yBAA0B,IAA1B,CAA0B,KAA1B,iB;MAAuC,C;;;;;;;;;;;;;;;;;kBAanDC,Q,EACAC,iB;;QADA,qB;QACA,8B;QAGI,aAAI,aAAmB,IAAnB,4BAA8C,IAA9C,CAA8C,KAA9C,EAAwD,IAAxD,C;;SADRC,CAAAA,EAAA;A,QAAA,iB;MAA8C,C;SAE9CC,CAA8BC,OAA9BD,EAAoE;A,QAAkB,OAAlB,CAAC,IAAD,CAAC,K;MAAgB,C;SACrFE,CAAsBD,O,EAA2BE,KAAjDD,EAAoE;A,QAAiC,OAAjC,IAAS,CAAT,KAAS,KAAS,OAAT,EAAkB,KAAlB,C;MAAuB,C;cAEpGE,CAAAA,EAAkC;A,YAAA,2B;QAA6C,OAA7C,yBAA0B,IAAS,CAAT,KAAS,WAAnC,iB;MAA4C,C;;;;;;;;;;;"}