@continuous-excellence/coupling-cli 1.1.498 → 1.1.499

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

@@ -7,30 +7,30 @@ import {
 } from './js/coreRuntime.mjs';
 import { 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 { Unit_instancev9v8hjid95df as Unit_instance } from './Unit.mjs';
 //region block: imports
 //endregion
 //region block: pre-declaration
 //endregion
 function init_kotlin_UnsupportedOperationException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.q8_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.l8_1);
 }
 var UnsupportedOperationExceptionClass;
 function UnsupportedOperationException() {
   if (UnsupportedOperationExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static r8() {
-        var $this = this.x3();
+      static m8() {
+        var $this = this.s3();
         init_kotlin_UnsupportedOperationException($this);
         return $this;
       }
-      static pa(message) {
-        var $this = this.db(message);
+      static ka(message) {
+        var $this = this.ya(message);
         init_kotlin_UnsupportedOperationException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'UnsupportedOperationException', $.r8);
+    initMetadataForClass($, 'UnsupportedOperationException', $.m8);
     UnsupportedOperationExceptionClass = $;
   }
   return UnsupportedOperationExceptionClass;
@@ -43,17 +43,17 @@ function IllegalStateException() {
   if (IllegalStateExceptionClass === VOID) {
     class $ extends RuntimeException() {
       static m() {
-        var $this = this.x3();
+        var $this = this.s3();
         init_kotlin_IllegalStateException($this);
         return $this;
       }
       static o(message) {
-        var $this = this.db(message);
+        var $this = this.ya(message);
         init_kotlin_IllegalStateException($this);
         return $this;
       }
       static q(message, cause) {
-        var $this = this.he(message, cause);
+        var $this = this.yd(message, cause);
         init_kotlin_IllegalStateException($this);
         return $this;
       }
@@ -64,345 +64,345 @@ function IllegalStateException() {
   return IllegalStateExceptionClass;
 }
 function init_kotlin_IllegalArgumentException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.q2_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.l2_1);
 }
 var IllegalArgumentExceptionClass;
 function IllegalArgumentException() {
   if (IllegalArgumentExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static ie() {
-        var $this = this.x3();
+      static zd() {
+        var $this = this.s3();
         init_kotlin_IllegalArgumentException($this);
         return $this;
       }
-      static r2(message) {
-        var $this = this.db(message);
+      static m2(message) {
+        var $this = this.ya(message);
         init_kotlin_IllegalArgumentException($this);
         return $this;
       }
-      static je(message, cause) {
-        var $this = this.he(message, cause);
+      static ae(message, cause) {
+        var $this = this.yd(message, cause);
         init_kotlin_IllegalArgumentException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'IllegalArgumentException', $.ie);
+    initMetadataForClass($, 'IllegalArgumentException', $.zd);
     IllegalArgumentExceptionClass = $;
   }
   return IllegalArgumentExceptionClass;
 }
 function init_kotlin_RuntimeException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.w3_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.r3_1);
 }
 var RuntimeExceptionClass;
 function RuntimeException() {
   if (RuntimeExceptionClass === VOID) {
     class $ extends Exception() {
-      static x3() {
-        var $this = this.ke();
+      static s3() {
+        var $this = this.be();
         init_kotlin_RuntimeException($this);
         return $this;
       }
-      static db(message) {
-        var $this = this.l5(message);
+      static ya(message) {
+        var $this = this.g5(message);
         init_kotlin_RuntimeException($this);
         return $this;
       }
-      static he(message, cause) {
-        var $this = this.le(message, cause);
+      static yd(message, cause) {
+        var $this = this.ce(message, cause);
         init_kotlin_RuntimeException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'RuntimeException', $.x3);
+    initMetadataForClass($, 'RuntimeException', $.s3);
     RuntimeExceptionClass = $;
   }
   return RuntimeExceptionClass;
 }
 function init_kotlin_Exception(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.k5_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.f5_1);
 }
 var ExceptionClass;
 function Exception() {
   if (ExceptionClass === VOID) {
     class $ extends Error {
-      static ke() {
+      static be() {
         var $this = createExternalThis(this, Error, [null]);
         setPropertiesToThrowableInstance($this);
         init_kotlin_Exception($this);
         return $this;
       }
-      static l5(message) {
+      static g5(message) {
         var $this = createExternalThis(this, Error, [message]);
         setPropertiesToThrowableInstance($this, message);
         init_kotlin_Exception($this);
         return $this;
       }
-      static le(message, cause) {
+      static ce(message, cause) {
         var $this = createExternalThis(this, Error, [message, setupCauseParameter(cause)]);
         setPropertiesToThrowableInstance($this, message, cause);
         init_kotlin_Exception($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'Exception', $.ke);
+    initMetadataForClass($, 'Exception', $.be);
     ExceptionClass = $;
   }
   return ExceptionClass;
 }
 function init_kotlin_NoSuchElementException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.g2_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.b2_1);
 }
 var NoSuchElementExceptionClass;
 function NoSuchElementException() {
   if (NoSuchElementExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static w6() {
-        var $this = this.x3();
+      static r6() {
+        var $this = this.s3();
         init_kotlin_NoSuchElementException($this);
         return $this;
       }
-      static h2(message) {
-        var $this = this.db(message);
+      static c2(message) {
+        var $this = this.ya(message);
         init_kotlin_NoSuchElementException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'NoSuchElementException', $.w6);
+    initMetadataForClass($, 'NoSuchElementException', $.r6);
     NoSuchElementExceptionClass = $;
   }
   return NoSuchElementExceptionClass;
 }
 function init_kotlin_IndexOutOfBoundsException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.oe_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.fe_1);
 }
 var IndexOutOfBoundsExceptionClass;
 function IndexOutOfBoundsException() {
   if (IndexOutOfBoundsExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static pe() {
-        var $this = this.x3();
+      static ge() {
+        var $this = this.s3();
         init_kotlin_IndexOutOfBoundsException($this);
         return $this;
       }
-      static qe(message) {
-        var $this = this.db(message);
+      static he(message) {
+        var $this = this.ya(message);
         init_kotlin_IndexOutOfBoundsException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'IndexOutOfBoundsException', $.pe);
+    initMetadataForClass($, 'IndexOutOfBoundsException', $.ge);
     IndexOutOfBoundsExceptionClass = $;
   }
   return IndexOutOfBoundsExceptionClass;
 }
 function init_kotlin_NullPointerException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.o5_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.n5_1);
 }
 var NullPointerExceptionClass;
 function NullPointerException() {
   if (NullPointerExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static p5() {
-        var $this = this.x3();
+      static o5() {
+        var $this = this.s3();
         init_kotlin_NullPointerException($this);
         return $this;
       }
-      static re(message) {
-        var $this = this.db(message);
+      static ie(message) {
+        var $this = this.ya(message);
         init_kotlin_NullPointerException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'NullPointerException', $.p5);
+    initMetadataForClass($, 'NullPointerException', $.o5);
     NullPointerExceptionClass = $;
   }
   return NullPointerExceptionClass;
 }
 function init_kotlin_ArithmeticException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.ue_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.le_1);
 }
 var ArithmeticExceptionClass;
 function ArithmeticException() {
   if (ArithmeticExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static ve() {
-        var $this = this.x3();
+      static me() {
+        var $this = this.s3();
         init_kotlin_ArithmeticException($this);
         return $this;
       }
-      static we(message) {
-        var $this = this.db(message);
+      static ne(message) {
+        var $this = this.ya(message);
         init_kotlin_ArithmeticException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'ArithmeticException', $.ve);
+    initMetadataForClass($, 'ArithmeticException', $.me);
     ArithmeticExceptionClass = $;
   }
   return ArithmeticExceptionClass;
 }
 function init_kotlin_Error(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.w_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.oe_1);
 }
 var ErrorClass;
 function Error_0() {
   if (ErrorClass === VOID) {
     class $ extends Error {
-      static xe() {
+      static pe() {
         var $this = createExternalThis(this, Error, [null]);
         setPropertiesToThrowableInstance($this);
         init_kotlin_Error($this);
         return $this;
       }
-      static x(message) {
+      static qe(message) {
         var $this = createExternalThis(this, Error, [message]);
         setPropertiesToThrowableInstance($this, message);
         init_kotlin_Error($this);
         return $this;
       }
-      static ye(message, cause) {
+      static re(message, cause) {
         var $this = createExternalThis(this, Error, [message, setupCauseParameter(cause)]);
         setPropertiesToThrowableInstance($this, message, cause);
         init_kotlin_Error($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'Error', $.xe);
+    initMetadataForClass($, 'Error', $.pe);
     ErrorClass = $;
   }
   return ErrorClass;
 }
 function init_kotlin_NumberFormatException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.cf_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.ve_1);
 }
 var NumberFormatExceptionClass;
 function NumberFormatException() {
   if (NumberFormatExceptionClass === VOID) {
     class $ extends IllegalArgumentException() {
-      static df() {
-        var $this = this.ie();
+      static we() {
+        var $this = this.zd();
         init_kotlin_NumberFormatException($this);
         return $this;
       }
-      static ef(message) {
-        var $this = this.r2(message);
+      static xe(message) {
+        var $this = this.m2(message);
         init_kotlin_NumberFormatException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'NumberFormatException', $.df);
+    initMetadataForClass($, 'NumberFormatException', $.we);
     NumberFormatExceptionClass = $;
   }
   return NumberFormatExceptionClass;
 }
 function init_kotlin_AssertionError(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.gf_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.ze_1);
 }
 var AssertionErrorClass;
 function AssertionError() {
   if (AssertionErrorClass === VOID) {
     class $ extends Error_0() {
-      static hf() {
-        var $this = this.xe();
+      static af() {
+        var $this = this.pe();
         init_kotlin_AssertionError($this);
         return $this;
       }
-      static if(message) {
-        var $this = this.x(message);
+      static bf(message) {
+        var $this = this.qe(message);
         init_kotlin_AssertionError($this);
         return $this;
       }
-      static jf(message) {
+      static cf(message) {
         var tmp = message == null ? null : toString(message);
-        var $this = this.ye(tmp, message instanceof Error ? message : null);
+        var $this = this.re(tmp, message instanceof Error ? message : null);
         init_kotlin_AssertionError($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'AssertionError', $.hf);
+    initMetadataForClass($, 'AssertionError', $.af);
     AssertionErrorClass = $;
   }
   return AssertionErrorClass;
 }
 function init_kotlin_ClassCastException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.w5_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.r5_1);
 }
 var ClassCastExceptionClass;
 function ClassCastException() {
   if (ClassCastExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static x5() {
-        var $this = this.x3();
+      static s5() {
+        var $this = this.s3();
         init_kotlin_ClassCastException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'ClassCastException', $.x5);
+    initMetadataForClass($, 'ClassCastException', $.s5);
     ClassCastExceptionClass = $;
   }
   return ClassCastExceptionClass;
 }
 function init_kotlin_UninitializedPropertyAccessException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.a1_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.v_1);
 }
 var UninitializedPropertyAccessExceptionClass;
 function UninitializedPropertyAccessException() {
   if (UninitializedPropertyAccessExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static kf() {
-        var $this = this.x3();
+      static df() {
+        var $this = this.s3();
         init_kotlin_UninitializedPropertyAccessException($this);
         return $this;
       }
-      static b1(message) {
-        var $this = this.db(message);
+      static w(message) {
+        var $this = this.ya(message);
         init_kotlin_UninitializedPropertyAccessException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'UninitializedPropertyAccessException', $.kf);
+    initMetadataForClass($, 'UninitializedPropertyAccessException', $.df);
     UninitializedPropertyAccessExceptionClass = $;
   }
   return UninitializedPropertyAccessExceptionClass;
 }
 function init_kotlin_ConcurrentModificationException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.ya_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.ta_1);
 }
 var ConcurrentModificationExceptionClass;
 function ConcurrentModificationException() {
   if (ConcurrentModificationExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static pb() {
-        var $this = this.x3();
+      static kb() {
+        var $this = this.s3();
         init_kotlin_ConcurrentModificationException($this);
         return $this;
       }
-      static za(message) {
-        var $this = this.db(message);
+      static ua(message) {
+        var $this = this.ya(message);
         init_kotlin_ConcurrentModificationException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'ConcurrentModificationException', $.pb);
+    initMetadataForClass($, 'ConcurrentModificationException', $.kb);
     ConcurrentModificationExceptionClass = $;
   }
   return ConcurrentModificationExceptionClass;
 }
 function init_kotlin_NoWhenBranchMatchedException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.s5_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.j5_1);
 }
 var NoWhenBranchMatchedExceptionClass;
 function NoWhenBranchMatchedException() {
   if (NoWhenBranchMatchedExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static t5() {
-        var $this = this.x3();
+      static k5() {
+        var $this = this.s3();
         init_kotlin_NoWhenBranchMatchedException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'NoWhenBranchMatchedException', $.t5);
+    initMetadataForClass($, 'NoWhenBranchMatchedException', $.k5);
     NoWhenBranchMatchedExceptionClass = $;
   }
   return NoWhenBranchMatchedExceptionClass;

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/js/src/kotlin/exceptions.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["message","cause"],"mappings":";;;;;;;;;;;;;;mDAsDA,a,EAAA;A;AAKA,C;;;;;;;;;;gBAH8BA,O;4BAA0B,O;;;;;;;;;;2CArBxD,a,EAAA;A;AAKA,C;;;;;;;;;;eAH8BA,O;4BAA0B,O;;;;eAC1BA,O,EAAkBC,K;4BAA2B,O,EAAS,K;;;;;;;;;;8CAVpF,a,EAAA;A;AAKA,C;;;;;;;;;;gBAH8BD,O;4BAA0B,O;;;;gBAC1BA,O,EAAkBC,K;4BAA2B,O,EAAS,K;;;;;;;;;;sCAVpF,a,EAAA;A;AAKA,C;;;;;;;;;;gBAH8BD,O;4BAA0B,O;;;;gBAC1BA,O,EAAkBC,K;4BAA2B,O,EAAS,K;;;;;;;;;;+BAVpF,a,EAAA;A;AAKA,C;;;;;;;yCAJkC,K;;;;gBACJD,O;qDAA0B,O;yCAAN,K,EAAM,O;;;;gBAC1BA,O,EAAkBC,K;qDAA2B,O,sBAAS,K;yCAAf,K,EAAM,O,EAAS,K;;;;;;;;;;4CAqEpF,a,EAAA;A;AAGA,C;;;;;;;;;;gBAD8BD,O;4BAA0B,O;;;;;;;;;;+CA9CxD,a,EAAA;A;AAGA,C;;;;;;;;;;gBAD8BA,O;4BAA0B,O;;;;;;;;;;0CAwBxD,a,EAAA;A;AAGA,C;;;;;;;;;;gBAD8BA,O;4BAA0B,O;;;;;;;;;;yCAqBxD,a,EAAA;A;AAIA,C;;;;;;;;;;gBAD8BA,O;4BAA0B,O;;;;;;;;;;2BAvFxD,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;;;;;;;;;;2CAoDpF,a,EAAA;A;AAGA,C;;;;;;;;;;gBAD8BD,O;4BAA0B,O;;;;;;;;;;oCAcxD,a,EAAA;A;AAMA,C;;;;;;;;;;gBAJuBA,O;2BAA0B,O;;;;gBACnBA,O;kBAAuB,OAAS,2BAAT,OAAS,C;iCAAY,O,oBAAA,O;;;;;;;;;;wCAR1E,a,EAAA;A;AAGA,C;;;;;;;;;;;;;;;;0DA4BA,a,EAAA;A;AAKA,C;;;;;;;;;;gBAH8BA,O;4BAA0B,O;;;;;;;;;;qDA3DxD,a,EAAA;A;AAKA,C;;;;;;;;;;gBAH8BA,O;4BAA0B,O;;;;;;;;;;kDAgDxD,a,EAAA;A;AAKA,C;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/js/src/kotlin/exceptions.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["message","cause"],"mappings":";;;;;;;;;;;;;;mDAsDA,a,EAAA;A;AAKA,C;;;;;;;;;;gBAH8BA,O;4BAA0B,O;;;;;;;;;;2CArBxD,a,EAAA;A;AAKA,C;;;;;;;;;;eAH8BA,O;4BAA0B,O;;;;eAC1BA,O,EAAkBC,K;4BAA2B,O,EAAS,K;;;;;;;;;;8CAVpF,a,EAAA;A;AAKA,C;;;;;;;;;;gBAH8BD,O;4BAA0B,O;;;;gBAC1BA,O,EAAkBC,K;4BAA2B,O,EAAS,K;;;;;;;;;;sCAVpF,a,EAAA;A;AAKA,C;;;;;;;;;;gBAH8BD,O;4BAA0B,O;;;;gBAC1BA,O,EAAkBC,K;4BAA2B,O,EAAS,K;;;;;;;;;;+BAVpF,a,EAAA;A;AAKA,C;;;;;;;yCAJkC,K;;;;gBACJD,O;qDAA0B,O;yCAAN,K,EAAM,O;;;;gBAC1BA,O,EAAkBC,K;qDAA2B,O,sBAAS,K;yCAAf,K,EAAM,O,EAAS,K;;;;;;;;;;4CAqEpF,a,EAAA;A;AAGA,C;;;;;;;;;;gBAD8BD,O;4BAA0B,O;;;;;;;;;;+CA9CxD,a,EAAA;A;AAGA,C;;;;;;;;;;gBAD8BA,O;4BAA0B,O;;;;;;;;;;0CAwBxD,a,EAAA;A;AAGA,C;;;;;;;;;;gBAD8BA,O;4BAA0B,O;;;;;;;;;;yCAqBxD,a,EAAA;A;AAIA,C;;;;;;;;;;gBAD8BA,O;4BAA0B,O;;;;;;;;;;2BAvFxD,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;;;;;;;;;;2CAoDpF,a,EAAA;A;AAGA,C;;;;;;;;;;gBAD8BD,O;4BAA0B,O;;;;;;;;;;oCAcxD,a,EAAA;A;AAMA,C;;;;;;;;;;gBAJuBA,O;4BAA0B,O;;;;gBACnBA,O;kBAAuB,OAAS,2BAAT,OAAS,C;iCAAY,yC;;;;;;;;;;wCAR1E,a,EAAA;A;AAGA,C;;;;;;;;;;;;;;;;0DA4BA,a,EAAA;A;AAKA,C;;;;;;;;;;eAH8BA,O;4BAA0B,O;;;;;;;;;;qDA3DxD,a,EAAA;A;AAKA,C;;;;;;;;;;gBAH8BA,O;4BAA0B,O;;;;;;;;;;kDAgDxD,a,EAAA;A;AAKA,C;;;;;;;;;;;;;;;;;;;;"}

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

@@ -1,6 +1,6 @@
 import {
-  NullPointerException3mu0rhxjjitqq as NullPointerException,
   NoWhenBranchMatchedException3krrgsc7u48pz as NoWhenBranchMatchedException,
+  NullPointerException3mu0rhxjjitqq as NullPointerException,
   ClassCastException1atiay3nqgbd as ClassCastException,
 } from './exceptions.mjs';
 import { KotlinNothingValueException2zr0cdstak0a9 as KotlinNothingValueException } from './ExceptionsH.mjs';
@@ -8,6 +8,18 @@ import { KotlinNothingValueException2zr0cdstak0a9 as KotlinNothingValueException
 //endregion
 //region block: pre-declaration
 //endregion
+function noWhenBranchMatchedException() {
+  throw NoWhenBranchMatchedException().k5();
+}
+function THROW_NPE() {
+  throw NullPointerException().o5();
+}
+function THROW_CCE() {
+  throw ClassCastException().s5();
+}
+function throwKotlinNothingValueException() {
+  throw KotlinNothingValueException().p3();
+}
 function ensureNotNull(v) {
   var tmp;
   if (v == null) {
@@ -17,18 +29,6 @@ function ensureNotNull(v) {
   }
   return tmp;
 }
-function THROW_NPE() {
-  throw NullPointerException().p5();
-}
-function noWhenBranchMatchedException() {
-  throw NoWhenBranchMatchedException().t5();
-}
-function THROW_CCE() {
-  throw ClassCastException().x5();
-}
-function throwKotlinNothingValueException() {
-  throw KotlinNothingValueException().u3();
-}
 //region block: exports
 export {
   THROW_CCE as THROW_CCE2g6jy02ryeudk,

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/js/runtime/hacks.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["ensureNotNull","v","THROW_NPE","noWhenBranchMatchedException","THROW_CCE","throwKotlinNothingValueException"],"mappings":";;;;;;;;;;sBAqCSA,CAA0BC,CAA1BD,EAAsC;A;EAAI,SAAK,IAAL,C;IAAW,W;;UAAiB,C;;EAAC,U;AAAD,C;kBAVtEE,CAAAA,EAAyB;A,EAC9B,iC;AACJ,C;qCAfSC,CAAAA,EAA8C;A,EAAA,yC;AAAmC,C;kBAQjFC,CAAAA,EAAyB;A,EAC9B,+B;AACJ,C;yCAdSC,CAAAA,EACL;A,EAAA,wC;AAAkC,C;;;;;"}
+{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/js/runtime/hacks.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["noWhenBranchMatchedException","THROW_NPE","THROW_CCE","throwKotlinNothingValueException","ensureNotNull","v"],"mappings":";;;;;;;;;;qCAcSA,CAAAA,EAA8C;A,EAAA,yC;AAAmC,C;kBAajFC,CAAAA,EAAyB;A,EAC9B,iC;AACJ,C;kBAPSC,CAAAA,EAAyB;A,EAC9B,+B;AACJ,C;yCAdSC,CAAAA,EACL;A,EAAA,wC;AAAkC,C;sBA0B7BC,CAA0BC,CAA1BD,EAAsC;A;EAAI,SAAK,IAAL,C;IAAW,W;;UAAiB,C;;EAAC,U;AAAD,C;;;;;"}

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

@@ -4,7 +4,7 @@ import { UninitializedPropertyAccessException8qin22n38p0w as UninitializedProper
 //region block: pre-declaration
 //endregion
 function throwUninitializedPropertyAccessException(name) {
-  throw UninitializedPropertyAccessException().b1('lateinit property ' + name + ' has not been initialized');
+  throw UninitializedPropertyAccessException().w('lateinit property ' + name + ' has not been initialized');
 }
 //region block: exports
 export {

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/internal/common-non-jvm/src/kotlin/internal/ThrowHelpers.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["throwUninitializedPropertyAccessException","name"],"mappings":";;;;;kDAWSA,CAA8CC,IAA9CD,EACL;A,EAAA,gDAA4C,oBAA5C,GAA+D,IAA/D,GAAmE,2BAAnE,C;AAA6F,C;;;;;"}
+{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/internal/common-non-jvm/src/kotlin/internal/ThrowHelpers.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["throwUninitializedPropertyAccessException","name"],"mappings":";;;;;kDAWSA,CAA8CC,IAA9CD,EACL;A,EAAA,+CAA4C,oBAA5C,GAA+D,IAA/D,GAAmE,2BAAnE,C;AAA6F,C;;;;;"}

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

@@ -10,7 +10,7 @@ function getProgressionLastElement(start, end, step) {
   } else if (step < 0) {
     tmp = start <= end ? end : end + differenceModulo(start, end, -step | 0) | 0;
   } else {
-    throw IllegalArgumentException().r2('Step is zero.');
+    throw IllegalArgumentException().m2('Step is zero.');
   }
   return tmp;
 }