@attocash/commons-js 5.0.0

package/kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs

@@ -0,0 +1,139 @@
+import { InterceptedCoroutine142wh200e9wbr as InterceptedCoroutine } from '../InterceptedCoroutine.mjs';
+import { NotImplementedErrorfzlkpv14xxr8 as NotImplementedError } from '../../Standard.mjs';
+import { CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl } from '../CoroutineImpl.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../js/void.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../hacks.mjs';
+import { Continuation1aa2oekvx7jm7 as Continuation } from '../Continuation.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../js/typeCheckUtils.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../js/metadataUtils.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function intercepted(_this__u8e3s4) {
+  var tmp0_safe_receiver = _this__u8e3s4 instanceof InterceptedCoroutine() ? _this__u8e3s4 : null;
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.mc();
+  return tmp1_elvis_lhs == null ? _this__u8e3s4 : tmp1_elvis_lhs;
+}
+function createCoroutineUnintercepted(_this__u8e3s4, receiver, completion) {
+  // Inline function 'kotlin.coroutines.intrinsics.createCoroutineFromSuspendFunction' call
+  return new (createCoroutineUnintercepted$$inlined$createCoroutineFromSuspendFunction$1())(completion, _this__u8e3s4, receiver, completion);
+}
+function invokeSuspendSuperTypeWithReceiver(_this__u8e3s4, receiver, completion) {
+  throw NotImplementedError().jd('It is intrinsic method');
+}
+function startCoroutineUninterceptedOrReturnNonGeneratorVersion(_this__u8e3s4, receiver, completion) {
+  var tmp;
+  if (!(completion instanceof InterceptedCoroutine())) {
+    tmp = createSimpleCoroutineForSuspendFunction(completion);
+  } else {
+    tmp = completion;
+  }
+  var wrappedCompletion = tmp;
+  // Inline function 'kotlin.js.asDynamic' call
+  var a = _this__u8e3s4;
+  return typeof a === 'function' ? a(receiver, wrappedCompletion) : _this__u8e3s4.kd(receiver, wrappedCompletion);
+}
+function createSimpleCoroutineForSuspendFunction(completion) {
+  return new (createSimpleCoroutineForSuspendFunction$1())(completion);
+}
+function startCoroutineUninterceptedOrReturnNonGeneratorVersion_0(_this__u8e3s4, receiver, param, completion) {
+  var tmp;
+  if (!(completion instanceof InterceptedCoroutine())) {
+    tmp = createSimpleCoroutineForSuspendFunction(completion);
+  } else {
+    tmp = completion;
+  }
+  var wrappedCompletion = tmp;
+  // Inline function 'kotlin.js.asDynamic' call
+  var a = _this__u8e3s4;
+  return typeof a === 'function' ? a(receiver, param, wrappedCompletion) : _this__u8e3s4.ld(receiver, param, wrappedCompletion);
+}
+function invokeSuspendSuperTypeWithReceiverAndParam(_this__u8e3s4, receiver, param, completion) {
+  throw NotImplementedError().jd('It is intrinsic method');
+}
+function createCoroutineUnintercepted_0(_this__u8e3s4, completion) {
+  // Inline function 'kotlin.coroutines.intrinsics.createCoroutineFromSuspendFunction' call
+  return new (createCoroutineUnintercepted$$inlined$createCoroutineFromSuspendFunction$2())(completion, _this__u8e3s4, completion);
+}
+function invokeSuspendSuperType(_this__u8e3s4, completion) {
+  throw NotImplementedError().jd('It is intrinsic method');
+}
+var createCoroutineUnintercepted$$inlined$createCoroutineFromSuspendFunction$1Class;
+function createCoroutineUnintercepted$$inlined$createCoroutineFromSuspendFunction$1() {
+  if (createCoroutineUnintercepted$$inlined$createCoroutineFromSuspendFunction$1Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($completion, $this_createCoroutineUnintercepted, $receiver, $completion$1, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.ud_1 = $this_createCoroutineUnintercepted;
+        $box.vd_1 = $receiver;
+        $box.wd_1 = $completion$1;
+        super(isInterface($completion, Continuation()) ? $completion : THROW_CCE(), $box);
+      }
+      ic() {
+        if (this.dc_1 != null)
+          throw this.dc_1;
+        // Inline function 'kotlin.js.asDynamic' call
+        var a = this.ud_1;
+        return typeof a === 'function' ? a(this.vd_1, this.wd_1) : this.ud_1.kd(this.vd_1, this.wd_1);
+      }
+    }
+    initMetadataForClass($);
+    createCoroutineUnintercepted$$inlined$createCoroutineFromSuspendFunction$1Class = $;
+  }
+  return createCoroutineUnintercepted$$inlined$createCoroutineFromSuspendFunction$1Class;
+}
+var createSimpleCoroutineForSuspendFunction$1Class;
+function createSimpleCoroutineForSuspendFunction$1() {
+  if (createSimpleCoroutineForSuspendFunction$1Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($completion) {
+        super(isInterface($completion, Continuation()) ? $completion : THROW_CCE());
+      }
+      ic() {
+        if (this.dc_1 != null)
+          throw this.dc_1;
+        return this.cc_1;
+      }
+    }
+    initMetadataForClass($);
+    createSimpleCoroutineForSuspendFunction$1Class = $;
+  }
+  return createSimpleCoroutineForSuspendFunction$1Class;
+}
+var createCoroutineUnintercepted$$inlined$createCoroutineFromSuspendFunction$2Class;
+function createCoroutineUnintercepted$$inlined$createCoroutineFromSuspendFunction$2() {
+  if (createCoroutineUnintercepted$$inlined$createCoroutineFromSuspendFunction$2Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($completion, $this_createCoroutineUnintercepted, $completion$1, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.ne_1 = $this_createCoroutineUnintercepted;
+        $box.oe_1 = $completion$1;
+        super(isInterface($completion, Continuation()) ? $completion : THROW_CCE(), $box);
+      }
+      ic() {
+        if (this.dc_1 != null)
+          throw this.dc_1;
+        // Inline function 'kotlin.js.asDynamic' call
+        var a = this.ne_1;
+        return typeof a === 'function' ? a(this.oe_1) : this.ne_1.pe(this.oe_1);
+      }
+    }
+    initMetadataForClass($);
+    createCoroutineUnintercepted$$inlined$createCoroutineFromSuspendFunction$2Class = $;
+  }
+  return createCoroutineUnintercepted$$inlined$createCoroutineFromSuspendFunction$2Class;
+}
+//region block: exports
+export {
+  createCoroutineUnintercepted_0 as createCoroutineUnintercepted21q5ochlctscl,
+  createCoroutineUnintercepted as createCoroutineUnintercepted3gya308dmbbtg,
+  intercepted as intercepted2ogpsikxxj4u0,
+  startCoroutineUninterceptedOrReturnNonGeneratorVersion as startCoroutineUninterceptedOrReturnNonGeneratorVersionyfrrvzbtl8bf,
+  startCoroutineUninterceptedOrReturnNonGeneratorVersion_0 as startCoroutineUninterceptedOrReturnNonGeneratorVersioncvnobqk7h8r9,
+};
+//endregion
+
+//# sourceMappingURL=IntrinsicsJs.mjs.map

