@continuous-excellence/coupling-cli 0.0.0

package/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineContextImpl.mjs

@@ -0,0 +1,238 @@
+import { Long2qws0ah9gnpki as Long } from '../Primitives.mjs';
+import {
+  CoroutineContext3n9ge8bnnq7z2 as CoroutineContext,
+  Element2gr7ezmxqaln7 as Element,
+  plusolev77jfy5r9 as plus,
+  get6d5x931vk0s as get,
+  fold36i9psb7d5v48 as fold,
+  minusKeyyqanvso9aovh as minusKey,
+} from './CoroutineContext.mjs';
+import {
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../Unit.mjs';
+import {
+  equals2au1ep9vhcato as equals,
+  toString1pkumu07cwy4m as toString,
+  hashCodeq5arwsb9dgti as hashCode,
+  protoOf180f3jzyo7rfj as protoOf,
+} from '../js/coreRuntime.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../hacks.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../js/typeCheckUtils.mjs';
+import { charSequenceLength3278n89t01tmv as charSequenceLength } from '../js/charSequenceJs.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var EmptyCoroutineContextClass;
+function EmptyCoroutineContext() {
+  if (EmptyCoroutineContextClass === VOID) {
+    class $ {
+      constructor() {
+        EmptyCoroutineContext_instance = this;
+        this.xo_1 = new (Long())(0, 0);
+      }
+      rd(key) {
+        return null;
+      }
+      vo(initial, operation) {
+        return initial;
+      }
+      wo(context) {
+        return context;
+      }
+      uo(key) {
+        return this;
+      }
+      hashCode() {
+        return 0;
+      }
+      toString() {
+        return 'EmptyCoroutineContext';
+      }
+    }
+    initMetadataForObject($, 'EmptyCoroutineContext', VOID, VOID, [CoroutineContext()]);
+    EmptyCoroutineContextClass = $;
+  }
+  return EmptyCoroutineContextClass;
+}
+var EmptyCoroutineContext_instance;
+function EmptyCoroutineContext_getInstance() {
+  if (EmptyCoroutineContext_instance === VOID)
+    new (EmptyCoroutineContext())();
+  return EmptyCoroutineContext_instance;
+}
+function size($this) {
+  var cur = $this;
+  var size = 2;
+  while (true) {
+    var tmp = cur.yo_1;
+    var tmp0_elvis_lhs = tmp instanceof CombinedContext() ? tmp : null;
+    var tmp_0;
+    if (tmp0_elvis_lhs == null) {
+      return size;
+    } else {
+      tmp_0 = tmp0_elvis_lhs;
+    }
+    cur = tmp_0;
+    size = size + 1 | 0;
+  }
+}
+function contains($this, element) {
+  return equals($this.rd(element.f3()), element);
+}
+function containsAll($this, context) {
+  var cur = context;
+  while (true) {
+    if (!contains($this, cur.zo_1))
+      return false;
+    var next = cur.yo_1;
+    if (next instanceof CombinedContext()) {
+      cur = next;
+    } else {
+      return contains($this, isInterface(next, Element()) ? next : THROW_CCE());
+    }
+  }
+}
+function CombinedContext$toString$lambda(acc, element) {
+  var tmp;
+  // Inline function 'kotlin.text.isEmpty' call
+  if (charSequenceLength(acc) === 0) {
+    tmp = toString(element);
+  } else {
+    tmp = acc + ', ' + toString(element);
+  }
+  return tmp;
+}
+var CombinedContextClass;
+function CombinedContext() {
+  if (CombinedContextClass === VOID) {
+    class $ {
+      constructor(left, element) {
+        this.yo_1 = left;
+        this.zo_1 = element;
+      }
+      rd(key) {
+        var cur = this;
+        while (true) {
+          var tmp0_safe_receiver = cur.zo_1.rd(key);
+          if (tmp0_safe_receiver == null)
+            null;
+          else {
+            // Inline function 'kotlin.let' call
+            return tmp0_safe_receiver;
+          }
+          var next = cur.yo_1;
+          if (next instanceof CombinedContext()) {
+            cur = next;
+          } else {
+            return next.rd(key);
+          }
+        }
+      }
+      vo(initial, operation) {
+        return operation(this.yo_1.vo(initial, operation), this.zo_1);
+      }
+      uo(key) {
+        if (this.zo_1.rd(key) == null)
+          null;
+        else {
+          // Inline function 'kotlin.let' call
+          return this.yo_1;
+        }
+        var newLeft = this.yo_1.uo(key);
+        return newLeft === this.yo_1 ? this : newLeft === EmptyCoroutineContext_getInstance() ? this.zo_1 : new (CombinedContext())(newLeft, this.zo_1);
+      }
+      equals(other) {
+        var tmp;
+        if (this === other) {
+          tmp = true;
+        } else {
+          var tmp_0;
+          var tmp_1;
+          if (other instanceof CombinedContext()) {
+            tmp_1 = size(other) === size(this);
+          } else {
+            tmp_1 = false;
+          }
+          if (tmp_1) {
+            tmp_0 = containsAll(other, this);
+          } else {
+            tmp_0 = false;
+          }
+          tmp = tmp_0;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return hashCode(this.yo_1) + hashCode(this.zo_1) | 0;
+      }
+      toString() {
+        return '[' + this.vo('', CombinedContext$toString$lambda) + ']';
+      }
+    }
+    protoOf($).wo = plus;
+    initMetadataForClass($, 'CombinedContext', VOID, VOID, [CoroutineContext()]);
+    CombinedContextClass = $;
+  }
+  return CombinedContextClass;
+}
+var AbstractCoroutineContextKeyClass;
+function AbstractCoroutineContextKey() {
+  if (AbstractCoroutineContextKeyClass === VOID) {
+    class $ {
+      constructor(baseKey, safeCast) {
+        this.qo_1 = safeCast;
+        var tmp = this;
+        var tmp_0;
+        if (baseKey instanceof AbstractCoroutineContextKey()) {
+          tmp_0 = baseKey.ro_1;
+        } else {
+          tmp_0 = baseKey;
+        }
+        tmp.ro_1 = tmp_0;
+      }
+      so(element) {
+        return this.qo_1(element);
+      }
+      to(key) {
+        return key === this || this.ro_1 === key;
+      }
+    }
+    initMetadataForClass($, 'AbstractCoroutineContextKey');
+    AbstractCoroutineContextKeyClass = $;
+  }
+  return AbstractCoroutineContextKeyClass;
+}
+var AbstractCoroutineContextElementClass;
+function AbstractCoroutineContextElement() {
+  if (AbstractCoroutineContextElementClass === VOID) {
+    class $ {
+      constructor(key) {
+        this.ap_1 = key;
+      }
+      f3() {
+        return this.ap_1;
+      }
+    }
+    protoOf($).rd = get;
+    protoOf($).vo = fold;
+    protoOf($).uo = minusKey;
+    protoOf($).wo = plus;
+    initMetadataForClass($, 'AbstractCoroutineContextElement', VOID, VOID, [Element()]);
+    AbstractCoroutineContextElementClass = $;
+  }
+  return AbstractCoroutineContextElementClass;
+}
+//region block: exports
+export {
+  EmptyCoroutineContext_getInstance as EmptyCoroutineContext_getInstance10e98b8bnsvr1,
+  AbstractCoroutineContextElement as AbstractCoroutineContextElement2rpehg0hv5szw,
+  AbstractCoroutineContextKey as AbstractCoroutineContextKey9xr9r6wlj5bm,
+  CombinedContext as CombinedContext278s863svhq02,
+};
+//endregion
+
+//# sourceMappingURL=CoroutineContextImpl.mjs.map

package/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineContextImpl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/src/kotlin/coroutines/CoroutineContextImpl.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/src/kotlin/text/Strings.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/src/kotlin/util/Standard.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["get","key","fold","initial","operation","plus","context","minusKey","hashCode","toString","size","cur","contains","element","containsAll","next","CombinedContext$toString$lambda","left","newLeft","equals","other","baseKey","safeCast","tryCast","isSubKey","<get-key>"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAiG+C,8B;;QAG3BA,CAAsBC,GAAtBD,EAAyC;A,QAAI,OAAJ,I;MAAG,C;QAC5CE,CAAaC,O,EAAYC,SAAzBF,EAA4D;A,QAAO,OAAP,O;MAAM,C;QAClEG,CAASC,OAATD,EAAwD;A,QAAO,OAAP,O;MAAM,C;QAC9DE,CAAaN,GAAbM,EAA8C;A,QAAI,OAAJ,I;MAAG,C;cACjDC,CAAAA,EAAsB;A,QAAC,OAAD,C;MAAA,C;cACtBC,CAAAA,EAAyB;A,QAAuB,OAAvB,uB;MAAsB,C;;;;;;;;;;;;;aAuCvDC,CAAA,KAAAA,EAAgB;A,MACpBC,MAAU,K;MACVD,OAAW,C;SACJ,I,EAAM;A,cACH,G,CAAI,I;QAAJ,8D;;IAAA,2B;MAAgC,OAAO,I;;cAAvC,c;;IAAN,W;IACA,OAAA,IAAI,IAAJ,I;EACJ,C;AACJ,C;iBAEQE,CAAA,K,EAAaC,OAAbD,EACJ;A,EAA2B,OAA3B,gBAAI,OAAQ,KAAZ,GAAoB,OAApB,C;AAA0B,C;oBAEtBE,CAAA,K,EAAgBR,OAAhBQ,EAAmD;A,MACvDH,MAAU,O;SACH,I,EAAM;A,IACL,KAAC,gBAAS,GAAT,CAAa,IAAb,CAAD,C;MAAwB,OAAO,K;QACnCI,OAAW,GAAXA,CAAe,I;IACX,sC,CAAyB;A,MACzB,MAAM,I;IACV,C;MACI,OAAO,4BAAS,IAAT,eAAS,IAAT,e;;EAEf,C;AACJ,C;wCAQmBC,CAAE,G,EAAK,OAAPA,EAAA;A;;EACP,ICsHoC,mBDtHpC,GCsHoC,MAAU,CDtH9C,C;UAAuB,SAAR,OAAQ,C;;UAAkB,G,GAAG,I,YAAG,O;;EAAQ,U;AAC/D,C;;;;;kBA/DIC,I,EACAJ,O;QADR,gB;QACA,mB;;QAGSb,CAAsBC,GAAtBD,EAAuC;A,YAC5CW,MAAU,I;eACH,I,EAAM;A,cACT,yBAAI,IAAJ,IAAY,GAAZ,C;UAAkB,+B;YAAA,I;eAAA;A;YEH+mD,OFGjoD,kB;UAAkC,C;cAClCI,OAAW,GAAXA,CAAe,I;UACX,sC,CAAyB;A,YACzB,MAAM,I;UACV,C;YACI,OAAO,QAAK,GAAL,C;;QAEf,C;MACJ,C;QAEgBb,CAAaC,O,EAAYC,SAAzBF,EACZ;A,QAAiD,OAAjD,UAAU,IAAK,CAAL,IAAK,IAAK,OAAL,EAAc,SAAd,CAAf,EAAyC,IAAzC,CAAyC,IAAzC,C;MAAgD,C;QAEpCK,CAAaN,GAAbM,EAA4C;A,QAC1C,IAAd,aAAQ,GAAR,CAAc,S;UAAA,I;aAAA;A;UEjBuiE,OAAO,IAAP,CAAO,I;QFiB5hE,C;YAChCW,UAAc,IAAK,CAAL,IAAK,IAAS,GAAT,C;QACnB,OACI,YAAY,IAAZ,CAAY,IAAZ,GAAoB,IAApB,GACA,kDAAqC,IAArC,CAAqC,IAArC,2BACwB,OADxB,EACiC,IADjC,CACiC,IADjC,C;MAGR,C;YA2BSC,CAAWC,KAAXD,EACL;A;QAAA,aAAS,KAAT,C;gBAAA,I;;;;UAAkB,uC;oBAAkC,KAAN,KAAM,CAAN,KAAgB,U;;oBAAhB,K;;UAA5B,U;oBAA4D,YAAN,KAAM,EAAY,IAAZ,C;;oBAAA,K;;;;QAAiB,U;MAAD,C;cAEzFX,CAAAA,EAAsB;A,QAAoC,OAA/B,SAAL,IAAK,CAAL,IAAK,CAAL,GAA0B,SAAR,IAAQ,CAAR,IAAQ,CAAU,I;MAAD,C;cAEzDC,CAAAA,EACL;A,QAEO,OAFP,MAAM,QAAK,EAAL,EAAS,+BAAT,CAAN,GAEI,G;MAAE,C;;;;;;;;;;;;kBA/HVY,O,EACQC,Q;QAAR,oB;kBAEiC,I;;QAAI,qD;kBAA8C,O,CAAQ,I;;kBAAgB,O;;QAA1E,gB;;QAExBC,CAAYV,OAAZU,EAAoC;A,QAAiB,OAAjB,UAAS,OAAT,C;MAAgB,C;QACpDC,CAAavB,GAAbuB,EAAqC;A,QAAkC,OAAlC,QAAQ,IAA0B,IAAlB,cAAe,G;MAAE,C;;;;;;;;;;;kBAxCbvB,G;QAAhB,e;;QAAgBwB,CAAAA,EAAA;A,QAAA,gB;MAAc,C;;;;;;;;;;;;;;;"}

package/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineImpl.mjs

@@ -0,0 +1,48 @@
+import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../exceptions.mjs';
+import { toString1pkumu07cwy4m as toString } from '../js/coreRuntime.mjs';
+import { Continuation1aa2oekvx7jm7 as Continuation } from './Continuation.mjs';
+import { initMetadataForObject1cxne3s9w65el as initMetadataForObject } from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var CompletedContinuationClass;
+function CompletedContinuation() {
+  if (CompletedContinuationClass === VOID) {
+    class $ {
+      bd() {
+        var message = 'This continuation is already complete';
+        throw IllegalStateException().o(toString(message));
+      }
+      cd(result) {
+        // Inline function 'kotlin.error' call
+        var message = 'This continuation is already complete';
+        throw IllegalStateException().o(toString(message));
+      }
+      dd(result) {
+        return this.cd(result);
+      }
+      toString() {
+        return 'This continuation is already complete';
+      }
+    }
+    initMetadataForObject($, 'CompletedContinuation', VOID, VOID, [Continuation()]);
+    CompletedContinuationClass = $;
+  }
+  return CompletedContinuationClass;
+}
+var CompletedContinuation_instance;
+function CompletedContinuation_getInstance() {
+  return CompletedContinuation_instance;
+}
+//region block: init
+CompletedContinuation_instance = new (CompletedContinuation())();
+//endregion
+//region block: exports
+export {
+  CompletedContinuation_instance as CompletedContinuation_instance2lals6b4jjykr,
+};
+//endregion
+
+//# sourceMappingURL=CoroutineImpl.mjs.map

package/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineImpl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/js/src/kotlin/coroutines/CoroutineImpl.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/src/kotlin/util/Preconditions.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-context>","resumeWith","result","toString"],"mappings":";;;;;;;;;;;;;QAqFQA,CAAAA,EAAQ;A,sBAAM,uC;QAQqhB,gCAAoC,SAAR,OAAQ,CAApC,C;MAR9e,C;QAEhDC,CAAeC,MAAfD,EAAqC;A;sBACpC,uC;QC4DmC,gCAAoC,SAAR,OAAQ,CAApC,C;MD3D7C,C;SAnE8DC,M;;;cAqErDC,CAAAA,EAAyB;A,QAAuC,OAAvC,uC;MAAsC,C;;;;;;;;;;;;;;;;;;"}

package/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/GeneratorCoroutineImpl.mjs

@@ -0,0 +1,192 @@
+import { InterceptedCoroutine142wh200e9wbr as InterceptedCoroutine } from './InterceptedCoroutine.mjs';
+import {
+  _Result___init__impl__xyqfz83a5421h46yeyh as _Result___init__impl__xyqfz8,
+  _Result___get_value__impl__bjfvqg3630bgmytqwyb as _Result___get_value__impl__bjfvqg,
+  _Result___get_isFailure__impl__jpiriv131ia60azkd5j as _Result___get_isFailure__impl__jpiriv,
+  Result__exceptionOrNull_impl_p6xea91su3v1n6nioxn as Result__exceptionOrNull_impl_p6xea9,
+  Companion_instance25ullnynvxd0w as Companion_instance,
+  createFailure8paxfkfa5dc7 as createFailure,
+} from '../Result.mjs';
+import {
+  ensureNotNull1e947j3ixpazm as ensureNotNull,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+} from '../hacks.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../Unit.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from './intrinsics/Intrinsics.mjs';
+import { Continuation1aa2oekvx7jm7 as Continuation } from './Continuation.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function get_dummyGenerator() {
+  _init_properties_GeneratorCoroutineImpl_kt__4u0pi3();
+  return dummyGenerator;
+}
+var dummyGenerator;
+function get_GeneratorFunction() {
+  _init_properties_GeneratorCoroutineImpl_kt__4u0pi3();
+  return GeneratorFunction;
+}
+var GeneratorFunction;
+var GeneratorCoroutineImplClass;
+function GeneratorCoroutineImpl() {
+  if (GeneratorCoroutineImplClass === VOID) {
+    class $ extends InterceptedCoroutine() {
+      constructor(resultContinuation) {
+        super();
+        this.fd_1 = resultContinuation;
+        var tmp = this;
+        // Inline function 'kotlin.arrayOf' call
+        // Inline function 'kotlin.js.unsafeCast' call
+        // Inline function 'kotlin.js.asDynamic' call
+        tmp.gd_1 = [];
+        var tmp_0 = this;
+        var tmp0_safe_receiver = this.fd_1;
+        tmp_0.hd_1 = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.bd();
+        this.id_1 = false;
+        this.jd_1 = _Result___init__impl__xyqfz8(Symbol());
+        this.kd_1 = this.jd_1;
+      }
+      bd() {
+        return ensureNotNull(this.hd_1);
+      }
+      ld() {
+        // Inline function 'kotlin.js.asDynamic' call
+        this.gd_1.pop();
+      }
+      md(iterator) {
+        // Inline function 'kotlin.js.asDynamic' call
+        this.gd_1.push(iterator);
+      }
+      nd() {
+        return !(_Result___get_value__impl__bjfvqg(this.jd_1) === _Result___get_value__impl__bjfvqg(this.kd_1));
+      }
+      cd(result) {
+        if (_Result___get_value__impl__bjfvqg(this.jd_1) === _Result___get_value__impl__bjfvqg(this.kd_1))
+          this.kd_1 = result;
+        if (this.id_1)
+          return Unit_instance;
+        // Inline function 'kotlin.Result.getOrNull' call
+        var this_0 = this.kd_1;
+        var tmp;
+        if (_Result___get_isFailure__impl__jpiriv(this_0)) {
+          tmp = null;
+        } else {
+          var tmp_0 = _Result___get_value__impl__bjfvqg(this_0);
+          tmp = (tmp_0 == null ? true : !(tmp_0 == null)) ? tmp_0 : THROW_CCE();
+        }
+        var currentResult = tmp;
+        var currentException = Result__exceptionOrNull_impl_p6xea9(this.kd_1);
+        this.kd_1 = this.jd_1;
+        var current = this;
+        while (true) {
+          $l$loop: while (true) {
+            // Inline function 'kotlin.coroutines.GeneratorCoroutineImpl.isCompleted' call
+            if (!!(current.gd_1.length === 0)) {
+              break $l$loop;
+            }
+            // Inline function 'kotlin.coroutines.GeneratorCoroutineImpl.getLastIterator' call
+            var this_1 = current;
+            var jsIterator = this_1.gd_1[this_1.gd_1.length - 1 | 0];
+            // Inline function 'kotlin.also' call
+            var this_2 = currentException;
+            currentException = null;
+            var exception = this_2;
+            this.id_1 = true;
+            try {
+              var step = exception == null ? jsIterator.next(currentResult) : jsIterator.throw(exception);
+              currentResult = step.value;
+              currentException = null;
+              if (step.done) {
+                current.ld();
+              }
+              if (!(_Result___get_value__impl__bjfvqg(this.jd_1) === _Result___get_value__impl__bjfvqg(this.kd_1))) {
+                // Inline function 'kotlin.Result.getOrNull' call
+                var this_3 = this.kd_1;
+                var tmp_1;
+                if (_Result___get_isFailure__impl__jpiriv(this_3)) {
+                  tmp_1 = null;
+                } else {
+                  var tmp_2 = _Result___get_value__impl__bjfvqg(this_3);
+                  tmp_1 = (tmp_2 == null ? true : !(tmp_2 == null)) ? tmp_2 : THROW_CCE();
+                }
+                currentResult = tmp_1;
+                currentException = Result__exceptionOrNull_impl_p6xea9(this.kd_1);
+                this.kd_1 = this.jd_1;
+              } else if (currentResult === get_COROUTINE_SUSPENDED())
+                return Unit_instance;
+            } catch ($p) {
+              if ($p instanceof Error) {
+                var e = $p;
+                currentException = e;
+                current.ld();
+              } else {
+                throw $p;
+              }
+            }
+            finally {
+              this.id_1 = false;
+            }
+          }
+          this.pd();
+          var completion = ensureNotNull(this.fd_1);
+          if (completion instanceof GeneratorCoroutineImpl()) {
+            current = completion;
+          } else {
+            var tmp_3;
+            if (!(currentException == null)) {
+              // Inline function 'kotlin.coroutines.resumeWithException' call
+              // Inline function 'kotlin.Companion.failure' call
+              var exception_0 = currentException;
+              var tmp$ret$6 = _Result___init__impl__xyqfz8(createFailure(exception_0));
+              completion.dd(tmp$ret$6);
+              tmp_3 = Unit_instance;
+            } else {
+              // Inline function 'kotlin.coroutines.resume' call
+              // Inline function 'kotlin.Companion.success' call
+              var value = currentResult;
+              var tmp$ret$8 = _Result___init__impl__xyqfz8(value);
+              completion.dd(tmp$ret$8);
+              tmp_3 = Unit_instance;
+            }
+            return tmp_3;
+          }
+        }
+      }
+      dd(result) {
+        return this.cd(result);
+      }
+    }
+    initMetadataForClass($, 'GeneratorCoroutineImpl', VOID, VOID, [InterceptedCoroutine(), Continuation()]);
+    GeneratorCoroutineImplClass = $;
+  }
+  return GeneratorCoroutineImplClass;
+}
+function isGeneratorSuspendStep(value) {
+  _init_properties_GeneratorCoroutineImpl_kt__4u0pi3();
+  return value != null && value.constructor === get_GeneratorFunction();
+}
+var properties_initialized_GeneratorCoroutineImpl_kt_yzcfjb;
+function _init_properties_GeneratorCoroutineImpl_kt__4u0pi3() {
+  if (!properties_initialized_GeneratorCoroutineImpl_kt_yzcfjb) {
+    properties_initialized_GeneratorCoroutineImpl_kt_yzcfjb = true;
+    dummyGenerator = function *(COROUTINE_SUSPENDED, generatorRef) {
+      var resultOrSuspended = generatorRef();
+      if (resultOrSuspended === COROUTINE_SUSPENDED)
+        resultOrSuspended = yield resultOrSuspended;
+      return resultOrSuspended;
+    };
+    GeneratorFunction = get_dummyGenerator().constructor.prototype;
+  }
+}
+//region block: exports
+export {
+  GeneratorCoroutineImpl as GeneratorCoroutineImpl2pzxhv55we2g3,
+  get_dummyGenerator as get_dummyGeneratoryu26m7xm6osk,
+  isGeneratorSuspendStep as isGeneratorSuspendStepcb59h14on5am,
+};
+//endregion
+
+//# sourceMappingURL=GeneratorCoroutineImpl.mjs.map

package/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/GeneratorCoroutineImpl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/js/src/kotlin/coroutines/GeneratorCoroutineImpl.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/src/kotlin/util/Result.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/src/kotlin/util/Standard.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/src/kotlin/coroutines/Continuation.kt"],"sourcesContent":[null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-dummyGenerator>","<get-GeneratorFunction>","resultContinuation","<get-context>","dropLastIterator","addNewIterator","iterator","shouldResumeImmediately","resumeWith","result","currentResult","currentException","current","jsIterator","exception","step","e","completion","isGeneratorSuspendStep","value","<init properties GeneratorCoroutineImpl.kt>","COROUTINE_SUSPENDED","generatorRef","resultOrSuspended"],"mappings":";;;;;;;;;;;;;;;;;;;;;;2BAWSA,CAAAA,EAAA;A;EAAA,qB;AAAiB,C;;8BAUjBC,CAAAA,EAAA;A;EAAA,wB;AAAoB,C;;;;;;kBAkBSC,kB;;QAAA,8B;kBACR,I;;;;QAAA,a;oBACiB,I;YAApB,8B;QAAoB,iDAApB,kBAAoB,K;QAElB,iB;QACW,yCAAU,MAAH,EAAP,C;QACI,qB;;QAEMC,CAAAA,EAAQ;A,QAAU,OAAV,wB;MAAS,C;QAExDC,CAAAA,EAAuB;A;QAC1B,IAAwB,CAAxB,IAAwB,M;MAC5B,C;QAEOC,CAAmBC,QAAnBD,EAA+C;A;QAClD,IAAwB,CAAxB,IAAwB,MAAK,QAAL,C;MAC5B,C;QAQOE,CAAAA,EAAyC;A,QAAmC,OAAnC,EAAQ,kCAAR,IAAQ,CAAR,IAAQ,CAAR,KAA8B,kCAAZ,IAAY,CAAZ,IAAY,CAA9B,C;MAAkC,C;QAEzEC,CAAeC,MAAfD,EAAqC;A,QACtC,IAAQ,kCAAR,IAAQ,CAAR,IAAQ,CAAR,KAA8B,kCAAZ,IAAY,CAAZ,IAAY,CAA9B,C;UAAqC,YAAc,M;QACnD,c;UAAW,oB;;qBAEW,I,CAAA,I;;QClBtB,kD;gBAAa,I;;sBACL,yC;4DAAA,K;;YDiBZE,mB;YACAC,mBAA+C,oCAAZ,IAAY,CAAZ,IAAY,C;QAE/C,YAAc,IAAd,CAAc,I;YAEdC,UAAc,I;eAEP,I,EAAM;A,gCACT;A;iBAAO,EAAC,OAnBgC,MAAY,MAAZ,KAAoB,CAmBrD,C;;;;yBACc,O;gBAAjBC,aAjB6C,YAAY,YAAY,MAAZ,GAAmB,CAA/B,K;;yBAkB7B,gB;YAAwB,mBAAmB,I;gBAA3DC,YEwBL,M;YFtBK,YAAY,I;YAEZ,IAAI;A,kBACAC,OAAiB,SACb,WAAQ,UAAW,MAAK,aAAL,CAAnB,GACQ,UAAW,OAAO,SAAP,C;cAGvB,gBAAgB,IAAhB,CAAqB,K;cACrB,mBAAmB,I;cAEf,SAAK,IAAL,C;gBAAW,OAAQ,K;;cACnB,MAAQ,kCAAR,IAAQ,CAAR,IAAQ,CAAR,KAA8B,kCAAZ,IAAY,CAAZ,IAAY,CAA9B,E,CAAqC;A;6BACrB,I,CAAA,I;;gBC3C5B,kD;0BAAa,I;;8BACL,yC;sEAAA,K;;gBD0CI,qB;gBACA,mBAA+B,oCAAZ,IAAY,CAAZ,IAAY,C;gBAC/B,YAAc,IAAd,CAAc,I;cAClB,C,MAAW,sBAAkB,yBAAlB,C;gBAAuC,oB;YACtD,C;uCAAuB;A,oBAAdC,M;gBACL,mBAAmB,C;gBACnB,OAAQ,K;cACZ,C;;;;oBAAU;A,cACN,YAAY,K;YAChB,C;UACJ,C;UAEA,S;cAEAC,aAAiB,wB;UAEb,mD,CAAsC;A,YACtC,UAAU,U;UACd,C;;YACe,0BAAoB,IAApB,E;;;gCACwB,gB;kBCbP,YAAhC,6BAAO,cAAc,WAAd,CAAP,C;cDaQ,UG7DhB,IAAkB,SAAlB,C;;;;;0BH+DkC,a;kBCxBb,YAAb,6BAAO,KAAP,C;cDwBQ,UGxEhB,IAAkB,SAAlB,C;;;YHqEY,Y;;QAMR,C;MACJ,C;SAjGYR,M;;;;;;;;;+BAAPS,CAA2BC,KAA3BD,EAAoD;A;EACzD,OAAO,SAAS,IAAhB,IAAwB,MAAM,WAAN,KAAsB,uB;AAClD,C;;2DAzBAE,CAAAA,E;;;+BAW8B,CAGXC,mB,EAAqBC,YAHV,E;MAIlB,IAAIC,oBAAoB,YAAY,E;MACpC,IAAI,iBAAkB,KAAI,mBAA1B,C;QAA+C,iBAAkB,GAAE,MAAM,iB;MACzE,OAAO,iB;K;wBAIc,oB,CAAe,W,CAAY,S;;C;;;;;"}

