@attocash/commons-js 5.0.0 → 5.1.1

package/ktor-ktor-http-cio/io/ktor/http/cio/RequestResponseBuilderJs.mjs

@@ -15,33 +15,33 @@ function RequestResponseBuilder() {
   if (RequestResponseBuilderClass === VOID) {
     class $ {
       constructor() {
-        this.z4n_1 = BytePacketBuilder();
+        this.n4o_1 = BytePacketBuilder();
       }
-      a4o(method, uri, version) {
-        writeText(this.z4n_1, method.u45_1);
-        this.z4n_1.x2s(32);
-        writeText(this.z4n_1, uri);
-        this.z4n_1.x2s(32);
-        writeText(this.z4n_1, version);
-        this.z4n_1.x2s(13);
-        this.z4n_1.x2s(10);
+      o4o(method, uri, version) {
+        writeText(this.n4o_1, method.i46_1);
+        this.n4o_1.l2t(32);
+        writeText(this.n4o_1, uri);
+        this.n4o_1.l2t(32);
+        writeText(this.n4o_1, version);
+        this.n4o_1.l2t(13);
+        this.n4o_1.l2t(10);
       }
-      b4o(name, value) {
-        append(this.z4n_1, name);
-        append(this.z4n_1, ': ');
-        append(this.z4n_1, value);
-        this.z4n_1.x2s(13);
-        this.z4n_1.x2s(10);
+      p4o(name, value) {
+        append(this.n4o_1, name);
+        append(this.n4o_1, ': ');
+        append(this.n4o_1, value);
+        this.n4o_1.l2t(13);
+        this.n4o_1.l2t(10);
       }
-      c4o() {
-        this.z4n_1.x2s(13);
-        this.z4n_1.x2s(10);
+      q4o() {
+        this.n4o_1.l2t(13);
+        this.n4o_1.l2t(10);
       }
       z1i() {
-        return build(this.z4n_1);
+        return build(this.n4o_1);
       }
-      y2n() {
-        this.z4n_1.v5();
+      m2o() {
+        this.n4o_1.v5();
       }
     }
     initMetadataForClass($, 'RequestResponseBuilder', RequestResponseBuilder);

package/ktor-ktor-http-cio/io/ktor/http/cio/internals/AsciiCharTree.mjs

@@ -98,16 +98,16 @@ function Node() {
   if (NodeClass === VOID) {
     class $ {
       constructor(ch, exact, children) {
-        this.z4m_1 = ch;
-        this.a4n_1 = exact;
-        this.b4n_1 = children;
+        this.n4n_1 = ch;
+        this.o4n_1 = exact;
+        this.p4n_1 = children;
         var tmp = this;
         var tmp_0 = 0;
         // Inline function 'kotlin.arrayOfNulls' call
         var tmp_1 = Array(256);
         while (tmp_0 < 256) {
           var tmp_2 = tmp_0;
-          var tmp0 = this.b4n_1;
+          var tmp0 = this.p4n_1;
           var tmp$ret$3;
           $l$block_0: {
             // Inline function 'kotlin.collections.singleOrNull' call
@@ -117,7 +117,7 @@ function Node() {
             while (_iterator__ex2g4s.e1()) {
               var element = _iterator__ex2g4s.f1();
               // Inline function 'kotlin.code' call
-              var this_0 = element.z4m_1;
+              var this_0 = element.n4n_1;
               if (Char__toInt_impl_vasixd(this_0) === tmp_2) {
                 if (found) {
                   tmp$ret$3 = null;
@@ -136,7 +136,7 @@ function Node() {
           tmp_1[tmp_2] = tmp$ret$3;
           tmp_0 = tmp_0 + 1 | 0;
         }
-        tmp.c4n_1 = tmp_1;
+        tmp.q4n_1 = tmp_1;
       }
     }
     initMetadataForClass($, 'Node');
@@ -148,11 +148,11 @@ var CompanionClass;
 function Companion() {
   if (CompanionClass === VOID) {
     class $ {
-      e4j(from) {
+      s4j(from) {
         var tmp = AsciiCharTree$Companion$build$lambda;
-        return this.m4f(from, tmp, AsciiCharTree$Companion$build$lambda_0);
+        return this.a4g(from, tmp, AsciiCharTree$Companion$build$lambda_0);
       }
-      m4f(from, length, charAt) {
+      a4g(from, length, charAt) {
         var tmp$ret$0;
         $l$block_0: {
           // Inline function 'kotlin.collections.maxByOrNull' call
@@ -239,13 +239,13 @@ function AsciiCharTree() {
   if (AsciiCharTreeClass === VOID) {
     class $ {
       constructor(root) {
-        this.g4f_1 = root;
+        this.u4f_1 = root;
       }
-      h4f(sequence, fromIdx, end, lowerCase, stopPredicate) {
+      v4f(sequence, fromIdx, end, lowerCase, stopPredicate) {
         // Inline function 'kotlin.text.isEmpty' call
         if (charSequenceLength(sequence) === 0)
           throw IllegalArgumentException().u("Couldn't search in char tree for empty string");
-        var node = this.g4f_1;
+        var node = this.u4f_1;
         var inductionVariable = fromIdx;
         if (inductionVariable < end)
           $l$loop: do {
@@ -256,12 +256,12 @@ function AsciiCharTree() {
             var currentCode = Char__toInt_impl_vasixd(current);
             if (stopPredicate(new (Char())(current), currentCode))
               break $l$loop;
-            var tmp0_elvis_lhs = node.c4n_1[currentCode];
+            var tmp0_elvis_lhs = node.q4n_1[currentCode];
             var tmp;
             if (tmp0_elvis_lhs == null) {
               var tmp_0;
               if (lowerCase) {
-                var tmp_1 = node.c4n_1;
+                var tmp_1 = node.q4n_1;
                 // Inline function 'kotlin.text.lowercaseChar' call
                 // Inline function 'kotlin.text.lowercase' call
                 // Inline function 'kotlin.js.asDynamic' call
@@ -288,13 +288,13 @@ function AsciiCharTree() {
             node = nextNode;
           }
            while (inductionVariable < end);
-        return node.a4n_1;
+        return node.o4n_1;
       }
-      o4f(sequence, fromIdx, end, lowerCase, stopPredicate, $super) {
+      c4g(sequence, fromIdx, end, lowerCase, stopPredicate, $super) {
         fromIdx = fromIdx === VOID ? 0 : fromIdx;
         end = end === VOID ? charSequenceLength(sequence) : end;
         lowerCase = lowerCase === VOID ? false : lowerCase;
-        return $super === VOID ? this.h4f(sequence, fromIdx, end, lowerCase, stopPredicate) : $super.h4f.call(this, sequence, fromIdx, end, lowerCase, stopPredicate);
+        return $super === VOID ? this.v4f(sequence, fromIdx, end, lowerCase, stopPredicate) : $super.v4f.call(this, sequence, fromIdx, end, lowerCase, stopPredicate);
       }
     }
     initMetadataForClass($, 'AsciiCharTree');

package/ktor-ktor-http-cio/io/ktor/http/cio/internals/CharArrayBuilder.mjs

@@ -27,7 +27,7 @@ var imul = Math.imul;
 //region block: pre-declaration
 //endregion
 function getImpl($this, index) {
-  return bufferForIndex($this, index)[index % ensureNotNull($this.i4h_1).length | 0];
+  return bufferForIndex($this, index)[index % ensureNotNull($this.w4h_1).length | 0];
 }
 function copy($this, startIndex, endIndex) {
   if (startIndex === endIndex)
@@ -60,27 +60,27 @@ function SubSequenceImpl() {
   if (SubSequenceImplClass === VOID) {
     class $ {
       constructor($outer, start, end) {
-        this.g4n_1 = $outer;
-        this.d4n_1 = start;
-        this.e4n_1 = end;
-        this.f4n_1 = null;
+        this.u4n_1 = $outer;
+        this.r4n_1 = start;
+        this.s4n_1 = end;
+        this.t4n_1 = null;
       }
       a() {
-        return this.e4n_1 - this.d4n_1 | 0;
+        return this.s4n_1 - this.r4n_1 | 0;
       }
       b(index) {
-        var withOffset = index + this.d4n_1 | 0;
+        var withOffset = index + this.r4n_1 | 0;
         // Inline function 'kotlin.require' call
         if (!(index >= 0)) {
           var message = 'index is negative: ' + index;
           throw IllegalArgumentException().u(toString(message));
         }
         // Inline function 'kotlin.require' call
-        if (!(withOffset < this.e4n_1)) {
+        if (!(withOffset < this.s4n_1)) {
           var message_0 = 'index (' + index + ') should be less than length (' + this.a() + ')';
           throw IllegalArgumentException().u(toString(message_0));
         }
-        return getImpl(this.g4n_1, withOffset);
+        return getImpl(this.u4n_1, withOffset);
       }
       c(startIndex, endIndex) {
         // Inline function 'kotlin.require' call
@@ -94,21 +94,21 @@ function SubSequenceImpl() {
           throw IllegalArgumentException().u(toString(message_0));
         }
         // Inline function 'kotlin.require' call
-        if (!(endIndex <= (this.e4n_1 - this.d4n_1 | 0))) {
+        if (!(endIndex <= (this.s4n_1 - this.r4n_1 | 0))) {
           var message_1 = 'end should be less than length (' + this.a() + ')';
           throw IllegalArgumentException().u(toString(message_1));
         }
         if (startIndex === endIndex)
           return '';
-        return new (SubSequenceImpl())(this.g4n_1, this.d4n_1 + startIndex | 0, this.d4n_1 + endIndex | 0);
+        return new (SubSequenceImpl())(this.u4n_1, this.r4n_1 + startIndex | 0, this.r4n_1 + endIndex | 0);
       }
       toString() {
-        var tmp0_elvis_lhs = this.f4n_1;
+        var tmp0_elvis_lhs = this.t4n_1;
         var tmp;
         if (tmp0_elvis_lhs == null) {
           // Inline function 'kotlin.also' call
-          var this_0 = toString(copy(this.g4n_1, this.d4n_1, this.e4n_1));
-          this.f4n_1 = this_0;
+          var this_0 = toString(copy(this.u4n_1, this.r4n_1, this.s4n_1));
+          this.t4n_1 = this_0;
           tmp = this_0;
         } else {
           tmp = tmp0_elvis_lhs;
@@ -120,12 +120,12 @@ function SubSequenceImpl() {
           return false;
         if (!(charSequenceLength(other) === this.a()))
           return false;
-        return rangeEqualsImpl(this.g4n_1, this.d4n_1, other, 0, this.a());
+        return rangeEqualsImpl(this.u4n_1, this.r4n_1, other, 0, this.a());
       }
       hashCode() {
-        var tmp0_safe_receiver = this.f4n_1;
+        var tmp0_safe_receiver = this.t4n_1;
         var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : getStringHashCode(tmp0_safe_receiver);
-        return tmp1_elvis_lhs == null ? hashCodeImpl(this.g4n_1, this.d4n_1, this.e4n_1) : tmp1_elvis_lhs;
+        return tmp1_elvis_lhs == null ? hashCodeImpl(this.u4n_1, this.r4n_1, this.s4n_1) : tmp1_elvis_lhs;
       }
     }
     initMetadataForClass($, 'SubSequenceImpl', VOID, VOID, [CharSequence()]);
@@ -134,12 +134,12 @@ function SubSequenceImpl() {
   return SubSequenceImplClass;
 }
 function bufferForIndex($this, index) {
-  var list = $this.h4h_1;
+  var list = $this.v4h_1;
   if (list == null) {
     if (index >= 2048) {
       throwSingleBuffer($this, index);
     }
-    var tmp0_elvis_lhs = $this.i4h_1;
+    var tmp0_elvis_lhs = $this.w4h_1;
     var tmp;
     if (tmp0_elvis_lhs == null) {
       throwSingleBuffer($this, index);
@@ -148,29 +148,29 @@ function bufferForIndex($this, index) {
     }
     return tmp;
   }
-  return list.j1(index / ensureNotNull($this.i4h_1).length | 0);
+  return list.j1(index / ensureNotNull($this.w4h_1).length | 0);
 }
 function throwSingleBuffer($this, index) {
-  if ($this.k4h_1)
+  if ($this.y4h_1)
     throw IllegalStateException().o4('Buffer is already released');
   throw IndexOutOfBoundsException().hf('' + index + ' is not in range [0; ' + currentPosition($this) + ')');
 }
 function nonFullBuffer($this) {
-  return $this.l4h_1 === 0 ? appendNewArray($this) : ensureNotNull($this.i4h_1);
+  return $this.z4h_1 === 0 ? appendNewArray($this) : ensureNotNull($this.w4h_1);
 }
 function appendNewArray($this) {
-  var newBuffer = $this.g4h_1.n3q();
-  var existing = $this.i4h_1;
-  $this.i4h_1 = newBuffer;
-  $this.l4h_1 = newBuffer.length;
-  $this.k4h_1 = false;
+  var newBuffer = $this.u4h_1.b3r();
+  var existing = $this.w4h_1;
+  $this.w4h_1 = newBuffer;
+  $this.z4h_1 = newBuffer.length;
+  $this.y4h_1 = false;
   if (!(existing == null)) {
-    var tmp0_elvis_lhs = $this.h4h_1;
+    var tmp0_elvis_lhs = $this.v4h_1;
     var tmp;
     if (tmp0_elvis_lhs == null) {
       // Inline function 'kotlin.also' call
       var this_0 = ArrayList().l1();
-      $this.h4h_1 = this_0;
+      $this.v4h_1 = this_0;
       this_0.m(existing);
       tmp = this_0;
     } else {
@@ -209,7 +209,7 @@ function hashCodeImpl($this, start, end) {
   return hc;
 }
 function currentPosition($this) {
-  return ensureNotNull($this.i4h_1).length - $this.l4h_1 | 0;
+  return ensureNotNull($this.w4h_1).length - $this.z4h_1 | 0;
 }
 var CharArrayBuilderClass;
 function CharArrayBuilder() {
@@ -217,16 +217,16 @@ function CharArrayBuilder() {
     class $ {
       constructor(pool) {
         pool = pool === VOID ? get_CharArrayPool() : pool;
-        this.g4h_1 = pool;
-        this.h4h_1 = null;
-        this.i4h_1 = null;
-        this.j4h_1 = null;
-        this.k4h_1 = false;
-        this.l4h_1 = 0;
-        this.m4h_1 = 0;
+        this.u4h_1 = pool;
+        this.v4h_1 = null;
+        this.w4h_1 = null;
+        this.x4h_1 = null;
+        this.y4h_1 = false;
+        this.z4h_1 = 0;
+        this.a4i_1 = 0;
       }
       a() {
-        return this.m4h_1;
+        return this.a4i_1;
       }
       b(index) {
         // Inline function 'kotlin.require' call
@@ -235,8 +235,8 @@ function CharArrayBuilder() {
           throw IllegalArgumentException().u(toString(message));
         }
         // Inline function 'kotlin.require' call
-        if (!(index < this.m4h_1)) {
-          var message_0 = 'index ' + index + ' is not in range [0, ' + this.m4h_1 + ')';
+        if (!(index < this.a4i_1)) {
+          var message_0 = 'index ' + index + ' is not in range [0, ' + this.a4i_1 + ')';
           throw IllegalArgumentException().u(toString(message_0));
         }
         return getImpl(this, index);
@@ -253,19 +253,19 @@ function CharArrayBuilder() {
           throw IllegalArgumentException().u(toString(message_0));
         }
         // Inline function 'kotlin.require' call
-        if (!(endIndex <= this.m4h_1)) {
-          var message_1 = 'endIndex (' + endIndex + ') is greater than length (' + this.m4h_1 + ')';
+        if (!(endIndex <= this.a4i_1)) {
+          var message_1 = 'endIndex (' + endIndex + ') is greater than length (' + this.a4i_1 + ')';
           throw IllegalArgumentException().u(toString(message_1));
         }
         return new (SubSequenceImpl())(this, startIndex, endIndex);
       }
       toString() {
-        var tmp0_elvis_lhs = this.j4h_1;
+        var tmp0_elvis_lhs = this.x4h_1;
         var tmp;
         if (tmp0_elvis_lhs == null) {
           // Inline function 'kotlin.also' call
-          var this_0 = toString(copy(this, 0, this.m4h_1));
-          this.j4h_1 = this_0;
+          var this_0 = toString(copy(this, 0, this.a4i_1));
+          this.x4h_1 = this_0;
           tmp = this_0;
         } else {
           tmp = tmp0_elvis_lhs;
@@ -275,20 +275,20 @@ function CharArrayBuilder() {
       equals(other) {
         if (!(!(other == null) ? isCharSequence(other) : false))
           return false;
-        if (!(this.m4h_1 === charSequenceLength(other)))
+        if (!(this.a4i_1 === charSequenceLength(other)))
           return false;
-        return rangeEqualsImpl(this, 0, other, 0, this.m4h_1);
+        return rangeEqualsImpl(this, 0, other, 0, this.a4i_1);
       }
       hashCode() {
-        var tmp0_safe_receiver = this.j4h_1;
+        var tmp0_safe_receiver = this.x4h_1;
         var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : getStringHashCode(tmp0_safe_receiver);
-        return tmp1_elvis_lhs == null ? hashCodeImpl(this, 0, this.m4h_1) : tmp1_elvis_lhs;
+        return tmp1_elvis_lhs == null ? hashCodeImpl(this, 0, this.a4i_1) : tmp1_elvis_lhs;
       }
       kb(value) {
-        nonFullBuffer(this)[ensureNotNull(this.i4h_1).length - this.l4h_1 | 0] = value;
-        this.j4h_1 = null;
-        this.l4h_1 = this.l4h_1 - 1 | 0;
-        this.m4h_1 = this.m4h_1 + 1 | 0;
+        nonFullBuffer(this)[ensureNotNull(this.w4h_1).length - this.z4h_1 | 0] = value;
+        this.x4h_1 = null;
+        this.z4h_1 = this.z4h_1 - 1 | 0;
+        this.a4i_1 = this.a4i_1 + 1 | 0;
         return this;
       }
       vh(value, startIndex, endIndex) {
@@ -297,10 +297,10 @@ function CharArrayBuilder() {
         var current = startIndex;
         while (current < endIndex) {
           var buffer = nonFullBuffer(this);
-          var offset = buffer.length - this.l4h_1 | 0;
+          var offset = buffer.length - this.z4h_1 | 0;
           var tmp0 = endIndex - current | 0;
           // Inline function 'kotlin.math.min' call
-          var b = this.l4h_1;
+          var b = this.z4h_1;
           var bytesToCopy = Math.min(tmp0, b);
           var inductionVariable = 0;
           if (inductionVariable < bytesToCopy)
@@ -311,10 +311,10 @@ function CharArrayBuilder() {
             }
              while (inductionVariable < bytesToCopy);
           current = current + bytesToCopy | 0;
-          this.l4h_1 = this.l4h_1 - bytesToCopy | 0;
+          this.z4h_1 = this.z4h_1 - bytesToCopy | 0;
         }
-        this.j4h_1 = null;
-        this.m4h_1 = this.m4h_1 + (endIndex - startIndex | 0) | 0;
+        this.x4h_1 = null;
+        this.a4i_1 = this.a4i_1 + (endIndex - startIndex | 0) | 0;
         return this;
       }
       b1(value) {
@@ -322,34 +322,34 @@ function CharArrayBuilder() {
           return this;
         return this.vh(value, 0, charSequenceLength(value));
       }
-      y2n() {
-        var list = this.h4h_1;
+      m2o() {
+        var list = this.v4h_1;
         if (!(list == null)) {
-          this.i4h_1 = null;
+          this.w4h_1 = null;
           var inductionVariable = 0;
           var last = list.i1();
           if (inductionVariable < last)
             do {
               var i = inductionVariable;
               inductionVariable = inductionVariable + 1 | 0;
-              this.g4h_1.o3q(list.j1(i));
+              this.u4h_1.c3r(list.j1(i));
             }
              while (inductionVariable < last);
         } else {
-          var tmp0_safe_receiver = this.i4h_1;
+          var tmp0_safe_receiver = this.w4h_1;
           if (tmp0_safe_receiver == null)
             null;
           else {
             // Inline function 'kotlin.let' call
-            this.g4h_1.o3q(tmp0_safe_receiver);
+            this.u4h_1.c3r(tmp0_safe_receiver);
           }
-          this.i4h_1 = null;
+          this.w4h_1 = null;
         }
-        this.k4h_1 = true;
-        this.h4h_1 = null;
-        this.j4h_1 = null;
-        this.m4h_1 = 0;
-        this.l4h_1 = 0;
+        this.y4h_1 = true;
+        this.v4h_1 = null;
+        this.x4h_1 = null;
+        this.a4i_1 = 0;
+        this.z4h_1 = 0;
       }
     }
     initMetadataForClass($, 'CharArrayBuilder', CharArrayBuilder, VOID, [CharSequence()]);

package/ktor-ktor-http-cio/io/ktor/http/cio/internals/CharArrayPool.mjs

@@ -17,7 +17,7 @@ var CharArrayPool$1Class;
 function CharArrayPool$1() {
   if (CharArrayPool$1Class === VOID) {
     class $ extends NoPoolImpl() {
-      n3q() {
+      b3r() {
         return charArray(2048);
       }
     }
@@ -33,7 +33,7 @@ function CharArrayPool$2() {
       constructor() {
         super(4096);
       }
-      g3q() {
+      u3q() {
         return charArray(2048);
       }
     }

package/ktor-ktor-http-cio/io/ktor/http/cio/internals/Chars.mjs

@@ -257,11 +257,11 @@ function numberFormatException_0(cs, idx) {
 }
 function DefaultHttpMethods$lambda(it) {
   _init_properties_Chars_kt__d3i39x();
-  return it.u45_1.length;
+  return it.i46_1.length;
 }
 function DefaultHttpMethods$lambda_0(m, idx) {
   _init_properties_Chars_kt__d3i39x();
-  return new (Char())(charCodeAt(m.u45_1, idx));
+  return new (Char())(charCodeAt(m.i46_1, idx));
 }
 var $writeIntHexCOROUTINE$Class;
 function $writeIntHexCOROUTINE$() {
@@ -269,8 +269,8 @@ function $writeIntHexCOROUTINE$() {
     class $ extends CoroutineImpl() {
       constructor(_this__u8e3s4, value, resultContinuation) {
         super(resultContinuation);
-        this.s4n_1 = _this__u8e3s4;
-        this.t4n_1 = value;
+        this.g4o_1 = _this__u8e3s4;
+        this.h4o_1 = value;
       }
       ic() {
         var suspendResult = this.cc_1;
@@ -280,29 +280,29 @@ function $writeIntHexCOROUTINE$() {
             switch (tmp) {
               case 0:
                 this.bc_1 = 8;
-                if (!(this.t4n_1 > 0)) {
+                if (!(this.h4o_1 > 0)) {
                   var message = 'Does only work for positive numbers';
                   throw IllegalArgumentException().u(toString_0(message));
                 }
 
-                this.u4n_1 = this.t4n_1;
-                this.v4n_1 = get_HexLetterTable();
-                this.w4n_1 = 0;
+                this.i4o_1 = this.h4o_1;
+                this.j4o_1 = get_HexLetterTable();
+                this.k4o_1 = 0;
                 this.ac_1 = 1;
                 continue $sm;
               case 1:
-                var _unary__edvuaz = this.w4n_1;
-                this.w4n_1 = _unary__edvuaz + 1 | 0;
+                var _unary__edvuaz = this.k4o_1;
+                this.k4o_1 = _unary__edvuaz + 1 | 0;
                 if (!(_unary__edvuaz < 8)) {
                   this.ac_1 = 4;
                   continue $sm;
                 }
 
-                this.x4n_1 = this.u4n_1 >>> 28 | 0;
-                this.u4n_1 = this.u4n_1 << 4;
-                if (!(this.x4n_1 === 0)) {
+                this.l4o_1 = this.i4o_1 >>> 28 | 0;
+                this.i4o_1 = this.i4o_1 << 4;
+                if (!(this.l4o_1 === 0)) {
                   this.ac_1 = 3;
-                  suspendResult = writeByte(this.s4n_1, this.v4n_1[this.x4n_1], this);
+                  suspendResult = writeByte(this.g4o_1, this.j4o_1[this.l4o_1], this);
                   if (suspendResult === get_COROUTINE_SUSPENDED()) {
                     return suspendResult;
                   }
@@ -322,17 +322,17 @@ function $writeIntHexCOROUTINE$() {
                 this.ac_1 = 5;
                 continue $sm;
               case 5:
-                var _unary__edvuaz_0 = this.w4n_1;
-                this.w4n_1 = _unary__edvuaz_0 + 1 | 0;
+                var _unary__edvuaz_0 = this.k4o_1;
+                this.k4o_1 = _unary__edvuaz_0 + 1 | 0;
                 if (!(_unary__edvuaz_0 < 8)) {
                   this.ac_1 = 7;
                   continue $sm;
                 }
 
-                this.y4n_1 = this.u4n_1 >>> 28 | 0;
-                this.u4n_1 = this.u4n_1 << 4;
+                this.m4o_1 = this.i4o_1 >>> 28 | 0;
+                this.i4o_1 = this.i4o_1 << 4;
                 this.ac_1 = 6;
-                suspendResult = writeByte(this.s4n_1, this.v4n_1[this.y4n_1], this);
+                suspendResult = writeByte(this.g4o_1, this.j4o_1[this.m4o_1], this);
                 if (suspendResult === get_COROUTINE_SUSPENDED()) {
                   return suspendResult;
                 }
@@ -368,9 +368,9 @@ function _init_properties_Chars_kt__d3i39x() {
   if (!properties_initialized_Chars_kt_phjfhp) {
     properties_initialized_Chars_kt_phjfhp = true;
     var tmp = Companion_instance;
-    var tmp_0 = Companion_getInstance().t45_1;
+    var tmp_0 = Companion_getInstance().h46_1;
     var tmp_1 = DefaultHttpMethods$lambda;
-    DefaultHttpMethods = tmp.m4f(tmp_0, tmp_1, DefaultHttpMethods$lambda_0);
+    DefaultHttpMethods = tmp.a4g(tmp_0, tmp_1, DefaultHttpMethods$lambda_0);
     // Inline function 'kotlin.collections.map' call
     var this_0 = numberRangeToNumber(0, 255);
     // Inline function 'kotlin.collections.mapTo' call

package/ktor-ktor-http-cio/io/ktor/http/cio/internals/Errors.mjs

@@ -10,9 +10,9 @@ var UnsupportedMediaTypeExceptionCIOClass;
 function UnsupportedMediaTypeExceptionCIO() {
   if (UnsupportedMediaTypeExceptionCIOClass === VOID) {
     class $ extends IOException() {
-      static m4j(message) {
-        var $this = this.l2u(message);
-        captureStack($this, $this.l4j_1);
+      static a4k(message) {
+        var $this = this.z2u(message);
+        captureStack($this, $this.z4j_1);
         return $this;
       }
     }

package/ktor-ktor-http-cio/io/ktor/http/cio/internals/MutableRange.mjs

@@ -9,11 +9,11 @@ function MutableRange() {
   if (MutableRangeClass === VOID) {
     class $ {
       constructor(start, end) {
-        this.l4i_1 = start;
-        this.m4i_1 = end;
+        this.z4i_1 = start;
+        this.a4j_1 = end;
       }
       toString() {
-        return 'MutableRange(start=' + this.l4i_1 + ', end=' + this.m4i_1 + ')';
+        return 'MutableRange(start=' + this.z4i_1 + ', end=' + this.a4j_1 + ')';
       }
     }
     initMetadataForClass($, 'MutableRange');

package/ktor-ktor-http-cio/io/ktor/http/cio/internals/Tokenizer.mjs

@@ -10,25 +10,25 @@ import { _Char___init__impl__6a9atx2js6krycynjoo as _Char___init__impl__6a9atx }
 //region block: pre-declaration
 //endregion
 function skipSpaces(text, range) {
-  var idx = range.l4i_1;
-  var end = range.m4i_1;
+  var idx = range.z4i_1;
+  var end = range.a4j_1;
   if (idx >= end || !isWhitespace(charSequenceGet(text, idx)))
     return Unit_instance;
   idx = idx + 1 | 0;
   $l$loop: while (idx < end && isWhitespace(charSequenceGet(text, idx))) {
     idx = idx + 1 | 0;
   }
-  range.l4i_1 = idx;
+  range.z4i_1 = idx;
 }
 function nextToken(text, range) {
   var spaceOrEnd = findSpaceOrEnd(text, range);
-  var s = charSequenceSubSequence(text, range.l4i_1, spaceOrEnd);
-  range.l4i_1 = spaceOrEnd;
+  var s = charSequenceSubSequence(text, range.z4i_1, spaceOrEnd);
+  range.z4i_1 = spaceOrEnd;
   return s;
 }
 function findSpaceOrEnd(text, range) {
-  var idx = range.l4i_1;
-  var end = range.m4i_1;
+  var idx = range.z4i_1;
+  var end = range.a4j_1;
   if (idx >= end || isWhitespace(charSequenceGet(text, idx)))
     return idx;
   idx = idx + 1 | 0;