@attocash/commons-js 5.0.0

package/kotlinx-atomicfu/kotlinx/atomicfu/AtomicFU.mjs

@@ -0,0 +1,232 @@
+import { toString30pk9tzaqopn as toString } from '../../../kotlin-kotlin-stdlib/kotlin/Library.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 { None_getInstance39nj59i93bjcl as None_getInstance } from './Trace.common.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var AtomicRefClass;
+function AtomicRef() {
+  if (AtomicRefClass === VOID) {
+    class $ {
+      constructor(value) {
+        this.kotlinx$atomicfu$value = value;
+      }
+      h1x(_set____db54di) {
+        this.kotlinx$atomicfu$value = _set____db54di;
+      }
+      i1x() {
+        return this.kotlinx$atomicfu$value;
+      }
+      atomicfu$compareAndSet(expect, update) {
+        if (!(this.kotlinx$atomicfu$value === expect))
+          return false;
+        this.kotlinx$atomicfu$value = update;
+        return true;
+      }
+      atomicfu$getAndSet(value) {
+        var oldValue = this.kotlinx$atomicfu$value;
+        this.kotlinx$atomicfu$value = value;
+        return oldValue;
+      }
+      toString() {
+        return toString(this.kotlinx$atomicfu$value);
+      }
+    }
+    initMetadataForClass($, 'AtomicRef');
+    AtomicRefClass = $;
+  }
+  return AtomicRefClass;
+}
+function atomic$ref$1(initial) {
+  return atomic$ref$(initial, None_getInstance());
+}
+var AtomicBooleanClass;
+function AtomicBoolean() {
+  if (AtomicBooleanClass === VOID) {
+    class $ {
+      constructor(value) {
+        this.kotlinx$atomicfu$value = value;
+      }
+      j1x(_set____db54di) {
+        this.kotlinx$atomicfu$value = _set____db54di;
+      }
+      i1x() {
+        return this.kotlinx$atomicfu$value;
+      }
+      atomicfu$compareAndSet(expect, update) {
+        if (!(this.kotlinx$atomicfu$value === expect))
+          return false;
+        this.kotlinx$atomicfu$value = update;
+        return true;
+      }
+      atomicfu$getAndSet(value) {
+        var oldValue = this.kotlinx$atomicfu$value;
+        this.kotlinx$atomicfu$value = value;
+        return oldValue;
+      }
+      toString() {
+        return this.kotlinx$atomicfu$value.toString();
+      }
+    }
+    initMetadataForClass($, 'AtomicBoolean');
+    AtomicBooleanClass = $;
+  }
+  return AtomicBooleanClass;
+}
+function atomic$boolean$1(initial) {
+  return atomic$boolean$(initial, None_getInstance());
+}
+var AtomicLongClass;
+function AtomicLong() {
+  if (AtomicLongClass === VOID) {
+    class $ {
+      constructor(value) {
+        this.kotlinx$atomicfu$value = value;
+      }
+      k1x(_set____db54di) {
+        this.kotlinx$atomicfu$value = _set____db54di;
+      }
+      i1x() {
+        return this.kotlinx$atomicfu$value;
+      }
+      atomicfu$compareAndSet(expect, update) {
+        if (!this.kotlinx$atomicfu$value.equals(expect))
+          return false;
+        this.kotlinx$atomicfu$value = update;
+        return true;
+      }
+      atomicfu$getAndSet(value) {
+        var oldValue = this.kotlinx$atomicfu$value;
+        this.kotlinx$atomicfu$value = value;
+        return oldValue;
+      }
+      atomicfu$getAndIncrement$long() {
+        var _unary__edvuaz = this.kotlinx$atomicfu$value;
+        this.kotlinx$atomicfu$value = _unary__edvuaz.u3();
+        return _unary__edvuaz;
+      }
+      atomicfu$getAndDecrement$long() {
+        var _unary__edvuaz = this.kotlinx$atomicfu$value;
+        this.kotlinx$atomicfu$value = _unary__edvuaz.v3();
+        return _unary__edvuaz;
+      }
+      atomicfu$getAndAdd$long(delta) {
+        var oldValue = this.kotlinx$atomicfu$value;
+        this.kotlinx$atomicfu$value = this.kotlinx$atomicfu$value.p3(delta);
+        return oldValue;
+      }
+      atomicfu$addAndGet$long(delta) {
+        this.kotlinx$atomicfu$value = this.kotlinx$atomicfu$value.p3(delta);
+        return this.kotlinx$atomicfu$value;
+      }
+      atomicfu$incrementAndGet$long() {
+        this.kotlinx$atomicfu$value = this.kotlinx$atomicfu$value.u3();
+        return this.kotlinx$atomicfu$value;
+      }
+      atomicfu$decrementAndGet$long() {
+        this.kotlinx$atomicfu$value = this.kotlinx$atomicfu$value.v3();
+        return this.kotlinx$atomicfu$value;
+      }
+      toString() {
+        return this.kotlinx$atomicfu$value.toString();
+      }
+    }
+    initMetadataForClass($, 'AtomicLong');
+    AtomicLongClass = $;
+  }
+  return AtomicLongClass;
+}
+function atomic$long$1(initial) {
+  return atomic$long$(initial, None_getInstance());
+}
+var AtomicIntClass;
+function AtomicInt() {
+  if (AtomicIntClass === VOID) {
+    class $ {
+      constructor(value) {
+        this.kotlinx$atomicfu$value = value;
+      }
+      l1x(_set____db54di) {
+        this.kotlinx$atomicfu$value = _set____db54di;
+      }
+      i1x() {
+        return this.kotlinx$atomicfu$value;
+      }
+      atomicfu$compareAndSet(expect, update) {
+        if (!(this.kotlinx$atomicfu$value === expect))
+          return false;
+        this.kotlinx$atomicfu$value = update;
+        return true;
+      }
+      atomicfu$getAndSet(value) {
+        var oldValue = this.kotlinx$atomicfu$value;
+        this.kotlinx$atomicfu$value = value;
+        return oldValue;
+      }
+      atomicfu$getAndIncrement() {
+        var _unary__edvuaz = this.kotlinx$atomicfu$value;
+        this.kotlinx$atomicfu$value = _unary__edvuaz + 1 | 0;
+        return _unary__edvuaz;
+      }
+      atomicfu$getAndDecrement() {
+        var _unary__edvuaz = this.kotlinx$atomicfu$value;
+        this.kotlinx$atomicfu$value = _unary__edvuaz - 1 | 0;
+        return _unary__edvuaz;
+      }
+      atomicfu$getAndAdd(delta) {
+        var oldValue = this.kotlinx$atomicfu$value;
+        this.kotlinx$atomicfu$value = this.kotlinx$atomicfu$value + delta | 0;
+        return oldValue;
+      }
+      atomicfu$addAndGet(delta) {
+        this.kotlinx$atomicfu$value = this.kotlinx$atomicfu$value + delta | 0;
+        return this.kotlinx$atomicfu$value;
+      }
+      atomicfu$incrementAndGet() {
+        this.kotlinx$atomicfu$value = this.kotlinx$atomicfu$value + 1 | 0;
+        return this.kotlinx$atomicfu$value;
+      }
+      atomicfu$decrementAndGet() {
+        this.kotlinx$atomicfu$value = this.kotlinx$atomicfu$value - 1 | 0;
+        return this.kotlinx$atomicfu$value;
+      }
+      toString() {
+        return this.kotlinx$atomicfu$value.toString();
+      }
+    }
+    initMetadataForClass($, 'AtomicInt');
+    AtomicIntClass = $;
+  }
+  return AtomicIntClass;
+}
+function atomic$int$1(initial) {
+  return atomic$int$(initial, None_getInstance());
+}
+function atomic$ref$(initial, trace) {
+  trace = trace === VOID ? None_getInstance() : trace;
+  return new (AtomicRef())(initial);
+}
+function atomic$boolean$(initial, trace) {
+  trace = trace === VOID ? None_getInstance() : trace;
+  return new (AtomicBoolean())(initial);
+}
+function atomic$long$(initial, trace) {
+  trace = trace === VOID ? None_getInstance() : trace;
+  return new (AtomicLong())(initial);
+}
+function atomic$int$(initial, trace) {
+  trace = trace === VOID ? None_getInstance() : trace;
+  return new (AtomicInt())(initial);
+}
+//region block: exports
+export {
+  atomic$boolean$1 as atomic$boolean$1iggki4z65a2h,
+  atomic$long$1 as atomic$long$129k9zwo6n9ogd,
+  atomic$ref$1 as atomic$ref$130aurmcwdfdf1,
+  atomic$int$1 as atomic$int$11d5swdyn6j0pu,
+};
+//endregion
+
+//# sourceMappingURL=AtomicFU.mjs.map