package/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/InterceptedCoroutine.mjs

@@ -0,0 +1,53 @@
+import { Key_instance1cmljiecd0y8y as Key_instance } from './ContinuationInterceptor.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../Unit.mjs';
+import { ensureNotNull1e947j3ixpazm as ensureNotNull } from '../hacks.mjs';
+import { CompletedContinuation_instance2lals6b4jjykr as CompletedContinuation_instance } from './CoroutineImpl.mjs';
+import { Continuation1aa2oekvx7jm7 as Continuation } from './Continuation.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var InterceptedCoroutineClass;
+function InterceptedCoroutine() {
+  if (InterceptedCoroutineClass === VOID) {
+    class $ {
+      constructor() {
+        this.od_1 = null;
+      }
+      qd() {
+        var tmp0_elvis_lhs = this.od_1;
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          var tmp1_safe_receiver = this.bd().rd(Key_instance);
+          var tmp2_elvis_lhs = tmp1_safe_receiver == null ? null : tmp1_safe_receiver.sd(this);
+          // Inline function 'kotlin.also' call
+          var this_0 = tmp2_elvis_lhs == null ? this : tmp2_elvis_lhs;
+          this.od_1 = this_0;
+          tmp = this_0;
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        return tmp;
+      }
+      pd() {
+        var intercepted = this.od_1;
+        if (!(intercepted == null) && !(intercepted === this)) {
+          ensureNotNull(this.bd().rd(Key_instance)).td(intercepted);
+        }
+        this.od_1 = CompletedContinuation_instance;
+      }
+    }
+    initMetadataForClass($, 'InterceptedCoroutine', VOID, VOID, [Continuation()]);
+    InterceptedCoroutineClass = $;
+  }
+  return InterceptedCoroutineClass;
+}
+//region block: exports
+export {
+  InterceptedCoroutine as InterceptedCoroutine142wh200e9wbr,
+};
+//endregion
+
+//# sourceMappingURL=InterceptedCoroutine.mjs.map