package/kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["js/src/kotlin/coroutines/intrinsics/IntrinsicsJs.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["intercepted","<this>","createCoroutineUnintercepted","receiver","completion","invokeSuspendSuperTypeWithReceiver","startCoroutineUninterceptedOrReturnNonGeneratorVersion","wrappedCompletion","a","createSimpleCoroutineForSuspendFunction","param","invokeSuspendSuperTypeWithReceiverAndParam","invokeSuspendSuperType","$receiver","$completion$1","doResume","$completion"],"mappings":";;;;;;;;;;;;oBAwMAA,CACsBC,aADtBD,EAEI;A,MAAC,2F;MAAD,iBAAiC,oCAAhC,kBAAgC,K;EAAqB,OAAtD,yBAAkD,aAAlD,iB;AAAqD,C;qCAhBzDE,CACyBD,a,EACrBE,Q,EACAC,UAHJF,EAKI;A;EAIC,OAaM,mFAjB4B,UAiB5B,sC;AAbP,C;2CApKJG,CAEoBJ,a,EAChBE,Q,EACAC,UAJJC,EAKQ;A,EACJ,MAAM,yBAAoB,wBAApB,C;AACV,C;+DAoEAC,CACoBL,a,EAChBE,Q,EACAC,UAHJE,EAIQ;A;EAEwB,oD;UACxB,wCAAwC,UAAxC,C;;UAEA,U;;MAHJC,uB;;MAIAC,IAAQ,a;EACR,OAAW,OAAS,CAAT,KAAe,UAAf,GAA2B,EAAE,QAAF,EAAY,iBAAZ,CAA3B,GACN,aAAK,IAAmC,QAAnC,EAA6C,iBAA7C,C;AACd,C;gDAiGAC,CACIL,UADJK,EAEmB;A,EACf,yDAAO,UAAP,C;AAOJ,C;iEAlGAH,CACuBL,a,EACnBE,Q,EACAO,K,EACAN,UAJJE,EAKQ;A;EAEwB,oD;UACxB,wCAAwC,UAAxC,C;;UAEA,U;;MAHJC,uB;;MAIAC,IAAQ,a;EACR,OAAW,OAAS,CAAT,KAAe,UAAf,GAA2B,EAAE,QAAF,EAAY,KAAZ,EAAmB,iBAAnB,CAA3B,GACN,aAAK,IAA2C,QAA3C,EAAqD,KAArD,EAA4D,iBAA5D,C;AACd,C;mDAjGAG,CAEuBV,a,EACnBE,Q,EACAO,K,EACAN,UALJO,EAMQ;A,EACJ,MAAM,yBAAoB,wBAApB,C;AACV,C;uCA2GAT,CACsBD,a,EAClBG,UAFJF,EAII;A;EAIC,OAwCM,mFA5C4B,UA4C5B,4B;AAxCP,C;+BAtJJU,CAEiBX,a,EACbG,UAHJQ,EAIQ;A,EACJ,MAAM,yBAAoB,wBAApB,C;AACV,C;;;;;+BAmKyB,kC,EACrBC,S,EACAC,a;;;;;;0BAmB8B,W,oBAAA,W;;QAC1BC,CAAAA,EAA8B;A,QACtB,iBAAa,IAAb,C;UAAmB,MAAM,IAAN,CAAM,I;;YAlBjCP,IAAQ,IAARA,CAAQ,I;QAmBJ,OAlBA,OAAS,CAAT,KAAe,UAAf,GAA2B,EAAE,IAAF,CAAE,IAAF,EAAY,IAAZ,CAAY,IAAZ,CAA3B,GACC,IAAK,CAAL,IAAK,IAAmC,IAAnC,CAAmC,IAAnC,EAA6C,IAA7C,CAA6C,IAA7C,C;MAkBV,C;;;;;;;;;;;kBAKJQ,W;0BAE8B,W,oBAAA,W;;QAC1BD,CAAAA,EAA8B;A,QAEtB,iBAAa,IAAb,C;UAAmB,MAAM,IAAN,CAAM,I;QAC7B,OAAO,IAAP,CAAO,I;MACX,C;;;;;;;;;;;+BA/Dc,kC,EAClBD,a;;;;;0BA8C8B,W,oBAAA,W;;QAC1BC,CAAAA,EAA8B;A,QACtB,iBAAa,IAAb,C;UAAmB,MAAM,IAAN,CAAM,I;;YA7CjCP,IAAQ,IAARA,CAAQ,I;QA8CJ,OA7CA,OAAS,CAAT,KAAe,UAAf,GAA2B,EAAE,IAAF,CAAE,IAAF,CAA3B,GACC,IAAK,CAAL,IAAK,IAAuB,IAAvB,CAAuB,IAAvB,C;MA6CV,C;;;;;;;;;;;"}

package/kotlin-kotlin-stdlib/kotlin/enums/EnumEntries.mjs

@@ -0,0 +1,69 @@
+import {
+  AbstractList3ck35puwbp1e9 as AbstractList,
+  Companion_instanceovl8he3jiijf as Companion_instance,
+} from '../collections/AbstractList.mjs';
+import { getOrNull1d60i0672n7ns as getOrNull } from '../collections/_Arrays.mjs';
+import { Enum3alwj03lh1n41 as Enum } from '../Enum.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../hacks.mjs';
+import { KtList3hktaavzmj137 as KtList } from '../collections/Collections.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 enumEntries(entries) {
+  return EnumEntriesList().rm(entries);
+}
+var EnumEntriesListClass;
+function EnumEntriesList() {
+  if (EnumEntriesListClass === VOID) {
+    class $ extends AbstractList() {
+      static rm(entries) {
+        var $this = this.nj();
+        $this.qm_1 = entries;
+        return $this;
+      }
+      i1() {
+        return this.qm_1.length;
+      }
+      j1(index) {
+        Companion_instance.s6(index, this.qm_1.length);
+        return this.qm_1[index];
+      }
+      sm(element) {
+        if (element === null)
+          return false;
+        var target = getOrNull(this.qm_1, element.h3_1);
+        return target === element;
+      }
+      q2(element) {
+        if (!(element instanceof Enum()))
+          return false;
+        return this.sm(element instanceof Enum() ? element : THROW_CCE());
+      }
+      tm(element) {
+        if (element === null)
+          return -1;
+        var ordinal = element.h3_1;
+        var target = getOrNull(this.qm_1, ordinal);
+        return target === element ? ordinal : -1;
+      }
+      s2(element) {
+        if (!(element instanceof Enum()))
+          return -1;
+        return this.tm(element instanceof Enum() ? element : THROW_CCE());
+      }
+    }
+    initMetadataForClass($, 'EnumEntriesList', VOID, VOID, [KtList(), AbstractList()]);
+    EnumEntriesListClass = $;
+  }
+  return EnumEntriesListClass;
+}
+//region block: exports
+export {
+  enumEntries as enumEntries20mr21zbe3az4,
+};
+//endregion
+
+//# sourceMappingURL=EnumEntries.mjs.map