package/kotlinx-atomicfu/kotlinx/atomicfu/AtomicFU.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../opt/buildAgent/work/711ef0d9c7c28b00/atomicfu/src/jsAndWasmSharedMain/kotlin/kotlinx/atomicfu/AtomicFU.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["value","<set-value>","<set-?>","<get-value>","compareAndSet","expect","update","getAndSet","oldValue","toString","atomic","initial","getAndIncrement","getAndDecrement","getAndAdd","delta","addAndGet","incrementAndGet","decrementAndGet","trace"],"mappings":"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"}

package/kotlinx-atomicfu/kotlinx/atomicfu/Trace.common.mjs

@@ -0,0 +1,55 @@
+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';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var NoneClass;
+function None() {
+  if (NoneClass === VOID) {
+    class $ extends atomicfu$TraceBase() {
+      constructor() {
+        None_instance = null;
+        super();
+        None_instance = this;
+      }
+    }
+    initMetadataForObject($, 'None');
+    NoneClass = $;
+  }
+  return NoneClass;
+}
+var None_instance;
+function None_getInstance() {
+  if (None_instance === VOID)
+    new (None())();
+  return None_instance;
+}
+var atomicfu$TraceBaseClass;
+function atomicfu$TraceBase() {
+  if (atomicfu$TraceBaseClass === VOID) {
+    class $ {
+      atomicfu$Trace$append$1(event) {
+      }
+      atomicfu$Trace$append$2(event1, event2) {
+      }
+      atomicfu$Trace$append$3(event1, event2, event3) {
+      }
+      atomicfu$Trace$append$4(event1, event2, event3, event4) {
+      }
+    }
+    initMetadataForClass($, 'TraceBase');
+    atomicfu$TraceBaseClass = $;
+  }
+  return atomicfu$TraceBaseClass;
+}
+//region block: exports
+export {
+  None_getInstance as None_getInstance39nj59i93bjcl,
+};
+//endregion
+
+//# sourceMappingURL=Trace.common.mjs.map