package/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/InterceptedCoroutine.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/js/src/kotlin/coroutines/InterceptedCoroutine.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/src/kotlin/util/Standard.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["intercepted","releaseIntercepted"],"mappings":";;;;;;;;;;;;;;;;QAQoD,gB;;QAEzCA,CAAAA,EACH;A,YAAA,0B;;QAAA,2B;cACQ,+C;cAAA,iBAAkC,oCAAlC,kBAAkC,IAAsB,IAAtB,C;;uBAAlC,yBAAiE,IAAjE,iB;UACQ,YCyFd,M;gBACC,M;;gBD5FH,c;;QAEmC,U;MAAD,C;QAE5BC,CAAAA,EAAyB;A,YAC/BD,cAAkB,IAAlBA,CAAkB,I;QACd,qBAAe,IAAf,KAAuB,kBAAgB,IAAhB,CAAvB,C,CAA6C;A,UAC7C,yCAAmC,IAA+B,WAA/B,C;QACvC,C;QACA,IAAK,sC;MACT,C;;;;;;;;;;;"}

package/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/SafeContinuationJs.mjs

@@ -0,0 +1,76 @@
+import { createThis2j2avj17cvnv2 as createThis } from '../js/coreRuntime.mjs';
+import {
+  CoroutineSingletons_UNDECIDED_getInstancezhfvt404mg6o as CoroutineSingletons_UNDECIDED_getInstance,
+  CoroutineSingletons_RESUMED_getInstance10y7d0morijg6 as CoroutineSingletons_RESUMED_getInstance,
+  get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED,
+} from './intrinsics/Intrinsics.mjs';
+import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../exceptions.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../Unit.mjs';
+import {
+  _Result___get_value__impl__bjfvqg3630bgmytqwyb as _Result___get_value__impl__bjfvqg,
+  Failure21qmuqji4xbjp as Failure,
+} from '../Result.mjs';
+import { Continuation1aa2oekvx7jm7 as Continuation } from './Continuation.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var SafeContinuationClass;
+function SafeContinuation() {
+  if (SafeContinuationClass === VOID) {
+    class $ {
+      static wd(delegate, initialResult) {
+        var $this = createThis(this);
+        $this.ud_1 = delegate;
+        $this.vd_1 = initialResult;
+        return $this;
+      }
+      static xd(delegate) {
+        return this.wd(delegate, CoroutineSingletons_UNDECIDED_getInstance());
+      }
+      bd() {
+        return this.ud_1.bd();
+      }
+      dd(result) {
+        var cur = this.vd_1;
+        if (cur === CoroutineSingletons_UNDECIDED_getInstance()) {
+          this.vd_1 = _Result___get_value__impl__bjfvqg(result);
+        } else if (cur === get_COROUTINE_SUSPENDED()) {
+          this.vd_1 = CoroutineSingletons_RESUMED_getInstance();
+          this.ud_1.dd(result);
+        } else
+          throw IllegalStateException().o('Already resumed');
+      }
+      yd() {
+        if (this.vd_1 === CoroutineSingletons_UNDECIDED_getInstance()) {
+          this.vd_1 = get_COROUTINE_SUSPENDED();
+          return get_COROUTINE_SUSPENDED();
+        }
+        var result = this.vd_1;
+        var tmp;
+        if (result === CoroutineSingletons_RESUMED_getInstance()) {
+          tmp = get_COROUTINE_SUSPENDED();
+        } else {
+          if (result instanceof Failure()) {
+            throw result.zd_1;
+          } else {
+            tmp = result;
+          }
+        }
+        return tmp;
+      }
+    }
+    initMetadataForClass($, 'SafeContinuation', VOID, VOID, [Continuation()]);
+    SafeContinuationClass = $;
+  }
+  return SafeContinuationClass;
+}
+//region block: exports
+export {
+  SafeContinuation as SafeContinuation1x0fxyaxo6cwq,
+};
+//endregion
+
+//# sourceMappingURL=SafeContinuationJs.mjs.map

