@attocash/commons-test 6.0.0

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

@@ -0,0 +1,77 @@
+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().il(entries);
+}
+var EnumEntriesListClass;
+function EnumEntriesList() {
+  if (EnumEntriesListClass === VOID) {
+    class $ extends AbstractList() {
+      static il(entries) {
+        var $this = this.hi();
+        $this.hl_1 = entries;
+        return $this;
+      }
+      n1() {
+        return this.hl_1.length;
+      }
+      o1(index) {
+        Companion_instance.y6(index, this.hl_1.length);
+        return this.hl_1[index];
+      }
+      jl(element) {
+        if (element === null)
+          return false;
+        var target = getOrNull(this.hl_1, element.v3_1);
+        return target === element;
+      }
+      h2(element) {
+        if (!(element instanceof Enum()))
+          return false;
+        return this.jl(element instanceof Enum() ? element : THROW_CCE());
+      }
+      kl(element) {
+        if (element === null)
+          return -1;
+        var ordinal = element.v3_1;
+        var target = getOrNull(this.hl_1, ordinal);
+        return target === element ? ordinal : -1;
+      }
+      d3(element) {
+        if (!(element instanceof Enum()))
+          return -1;
+        return this.kl(element instanceof Enum() ? element : THROW_CCE());
+      }
+      ll(element) {
+        return this.kl(element);
+      }
+      e3(element) {
+        if (!(element instanceof Enum()))
+          return -1;
+        return this.ll(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","lastIndexOf"],"mappings":";;;;;;;;;;;;;;oBA6CSA,CAA8BC,OAA9BD,EAAmE;A,EAAwB,4BAAR,OAAQ,C;AAAD,C;;;;;gBAGhDC,O;;QAAR,oB;;;QAOnCC,CAAAA,EAAQ;A,QAAY,OAAZ,IAAY,CAAZ,IAAY,CAAJ,M;MAAG,C;QAEdC,CAAQC,KAARD,EAAuB;A,QAC5B,sBAAkB,KAAlB,EAAyB,IAAzB,CAAyB,IAAzB,CAAiC,MAAjC,C;QACA,OAAO,UAAQ,KAAR,C;MACX,C;QAKSE,CAAaC,OAAbD,EAAkC;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;SAwBsHD,O;;;;;QAtB7GE,CAAYF,OAAZE,EAA6B;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;SAei0OD,O;;;;;QAbxzOI,CAAgBJ,OAAhBI,EAAmC;A,QAAgB,OAAhB,QAAQ,OAAR,C;MAAe,C;SAa6qPJ,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.ed_1);
+}
+var ExceptionClass;
+function Exception() {
+  if (ExceptionClass === VOID) {
+    class $ extends Error {
+      static fd() {
+        var $this = createExternalThis(this, Error, [null]);
+        setPropertiesToThrowableInstance($this);
+        init_kotlin_Exception($this);
+        return $this;
+      }
+      static gd(message) {
+        var $this = createExternalThis(this, Error, [message]);
+        setPropertiesToThrowableInstance($this, message);
+        init_kotlin_Exception($this);
+        return $this;
+      }
+      static hd(message, cause) {
+        var $this = createExternalThis(this, Error, [message, setupCauseParameter(cause)]);
+        setPropertiesToThrowableInstance($this, message, cause);
+        init_kotlin_Exception($this);
+        return $this;
+      }
+      static id(cause) {
+        var $this = createExternalThis(this, Error, [null, setupCauseParameter(cause)]);
+        setPropertiesToThrowableInstance($this, VOID, cause);
+        init_kotlin_Exception($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'Exception', $.fd);
+    ExceptionClass = $;
+  }
+  return ExceptionClass;
+}
+function init_kotlin_IllegalArgumentException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.h1_1);
+}
+var IllegalArgumentExceptionClass;
+function IllegalArgumentException() {
+  if (IllegalArgumentExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static jd() {
+        var $this = this.p2();
+        init_kotlin_IllegalArgumentException($this);
+        return $this;
+      }
+      static i1(message) {
+        var $this = this.ga(message);
+        init_kotlin_IllegalArgumentException($this);
+        return $this;
+      }
+      static kd(message, cause) {
+        var $this = this.ld(message, cause);
+        init_kotlin_IllegalArgumentException($this);
+        return $this;
+      }
+      static md(cause) {
+        var $this = this.nd(cause);
+        init_kotlin_IllegalArgumentException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'IllegalArgumentException', $.jd);
+    IllegalArgumentExceptionClass = $;
+  }
+  return IllegalArgumentExceptionClass;
+}
+function init_kotlin_IllegalStateException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.v4_1);
+}
+var IllegalStateExceptionClass;
+function IllegalStateException() {
+  if (IllegalStateExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static uc() {
+        var $this = this.p2();
+        init_kotlin_IllegalStateException($this);
+        return $this;
+      }
+      static w4(message) {
+        var $this = this.ga(message);
+        init_kotlin_IllegalStateException($this);
+        return $this;
+      }
+      static xc(message, cause) {
+        var $this = this.ld(message, cause);
+        init_kotlin_IllegalStateException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'IllegalStateException', $.uc);
+    IllegalStateExceptionClass = $;
+  }
+  return IllegalStateExceptionClass;
+}
+function init_kotlin_UnsupportedOperationException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.i4_1);
+}
+var UnsupportedOperationExceptionClass;
+function UnsupportedOperationException() {
+  if (UnsupportedOperationExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static j4() {
+        var $this = this.p2();
+        init_kotlin_UnsupportedOperationException($this);
+        return $this;
+      }
+      static s9(message) {
+        var $this = this.ga(message);
+        init_kotlin_UnsupportedOperationException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'UnsupportedOperationException', $.j4);
+    UnsupportedOperationExceptionClass = $;
+  }
+  return UnsupportedOperationExceptionClass;
+}
+function init_kotlin_RuntimeException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.o2_1);
+}
+var RuntimeExceptionClass;
+function RuntimeException() {
+  if (RuntimeExceptionClass === VOID) {
+    class $ extends Exception() {
+      static p2() {
+        var $this = this.fd();
+        init_kotlin_RuntimeException($this);
+        return $this;
+      }
+      static ga(message) {
+        var $this = this.gd(message);
+        init_kotlin_RuntimeException($this);
+        return $this;
+      }
+      static ld(message, cause) {
+        var $this = this.hd(message, cause);
+        init_kotlin_RuntimeException($this);
+        return $this;
+      }
+      static nd(cause) {
+        var $this = this.id(cause);
+        init_kotlin_RuntimeException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'RuntimeException', $.p2);
+    RuntimeExceptionClass = $;
+  }
+  return RuntimeExceptionClass;
+}
+function init_kotlin_NoSuchElementException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.d1_1);
+}
+var NoSuchElementExceptionClass;
+function NoSuchElementException() {
+  if (NoSuchElementExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static i6() {
+        var $this = this.p2();
+        init_kotlin_NoSuchElementException($this);
+        return $this;
+      }
+      static e1(message) {
+        var $this = this.ga(message);
+        init_kotlin_NoSuchElementException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'NoSuchElementException', $.i6);
+    NoSuchElementExceptionClass = $;
+  }
+  return NoSuchElementExceptionClass;
+}
+function init_kotlin_Error(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.h_1);
+}
+var ErrorClass;
+function Error_0() {
+  if (ErrorClass === VOID) {
+    class $ extends Error {
+      static od() {
+        var $this = createExternalThis(this, Error, [null]);
+        setPropertiesToThrowableInstance($this);
+        init_kotlin_Error($this);
+        return $this;
+      }
+      static i(message) {
+        var $this = createExternalThis(this, Error, [message]);
+        setPropertiesToThrowableInstance($this, message);
+        init_kotlin_Error($this);
+        return $this;
+      }
+      static pd(message, cause) {
+        var $this = createExternalThis(this, Error, [message, setupCauseParameter(cause)]);
+        setPropertiesToThrowableInstance($this, message, cause);
+        init_kotlin_Error($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'Error', $.od);
+    ErrorClass = $;
+  }
+  return ErrorClass;
+}
+function init_kotlin_IndexOutOfBoundsException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.sd_1);
+}
+var IndexOutOfBoundsExceptionClass;
+function IndexOutOfBoundsException() {
+  if (IndexOutOfBoundsExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static td() {
+        var $this = this.p2();
+        init_kotlin_IndexOutOfBoundsException($this);
+        return $this;
+      }
+      static ud(message) {
+        var $this = this.ga(message);
+        init_kotlin_IndexOutOfBoundsException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'IndexOutOfBoundsException', $.td);
+    IndexOutOfBoundsExceptionClass = $;
+  }
+  return IndexOutOfBoundsExceptionClass;
+}
+function init_kotlin_NumberFormatException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.yd_1);
+}
+var NumberFormatExceptionClass;
+function NumberFormatException() {
+  if (NumberFormatExceptionClass === VOID) {
+    class $ extends IllegalArgumentException() {
+      static zd() {
+        var $this = this.jd();
+        init_kotlin_NumberFormatException($this);
+        return $this;
+      }
+      static ae(message) {
+        var $this = this.i1(message);
+        init_kotlin_NumberFormatException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'NumberFormatException', $.zd);
+    NumberFormatExceptionClass = $;
+  }
+  return NumberFormatExceptionClass;
+}
+function init_kotlin_ArithmeticException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.de_1);
+}
+var ArithmeticExceptionClass;
+function ArithmeticException() {
+  if (ArithmeticExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static ee() {
+        var $this = this.p2();
+        init_kotlin_ArithmeticException($this);
+        return $this;
+      }
+      static fe(message) {
+        var $this = this.ga(message);
+        init_kotlin_ArithmeticException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'ArithmeticException', $.ee);
+    ArithmeticExceptionClass = $;
+  }
+  return ArithmeticExceptionClass;
+}
+function init_kotlin_AssertionError(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.he_1);
+}
+var AssertionErrorClass;
+function AssertionError() {
+  if (AssertionErrorClass === VOID) {
+    class $ extends Error_0() {
+      static ie() {
+        var $this = this.od();
+        init_kotlin_AssertionError($this);
+        return $this;
+      }
+      static je(message) {
+        var tmp = message == null ? null : toString(message);
+        var $this = this.pd(tmp, message instanceof Error ? message : null);
+        init_kotlin_AssertionError($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'AssertionError', $.ie);
+    AssertionErrorClass = $;
+  }
+  return AssertionErrorClass;
+}
+function init_kotlin_ConcurrentModificationException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.ba_1);
+}
+var ConcurrentModificationExceptionClass;
+function ConcurrentModificationException() {
+  if (ConcurrentModificationExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static sa() {
+        var $this = this.p2();
+        init_kotlin_ConcurrentModificationException($this);
+        return $this;
+      }
+      static ca(message) {
+        var $this = this.ga(message);
+        init_kotlin_ConcurrentModificationException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'ConcurrentModificationException', $.sa);
+    ConcurrentModificationExceptionClass = $;
+  }
+  return ConcurrentModificationExceptionClass;
+}
+function init_kotlin_NullPointerException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.z4_1);
+}
+var NullPointerExceptionClass;
+function NullPointerException() {
+  if (NullPointerExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static a5() {
+        var $this = this.p2();
+        init_kotlin_NullPointerException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'NullPointerException', $.a5);
+    NullPointerExceptionClass = $;
+  }
+  return NullPointerExceptionClass;
+}
+function init_kotlin_NoWhenBranchMatchedException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.d5_1);
+}
+var NoWhenBranchMatchedExceptionClass;
+function NoWhenBranchMatchedException() {
+  if (NoWhenBranchMatchedExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static e5() {
+        var $this = this.p2();
+        init_kotlin_NoWhenBranchMatchedException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'NoWhenBranchMatchedException', $.e5);
+    NoWhenBranchMatchedExceptionClass = $;
+  }
+  return NoWhenBranchMatchedExceptionClass;
+}
+function init_kotlin_ClassCastException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.h5_1);
+}
+var ClassCastExceptionClass;
+function ClassCastException() {
+  if (ClassCastExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static i5() {
+        var $this = this.p2();
+        init_kotlin_ClassCastException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'ClassCastException', $.i5);
+    ClassCastExceptionClass = $;
+  }
+  return ClassCastExceptionClass;
+}
+function init_kotlin_UninitializedPropertyAccessException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.l5_1);
+}
+var UninitializedPropertyAccessExceptionClass;
+function UninitializedPropertyAccessException() {
+  if (UninitializedPropertyAccessExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static ke() {
+        var $this = this.p2();
+        init_kotlin_UninitializedPropertyAccessException($this);
+        return $this;
+      }
+      static m5(message) {
+        var $this = this.ga(message);
+        init_kotlin_UninitializedPropertyAccessException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'UninitializedPropertyAccessException', $.ke);
+    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;;;;;;;;;;gBAH8BD,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;;;;;;;;;;gBAD8BD,O;4BAA0B,O;;;;;;;;;;2BAjFxD,a,EAAA;A;AAKA,C;;;;;;;yCAJkC,K;;;;eACJA,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;;;;;;;;;;2CAkBxD,a,EAAA;A;AAGA,C;;;;;;;;;;gBAD8BA,O;4BAA0B,O;;;;;;;;;;yCA2BxD,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;;;;;;;;;;0CAmBxD,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;;;;;;;;;;;;;;"}

package/kotlin-kotlin-stdlib/kotlin/hacks.mjs

@@ -0,0 +1,51 @@
+import {
+  NullPointerException3mu0rhxjjitqq as NullPointerException,
+  NoWhenBranchMatchedException3krrgsc7u48pz as NoWhenBranchMatchedException,
+  ClassCastException1atiay3nqgbd as ClassCastException,
+  UninitializedPropertyAccessException8qin22n38p0w as UninitializedPropertyAccessException,
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+} from './exceptions.mjs';
+import { KotlinNothingValueException2zr0cdstak0a9 as KotlinNothingValueException } from './ExceptionsH.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function ensureNotNull(v) {
+  var tmp;
+  if (v == null) {
+    THROW_NPE();
+  } else {
+    tmp = v;
+  }
+  return tmp;
+}
+function THROW_NPE() {
+  throw NullPointerException().a5();
+}
+function noWhenBranchMatchedException() {
+  throw NoWhenBranchMatchedException().e5();
+}
+function THROW_CCE() {
+  throw ClassCastException().i5();
+}
+function throwUninitializedPropertyAccessException(name) {
+  throw UninitializedPropertyAccessException().m5('lateinit property ' + name + ' has not been initialized');
+}
+function throwKotlinNothingValueException() {
+  throw KotlinNothingValueException().m2();
+}
+function THROW_IAE(msg) {
+  throw IllegalArgumentException().i1(msg);
+}
+//region block: exports
+export {
+  THROW_CCE as THROW_CCE2g6jy02ryeudk,
+  THROW_IAE as THROW_IAE23kobfj9wdoxr,
+  ensureNotNull as ensureNotNull1e947j3ixpazm,
+  noWhenBranchMatchedException as noWhenBranchMatchedException2a6r7ubxgky5j,
+  throwKotlinNothingValueException as throwKotlinNothingValueException2lxmvl03dor6f,
+  throwUninitializedPropertyAccessException as throwUninitializedPropertyAccessExceptionyynx7gkm73wd,
+};
+//endregion
+
+//# sourceMappingURL=hacks.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["js/runtime/hacks.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["ensureNotNull","v","THROW_NPE","noWhenBranchMatchedException","THROW_CCE","throwUninitializedPropertyAccessException","name","throwKotlinNothingValueException","THROW_IAE","msg"],"mappings":";;;;;;;;;;;;sBAqCSA,CAA0BC,CAA1BD,EAAsC;A;EAAI,SAAK,IAAL,C;IAAW,W;;UAAiB,C;;EAAC,U;AAAD,C;kBARtEE,CAAAA,EAAyB;A,EAC9B,iC;AACJ,C;qCAZSC,CAAAA,EAA8C;A,EAAA,yC;AAAmC,C;kBAMjFC,CAAAA,EAAyB;A,EAC9B,+B;AACJ,C;kDAnBSC,CAA8CC,IAA9CD,EACL;A,EAAA,gDAA4C,oBAA5C,GAA+D,IAA/D,GAAmE,2BAAnE,C;AAA6F,C;yCAOxFE,CAAAA,EACL;A,EAAA,wC;AAAkC,C;kBAgB7BC,CAAcC,GAAdD,EAAoC;A,EACzC,oCAA+B,GAA/B,C;AACJ,C;;;;;"}

package/kotlin-kotlin-stdlib/kotlin/internal/IrLinkageError.mjs

@@ -0,0 +1,33 @@
+import { Error3ofk6owajcepa as Error_0 } from '../exceptions.mjs';
+import { captureStack1fzi4aczwc4hg as captureStack } from '../js/coreRuntime.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 throwIrLinkageError(message) {
+  throw IrLinkageError().g(message);
+}
+var IrLinkageErrorClass;
+function IrLinkageError() {
+  if (IrLinkageErrorClass === VOID) {
+    class $ extends Error_0() {
+      static g(message) {
+        var $this = this.i(message);
+        captureStack($this, $this.f_1);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'IrLinkageError');
+    IrLinkageErrorClass = $;
+  }
+  return IrLinkageErrorClass;
+}
+//region block: exports
+export {
+  throwIrLinkageError as throwIrLinkageError175icmue6aqas,
+};
+//endregion
+
+//# sourceMappingURL=IrLinkageError.mjs.map

package/kotlin-kotlin-stdlib/kotlin/internal/IrLinkageError.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["common-non-jvm/src/kotlin/internal/IrLinkageError.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["throwIrLinkageError","message"],"mappings":";;;;;;;;4BASSA,CAAwBC,OAAxBD,EAAmD;A,EACxD,yBAAqB,OAArB,C;AACJ,C;;;;;eAJ8BC,O;2BAA0B,O;;;;;;;;;;;;;;"}

package/kotlin-kotlin-stdlib/kotlin/internal/SharedVariableBox.mjs

@@ -0,0 +1,4 @@
+//region block: pre-declaration
+//endregion
+
+//# sourceMappingURL=SharedVariableBox.mjs.map

package/kotlin-kotlin-stdlib/kotlin/internal/SharedVariableBox.mjs.map

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

package/kotlin-kotlin-stdlib/kotlin/internal/progressionUtil.mjs

@@ -0,0 +1,30 @@
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../exceptions.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function getProgressionLastElement(start, end, step) {
+  var tmp;
+  if (step > 0) {
+    tmp = start >= end ? end : end - differenceModulo(end, start, step) | 0;
+  } else if (step < 0) {
+    tmp = start <= end ? end : end + differenceModulo(start, end, -step | 0) | 0;
+  } else {
+    throw IllegalArgumentException().i1('Step is zero.');
+  }
+  return tmp;
+}
+function differenceModulo(a, b, c) {
+  return mod(mod(a, c) - mod(b, c) | 0, c);
+}
+function mod(a, b) {
+  var mod = a % b | 0;
+  return mod >= 0 ? mod : mod + b | 0;
+}
+//region block: exports
+export {
+  getProgressionLastElement as getProgressionLastElement2w30kdy2w5nkt,
+};
+//endregion
+
+//# sourceMappingURL=progressionUtil.mjs.map

package/kotlin-kotlin-stdlib/kotlin/internal/progressionUtil.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["src/kotlin/internal/progressionUtil.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["getProgressionLastElement","start","end","step","differenceModulo","a","b","c","mod"],"mappings":";;;;;kCA4CSA,CAA8BC,K,EAAYC,G,EAAUC,IAApDH,EAAsE;A;EAC3E,WAAO,CAAP,C;UAAgB,SAAS,GAAT,GAAc,GAAd,GAAuB,MAAM,iBAAiB,GAAjB,EAAsB,KAAtB,EAA6B,IAA7B,CAA7B,I;SAChB,WAAO,CAAP,C;UAAgB,SAAS,GAAT,GAAc,GAAd,GAAuB,MAAM,iBAAiB,KAAjB,EAAwB,GAAxB,EAA6B,CAAC,IAA9B,KAA7B,I;;IACR,oCAAsC,eAAtC,C;;EACX,U;AAAD,C;yBA7BQI,CAAqBC,C,EAAQC,C,EAAQC,CAArCH,EAAkD;A,EACtD,OAAO,IAAI,IAAI,CAAJ,EAAO,CAAP,IAAY,IAAI,CAAJ,EAAO,CAAP,CAAhB,MAA2B,CAA3B,C;AACX,C;YAbQI,CAAQH,C,EAAQC,CAAhBE,EAA6B;A,MACjCA,MAAU,IAAI,CAAdA,I;EACA,OAAW,OAAO,CAAP,GAAU,GAAV,GAAmB,MAAM,CAAzB,I;AACf,C;;;;;"}