@attocash/commons-test 6.0.0

package/kotlin-kotlin-stdlib/kotlin/comparisons/Comparisons.mjs

@@ -0,0 +1,50 @@
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../exceptions.mjs';
+import { toString1pkumu07cwy4m as toString } from '../js/coreRuntime.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../Unit.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../hacks.mjs';
+import { isComparableviyv6ctzm76u as isComparable } from '../js/typeCheckUtils.mjs';
+import { compareTo3ankvs086tmwq as compareTo } from '../js/compareTo.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function compareValuesBy(a, b, selectors) {
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.require' call
+  if (!(selectors.length > 0)) {
+    var message = 'Failed requirement.';
+    throw IllegalArgumentException().i1(toString(message));
+  }
+  return compareValuesByImpl(a, b, selectors);
+}
+function compareValues(a, b) {
+  if (a === b)
+    return 0;
+  if (a == null)
+    return -1;
+  if (b == null)
+    return 1;
+  return compareTo((!(a == null) ? isComparable(a) : false) ? a : THROW_CCE(), b);
+}
+function compareValuesByImpl(a, b, selectors) {
+  var inductionVariable = 0;
+  var last = selectors.length;
+  while (inductionVariable < last) {
+    var fn = selectors[inductionVariable];
+    inductionVariable = inductionVariable + 1 | 0;
+    var v1 = fn(a);
+    var v2 = fn(b);
+    var diff = compareValues(v1, v2);
+    if (!(diff === 0))
+      return diff;
+  }
+  return 0;
+}
+//region block: exports
+export {
+  compareValuesBy as compareValuesBy2ycqeh37x2wfm,
+  compareValues as compareValues1n2ayl87ihzfk,
+};
+//endregion
+
+//# sourceMappingURL=Comparisons.mjs.map

package/kotlin-kotlin-stdlib/kotlin/comparisons/Comparisons.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["src/kotlin/comparisons/Comparisons.kt","src/kotlin/util/Preconditions.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["compareValuesBy","a","b","selectors","message","compareValues","compareValuesByImpl","fn","v1","v2","diff"],"mappings":";;;;;;;;;;wBAiBOA,CAAwBC,C,EAAMC,C,EAAMC,SAApCH,EAAkF;A;;ECkBjF,MDjBI,UAAU,MAAV,GAAiB,CCiBrB,E,CAAQ;A,QACRI,UAda,qB;IAeb,oCAAuC,SAAR,OAAQ,CAAvC,C;EACJ,C;EDnBA,OAAO,oBAAoB,CAApB,EAAuB,CAAvB,EAA0B,SAA1B,C;AACX,C;sBAmDOC,CAAsCJ,C,EAAOC,CAA7CG,EAAyD;A,EACxD,UAAM,CAAN,C;IAAS,OAAO,C;EAChB,SAAK,IAAL,C;IAAW,OAAO,E;EAClB,SAAK,IAAL,C;IAAW,OAAO,C;EAGtB,OAA8B,aAAtB,CAAsB,yBAAtB,CAAsB,aAAtB,CAAsB,gBAAU,CAAV,C;AAClC,C;4BAxDQC,CAA4BL,C,EAAMC,C,EAAMC,SAAxCG,EAA0F;A,MACnF,qB;MAAA,uB;SAAX,oBAAW,I,EAAX;A,QAAKC,KAAM,4B;IAAA,6C;QACPC,KAAS,GAAG,CAAH,C;QACTC,KAAS,GAAG,CAAH,C;QACTC,OAAW,cAAc,EAAd,EAAkB,EAAlB,C;IACP,eAAQ,CAAR,E;MAAW,OAAO,I;;EAE1B,OAAO,C;AACX,C;;;;;"}

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

@@ -0,0 +1,39 @@
+import { initMetadataForInterface1egvbzx539z91 as initMetadataForInterface } from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+import {
+  createCoroutineUninterceptedGeneratorVersion2gduom218i9ay as createCoroutineUninterceptedGeneratorVersion,
+  intercepted2ogpsikxxj4u0 as intercepted,
+} from './intrinsics/IntrinsicsJs.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../Unit.mjs';
+import {
+  Companion_instance2oawqq9qiaris as Companion_instance,
+  _Result___init__impl__xyqfz83hut4nr3dfvi3 as _Result___init__impl__xyqfz8,
+} from '../Result.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var ContinuationClass;
+function Continuation() {
+  if (ContinuationClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'Continuation');
+    ContinuationClass = $;
+  }
+  return ContinuationClass;
+}
+function startCoroutine(_this__u8e3s4, receiver, completion) {
+  // Inline function 'kotlin.coroutines.resume' call
+  var this_0 = intercepted(createCoroutineUninterceptedGeneratorVersion(_this__u8e3s4, receiver, completion));
+  // Inline function 'kotlin.Companion.success' call
+  var tmp$ret$0 = _Result___init__impl__xyqfz8(Unit_instance);
+  this_0.vb(tmp$ret$0);
+}
+//region block: exports
+export {
+  Continuation as Continuation1aa2oekvx7jm7,
+  startCoroutine as startCoroutine327fwvtqvedik,
+};
+//endregion
+
+//# sourceMappingURL=Continuation.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["src/kotlin/coroutines/Continuation.kt","src/kotlin/util/Result.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["startCoroutine","<this>","receiver","completion"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;uBA4HOA,CAAWC,a,EACdC,Q,EACAC,UAFGH,EAGL;A;eACqD,YAAnD,4DAA6B,QAA7B,EAAuC,UAAvC,CAAmD,C;;MCpC9B,YAAb,2C;EDhDR,UAAkB,SAAlB,C;AAqFJ,C;;;;;"}

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

