@attocash/commons-test 6.1.0 → 6.2.0

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

@@ -5,414 +5,414 @@ import {
   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';
+import { VOID3gxj6tk5isa35 as VOID } from './js/void.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from './Unit.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);
+function init_kotlin_UnsupportedOperationException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.o5_1);
 }
-var IllegalArgumentExceptionClass;
-function IllegalArgumentException() {
-  if (IllegalArgumentExceptionClass === VOID) {
+var UnsupportedOperationExceptionClass;
+function UnsupportedOperationException() {
+  if (UnsupportedOperationExceptionClass === 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);
+      static p5() {
+        var $this = this.w3();
+        init_kotlin_UnsupportedOperationException($this);
         return $this;
       }
-      static md(cause) {
-        var $this = this.nd(cause);
-        init_kotlin_IllegalArgumentException($this);
+      static qa(message) {
+        var $this = this.eb(message);
+        init_kotlin_UnsupportedOperationException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'IllegalArgumentException', $.jd);
-    IllegalArgumentExceptionClass = $;
+    initMetadataForClass($, 'UnsupportedOperationException', $.p5);
+    UnsupportedOperationExceptionClass = $;
   }
-  return IllegalArgumentExceptionClass;
+  return UnsupportedOperationExceptionClass;
 }
 function init_kotlin_IllegalStateException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.v4_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.l_1);
 }
 var IllegalStateExceptionClass;
 function IllegalStateException() {
   if (IllegalStateExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static uc() {
-        var $this = this.p2();
+      static m() {
+        var $this = this.w3();
         init_kotlin_IllegalStateException($this);
         return $this;
       }
-      static w4(message) {
-        var $this = this.ga(message);
+      static o(message) {
+        var $this = this.eb(message);
         init_kotlin_IllegalStateException($this);
         return $this;
       }
-      static xc(message, cause) {
-        var $this = this.ld(message, cause);
+      static q(message, cause) {
+        var $this = this.td(message, cause);
         init_kotlin_IllegalStateException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'IllegalStateException', $.uc);
+    initMetadataForClass($, 'IllegalStateException', $.m);
     IllegalStateExceptionClass = $;
   }
   return IllegalStateExceptionClass;
 }
-function init_kotlin_UnsupportedOperationException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.i4_1);
+function init_kotlin_IllegalArgumentException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.r2_1);
 }
