@continuous-excellence/coupling-cli 1.1.583 → 1.1.584

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

@@ -144,6 +144,12 @@ function Exception() {
         init_kotlin_Exception($this);
         return $this;
       }
+      static de(cause) {
+        var $this = createExternalThis(this, Error, [null, setupCauseParameter(cause)]);
+        setPropertiesToThrowableInstance($this, VOID, cause);
+        init_kotlin_Exception($this);
+        return $this;
+      }
     }
     initMetadataForClass($, 'Exception', $.be);
     ExceptionClass = $;
@@ -174,24 +180,24 @@ function NoSuchElementException() {
   return NoSuchElementExceptionClass;
 }
 function init_kotlin_IndexOutOfBoundsException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.fe_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.ge_1);
 }
 var IndexOutOfBoundsExceptionClass;
 function IndexOutOfBoundsException() {
   if (IndexOutOfBoundsExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static ge() {
+      static he() {
         var $this = this.s3();
         init_kotlin_IndexOutOfBoundsException($this);
         return $this;
       }
-      static he(message) {
+      static ie(message) {
         var $this = this.ya(message);
         init_kotlin_IndexOutOfBoundsException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'IndexOutOfBoundsException', $.ge);
+    initMetadataForClass($, 'IndexOutOfBoundsException', $.he);
     IndexOutOfBoundsExceptionClass = $;
   }
   return IndexOutOfBoundsExceptionClass;
@@ -208,7 +214,7 @@ function NullPointerException() {
         init_kotlin_NullPointerException($this);
         return $this;
       }
-      static ie(message) {
+      static je(message) {
         var $this = this.ya(message);
         init_kotlin_NullPointerException($this);
         return $this;
@@ -220,107 +226,107 @@ function NullPointerException() {
   return NullPointerExceptionClass;
 }
 function init_kotlin_ArithmeticException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.le_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.me_1);
 }
 var ArithmeticExceptionClass;
 function ArithmeticException() {
   if (ArithmeticExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static me() {
+      static ne() {
         var $this = this.s3();
         init_kotlin_ArithmeticException($this);
         return $this;
       }
-      static ne(message) {
+      static oe(message) {
         var $this = this.ya(message);
         init_kotlin_ArithmeticException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'ArithmeticException', $.me);
+    initMetadataForClass($, 'ArithmeticException', $.ne);
     ArithmeticExceptionClass = $;
   }
   return ArithmeticExceptionClass;
 }
 function init_kotlin_Error(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.oe_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.pe_1);
 }
 var ErrorClass;
 function Error_0() {
   if (ErrorClass === VOID) {
     class $ extends Error {
-      static pe() {
+      static qe() {
         var $this = createExternalThis(this, Error, [null]);
         setPropertiesToThrowableInstance($this);
         init_kotlin_Error($this);
         return $this;
       }
-      static qe(message) {
+      static re(message) {
         var $this = createExternalThis(this, Error, [message]);
         setPropertiesToThrowableInstance($this, message);
         init_kotlin_Error($this);
         return $this;
       }
-      static re(message, cause) {
+      static se(message, cause) {
         var $this = createExternalThis(this, Error, [message, setupCauseParameter(cause)]);
         setPropertiesToThrowableInstance($this, message, cause);
         init_kotlin_Error($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'Error', $.pe);
+    initMetadataForClass($, 'Error', $.qe);
     ErrorClass = $;
   }
   return ErrorClass;
 }
 function init_kotlin_NumberFormatException(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.ve_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.we_1);
 }
 var NumberFormatExceptionClass;
 function NumberFormatException() {
   if (NumberFormatExceptionClass === VOID) {
     class $ extends IllegalArgumentException() {
-      static we() {
+      static xe() {
         var $this = this.zd();
         init_kotlin_NumberFormatException($this);
         return $this;
       }
-      static xe(message) {
+      static ye(message) {
         var $this = this.m2(message);
         init_kotlin_NumberFormatException($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'NumberFormatException', $.we);
+    initMetadataForClass($, 'NumberFormatException', $.xe);
     NumberFormatExceptionClass = $;
   }
   return NumberFormatExceptionClass;
 }
 function init_kotlin_AssertionError(_this__u8e3s4) {
-  captureStack(_this__u8e3s4, _this__u8e3s4.ze_1);
+  captureStack(_this__u8e3s4, _this__u8e3s4.af_1);
 }
 var AssertionErrorClass;
 function AssertionError() {
   if (AssertionErrorClass === VOID) {
     class $ extends Error_0() {
-      static af() {
-        var $this = this.pe();
+      static bf() {
+        var $this = this.qe();
         init_kotlin_AssertionError($this);
         return $this;
       }
-      static bf(message) {
-        var $this = this.qe(message);
+      static cf(message) {
+        var $this = this.re(message);
         init_kotlin_AssertionError($this);
         return $this;
       }
-      static cf(message) {
+      static df(message) {
         var tmp = message == null ? null : toString(message);
-        var $this = this.re(tmp, message instanceof Error ? message : null);
+        var $this = this.se(tmp, message instanceof Error ? message : null);
         init_kotlin_AssertionError($this);
         return $this;
       }
     }
-    initMetadataForClass($, 'AssertionError', $.af);
+    initMetadataForClass($, 'AssertionError', $.bf);
     AssertionErrorClass = $;
   }
   return AssertionErrorClass;
@@ -350,7 +356,7 @@ var UninitializedPropertyAccessExceptionClass;
 function UninitializedPropertyAccessException() {
   if (UninitializedPropertyAccessExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static df() {
+      static ef() {
         var $this = this.s3();
         init_kotlin_UninitializedPropertyAccessException($this);
         return $this;
@@ -361,7 +367,7 @@ function UninitializedPropertyAccessException() {
         return $this;
       }
     }
-    initMetadataForClass($, 'UninitializedPropertyAccessException', $.df);
+    initMetadataForClass($, 'UninitializedPropertyAccessException', $.ef);
     UninitializedPropertyAccessExceptionClass = $;
   }
   return UninitializedPropertyAccessExceptionClass;

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;;;;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;;;;;;;;;;;;;;;;;;;;"}
+{"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;;;;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;;;;;;;;;;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/io/encoding/Base64.mjs

@@ -63,15 +63,15 @@ function PaddingOption() {
   return PaddingOptionClass;
 }
 function shouldPadOnEncode($this) {
-  return $this.ap_1.equals(PaddingOption_PRESENT_getInstance()) || $this.ap_1.equals(PaddingOption_PRESENT_OPTIONAL_getInstance());
+  return $this.cp_1.equals(PaddingOption_PRESENT_getInstance()) || $this.cp_1.equals(PaddingOption_PRESENT_OPTIONAL_getInstance());
 }
 function checkDestinationBounds($this, destinationSize, destinationOffset, capacityNeeded) {
   if (destinationOffset < 0 || destinationOffset > destinationSize) {
-    throw IndexOutOfBoundsException().he('destination offset: ' + destinationOffset + ', destination size: ' + destinationSize);
+    throw IndexOutOfBoundsException().ie('destination offset: ' + destinationOffset + ', destination size: ' + destinationSize);
   }
   var destinationEndIndex = destinationOffset + capacityNeeded | 0;
   if (destinationEndIndex < 0 || destinationEndIndex > destinationSize) {
-    throw IndexOutOfBoundsException().he('The destination array does not have enough capacity, ' + ('destination offset: ' + destinationOffset + ', destination size: ' + destinationSize + ', capacity needed: ' + capacityNeeded));
+    throw IndexOutOfBoundsException().ie('The destination array does not have enough capacity, ' + ('destination offset: ' + destinationOffset + ', destination size: ' + destinationSize + ', capacity needed: ' + capacityNeeded));
   }
 }
 var DefaultClass;
@@ -82,13 +82,13 @@ function Default() {
         Default_instance = null;
         super(false, false, -1, PaddingOption_PRESENT_getInstance());
         Default_instance = this;
-        this.hp_1 = 8;
-        this.ip_1 = 6;
-        this.jp_1 = 3;
-        this.kp_1 = 4;
-        this.lp_1 = 61;
-        this.mp_1 = 76;
-        this.np_1 = 64;
+        this.jp_1 = 8;
+        this.kp_1 = 6;
+        this.lp_1 = 3;
+        this.mp_1 = 4;
+        this.np_1 = 61;
+        this.op_1 = 76;
+        this.pp_1 = 64;
         var tmp = this;
         // Inline function 'kotlin.code' call
         var this_0 = _Char___init__impl__6a9atx(13);
@@ -98,10 +98,10 @@ function Default() {
         var this_1 = _Char___init__impl__6a9atx(10);
         var tmp$ret$1 = Char__toInt_impl_vasixd(this_1);
         // Inline function 'kotlin.byteArrayOf' call
-        tmp.op_1 = new Int8Array([tmp_0, toByte(tmp$ret$1)]);
-        this.pp_1 = new (Base64())(true, false, -1, PaddingOption_PRESENT_getInstance());
-        this.qp_1 = new (Base64())(false, true, 76, PaddingOption_PRESENT_getInstance());
-        this.rp_1 = new (Base64())(false, true, 64, PaddingOption_PRESENT_getInstance());
+        tmp.qp_1 = new Int8Array([tmp_0, toByte(tmp$ret$1)]);
+        this.rp_1 = new (Base64())(true, false, -1, PaddingOption_PRESENT_getInstance());
+        this.sp_1 = new (Base64())(false, true, 76, PaddingOption_PRESENT_getInstance());
+        this.tp_1 = new (Base64())(false, true, 64, PaddingOption_PRESENT_getInstance());
       }
     }
     initMetadataForObject($, 'Default');
@@ -129,42 +129,42 @@ function Base64() {
     class $ {
       constructor(isUrlSafe, isMimeScheme, mimeLineLength, paddingOption) {
         Default_getInstance();
-        this.xo_1 = isUrlSafe;
-        this.yo_1 = isMimeScheme;
-        this.zo_1 = mimeLineLength;
-        this.ap_1 = paddingOption;
+        this.zo_1 = isUrlSafe;
+        this.ap_1 = isMimeScheme;
+        this.bp_1 = mimeLineLength;
+        this.cp_1 = paddingOption;
         // Inline function 'kotlin.require' call
         // Inline function 'kotlin.require' call
-        if (!(!this.xo_1 || !this.yo_1)) {
+        if (!(!this.zo_1 || !this.ap_1)) {
           var message = 'Failed requirement.';
           throw IllegalArgumentException().m2(toString(message));
         }
-        this.bp_1 = this.zo_1 / 4 | 0;
+        this.dp_1 = this.bp_1 / 4 | 0;
       }
-      sp(source, startIndex, endIndex) {
+      up(source, startIndex, endIndex) {
         // Inline function 'kotlin.io.encoding.platformEncodeToString' call
-        var byteResult = this.up(source, startIndex, endIndex);
-        return this.xp(byteResult);
+        var byteResult = this.wp(source, startIndex, endIndex);
+        return this.zp(byteResult);
       }
-      tp(source, startIndex, endIndex, $super) {
+      vp(source, startIndex, endIndex, $super) {
         startIndex = startIndex === VOID ? 0 : startIndex;
         endIndex = endIndex === VOID ? source.length : endIndex;
-        return $super === VOID ? this.sp(source, startIndex, endIndex) : $super.sp.call(this, source, startIndex, endIndex);
+        return $super === VOID ? this.up(source, startIndex, endIndex) : $super.up.call(this, source, startIndex, endIndex);
       }
-      up(source, startIndex, endIndex) {
-        this.yp(source.length, startIndex, endIndex);
-        var encodeSize = this.wp(endIndex - startIndex | 0);
+      wp(source, startIndex, endIndex) {
+        this.aq(source.length, startIndex, endIndex);
+        var encodeSize = this.yp(endIndex - startIndex | 0);
         var destination = new Int8Array(encodeSize);
-        this.vp(source, destination, 0, startIndex, endIndex);
+        this.xp(source, destination, 0, startIndex, endIndex);
         return destination;
       }
-      vp(source, destination, destinationOffset, startIndex, endIndex) {
-        this.yp(source.length, startIndex, endIndex);
-        checkDestinationBounds(this, destination.length, destinationOffset, this.wp(endIndex - startIndex | 0));
-        var encodeMap = this.xo_1 ? get_base64UrlEncodeMap() : get_base64EncodeMap();
+      xp(source, destination, destinationOffset, startIndex, endIndex) {
+        this.aq(source.length, startIndex, endIndex);
+        checkDestinationBounds(this, destination.length, destinationOffset, this.yp(endIndex - startIndex | 0));
+        var encodeMap = this.zo_1 ? get_base64UrlEncodeMap() : get_base64EncodeMap();
         var sourceIndex = startIndex;
         var destinationIndex = destinationOffset;
-        var groupsPerLine = this.yo_1 ? this.bp_1 : 2147483647;
+        var groupsPerLine = this.ap_1 ? this.dp_1 : 2147483647;
         while ((sourceIndex + 2 | 0) < endIndex) {
           // Inline function 'kotlin.comparisons.minOf' call
           var a = (endIndex - sourceIndex | 0) / 3 | 0;
@@ -201,10 +201,10 @@ function Base64() {
           if (groups === groupsPerLine && !(sourceIndex === endIndex)) {
             var _unary__edvuaz_6 = destinationIndex;
             destinationIndex = _unary__edvuaz_6 + 1 | 0;
-            destination[_unary__edvuaz_6] = Default_getInstance().op_1[0];
+            destination[_unary__edvuaz_6] = Default_getInstance().qp_1[0];
             var _unary__edvuaz_7 = destinationIndex;
             destinationIndex = _unary__edvuaz_7 + 1 | 0;
-            destination[_unary__edvuaz_7] = Default_getInstance().op_1[1];
+            destination[_unary__edvuaz_7] = Default_getInstance().qp_1[1];
           }
         }
         var tmp0_subject = endIndex - sourceIndex | 0;
@@ -256,7 +256,7 @@ function Base64() {
         }
         return destinationIndex - destinationOffset | 0;
       }
-      wp(sourceSize) {
+      yp(sourceSize) {
         var groups = sourceSize / 3 | 0;
         var trailingBytes = sourceSize % 3 | 0;
         var size = imul(groups, 4);
@@ -266,15 +266,15 @@ function Base64() {
         if (size < 0) {
           throw IllegalArgumentException().m2('Input is too big');
         }
-        if (this.yo_1) {
-          size = size + imul((size - 1 | 0) / this.zo_1 | 0, 2) | 0;
+        if (this.ap_1) {
+          size = size + imul((size - 1 | 0) / this.bp_1 | 0, 2) | 0;
         }
         if (size < 0) {
           throw IllegalArgumentException().m2('Input is too big');
         }
         return size;
       }
-      xp(source) {
+      zp(source) {
         var stringBuilder = StringBuilder().bc(source.length);
         var inductionVariable = 0;
         var last = source.length;
@@ -285,8 +285,8 @@ function Base64() {
         }
         return stringBuilder.toString();
       }
-      yp(sourceSize, startIndex, endIndex) {
-        Companion_instance.ch(startIndex, endIndex, sourceSize);
+      aq(sourceSize, startIndex, endIndex) {
+        Companion_instance.eh(startIndex, endIndex, sourceSize);
       }
     }
     initMetadataForClass($, 'Base64');

package/kotlin/kotlin-kotlin-stdlib/kotlin/js/JsClass.mjs

@@ -5,7 +5,7 @@ import { KClassImpl3o7kfo8v13fhm as KClassImpl } from '../reflect/js/internal/KC
 //region block: pre-declaration
 //endregion
 function get_js(_this__u8e3s4) {
-  return (_this__u8e3s4 instanceof KClassImpl() ? _this__u8e3s4 : THROW_CCE()).ef();
+  return (_this__u8e3s4 instanceof KClassImpl() ? _this__u8e3s4 : THROW_CCE()).ff();
 }
 //region block: exports
 export {

package/kotlin/kotlin-kotlin-stdlib/kotlin/random/Random.mjs

@@ -37,36 +37,36 @@ var DefaultClass;
 function Default() {
   if (DefaultClass === VOID) {
     class $ extends Random() {
-      static bq() {
+      static dq() {
         Default_instance = null;
-        var $this = this.cq();
+        var $this = this.eq();
         Default_instance = $this;
-        $this.aq_1 = defaultPlatformRandom();
+        $this.cq_1 = defaultPlatformRandom();
         return $this;
       }
-      dq(bitCount) {
-        return this.aq_1.dq(bitCount);
+      fq(bitCount) {
+        return this.cq_1.fq(bitCount);
       }
-      xl() {
-        return this.aq_1.xl();
+      zl() {
+        return this.cq_1.zl();
       }
-      eq() {
-        return this.aq_1.eq();
+      gq() {
+        return this.cq_1.gq();
       }
-      fq(until) {
-        return this.aq_1.fq(until);
+      hq(until) {
+        return this.cq_1.hq(until);
       }
-      gq(from, until) {
-        return this.aq_1.gq(from, until);
+      iq(from, until) {
+        return this.cq_1.iq(from, until);
       }
-      hq(array) {
-        return this.aq_1.hq(array);
+      jq(array) {
+        return this.cq_1.jq(array);
       }
-      iq(size) {
-        return this.aq_1.iq(size);
+      kq(size) {
+        return this.cq_1.kq(size);
       }
-      jq(array, fromIndex, toIndex) {
-        return this.aq_1.jq(array, fromIndex, toIndex);
+      lq(array, fromIndex, toIndex) {
+        return this.cq_1.lq(array, fromIndex, toIndex);
       }
     }
     initMetadataForObject($, 'Default');
@@ -77,30 +77,30 @@ function Default() {
 var Default_instance;
 function Default_getInstance() {
   if (Default_instance === VOID)
-    Default().bq();
+    Default().dq();
   return Default_instance;
 }
 var RandomClass;
 function Random() {
   if (RandomClass === VOID) {
     class $ {
-      static cq() {
+      static eq() {
         Default_getInstance();
         return createThis(this);
       }
-      xl() {
-        return this.dq(32);
+      zl() {
+        return this.fq(32);
       }
-      eq() {
-        var tmp0 = shiftLeft(fromInt(this.xl()), 32);
+      gq() {
+        var tmp0 = shiftLeft(fromInt(this.zl()), 32);
         // Inline function 'kotlin.Long.plus' call
-        var other = this.xl();
+        var other = this.zl();
         return add(tmp0, fromInt(other));
       }
-      fq(until) {
-        return this.gq(new (Long())(0, 0), until);
+      hq(until) {
+        return this.iq(new (Long())(0, 0), until);
       }
-      gq(from, until) {
+      iq(from, until) {
         checkRangeBounds(from, until);
         var n = subtract(until, from);
         if (compare(n, new (Long())(0, 0)) > 0) {
@@ -111,19 +111,19 @@ function Random() {
             var tmp;
             if (!(nLow === 0)) {
               var bitCount = fastLog2(nLow);
-              tmp = bitwiseAnd(fromInt(this.dq(bitCount)), new (Long())(-1, 0));
+              tmp = bitwiseAnd(fromInt(this.fq(bitCount)), new (Long())(-1, 0));
             } else if (nHigh === 1) {
-              tmp = bitwiseAnd(fromInt(this.xl()), new (Long())(-1, 0));
+              tmp = bitwiseAnd(fromInt(this.zl()), new (Long())(-1, 0));
             } else {
               var bitCount_0 = fastLog2(nHigh);
-              tmp = add(shiftLeft(fromInt(this.dq(bitCount_0)), 32), bitwiseAnd(fromInt(this.xl()), new (Long())(-1, 0)));
+              tmp = add(shiftLeft(fromInt(this.fq(bitCount_0)), 32), bitwiseAnd(fromInt(this.zl()), new (Long())(-1, 0)));
             }
             rnd = tmp;
           } else {
             var v;
             $l$1: do {
               $l$0: do {
-                var bits = shiftRightUnsigned(this.eq(), 1);
+                var bits = shiftRightUnsigned(this.gq(), 1);
                 v = modulo(bits, n);
               }
                while (false);
@@ -137,13 +137,13 @@ function Random() {
           return add(from, rnd);
         } else {
           while (true) {
-            var rnd_0 = this.eq();
+            var rnd_0 = this.gq();
             if (compare(from, rnd_0) <= 0 ? compare(rnd_0, until) < 0 : false)
               return rnd_0;
           }
         }
       }
-      jq(array, fromIndex, toIndex) {
+      lq(array, fromIndex, toIndex) {
         // Inline function 'kotlin.require' call
         if (!((0 <= fromIndex ? fromIndex <= array.length : false) && (0 <= toIndex ? toIndex <= array.length : false))) {
           var message = 'fromIndex (' + fromIndex + ') or toIndex (' + toIndex + ') are out of range: 0..' + array.length + '.';
@@ -162,7 +162,7 @@ function Random() {
           do {
             var index = inductionVariable;
             inductionVariable = inductionVariable + 1 | 0;
-            var v = this.xl();
+            var v = this.zl();
             array[position] = toByte(v);
             array[position + 1 | 0] = toByte(v >>> 8 | 0);
             array[position + 2 | 0] = toByte(v >>> 16 | 0);
@@ -171,7 +171,7 @@ function Random() {
           }
            while (inductionVariable < steps);
         var remainder = toIndex - position | 0;
-        var vr = this.dq(imul(remainder, 8));
+        var vr = this.fq(imul(remainder, 8));
         var inductionVariable_0 = 0;
         if (inductionVariable_0 < remainder)
           do {
@@ -182,11 +182,11 @@ function Random() {
            while (inductionVariable_0 < remainder);
         return array;
       }
-      hq(array) {
-        return this.jq(array, 0, array.length);
+      jq(array) {
+        return this.lq(array, 0, array.length);
       }
-      iq(size) {
-        return this.hq(new Int8Array(size));
+      kq(size) {
+        return this.jq(new Int8Array(size));
       }
     }
     initMetadataForClass($, 'Random');
@@ -195,7 +195,7 @@ function Random() {
   return RandomClass;
 }
 function Random_0(seed) {
-  return XorWowRandom().qq(convertToInt(seed), convertToInt(shiftRight(seed, 32)));
+  return XorWowRandom().sq(convertToInt(seed), convertToInt(shiftRight(seed, 32)));
 }
 function fastLog2(value) {
   // Inline function 'kotlin.countLeadingZeroBits' call
@@ -213,7 +213,7 @@ function boundsErrorMessage(from, until) {
   return 'Random range is empty: [' + toString(from) + ', ' + toString(until) + ').';
 }
 function Random_1(seed) {
-  return XorWowRandom().qq(seed, seed >> 31);
+  return XorWowRandom().sq(seed, seed >> 31);
 }
 function takeUpperBits(_this__u8e3s4, bitCount) {
   return (_this__u8e3s4 >>> (32 - bitCount | 0) | 0) & (-bitCount | 0) >> 31;

package/kotlin/kotlin-kotlin-stdlib/kotlin/random/XorWowRandom.mjs

@@ -17,7 +17,7 @@ import {
 //endregion
 function checkInvariants($this) {
   // Inline function 'kotlin.require' call
-  if (!!(($this.kq_1 | $this.lq_1 | $this.mq_1 | $this.nq_1 | $this.oq_1) === 0)) {
+  if (!!(($this.mq_1 | $this.nq_1 | $this.oq_1 | $this.pq_1 | $this.qq_1) === 0)) {
     var message = 'Initial state must have at least one non-zero element.';
     throw IllegalArgumentException().m2(toString(message));
   }
@@ -28,7 +28,7 @@ function Companion() {
     class $ {
       constructor() {
         Companion_instance = this;
-        this.rq_1 = new (Long())(0, 0);
+        this.tq_1 = new (Long())(0, 0);
       }
     }
     initMetadataForCompanion($);
@@ -46,15 +46,15 @@ var XorWowRandomClass;
 function XorWowRandom() {
   if (XorWowRandomClass === VOID) {
     class $ extends Random() {
-      static sq(x, y, z, w, v, addend) {
+      static uq(x, y, z, w, v, addend) {
         Companion_getInstance();
-        var $this = this.cq();
-        $this.kq_1 = x;
-        $this.lq_1 = y;
-        $this.mq_1 = z;
-        $this.nq_1 = w;
-        $this.oq_1 = v;
-        $this.pq_1 = addend;
+        var $this = this.eq();
+        $this.mq_1 = x;
+        $this.nq_1 = y;
+        $this.oq_1 = z;
+        $this.pq_1 = w;
+        $this.qq_1 = v;
+        $this.rq_1 = addend;
         checkInvariants($this);
         // Inline function 'kotlin.repeat' call
         var inductionVariable = 0;
@@ -62,30 +62,30 @@ function XorWowRandom() {
           do {
             var index = inductionVariable;
             inductionVariable = inductionVariable + 1 | 0;
-            $this.xl();
+            $this.zl();
           }
            while (inductionVariable < 64);
         return $this;
       }
-      static qq(seed1, seed2) {
+      static sq(seed1, seed2) {
         Companion_getInstance();
-        return this.sq(seed1, seed2, 0, 0, ~seed1, seed1 << 10 ^ (seed2 >>> 4 | 0));
+        return this.uq(seed1, seed2, 0, 0, ~seed1, seed1 << 10 ^ (seed2 >>> 4 | 0));
       }
-      xl() {
-        var t = this.kq_1;
+      zl() {
+        var t = this.mq_1;
         t = t ^ (t >>> 2 | 0);
-        this.kq_1 = this.lq_1;
-        this.lq_1 = this.mq_1;
         this.mq_1 = this.nq_1;
-        var v0 = this.oq_1;
-        this.nq_1 = v0;
+        this.nq_1 = this.oq_1;
+        this.oq_1 = this.pq_1;
+        var v0 = this.qq_1;
+        this.pq_1 = v0;
         t = t ^ t << 1 ^ v0 ^ v0 << 4;
-        this.oq_1 = t;
-        this.pq_1 = this.pq_1 + 362437 | 0;
-        return t + this.pq_1 | 0;
+        this.qq_1 = t;
+        this.rq_1 = this.rq_1 + 362437 | 0;
+        return t + this.rq_1 | 0;
       }
-      dq(bitCount) {
-        return takeUpperBits(this.xl(), bitCount);
+      fq(bitCount) {
+        return takeUpperBits(this.zl(), bitCount);
       }
     }
     initMetadataForClass($, 'XorWowRandom');