package/kotlinx-atomicfu/kotlinx/atomicfu/Trace.common.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../opt/buildAgent/work/711ef0d9c7c28b00/atomicfu/src/commonMain/kotlin/kotlinx/atomicfu/Trace.common.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["append","event","event1","event2","event3","event4"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAwEIA,CACuBC,KADvBD,EACmC;A,MAAC,C;6BAKpCA,CACuBE,M,EAAaC,MADpCH,EACiD;A,MAAC,C;6BAKlDA,CACuBE,M,EAAaC,M,EAAaC,MADjDJ,EAC8D;A,MAAC,C;6BAK/DA,CACuBE,M,EAAaC,M,EAAaC,M,EAAaC,MAD9DL,EAC2E;A,MAAC,C;;;;;;;;;;;"}

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

@@ -0,0 +1,98 @@
+import {
+  JobSupport3fdjh0rbee4be as JobSupport,
+  get_COMPLETING_WAITING_CHILDREN3nnjgv5wv89p1 as get_COMPLETING_WAITING_CHILDREN,
+} from './JobSupport.mjs';
+import {
+  Key_instance2tirv2rj82ml4 as Key_instance,
+  Job29shfjfygy86k as Job,
+} from './Job.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { get_classSimpleName2jgk6lzg9ft1 as get_classSimpleName } from './Debug.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import {
+  CompletedExceptionally3itrk74dxkv9s as CompletedExceptionally,
+  toState1lqvgl5d0bogr as toState,
+} from './CompletionState.mjs';
+import { handleCoroutineExceptionv1m1bdk4j2te as handleCoroutineException } from './CoroutineExceptionHandler.mjs';
+import { get_coroutineName3a0vy840b4l1i as get_coroutineName } from './CoroutineContext.mjs';
+import { Continuation1aa2oekvx7jm7 as Continuation } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/Continuation.mjs';
+import { CoroutineScopefcb5f5dwqcas as CoroutineScope } from './CoroutineScope.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 AbstractCoroutineClass;
+function AbstractCoroutine() {
+  if (AbstractCoroutineClass === VOID) {
+    class $ extends JobSupport() {
+      constructor(parentContext, initParentJob, active) {
+        super(active);
+        if (initParentJob) {
+          this.o1x(parentContext.nc(Key_instance));
+        }
+        this.r1x_1 = parentContext.lm(this);
+      }
+      gc() {
+        return this.r1x_1;
+      }
+      s1x() {
+        return this.r1x_1;
+      }
+      t1x() {
+        return super.t1x();
+      }
+      u1x(value) {
+      }
+      v1x(cause, handled) {
+      }
+      w1x() {
+        return get_classSimpleName(this) + ' was cancelled';
+      }
+      x1x(state) {
+        if (state instanceof CompletedExceptionally()) {
+          this.v1x(state.y1x_1, state.a1y());
+        } else {
+          this.u1x((state == null ? true : !(state == null)) ? state : THROW_CCE());
+        }
+      }
+      lc(result) {
+        var state = this.b1y(toState(result));
+        if (state === get_COMPLETING_WAITING_CHILDREN())
+          return Unit_instance;
+        this.c1y(state);
+      }
+      c1y(state) {
+        return this.d1y(state);
+      }
+      e1y(exception) {
+        handleCoroutineException(this.r1x_1, exception);
+      }
+      f1y() {
+        var tmp0_elvis_lhs = get_coroutineName(this.r1x_1);
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          return super.f1y();
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        var coroutineName = tmp;
+        return '"' + coroutineName + '":' + super.f1y();
+      }
+      g1y(start, receiver, block) {
+        start.j1y(block, receiver, this);
+      }
+    }
+    initMetadataForClass($, 'AbstractCoroutine', VOID, VOID, [JobSupport(), Job(), Continuation(), CoroutineScope()], [0]);
+    AbstractCoroutineClass = $;
+  }
+  return AbstractCoroutineClass;
+}
+//region block: exports
+export {
+  AbstractCoroutine as AbstractCoroutine2jzyhqo91sb0o,
+};
+//endregion
+
+//# sourceMappingURL=AbstractCoroutine.mjs.map

package/kotlinx-coroutines-core/kotlinx/coroutines/AbstractCoroutine.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/AbstractCoroutine.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["parentContext","initParentJob","active","<get-context>","<get-coroutineContext>","<get-isActive>","onCompleted","value","onCancelled","cause","handled","cancellationExceptionMessage","onCompletionInternal","state","resumeWith","result","afterResume","handleOnCompletionException","exception","nameString","coroutineName","start","receiver","block"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoCIA,a,EACAC,a,EACAC,M;cACW,M;QAUH,kB;UAAe,SAAc,8BAAd,C;;QAO+B,8BAAgB,IAAhB,C;;QADtDC,CAAAA,EAAA;A,QAAA,iB;MACkD,C;SAKKC,CAAAA,EAAQ;A,QAAO,OAAP,IAAO,CAAP,K;MAAM,C;SAEtCC,CAAAA,EAAQ;A,QAAc,OAAR,W;MAAO,C;SAMpDC,CAA+BC,KAA/BD,EAAyC;A,MAAC,C;SAa1CE,CAA+BC,K,EAAkBC,OAAjDF,EAAmE;A,MAAC,C;SAEpEG,CAAAA,EAAsD;A,QAAgC,OAA9B,yBAA8B,GAAf,gB;MAAc,C;SAErFC,CACkDC,KADlDD,EAC+D;A,QACvD,8C;UACA,SAAY,KAAZ,CAAkB,KAAlB,EAAyB,KAAM,MAA/B,C;;UAEA,UAAY,KAAZ,oBAAY,KAAZ,aAAY,KAAZ,e;;MACR,C;QAKAE,CAAqCC,MAArCD,EAAwD;A,YACpDD,QAAY,SAA0B,QAAP,MAAO,CAA1B,C;QACR,cAAU,iCAAV,C;UAAuC,oB;QAC3C,SAAY,KAAZ,C;MACJ,C;SAWAG,CAA+BH,KAA/BG,EAAoD;A,QAAsB,OAAtB,SAAgB,KAAhB,C;MAAqB,C;SAEzEC,CAAwDC,SAAxDD,EAA8E;A,QAC1E,yBAAyB,IAAzB,CAAyB,KAAzB,EAAkC,SAAlC,C;MACJ,C;SAEAE,CAAAA,EAA2C;A,YACnB,iBAAQ,kBAAR,IAAQ,CAAR,KAAQ,C;;QAAR,2B;UAAyB,OAAa,W;;gBAAtC,c;;YAApBC,mB;QACA,OAAQ,GAAR,GAAW,aAAX,GAAwB,IAAxB,GAAmC,W;MACvC,C;SAWAC,CAAqBA,K,EAAuBC,Q,EAAaC,KAAzDF,EAAmF;A,QAC/E,UAAM,KAAN,EAAa,QAAb,EAAuB,IAAvB,C;MACJ,C;;;;;;;;;;;"}

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

@@ -0,0 +1,285 @@
+import { EmptyCoroutineContext_getInstance31fow51ayy30t 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_getInstance2bbgmtawlnkke 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_instance17k9ki7fvysxq 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 { AbstractCoroutine2jzyhqo91sb0o as AbstractCoroutine } from './AbstractCoroutine.mjs';
+import { handleCoroutineExceptionv1m1bdk4j2te as handleCoroutineException } from './CoroutineExceptionHandler.mjs';
+import {
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+} from '../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import {
+  createCoroutineUnintercepted3gya308dmbbtg as createCoroutineUnintercepted,
+  intercepted2ogpsikxxj4u0 as intercepted,
+} from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { Unit_instance1fbcbse1fwigr 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 { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { unboxStateze7t12boxn2m as unboxState } from './JobSupport.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl } from '../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineImpl.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+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.v1z() ? new (LazyStandaloneCoroutine())(newContext, block) : new (StandaloneCoroutine())(newContext, true);
+  coroutine.g1y(start, coroutine, block);
+  return coroutine;
+}
+function withContext(context, block, $completion) {
+  var tmp$ret$0;
+  $l$block_0: {
+    var oldContext = $completion.gc();
+    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.nc(Key_instance), oldContext.nc(Key_instance))) {
+      var coroutine_0 = new (UndispatchedCoroutine())(newContext, $completion);
+      // Inline function 'kotlinx.coroutines.withCoroutineContext' call
+      coroutine_0.r1x_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.b20();
+  }
+  return tmp$ret$0;
+}
+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.v1z() ? new (LazyDeferredCoroutine())(newContext, block) : new (DeferredCoroutine())(newContext, true);
+  coroutine.g1y(start, coroutine, block);
+  return coroutine;
+}
+var StandaloneCoroutineClass;
+function StandaloneCoroutine() {
+  if (StandaloneCoroutineClass === VOID) {
+    class $ extends AbstractCoroutine() {
+      constructor(parentContext, active) {
+        super(parentContext, true, active);
+      }
+      q1z(exception) {
+        handleCoroutineException(this.r1x_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.i20_1 = createCoroutineUnintercepted(block, this, this);
+      }
+      r1y() {
+        startCoroutineCancellable_0(this.i20_1, this);
+      }
+    }
+    initMetadataForClass($, 'LazyStandaloneCoroutine', VOID, VOID, VOID, [0]);
+    LazyStandaloneCoroutineClass = $;
+  }
+  return LazyStandaloneCoroutineClass;
+}
+function trySuspend($this) {
+  // Inline function 'kotlinx.atomicfu.loop' call
+  var this_0 = $this.a20_1;
+  while (true) {
+    switch (this_0.kotlinx$atomicfu$value) {
+      case 0:
+        if ($this.a20_1.atomicfu$compareAndSet(0, 1))
+          return true;
+        break;
+      case 2:
+        return false;
+      default:
+        // Inline function 'kotlin.error' call
+
+        var message = 'Already suspended';
+        throw IllegalStateException().o4(toString(message));
+    }
+  }
+}
+function tryResume($this) {
+  // Inline function 'kotlinx.atomicfu.loop' call
+  var this_0 = $this.a20_1;
+  while (true) {
+    switch (this_0.kotlinx$atomicfu$value) {
+      case 0:
+        if ($this.a20_1.atomicfu$compareAndSet(0, 2))
+          return true;
+        break;
+      case 1:
+        return false;
+      default:
+        // Inline function 'kotlin.error' call
+
+        var message = 'Already resumed';
+        throw IllegalStateException().o4(toString(message));
+    }
+  }
+}
+var DispatchedCoroutineClass;
+function DispatchedCoroutine() {
+  if (DispatchedCoroutineClass === VOID) {
+    class $ extends ScopeCoroutine() {
+      constructor(context, uCont) {
+        super(context, uCont);
+        this.a20_1 = atomic$int$1(0);
+      }
+      d1y(state) {
+        this.c1y(state);
+      }
+      c1y(state) {
+        if (tryResume(this))
+          return Unit_instance;
+        resumeCancellableWith(intercepted(this.m20_1), recoverResult(state, this.m20_1));
+      }
+      b20() {
+        if (trySuspend(this))
+          return get_COROUTINE_SUSPENDED();
+        var state = unboxState(this.n1y());
+        if (state instanceof CompletedExceptionally())
+          throw state.y1x_1;
+        return (state == null ? true : !(state == null)) ? state : THROW_CCE();
+      }
+    }
+    initMetadataForClass($, 'DispatchedCoroutine', VOID, VOID, VOID, [0]);
+    DispatchedCoroutineClass = $;
+  }
+  return DispatchedCoroutineClass;
+}
+var $awaitCOROUTINE$Class;
+function $awaitCOROUTINE$() {
+  if ($awaitCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, resultContinuation) {
+        super(resultContinuation);
+        this.w20_1 = _this__u8e3s4;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 2;
+                this.ac_1 = 1;
+                suspendResult = this.w20_1.u1z(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                return (suspendResult == null ? true : !(suspendResult == null)) ? suspendResult : THROW_CCE();
+              case 2:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 2) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $awaitCOROUTINE$Class = $;
+  }
+  return $awaitCOROUTINE$Class;
+}
+var DeferredCoroutineClass;
+function DeferredCoroutine() {
+  if (DeferredCoroutineClass === VOID) {
+    class $ extends AbstractCoroutine() {
+      constructor(parentContext, active) {
+        super(parentContext, true, active);
+      }
+      a21() {
+        var tmp = this.t1z();
+        return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+      }
+      b21($completion) {
+        var tmp = new ($awaitCOROUTINE$())(this, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+    }
+    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.f21_1 = createCoroutineUnintercepted(block, this, this);
+      }
+      r1y() {
+        startCoroutineCancellable_0(this.f21_1, this);
+      }
+    }
+    initMetadataForClass($, 'LazyDeferredCoroutine', VOID, VOID, VOID, [0]);
+    LazyDeferredCoroutineClass = $;
+  }
+  return LazyDeferredCoroutineClass;
+}
+//region block: exports
+export {
+  withContext as withContexte657h72vdbqn,
+  async as asyncz02dsa2nb2zt,
+  launch as launch1c91vkjzdi9sd,
+};
+//endregion
+
+//# sourceMappingURL=Builders.common.mjs.map