@attocash/commons-js 5.0.0

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

@@ -0,0 +1,78 @@
+import { EmptyCoroutineContext_getInstance31fow51ayy30t as EmptyCoroutineContext_getInstance } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineContextImpl.mjs';
+import {
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+} from '../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  Job13y4jkazwjho0 as Job,
+  Key_instance2tirv2rj82ml4 as Key_instance,
+} from './Job.mjs';
+import { ContextScoper0znlsj7ufhq as ContextScope } from './internal/Scopes.mjs';
+import { CancellationExceptionjngvjj221x3v as CancellationException } from './Exceptions.mjs';
+import { toString1pkumu07cwy4m as toString } from '../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var GlobalScopeClass;
+function GlobalScope() {
+  if (GlobalScopeClass === VOID) {
+    class $ {
+      s1x() {
+        return EmptyCoroutineContext_getInstance();
+      }
+    }
+    initMetadataForObject($, 'GlobalScope', VOID, VOID, [CoroutineScope()]);
+    GlobalScopeClass = $;
+  }
+  return GlobalScopeClass;
+}
+var GlobalScope_instance;
+function GlobalScope_getInstance() {
+  return GlobalScope_instance;
+}
+var CoroutineScopeClass;
+function CoroutineScope() {
+  if (CoroutineScopeClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'CoroutineScope');
+    CoroutineScopeClass = $;
+  }
+  return CoroutineScopeClass;
+}
+function CoroutineScope_0(context) {
+  return new (ContextScope())(!(context.nc(Key_instance) == null) ? context : context.lm(Job()));
+}
+function cancel(_this__u8e3s4, message, cause) {
+  cause = cause === VOID ? null : cause;
+  return cancel_0(_this__u8e3s4, CancellationException(message, cause));
+}
+function cancel_0(_this__u8e3s4, cause) {
+  cause = cause === VOID ? null : cause;
+  var tmp0_elvis_lhs = _this__u8e3s4.s1x().nc(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().o4(toString(message));
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var job = tmp;
+  job.c1z(cause);
+}
+//region block: init
+GlobalScope_instance = new (GlobalScope())();
+//endregion
+//region block: exports
+export {
+  GlobalScope_instance as GlobalScope_instance1sfulufhd2ijt,
+  CoroutineScope_0 as CoroutineScopelux7s7zphw7e,
+  CoroutineScope as CoroutineScopefcb5f5dwqcas,
+  cancel_0 as cancel36mj9lv3a0whl,
+  cancel as cancel2ztysw4v4hav6,
+};
+//endregion
+
+//# sourceMappingURL=CoroutineScope.mjs.map

package/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>","CoroutineScope","context","cancel","<this>","message","cause","job"],"mappings":";;;;;;;;;;;;;;;;;;;;;;SAkPQA,CAAAA,EAAQ;A,QAAqB,0C;MAAD,C;;;;;;;;;;;;;;;;;;;;yBAsDpCC,CAC0BC,OAD1BD,EAEI;A,EAAoE,4BAAnD,8BAAgB,IAAhB,IAAsB,OAAtB,GAAmC,WAAU,KAAV,CAAgB,C;AAAD,C;eAkBvEE,CAAWC,a,EAAsBC,O,EAAiBC,KAAlDH,EAAoF;A,2BAAd,I;EAA2D,OAA7C,wBAAO,sBAAsB,OAAtB,EAA+B,KAA/B,CAAP,C;AAA4C,C;iBAVhIA,CAAWC,a,EAAsBE,KAAjCH,EAAuE;A,2BAAN,I;MACnD,qD;;EAAA,2B;kBAAgC,4DAAD,YAA4D,aAA5D,C;IApOwB,iCAAoC,SAAR,OAAQ,CAApC,C;;UAoOvD,c;;MAAVI,S;EACA,GAAI,KAAO,KAAP,C;AACR,C;;;;;;;;"}

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

@@ -0,0 +1,83 @@
+import { Unit_instance1fbcbse1fwigr 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() {
+      j1y(block, receiver, completion) {
+        var tmp;
+        switch (this.h3_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;
+      }
+      v1z() {
+        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;
+}
+//region block: exports
+export {
+  CoroutineStart_ATOMIC_getInstance as CoroutineStart_ATOMIC_getInstance30g3oja6rp37m,
+  CoroutineStart_DEFAULT_getInstance as CoroutineStart_DEFAULT_getInstance2bbgmtawlnkke,
+};
+//endregion
+
+//# sourceMappingURL=CoroutineStart.mjs.map

package/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;;;;;;SAkWIA,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/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/kotlinx-coroutines-core/kotlinx/coroutines/Debug.common.mjs.map

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

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

@@ -0,0 +1,39 @@
+import { getKClassFromExpression3vpejubogshaw as getKClassFromExpression } from '../../../kotlin-kotlin-stdlib/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).ag();
+  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/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/kotlinx-coroutines-core/kotlinx/coroutines/Delay.mjs

@@ -0,0 +1,59 @@
+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_instance17k9ki7fvysxq as Key_instance } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/ContinuationInterceptor.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { Long2qws0ah9gnpki as Long } from '../../../kotlin-kotlin-stdlib/kotlin/Primitives.mjs';
+import { intercepted2ogpsikxxj4u0 as intercepted } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import { CancellableContinuationImpl1cx201opicavg as CancellableContinuationImpl } from './CancellableContinuationImpl.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function invokeOnTimeout(timeMillis, block, context) {
+  return get_DefaultDelay().q25(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.nc(Key_instance);
+  var tmp0_elvis_lhs = (!(tmp == null) ? isInterface(tmp, Delay()) : false) ? tmp : null;
+  return tmp0_elvis_lhs == null ? get_DefaultDelay() : tmp0_elvis_lhs;
+}
+function delay(timeMillis, $completion) {
+  if (timeMillis.a2(new (Long())(0, 0)) <= 0)
+    return Unit_instance;
+  var cancellable = new (CancellableContinuationImpl())(intercepted($completion), 1);
+  cancellable.a23();
+  if (timeMillis.a2(new (Long())(-1, 2147483647)) < 0) {
+    get_delay(cancellable.gc()).p25(timeMillis, cancellable);
+  }
+  return cancellable.b20();
+}
+var DelayWithTimeoutDiagnosticsClass;
+function DelayWithTimeoutDiagnostics() {
+  if (DelayWithTimeoutDiagnosticsClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'DelayWithTimeoutDiagnostics', VOID, VOID, [Delay()], [1]);
+    DelayWithTimeoutDiagnosticsClass = $;
+  }
+  return DelayWithTimeoutDiagnosticsClass;
+}
+//region block: exports
+export {
+  delay as delayolwo40i9ucjz,
+  DelayWithTimeoutDiagnostics as DelayWithTimeoutDiagnostics19ibxwhhgbjz0,
+  Delay as Delay9umexudtwyie,
+  get_delay as get_delaynv5kl66dta33,
+};
+//endregion
+
+//# sourceMappingURL=Delay.mjs.map

package/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"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["invokeOnTimeout","timeMillis","block","context","<get-delay>","<this>","delay","$completion","cancellable"],"mappings":";;;;;;;;;;;;;wBAmDIA,CAA2BC,U,EAAkBC,K,EAAiBC,OAA9DH,EACI;A,EAAwD,OAAxD,kBAAa,KAAgB,UAAhB,EAA4B,KAA5B,EAAmC,OAAnC,C;AAA0C,C;;;;;;;;;;kBAgGpBI,CAA9BC,aAA8BD,EAAQ;A,YAAA,8B;MAAA,kF;EAAsD,OAAtD,yBAA0C,kBAA1C,iB;AAAqD,C;cA5BxGE,CAAyBL,U,EAAzBM,WAAAD,EAA2C;A,EACnC,+BAAc,CAAd,EAAc,CAAd,Q;IAAiB,oB;MCiTjBE,kDAAoD,YD1YuB,WC0YvB,CAApDA,EAAgF,CAAhFA,C;EAMA,WAAY,M;EDpTR,+BAAkB,EAAlB,EAAkB,UAAlB,O,CAA6B;A,IAChB,UCoTX,WDpTG,KAAQ,CAAM,KAAyB,UAAzB,ECoTjB,WDpTiB,C;EACvB,C;EAJJ,OCwTI,WAAY,M;ADlTpB,C;;;;;;;;;;;;;;"}

package/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_instance1fbcbse1fwigr 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_instance2tirv2rj82ml4 as Key_instance } from './Job.mjs';
+import {
+  Companion_instance2oawqq9qiaris as Companion_instance,
+  _Result___init__impl__xyqfz83hut4nr3dfvi3 as _Result___init__impl__xyqfz8,
+  createFailure8paxfkfa5dc7 as createFailure,
+} from '../../../kotlin-kotlin-stdlib/kotlin/Result.mjs';
+import { 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_getInstance36jwo3qw2bxas 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.e22_1 = resumeMode;
+      }
+      c23(takenState, cause) {
+      }
+      j23(state) {
+        return (state == null ? true : !(state == null)) ? state : THROW_CCE();
+      }
+      s23(state) {
+        var tmp0_safe_receiver = state instanceof CompletedExceptionally() ? state : null;
+        return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.y1x_1;
+      }
+      u23() {
+        // Inline function 'kotlinx.coroutines.assert' call
+        try {
+          var tmp = this.z22();
+          var delegate = tmp instanceof DispatchedContinuation() ? tmp : THROW_CCE();
+          var continuation = delegate.x21_1;
+          // Inline function 'kotlinx.coroutines.withContinuationContext' call
+          delegate.z21_1;
+          var context = continuation.gc();
+          var state = this.b23();
+          var exception = this.s23(state);
+          var job = exception == null && get_isCancellableMode(this.e22_1) ? context.nc(Key_instance) : null;
+          if (!(job == null) && !job.t1x()) {
+            var cause = job.s1y();
+            this.c23(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.lc(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.lc(tmp$ret$3);
+            } else {
+              // Inline function 'kotlin.coroutines.resume' call
+              // Inline function 'kotlin.Companion.success' call
+              var value = this.j23(state);
+              var tmp$ret$5 = _Result___init__impl__xyqfz8(value);
+              continuation.lc(tmp$ret$5);
+            }
+          }
+        } catch ($p) {
+          if ($p instanceof DispatchException()) {
+            var e = $p;
+            handleCoroutineException(this.z22().gc(), e.j25_1);
+          } else {
+            if ($p instanceof Error) {
+              var e_0 = $p;
+              this.v23(e_0);
+            } else {
+              throw $p;
+            }
+          }
+        }
+      }
+      v23(exception) {
+        var reason = CoroutinesInternalError().k26('Fatal exception in coroutines machinery for ' + toString(this) + '. ' + "Please read KDoc to 'handleFatalException' method and report this incident to maintainers", exception);
+        handleCoroutineException(this.z22().gc(), 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.z22();
+  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.e22_1);
+  } else {
+    tmp = false;
+  }
+  if (tmp) {
+    var dispatcher = delegate.w21_1;
+    var context = delegate.gc();
+    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 e2n(cause, dispatcher, context) {
+        var $this = this.re('Coroutine dispatcher ' + dispatcher.toString() + ' threw an exception, context = ' + toString(context), cause);
+        captureStack($this, $this.k25_1);
+        $this.j25_1 = cause;
+        delete $this.cause;
+        return $this;
+      }
+      gd() {
+        return this.j25_1;
+      }
+      get cause() {
+        return this.gd();
+      }
+    }
+    initMetadataForClass($, 'DispatchException');
+    DispatchExceptionClass = $;
+  }
+  return DispatchExceptionClass;
+}
+function resumeUnconfined(_this__u8e3s4) {
+  var eventLoop = ThreadLocalEventLoop_getInstance().e26();
+  if (eventLoop.y25()) {
+    eventLoop.x25(_this__u8e3s4);
+  } else {
+    // Inline function 'kotlinx.coroutines.runUnconfinedEventLoop' call
+    eventLoop.a26(true);
+    try {
+      resume(_this__u8e3s4, _this__u8e3s4.z22(), true);
+      $l$loop: while (eventLoop.w25()) {
+      }
+    } catch ($p) {
+      if ($p instanceof Error) {
+        var e = $p;
+        _this__u8e3s4.v23(e);
+      } else {
+        throw $p;
+      }
+    }
+    finally {
+      eventLoop.b26(true);
+    }
+  }
+}
+function resume(_this__u8e3s4, delegate, undispatched) {
+  var state = _this__u8e3s4.b23();
+  var exception = _this__u8e3s4.s23(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.j23(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.x21_1;
+    // Inline function 'kotlinx.coroutines.withContinuationContext' call
+    this_0.z21_1;
+    this_0.x21_1.lc(result);
+  } else {
+    delegate.lc(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/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","src/kotlin/util/Result.kt","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/kotlinx-coroutines-core/kotlinx/coroutines/Dispatchers.mjs

@@ -0,0 +1,75 @@
+import { createDefaultDispatcher34z5li45gie67 as createDefaultDispatcher } from './CoroutineContext.mjs';
+import { Unconfined_getInstance6pooz906dfij 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.k2a_1 = createDefaultDispatcher();
+        this.l2a_1 = Unconfined_getInstance();
+        this.m2a_1 = new (JsMainDispatcher())(this.k2a_1, false);
+        this.n2a_1 = null;
+      }
+      o2a() {
+        var tmp0_elvis_lhs = this.n2a_1;
+        return tmp0_elvis_lhs == null ? this.m2a_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.z2p_1 = delegate;
+        this.a2q_1 = invokeImmediately;
+        this.b2q_1 = this.a2q_1 ? this : new (JsMainDispatcher())(this.z2p_1, true);
+      }
+      i2a() {
+        return this.b2q_1;
+      }
+      f25(context) {
+        return !this.a2q_1;
+      }
+      g25(context, block) {
+        return this.z2p_1.g25(context, block);
+      }
+      toString() {
+        var tmp0_elvis_lhs = this.j2a();
+        return tmp0_elvis_lhs == null ? this.z2p_1.toString() : tmp0_elvis_lhs;
+      }
+    }
+    initMetadataForClass($, 'JsMainDispatcher');
+    JsMainDispatcherClass = $;
+  }
+  return JsMainDispatcherClass;
+}
+//region block: exports
+export {
+  Dispatchers_getInstance as Dispatchers_getInstanceitgtkvqfcnx3,
+};
+//endregion
+
+//# sourceMappingURL=Dispatchers.mjs.map

package/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;;;;;;;;;;;"}