@@ -0,0 +1,78 @@
+import {
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+} from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+import { Element2gr7ezmxqaln7 as Element } from './CoroutineContext.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../js/typeCheckUtils.mjs';
+import {
+  AbstractCoroutineContextKey9xr9r6wlj5bm as AbstractCoroutineContextKey,
+  EmptyCoroutineContext_instance2qpebg1xogbvt as EmptyCoroutineContext_instance,
+} from './CoroutineContextImpl.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../hacks.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var KeyClass;
+function Key() {
+  if (KeyClass === VOID) {
+    class $ {}
+    initMetadataForObject($, 'Key');
+    KeyClass = $;
+  }
+  return KeyClass;
+}
+var Key_instance;
+function Key_getInstance() {
+  return Key_instance;
+}
+function releaseInterceptedContinuation(continuation) {
+}
+function get(key) {
+  if (key instanceof AbstractCoroutineContextKey()) {
+    var tmp;
+    if (key.zk(this.y1())) {
+      var tmp_0 = key.yk(this);
+      tmp = (!(tmp_0 == null) ? isInterface(tmp_0, Element()) : false) ? tmp_0 : null;
+    } else {
+      tmp = null;
+    }
+    return tmp;
+  }
+  var tmp_1;
+  if (Key_instance === key) {
+    tmp_1 = isInterface(this, Element()) ? this : THROW_CCE();
+  } else {
+    tmp_1 = null;
+  }
+  return tmp_1;
+}
+function minusKey(key) {
+  if (key instanceof AbstractCoroutineContextKey()) {
+    return key.zk(this.y1()) && !(key.yk(this) == null) ? EmptyCoroutineContext_instance : this;
+  }
+  return Key_instance === key ? EmptyCoroutineContext_instance : this;
+}
+var ContinuationInterceptorClass;
+function ContinuationInterceptor() {
+  if (ContinuationInterceptorClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'ContinuationInterceptor', VOID, VOID, [Element()]);
+    ContinuationInterceptorClass = $;
+  }
+  return ContinuationInterceptorClass;
+}
+//region block: init
+Key_instance = new (Key())();
+//endregion
+//region block: exports
+export {
+  Key_instance as Key_instance17k9ki7fvysxq,
+  get as getxe4seun860fg,
+  minusKey as minusKey2uxs00uz5ceqp,
+  ContinuationInterceptor as ContinuationInterceptor2624y0vaqwxwf,
+};
+//endregion
+
+//# sourceMappingURL=ContinuationInterceptor.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["src/kotlin/coroutines/ContinuationInterceptor.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["releaseInterceptedContinuation","continuation","get","key","minusKey"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCA+CWA,CAAmCC,YAAnCD,EAAkE;AAEzE,C;YAEyBE,CAAuCC,GAAvCD,EAAyE;A,EAG1F,iD,CAA0C;A;IAE/B,IAAA,GAAI,IAAS,IAAK,KAAd,CAAJ,C;kBAAwB,GAAI,IAAQ,IAAR,C;yEAAJ,K;;YAA6B,I;;IAAhE,U;EACJ,C;;EAEW,qBAA4B,GAA5B,C;wBAAiC,I,eAAA,I;;YAAe,I;;EAA3D,Y;AACJ,C;iBAGgBE,CAAaD,GAAbC,EAA6D;A,EAGrE,iD,CAA0C;A,IAC1C,OAAW,GAAI,IAAS,IAAK,KAAd,CAAJ,IAA0B,EAAA,GAAI,IAAQ,IAAR,CAAJ,IAAqB,IAArB,CAA1B,oCAAgF,I;EAC/F,C;EACA,OAAW,iBAA4B,GAA5B,oCAA4D,I;AAC3E,C;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,86 @@
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../hacks.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../js/typeCheckUtils.mjs';
+import { equals2au1ep9vhcato as equals } from '../js/coreRuntime.mjs';
+import {
+  EmptyCoroutineContext_instance2qpebg1xogbvt as EmptyCoroutineContext_instance,
+  CombinedContext278s863svhq02 as CombinedContext,
+} from './CoroutineContextImpl.mjs';
+import { initMetadataForInterface1egvbzx539z91 as initMetadataForInterface } from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+import { Key_instance17k9ki7fvysxq as Key_instance } from './ContinuationInterceptor.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function get(key) {
+  var tmp;
+  if (equals(this.y1(), key)) {
+    tmp = isInterface(this, Element()) ? this : THROW_CCE();
+  } else {
+    tmp = null;
+  }
+  return tmp;
+}
+function fold(initial, operation) {
+  return operation(initial, this);
+}
+function minusKey(key) {
+  return equals(this.y1(), key) ? EmptyCoroutineContext_instance : this;
+}
+var ElementClass;
+function Element() {
+  if (ElementClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'Element', VOID, VOID, [CoroutineContext()]);
+    ElementClass = $;
+  }
+  return ElementClass;
+}
+function CoroutineContext$plus$lambda(acc, element) {
+  var removed = acc.al(element.y1());
+  var tmp;
+  if (removed === EmptyCoroutineContext_instance) {
+    tmp = element;
+  } else {
+    var interceptor = removed.gc(Key_instance);
+    var tmp_0;
+    if (interceptor == null) {
+      tmp_0 = new (CombinedContext())(removed, element);
+    } else {
+      var left = removed.al(Key_instance);
+      tmp_0 = left === EmptyCoroutineContext_instance ? new (CombinedContext())(element, interceptor) : new (CombinedContext())(new (CombinedContext())(left, element), interceptor);
+    }
+    tmp = tmp_0;
+  }
+  return tmp;
+}
+function plus(context) {
+  var tmp;
+  if (context === EmptyCoroutineContext_instance) {
+    tmp = this;
+  } else {
+    tmp = context.bl(this, CoroutineContext$plus$lambda);
+  }
+  return tmp;
+}
+var CoroutineContextClass;
+function CoroutineContext() {
+  if (CoroutineContextClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'CoroutineContext');
+    CoroutineContextClass = $;
+  }
+  return CoroutineContextClass;
+}
+//region block: exports
+export {
+  fold as fold36i9psb7d5v48,
+  get as get6d5x931vk0s,
+  minusKey as minusKeyyqanvso9aovh,
+  Element as Element2gr7ezmxqaln7,
+  plus as plusolev77jfy5r9,
+  CoroutineContext as CoroutineContext3n9ge8bnnq7z2,
+};
+//endregion
+
+//# sourceMappingURL=CoroutineContext.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["src/kotlin/coroutines/CoroutineContext.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["get","key","fold","initial","operation","minusKey","CoroutineContext$plus$lambda","removed","interceptor","left","plus","context"],"mappings":";;;;;;;;;;;;;;YAgEiCA,CAAsBC,GAAtBD,EAErB;A;EAAI,WAAA,IAAK,KAAL,EAAY,GAAZ,E;sBAAiB,I,eAAA,I;;UAAe,I;;EAAI,U;AAAD,C;aAE3BE,CAAaC,O,EAAYC,SAAzBF,EACZ;A,EAAwB,OAAxB,UAAU,OAAV,EAAmB,IAAnB,C;AAAuB,C;iBAEXG,CAAaJ,GAAbI,EACZ;A,EAAoD,OAAhD,OAAA,IAAK,KAAL,EAAY,GAAZ,qCAA4C,I;AAAG,C;;;;;;;;;;qCAzChCC,CAAE,G,EAAK,OAAPA,EAAA;A,MACfC,UAAc,GAAI,IAAS,OAAQ,KAAjB,C;;EACd,+C;UAAmC,O;;QAEnCC,cAAkB,wB;;IACd,mBAAe,IAAf,C;sCAAqC,O,EAAS,O;;UAC9CC,OAAW,OAAQ,iB;cACf,kEAAgD,OAAhD,EAAyD,WAAzD,oDACgC,IADhC,EACsC,OADtC,GACgD,WADhD,C;;;;EAGX,U;AACL,C;aAbQC,CAASC,OAATD,EACZ;A;EAAI,+C;UAAmC,I;;UACnC,OAAQ,IAAK,IAAL,EAAW,4BAAX,C;;EAWP,U;AAAD,C;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,237 @@
+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_instance1fbcbse1fwigr 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() {
+        this.dl_1 = 0n;
+      }
+      gc(key) {
+        return null;
+      }
+      bl(initial, operation) {
+        return initial;
+      }
+      cl(context) {
+        return context;
+      }
+      al(key) {
+        return this;
+      }
+      hashCode() {
+        return 0;
+      }
+      toString() {
+        return 'EmptyCoroutineContext';
+      }
+    }
+    initMetadataForObject($, 'EmptyCoroutineContext', VOID, VOID, [CoroutineContext()]);
+    EmptyCoroutineContextClass = $;
+  }
+  return EmptyCoroutineContextClass;
+}
+var EmptyCoroutineContext_instance;
+function EmptyCoroutineContext_getInstance() {
+  return EmptyCoroutineContext_instance;
+}
+function size($this) {
+  var cur = $this;
+  var size = 2;
+  while (true) {
+    var tmp = cur.el_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.gc(element.y1()), element);
+}
+function containsAll($this, context) {
+  var cur = context;
+  while (true) {
+    if (!contains($this, cur.fl_1))
+      return false;
+    var next = cur.el_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.el_1 = left;
+        this.fl_1 = element;
+      }
+      gc(key) {
+        var cur = this;
+        while (true) {
+          var tmp0_safe_receiver = cur.fl_1.gc(key);
+          if (tmp0_safe_receiver == null)
+            null;
+          else {
+            // Inline function 'kotlin.let' call
+            return tmp0_safe_receiver;
+          }
+          var next = cur.el_1;
+          if (next instanceof CombinedContext()) {
+            cur = next;
+          } else {
+            return next.gc(key);
+          }
+        }
+      }
+      bl(initial, operation) {
+        return operation(this.el_1.bl(initial, operation), this.fl_1);
+      }
+      al(key) {
+        if (this.fl_1.gc(key) == null)
+          null;
+        else {
+          // Inline function 'kotlin.let' call
+          return this.el_1;
+        }
+        var newLeft = this.el_1.al(key);
+        return newLeft === this.el_1 ? this : newLeft === EmptyCoroutineContext_instance ? this.fl_1 : new (CombinedContext())(newLeft, this.fl_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.el_1) + hashCode(this.fl_1) | 0;
+      }
+      toString() {
+        return '[' + this.bl('', CombinedContext$toString$lambda) + ']';
+      }
+    }
+    protoOf($).cl = plus;
+    initMetadataForClass($, 'CombinedContext', VOID, VOID, [CoroutineContext()]);
+    CombinedContextClass = $;
+  }
+  return CombinedContextClass;
+}
+var AbstractCoroutineContextKeyClass;
+function AbstractCoroutineContextKey() {
+  if (AbstractCoroutineContextKeyClass === VOID) {
+    class $ {
+      constructor(baseKey, safeCast) {
+        this.wk_1 = safeCast;
+        var tmp = this;
+        var tmp_0;
+        if (baseKey instanceof AbstractCoroutineContextKey()) {
+          tmp_0 = baseKey.xk_1;
+        } else {
+          tmp_0 = baseKey;
+        }
+        tmp.xk_1 = tmp_0;
+      }
+      yk(element) {
+        return this.wk_1(element);
+      }
+      zk(key) {
+        return key === this || this.xk_1 === key;
+      }
+    }
+    initMetadataForClass($, 'AbstractCoroutineContextKey');
+    AbstractCoroutineContextKeyClass = $;
+  }
+  return AbstractCoroutineContextKeyClass;
+}
+var AbstractCoroutineContextElementClass;
+function AbstractCoroutineContextElement() {
+  if (AbstractCoroutineContextElementClass === VOID) {
+    class $ {
+      constructor(key) {
+        this.gl_1 = key;
+      }
+      y1() {
+        return this.gl_1;
+      }
+    }
+    protoOf($).gc = get;
+    protoOf($).bl = fold;
+    protoOf($).al = minusKey;
+    protoOf($).cl = plus;
+    initMetadataForClass($, 'AbstractCoroutineContextElement', VOID, VOID, [Element()]);
+    AbstractCoroutineContextElementClass = $;
+  }
+  return AbstractCoroutineContextElementClass;
+}
+//region block: init
+EmptyCoroutineContext_instance = new (EmptyCoroutineContext())();
+//endregion
+//region block: exports
+export {
+  EmptyCoroutineContext_instance as EmptyCoroutineContext_instance2qpebg1xogbvt,
+  AbstractCoroutineContextElement as AbstractCoroutineContextElement2rpehg0hv5szw,
+  AbstractCoroutineContextKey as AbstractCoroutineContextKey9xr9r6wlj5bm,
+  CombinedContext as CombinedContext278s863svhq02,
+};
+//endregion
+
+//# sourceMappingURL=CoroutineContextImpl.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["src/kotlin/coroutines/CoroutineContextImpl.kt","src/kotlin/text/Strings.kt","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":"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"}

package/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 $ {
+      tb() {
+        var message = 'This continuation is already complete';
+        throw IllegalStateException().w4(toString(message));
+      }
+      ub(result) {
+        // Inline function 'kotlin.error' call
+        var message = 'This continuation is already complete';
+        throw IllegalStateException().w4(toString(message));
+      }
+      vb(result) {
+        return this.ub(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_instance3dg1zdo5y8x70,
+};
+//endregion
+
+//# sourceMappingURL=CoroutineImpl.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["js/src/kotlin/coroutines/CoroutineImpl.kt","src/kotlin/util/Preconditions.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-context>","resumeWith","result","toString"],"mappings":";;;;;;;;;;;;;QAmFQA,CAAAA,EAAQ;A,sBAAM,uC;QAQ4gB,iCAAoC,SAAR,OAAQ,CAApC,C;MARre,C;QAEhDC,CAAeC,MAAfD,EAAqC;A;sBACpC,uC;QC0DmC,iCAAoC,SAAR,OAAQ,CAApC,C;MDzD7C,C;SA/DCC,M;;;cAiEQC,CAAAA,EAAyB;A,QAAuC,OAAvC,uC;MAAsC,C;;;;;;;;;;;;;;;;;;"}