package/kotlin-kotlin-stdlib/kotlin/enums/EnumEntries.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["src/kotlin/enums/EnumEntries.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["enumEntries","entries","<get-size>","get","index","contains","element","target","indexOf","ordinal"],"mappings":";;;;;;;;;;;;;;oBA2CAA,CAEuCC,OAFvCD,EAE4E;A,EAAwB,4BAAR,OAAQ,C;AAAD,C;;;;;gBAGxDC,O;;QAAA,oB;;;QAOnCC,CAAAA,EAAQ;A,QAAY,OAAZ,IAAY,CAAZ,IAAY,CAAJ,M;MAAG,C;QAEvBC,CAAiBC,KAAjBD,EAAgC;A,QAC5B,sBAAkB,KAAlB,EAAyB,IAAzB,CAAyB,IAAzB,CAAiC,MAAjC,C;QACA,OAAO,UAAQ,KAAR,C;MACX,C;QAKAE,CAAsBC,OAAtBD,EAA2C;A,QAEnC,gBAAY,IAAZ,C;UAAkB,OAAO,K;YAE7BE,SAAqB,UAAR,IAAQ,CAAR,IAAQ,EAAU,OAAV,CAAkB,IAAlB,C;QACrB,OAAO,WAAW,O;MACtB,C;SApBWD,O;;;;;QAsBXE,CAAqBF,OAArBE,EAAsC;A,QAE9B,gBAAY,IAAZ,C;UAAkB,OAAO,E;YAE7BC,UAAc,OAAdA,CAAsB,I;YACtBF,SAAqB,UAAR,IAAQ,CAAR,IAAQ,EAAU,OAAV,C;QACrB,OAAW,WAAW,OAAX,GAAoB,OAApB,GAAiC,E;MAChD,C;SAesrDD,O;;;;;;;;;;;;;;;"}

package/kotlin-kotlin-stdlib/kotlin/exceptions.mjs

@@ -0,0 +1,437 @@
+import {
+  captureStack1fzi4aczwc4hg as captureStack,
+  createExternalThis2k2orr8ix0ytc as createExternalThis,
+  setPropertiesToThrowableInstance1w2jjvl9y77yc as setPropertiesToThrowableInstance,
+  setupCauseParameter20kc7dphipdif as setupCauseParameter,
+  toString1pkumu07cwy4m as toString,
+} from './js/coreRuntime.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from './js/void.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from './Unit.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from './js/metadataUtils.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function init_kotlin_Exception(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.f5_1);
+}
+var ExceptionClass;
+function Exception() {
+  if (ExceptionClass === VOID) {
+    class $ extends Error {
+      static qe() {
+        var $this = createExternalThis(this, Error, [null]);
+        setPropertiesToThrowableInstance($this);
+        init_kotlin_Exception($this);
+        return $this;
+      }
+      static g5(message) {
+        var $this = createExternalThis(this, Error, [message]);
+        setPropertiesToThrowableInstance($this, message);
+        init_kotlin_Exception($this);
+        return $this;
+      }
+      static re(message, cause) {
+        var $this = createExternalThis(this, Error, [message, setupCauseParameter(cause)]);
+        setPropertiesToThrowableInstance($this, message, cause);
+        init_kotlin_Exception($this);
+        return $this;
+      }
+      static se(cause) {
+        var $this = createExternalThis(this, Error, [null, setupCauseParameter(cause)]);
+        setPropertiesToThrowableInstance($this, VOID, cause);
+        init_kotlin_Exception($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'Exception', $.qe);
+    ExceptionClass = $;
+  }
+  return ExceptionClass;
+}
+function init_kotlin_IllegalArgumentException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.t_1);
+}
+var IllegalArgumentExceptionClass;
+function IllegalArgumentException() {
+  if (IllegalArgumentExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static te() {
+        var $this = this.ue();
+        init_kotlin_IllegalArgumentException($this);
+        return $this;
+      }
+      static u(message) {
+        var $this = this.ha(message);
+        init_kotlin_IllegalArgumentException($this);
+        return $this;
+      }
+      static ve(message, cause) {
+        var $this = this.we(message, cause);
+        init_kotlin_IllegalArgumentException($this);
+        return $this;
+      }
+      static xe(cause) {
+        var $this = this.ye(cause);
+        init_kotlin_IllegalArgumentException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'IllegalArgumentException', $.te);
+    IllegalArgumentExceptionClass = $;
+  }
+  return IllegalArgumentExceptionClass;
+}
+function init_kotlin_IllegalStateException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.n4_1);
+}
+var IllegalStateExceptionClass;
+function IllegalStateException() {
+  if (IllegalStateExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static bd() {
+        var $this = this.ue();
+        init_kotlin_IllegalStateException($this);
+        return $this;
+      }
+      static o4(message) {
+        var $this = this.ha(message);
+        init_kotlin_IllegalStateException($this);
+        return $this;
+      }
+      static ed(message, cause) {
+        var $this = this.we(message, cause);
+        init_kotlin_IllegalStateException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'IllegalStateException', $.bd);
+    IllegalStateExceptionClass = $;
+  }
+  return IllegalStateExceptionClass;
+}
+function init_kotlin_UnsupportedOperationException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.v7_1);
+}
+var UnsupportedOperationExceptionClass;
+function UnsupportedOperationException() {
+  if (UnsupportedOperationExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static w7() {
+        var $this = this.ue();
+        init_kotlin_UnsupportedOperationException($this);
+        return $this;
+      }
+      static r9(message) {
+        var $this = this.ha(message);
+        init_kotlin_UnsupportedOperationException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'UnsupportedOperationException', $.w7);
+    UnsupportedOperationExceptionClass = $;
+  }
+  return UnsupportedOperationExceptionClass;
+}
+function init_kotlin_RuntimeException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.ga_1);
+}
+var RuntimeExceptionClass;
+function RuntimeException() {
+  if (RuntimeExceptionClass === VOID) {
+    class $ extends Exception() {
+      static ue() {
+        var $this = this.qe();
+        init_kotlin_RuntimeException($this);
+        return $this;
+      }
+      static ha(message) {
+        var $this = this.g5(message);
+        init_kotlin_RuntimeException($this);
+        return $this;
+      }
+      static we(message, cause) {
+        var $this = this.re(message, cause);
+        init_kotlin_RuntimeException($this);
+        return $this;
+      }
+      static ye(cause) {
+        var $this = this.se(cause);
+        init_kotlin_RuntimeException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'RuntimeException', $.ue);
+    RuntimeExceptionClass = $;
+  }
+  return RuntimeExceptionClass;
+}
+function init_kotlin_NoSuchElementException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.p_1);
+}
+var NoSuchElementExceptionClass;
+function NoSuchElementException() {
+  if (NoSuchElementExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static d6() {
+        var $this = this.ue();
+        init_kotlin_NoSuchElementException($this);
+        return $this;
+      }
+      static q(message) {
+        var $this = this.ha(message);
+        init_kotlin_NoSuchElementException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'NoSuchElementException', $.d6);
+    NoSuchElementExceptionClass = $;
+  }
+  return NoSuchElementExceptionClass;
+}
+function init_kotlin_Error(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.ze_1);
+}
+var ErrorClass;
+function Error_0() {
+  if (ErrorClass === VOID) {
+    class $ extends Error {
+      static af() {
+        var $this = createExternalThis(this, Error, [null]);
+        setPropertiesToThrowableInstance($this);
+        init_kotlin_Error($this);
+        return $this;
+      }
+      static bf(message) {
+        var $this = createExternalThis(this, Error, [message]);
+        setPropertiesToThrowableInstance($this, message);
+        init_kotlin_Error($this);
+        return $this;
+      }
+      static cf(message, cause) {
+        var $this = createExternalThis(this, Error, [message, setupCauseParameter(cause)]);
+        setPropertiesToThrowableInstance($this, message, cause);
+        init_kotlin_Error($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'Error', $.af);
+    ErrorClass = $;
+  }
+  return ErrorClass;
+}
+function init_kotlin_IndexOutOfBoundsException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.ff_1);
+}
+var IndexOutOfBoundsExceptionClass;
+function IndexOutOfBoundsException() {
+  if (IndexOutOfBoundsExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static gf() {
+        var $this = this.ue();
+        init_kotlin_IndexOutOfBoundsException($this);
+        return $this;
+      }
+      static hf(message) {
+        var $this = this.ha(message);
+        init_kotlin_IndexOutOfBoundsException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'IndexOutOfBoundsException', $.gf);
+    IndexOutOfBoundsExceptionClass = $;
+  }
+  return IndexOutOfBoundsExceptionClass;
+}
+function init_kotlin_ArithmeticException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.kf_1);
+}
+var ArithmeticExceptionClass;
+function ArithmeticException() {
+  if (ArithmeticExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static lf() {
+        var $this = this.ue();
+        init_kotlin_ArithmeticException($this);
+        return $this;
+      }
+      static mf(message) {
+        var $this = this.ha(message);
+        init_kotlin_ArithmeticException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'ArithmeticException', $.lf);
+    ArithmeticExceptionClass = $;
+  }
+  return ArithmeticExceptionClass;
+}
+function init_kotlin_AssertionError(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.of_1);
+}
+var AssertionErrorClass;
+function AssertionError() {
+  if (AssertionErrorClass === VOID) {
+    class $ extends Error_0() {
+      static pf() {
+        var $this = this.af();
+        init_kotlin_AssertionError($this);
+        return $this;
+      }
+      static qf(message) {
+        var tmp = message == null ? null : toString(message);
+        var $this = this.cf(tmp, message instanceof Error ? message : null);
+        init_kotlin_AssertionError($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'AssertionError', $.pf);
+    AssertionErrorClass = $;
+  }
+  return AssertionErrorClass;
+}
+function init_kotlin_ConcurrentModificationException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.aa_1);
+}
+var ConcurrentModificationExceptionClass;
+function ConcurrentModificationException() {
+  if (ConcurrentModificationExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static ta() {
+        var $this = this.ue();
+        init_kotlin_ConcurrentModificationException($this);
+        return $this;
+      }
+      static ba(message) {
+        var $this = this.ha(message);
+        init_kotlin_ConcurrentModificationException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'ConcurrentModificationException', $.ta);
+    ConcurrentModificationExceptionClass = $;
+  }
+  return ConcurrentModificationExceptionClass;
+}
+function init_kotlin_NumberFormatException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.uf_1);
+}
+var NumberFormatExceptionClass;
+function NumberFormatException() {
+  if (NumberFormatExceptionClass === VOID) {
+    class $ extends IllegalArgumentException() {
+      static vf() {
+        var $this = this.te();
+        init_kotlin_NumberFormatException($this);
+        return $this;
+      }
+      static wf(message) {
+        var $this = this.u(message);
+        init_kotlin_NumberFormatException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'NumberFormatException', $.vf);
+    NumberFormatExceptionClass = $;
+  }
+  return NumberFormatExceptionClass;
+}
+function init_kotlin_NullPointerException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.r4_1);
+}
+var NullPointerExceptionClass;
+function NullPointerException() {
+  if (NullPointerExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static s4() {
+        var $this = this.ue();
+        init_kotlin_NullPointerException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'NullPointerException', $.s4);
+    NullPointerExceptionClass = $;
+  }
+  return NullPointerExceptionClass;
+}
+function init_kotlin_NoWhenBranchMatchedException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.v4_1);
+}
+var NoWhenBranchMatchedExceptionClass;
+function NoWhenBranchMatchedException() {
+  if (NoWhenBranchMatchedExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static w4() {
+        var $this = this.ue();
+        init_kotlin_NoWhenBranchMatchedException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'NoWhenBranchMatchedException', $.w4);
+    NoWhenBranchMatchedExceptionClass = $;
+  }
+  return NoWhenBranchMatchedExceptionClass;
+}
+function init_kotlin_ClassCastException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.z4_1);
+}
+var ClassCastExceptionClass;
+function ClassCastException() {
+  if (ClassCastExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static a5() {
+        var $this = this.ue();
+        init_kotlin_ClassCastException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'ClassCastException', $.a5);
+    ClassCastExceptionClass = $;
+  }
+  return ClassCastExceptionClass;
+}
+function init_kotlin_UninitializedPropertyAccessException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.d5_1);
+}
+var UninitializedPropertyAccessExceptionClass;
+function UninitializedPropertyAccessException() {
+  if (UninitializedPropertyAccessExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static xf() {
+        var $this = this.ue();
+        init_kotlin_UninitializedPropertyAccessException($this);
+        return $this;
+      }
+      static e5(message) {
+        var $this = this.ha(message);
+        init_kotlin_UninitializedPropertyAccessException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'UninitializedPropertyAccessException', $.xf);
+    UninitializedPropertyAccessExceptionClass = $;
+  }
+  return UninitializedPropertyAccessExceptionClass;
+}
+//region block: exports
+export {
+  ArithmeticException as ArithmeticException18dajwq7kbp38,
+  AssertionError as AssertionError3yq7q0knw9m5,
+  ClassCastException as ClassCastException1atiay3nqgbd,
+  ConcurrentModificationException as ConcurrentModificationException3974vl9oonkcj,
+  Error_0 as Error3ofk6owajcepa,
+  Exception as Exceptiondt2hlxn7j7vw,
+  IllegalArgumentException as IllegalArgumentException2asla15b5jaob,
+  IllegalStateException as IllegalStateExceptionkoljg5n0nrlr,
+  IndexOutOfBoundsException as IndexOutOfBoundsException1qfr429iumro0,
+  NoSuchElementException as NoSuchElementException679xzhnp5bpj,
+  NoWhenBranchMatchedException as NoWhenBranchMatchedException3krrgsc7u48pz,
+  NullPointerException as NullPointerException3mu0rhxjjitqq,
+  NumberFormatException as NumberFormatException3bgsm2s9o4t55,
+  RuntimeException as RuntimeException1r3t0zl97011n,
+  UninitializedPropertyAccessException as UninitializedPropertyAccessException8qin22n38p0w,
+  UnsupportedOperationException as UnsupportedOperationException2tkumpmhredt3,
+};
+//endregion
+
+//# sourceMappingURL=exceptions.mjs.map