-var UnsupportedOperationExceptionClass;
-function UnsupportedOperationException() {
-  if (UnsupportedOperationExceptionClass === VOID) {
+var IllegalArgumentExceptionClass;
+function IllegalArgumentException() {
+  if (IllegalArgumentExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static j4() {
-        var $this = this.p2();
-        init_kotlin_UnsupportedOperationException($this);
+      static ud() {
+        var $this = this.w3();
+        init_kotlin_IllegalArgumentException($this);
         return $this;
       }
-      static s9(message) {
-        var $this = this.ga(message);
-        init_kotlin_UnsupportedOperationException($this);
+      static s2(message) {
+        var $this = this.eb(message);
+        init_kotlin_IllegalArgumentException($this);
+        return $this;
+      }
+      static vd(message, cause) {
+        var $this = this.td(message, cause);
+        init_kotlin_IllegalArgumentException($this);
+        return $this;
+      }
+      static wd(cause) {
+        var $this = this.xd(cause);
+        init_kotlin_IllegalArgumentException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'UnsupportedOperationException', $.j4);
-    UnsupportedOperationExceptionClass = $;
+    initMetadataForClass($, 'IllegalArgumentException', $.ud);
+    IllegalArgumentExceptionClass = $;
   }
-  return UnsupportedOperationExceptionClass;
+  return IllegalArgumentExceptionClass;
 }
 function init_kotlin_RuntimeException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.o2_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.v3_1);
 }
 var RuntimeExceptionClass;
 function RuntimeException() {
   if (RuntimeExceptionClass === VOID) {
     class $ extends Exception() {
-      static p2() {
-        var $this = this.fd();
+      static w3() {
+        var $this = this.zd();
         init_kotlin_RuntimeException($this);
         return $this;
       }
-      static ga(message) {
-        var $this = this.gd(message);
+      static eb(message) {
+        var $this = this.ae(message);
         init_kotlin_RuntimeException($this);
         return $this;
       }
-      static ld(message, cause) {
-        var $this = this.hd(message, cause);
+      static td(message, cause) {
+        var $this = this.be(message, cause);
         init_kotlin_RuntimeException($this);
         return $this;
       }
-      static nd(cause) {
-        var $this = this.id(cause);
+      static xd(cause) {
+        var $this = this.ce(cause);
         init_kotlin_RuntimeException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'RuntimeException', $.p2);
+    initMetadataForClass($, 'RuntimeException', $.w3);
     RuntimeExceptionClass = $;
   }
   return RuntimeExceptionClass;
 }
+function init_kotlin_Exception(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.yd_1);
+}
+var ExceptionClass;
+function Exception() {
+  if (ExceptionClass === VOID) {
+    class $ extends Error {
+      static zd() {
+        var $this = createExternalThis(this, Error, [null]);
+        setPropertiesToThrowableInstance($this);
+        init_kotlin_Exception($this);
+        return $this;
+      }
+      static ae(message) {
+        var $this = createExternalThis(this, Error, [message]);
+        setPropertiesToThrowableInstance($this, message);
+        init_kotlin_Exception($this);
+        return $this;
+      }
+      static be(message, cause) {
+        var $this = createExternalThis(this, Error, [message, setupCauseParameter(cause)]);
+        setPropertiesToThrowableInstance($this, message, cause);
+        init_kotlin_Exception($this);
+        return $this;
+      }
+      static ce(cause) {
+        var $this = createExternalThis(this, Error, [null, setupCauseParameter(cause)]);
+        setPropertiesToThrowableInstance($this, VOID, cause);
+        init_kotlin_Exception($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'Exception', $.zd);
+    ExceptionClass = $;
+  }
+  return ExceptionClass;
+}
 function init_kotlin_NoSuchElementException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.d1_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.n2_1);
 }
 var NoSuchElementExceptionClass;
 function NoSuchElementException() {
   if (NoSuchElementExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static i6() {
-        var $this = this.p2();
+      static g7() {
+        var $this = this.w3();
         init_kotlin_NoSuchElementException($this);
         return $this;
       }
-      static e1(message) {
-        var $this = this.ga(message);
+      static o2(message) {
+        var $this = this.eb(message);
         init_kotlin_NoSuchElementException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'NoSuchElementException', $.i6);
+    initMetadataForClass($, 'NoSuchElementException', $.g7);
     NoSuchElementExceptionClass = $;
   }
   return NoSuchElementExceptionClass;
 }
+function init_kotlin_IndexOutOfBoundsException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.fe_1);
+}
+var IndexOutOfBoundsExceptionClass;
+function IndexOutOfBoundsException() {
+  if (IndexOutOfBoundsExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static ge() {
+        var $this = this.w3();
+        init_kotlin_IndexOutOfBoundsException($this);
+        return $this;
+      }
+      static he(message) {
+        var $this = this.eb(message);
+        init_kotlin_IndexOutOfBoundsException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'IndexOutOfBoundsException', $.ge);
+    IndexOutOfBoundsExceptionClass = $;
+  }
+  return IndexOutOfBoundsExceptionClass;
+}
 function init_kotlin_Error(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.h_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.w_1);
 }
 var ErrorClass;
 function Error_0() {
   if (ErrorClass === VOID) {
     class $ extends Error {
-      static od() {
+      static ie() {
         var $this = createExternalThis(this, Error, [null]);
         setPropertiesToThrowableInstance($this);
         init_kotlin_Error($this);
         return $this;
       }
-      static i(message) {
+      static x(message) {
         var $this = createExternalThis(this, Error, [message]);
         setPropertiesToThrowableInstance($this, message);
         init_kotlin_Error($this);
         return $this;
       }
-      static pd(message, cause) {
+      static je(message, cause) {
         var $this = createExternalThis(this, Error, [message, setupCauseParameter(cause)]);
         setPropertiesToThrowableInstance($this, message, cause);
         init_kotlin_Error($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'Error', $.od);
+    initMetadataForClass($, 'Error', $.ie);
     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);
+  captureStack(_this__u8e3s4, _this__u8e3s4.ne_1);
 }
 var NumberFormatExceptionClass;
 function NumberFormatException() {
   if (NumberFormatExceptionClass === VOID) {
     class $ extends IllegalArgumentException() {
-      static zd() {
-        var $this = this.jd();
+      static oe() {
+        var $this = this.ud();
         init_kotlin_NumberFormatException($this);
         return $this;
       }
-      static ae(message) {
-        var $this = this.i1(message);
+      static pe(message) {
+        var $this = this.s2(message);
         init_kotlin_NumberFormatException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'NumberFormatException', $.zd);
+    initMetadataForClass($, 'NumberFormatException', $.oe);
     NumberFormatExceptionClass = $;
   }
   return NumberFormatExceptionClass;
 }
 function init_kotlin_ArithmeticException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.de_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.se_1);
 }
 var ArithmeticExceptionClass;
 function ArithmeticException() {
   if (ArithmeticExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static ee() {
-        var $this = this.p2();
+      static te() {
+        var $this = this.w3();
         init_kotlin_ArithmeticException($this);
         return $this;
       }
-      static fe(message) {
-        var $this = this.ga(message);
+      static ue(message) {
+        var $this = this.eb(message);
         init_kotlin_ArithmeticException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'ArithmeticException', $.ee);
+    initMetadataForClass($, 'ArithmeticException', $.te);
     ArithmeticExceptionClass = $;
   }
   return ArithmeticExceptionClass;
 }
 function init_kotlin_AssertionError(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.he_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.we_1);
 }
 var AssertionErrorClass;
 function AssertionError() {
   if (AssertionErrorClass === VOID) {
     class $ extends Error_0() {
-      static ie() {
-        var $this = this.od();
+      static xe() {
+        var $this = this.ie();
         init_kotlin_AssertionError($this);
         return $this;
       }
-      static je(message) {
+      static ye(message) {
         var tmp = message == null ? null : toString(message);
-        var $this = this.pd(tmp, message instanceof Error ? message : null);
+        var $this = this.je(tmp, message instanceof Error ? message : null);
         init_kotlin_AssertionError($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'AssertionError', $.ie);
+    initMetadataForClass($, 'AssertionError', $.xe);
     AssertionErrorClass = $;
   }
   return AssertionErrorClass;
 }
 function init_kotlin_ConcurrentModificationException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.ba_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.za_1);
 }
 var ConcurrentModificationExceptionClass;
 function ConcurrentModificationException() {
   if (ConcurrentModificationExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static sa() {
-        var $this = this.p2();
+      static qb() {
+        var $this = this.w3();
         init_kotlin_ConcurrentModificationException($this);
         return $this;
       }
-      static ca(message) {
-        var $this = this.ga(message);
+      static ab(message) {
+        var $this = this.eb(message);
         init_kotlin_ConcurrentModificationException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'ConcurrentModificationException', $.sa);
+    initMetadataForClass($, 'ConcurrentModificationException', $.qb);
     ConcurrentModificationExceptionClass = $;
   }
   return ConcurrentModificationExceptionClass;
 }
 function init_kotlin_NullPointerException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.z4_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.b6_1);
 }
 var NullPointerExceptionClass;
 function NullPointerException() {
   if (NullPointerExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static a5() {
-        var $this = this.p2();
+      static c6() {
+        var $this = this.w3();
         init_kotlin_NullPointerException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'NullPointerException', $.a5);
+    initMetadataForClass($, 'NullPointerException', $.c6);
     NullPointerExceptionClass = $;
   }
   return NullPointerExceptionClass;
 }
+function init_kotlin_UninitializedPropertyAccessException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.a1_1);
+}
+var UninitializedPropertyAccessExceptionClass;
+function UninitializedPropertyAccessException() {
+  if (UninitializedPropertyAccessExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static ze() {
+        var $this = this.w3();
+        init_kotlin_UninitializedPropertyAccessException($this);
+        return $this;
+      }
+      static b1(message) {
+        var $this = this.eb(message);
+        init_kotlin_UninitializedPropertyAccessException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'UninitializedPropertyAccessException', $.ze);
+    UninitializedPropertyAccessExceptionClass = $;
+  }
+  return UninitializedPropertyAccessExceptionClass;
+}
 function init_kotlin_NoWhenBranchMatchedException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.d5_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.f6_1);
 }
 var NoWhenBranchMatchedExceptionClass;
 function NoWhenBranchMatchedException() {
   if (NoWhenBranchMatchedExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static e5() {
-        var $this = this.p2();
+      static g6() {
+        var $this = this.w3();
         init_kotlin_NoWhenBranchMatchedException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'NoWhenBranchMatchedException', $.e5);
+    initMetadataForClass($, 'NoWhenBranchMatchedException', $.g6);
     NoWhenBranchMatchedExceptionClass = $;
   }
   return NoWhenBranchMatchedExceptionClass;
 }
 function init_kotlin_ClassCastException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.h5_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.j6_1);
 }
 var ClassCastExceptionClass;
 function ClassCastException() {
   if (ClassCastExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static i5() {
-        var $this = this.p2();
+      static k6() {
+        var $this = this.w3();
         init_kotlin_ClassCastException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'ClassCastException', $.i5);
+    initMetadataForClass($, 'ClassCastException', $.k6);
     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,

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

@@ -1 +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;;;;;;;;;;;;;;"}
+{"version":3,"sources":["../../../../../commons-test/build/compileSync/js/main/productionLibrary/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;;;;gBACtDA,K;4BAA2B,K;;;;;;;;;;sCAXzD,a,EAAA;A;AAKA,C;;;;;;;;;;gBAH8BD,O;4BAA0B,O;;;;gBAC1BA,O,EAAkBC,K;4BAA2B,O,EAAS,K;;;;gBACtDA,K;4BAA2B,K;;;;;;;;;;+BAXzD,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;;;;gBACtDA,K;+EAA2B,K;yCAAN,K,QAAM,K;;;;;;;;;;4CAoEzD,a,EAAA;A;AAGA,C;;;;;;;;;;gBAD8BD,O;4BAA0B,O;;;;;;;;;;+CA9CxD,a,EAAA;A;AAGA,C;;;;;;;;;;gBAD8BA,O;4BAA0B,O;;;;;;;;;;2BArCxD,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;;;;;;;;;;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;;;;;;;;;;;;;;;;0DAiCA,a,EAAA;A;AAKA,C;;;;;;;;;;gBAH8BA,O;4BAA0B,O;;;;;;;;;;kDATxD,a,EAAA;A;AAKA,C;;;;;;;;;;;;;;;;wCA7BA,a,EAAA;A;AAGA,C;;;;;;;;;;;;;;;;;;;;"}

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

@@ -2,7 +2,6 @@ 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';
@@ -20,22 +19,19 @@ function ensureNotNull(v) {
   return tmp;
 }
 function THROW_NPE() {
-  throw NullPointerException().a5();
+  throw NullPointerException().c6();
 }
 function noWhenBranchMatchedException() {
-  throw NoWhenBranchMatchedException().e5();
+  throw NoWhenBranchMatchedException().g6();
 }
 function THROW_CCE() {
-  throw ClassCastException().i5();
-}
-function throwUninitializedPropertyAccessException(name) {
-  throw UninitializedPropertyAccessException().m5('lateinit property ' + name + ' has not been initialized');
+  throw ClassCastException().k6();
 }
 function throwKotlinNothingValueException() {
-  throw KotlinNothingValueException().m2();
+  throw KotlinNothingValueException().t3();
 }
 function THROW_IAE(msg) {
-  throw IllegalArgumentException().i1(msg);
+  throw IllegalArgumentException().s2(msg);
 }
 //region block: exports
 export {
@@ -44,7 +40,6 @@ export {
   ensureNotNull as ensureNotNull1e947j3ixpazm,
   noWhenBranchMatchedException as noWhenBranchMatchedException2a6r7ubxgky5j,
   throwKotlinNothingValueException as throwKotlinNothingValueException2lxmvl03dor6f,
-  throwUninitializedPropertyAccessException as throwUninitializedPropertyAccessExceptionyynx7gkm73wd,
 };
 //endregion
 

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

@@ -1 +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;;;;;"}
+{"version":3,"sources":["../../../../../commons-test/build/compileSync/js/main/productionLibrary/kotlin/kotlin-kotlin-stdlib/kotlin/js/runtime/hacks.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["ensureNotNull","v","THROW_NPE","noWhenBranchMatchedException","THROW_CCE","throwKotlinNothingValueException","THROW_IAE","msg"],"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;kBAqB7BC,CAAcC,GAAdD,EAAoC;A,EACzC,oCAA+B,GAA/B,C;AACJ,C;;;;;"}