package/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/SafeContinuationJs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/js/src/kotlin/coroutines/SafeContinuationJs.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["delegate","initialResult","<get-context>","resumeWith","result","cur","getOrThrow"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;gBAcYA,Q,EACRC,a;;QADA,qB;QAS2B,0B;;;gBALCD,Q;uBAAkC,Q,EAAU,2C;;QAGpEE,CAAAA,EAAQ;A,QAAgB,OAAhB,IAAS,CAAT,IAAS,K;MAAM,C;QAIJC,CAAeC,MAAfD,EAAkC;A,YACrDE,MAAU,IAAVA,CAAe,I;QAEX,YAAQ,2CAAR,C,CAAqB;A,UACjB,IAAK,QAAgB,kCAAP,MAAO,C;QACzB,C,MACA,YAAQ,yBAAR,C,CAA+B;A,UAC3B,IAAK,QAAS,yC;UACd,IAAS,CAAT,IAAS,IAAW,MAAX,C;QACb,C;UACQ,gCAA4B,iBAA5B,C;MAEhB,C;QAGgBC,CAAAA,EAAuB;A,QAC/B,kBAAW,2CAAX,C,CAAsB;A,UACtB,YAAS,yB;UACT,OAAO,yB;QACX,C;YACAF,SAAa,IAAbA,CAAkB,I;;QAEd,eAAW,yCAAX,C;gBAAsB,yB;;UACtB,gC;YAA4B,MAAM,MAAN,CAAa,I;;kBACjC,M;;;QAHZ,U;MAKJ,C;;;;;;;;;;;"}

package/kotlin/kotlin-kotlin-stdlib/kotlin/coroutines/cancellation/CancellationException.mjs

@@ -0,0 +1,43 @@
+import { captureStack1fzi4aczwc4hg as captureStack } from '../../js/coreRuntime.mjs';
+import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../../exceptions.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function init_kotlin_coroutines_cancellation_CancellationException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.h_1);
+}
+var CancellationExceptionClass;
+function CancellationException() {
+  if (CancellationExceptionClass === VOID) {
+    class $ extends IllegalStateException() {
+      static i() {
+        var $this = this.m();
+        init_kotlin_coroutines_cancellation_CancellationException($this);
+        return $this;
+      }
+      static n(message) {
+        var $this = this.o(message);
+        init_kotlin_coroutines_cancellation_CancellationException($this);
+        return $this;
+      }
+      static p(message, cause) {
+        var $this = this.q(message, cause);
+        init_kotlin_coroutines_cancellation_CancellationException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'CancellationException', $.i);
+    CancellationExceptionClass = $;
+  }
+  return CancellationExceptionClass;
+}
+//region block: exports
+export {
+  CancellationException as CancellationException3b36o9qz53rgr,
+};
+//endregion
+
+//# sourceMappingURL=CancellationException.mjs.map