package/kotlin-kotlin-stdlib/kotlin/exceptions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["js/src/kotlin/exceptions.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["message","cause"],"mappings":";;;;;;;;;;;;;;+BAcA,a,EAAA;A;AAKA,C;;;;;;;yCAJkC,K;;;;gBACJA,O;qDAA0B,O;yCAAN,K,EAAM,O;;;;gBAC1BA,O,EAAkBC,K;qDAA2B,O,sBAAS,K;yCAAf,K,EAAM,O,EAAS,K;;;;gBACtDA,K;+EAA2B,K;yCAAN,K,QAAM,K;;;;;;;;;;8CAUzD,a,EAAA;A;AAKA,C;;;;;;;;;;eAH8BD,O;4BAA0B,O;;;;gBAC1BA,O,EAAkBC,K;4BAA2B,O,EAAS,K;;;;gBACtDA,K;4BAA2B,K;;;;;;;;;;2CAGzD,a,EAAA;A;AAKA,C;;;;;;;;;;gBAH8BD,O;4BAA0B,O;;;;gBAC1BA,O,EAAkBC,K;4BAA2B,O,EAAS,K;;;;;;;;;;mDAgBpF,a,EAAA;A;AAKA,C;;;;;;;;;;gBAH8BD,O;4BAA0B,O;;;;;;;;;;sCAnCxD,a,EAAA;A;AAKA,C;;;;;;;;;;gBAH8BA,O;4BAA0B,O;;;;gBAC1BA,O,EAAkBC,K;4BAA2B,O,EAAS,K;;;;gBACtDA,K;4BAA2B,K;;;;;;;;;;4CA6DzD,a,EAAA;A;AAGA,C;;;;;;;;;;eAD8BD,O;4BAA0B,O;;;;;;;;;;2BAjFxD,a,EAAA;A;AAKA,C;;;;;;;yCAJkC,K;;;;gBACJA,O;qDAA0B,O;yCAAN,K,EAAM,O;;;;gBAC1BA,O,EAAkBC,K;qDAA2B,O,sBAAS,K;yCAAf,K,EAAM,O,EAAS,K;;;;;;;;;;+CAgCpF,a,EAAA;A;AAGA,C;;;;;;;;;;gBAD8BD,O;4BAA0B,O;;;;;;;;;;yCA+CxD,a,EAAA;A;AAIA,C;;;;;;;;;;gBAD8BA,O;4BAA0B,O;;;;;;;;;;oCAhBxD,a,EAAA;A;AAMA,C;;;;;;;;;;gBAH8BA,O;kBAAuB,OAAS,2BAAT,OAAS,C;iCAAY,O,oBAAA,O;;;;;;;;;;qDAlC1E,a,EAAA;A;AAKA,C;;;;;;;;;;gBAH8BA,O;4BAA0B,O;;;;;;;;;;2CAaxD,a,EAAA;A;AAGA,C;;;;;;;;;;gBAD8BA,O;2BAA0B,O;;;;;;;;;;0CAIxD,a,EAAA;A;AAGA,C;;;;;;;;;;;;;;;;kDA0BA,a,EAAA;A;AAKA,C;;;;;;;;;;;;;;;;wCA7BA,a,EAAA;A;AAGA,C;;;;;;;;;;;;;;;;0DA4BA,a,EAAA;A;AAKA,C;;;;;;;;;;gBAH8BA,O;4BAA0B,O;;;;;;;;;;;;;;"}