@continuous-excellence/coupling-cli 1.1.509 → 1.1.511

package/kotlin/ktor-ktor-utils/io/ktor/util/CaseInsensitiveMap.mjs

@@ -1,64 +1,508 @@
+import { Unit_instancev9v8hjid95df as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
 import {
-  caseInsensitive293j1l8ok4b2v as caseInsensitive,
-  CaseInsensitiveStringghw1fh6uf9mm as CaseInsensitiveString,
-} from './Text.mjs';
-import { LinkedHashMap1zhqxkxv3xnkl as LinkedHashMap } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/LinkedHashMap.mjs';
+  NoSuchElementException679xzhnp5bpj as NoSuchElementException,
+  IllegalStateExceptionkoljg5n0nrlr as IllegalStateException,
+  UnsupportedOperationException2tkumpmhredt3 as UnsupportedOperationException,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
 import {
-  THROW_CCE2g6jy02ryeudk as THROW_CCE,
   ensureNotNull1e947j3ixpazm as ensureNotNull,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
 } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
-import { Unit_instancev9v8hjid95df as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
-import { DelegatingMutableSet198sgh8jelkh1 as DelegatingMutableSet } from './DelegatingMutableSet.mjs';
 import {
-  equals2au1ep9vhcato as equals,
-  hashCodeq5arwsb9dgti as hashCode,
-} from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { charCodeAt1yspne1d8erbm as charCodeAt } from '../../../../kotlin-kotlin-stdlib/kotlin/js/charSequenceJs.mjs';
 import {
-  KtMutableMap1kqeifoi36kpz as KtMutableMap,
+  toString22rbkbhdb5cl2 as toString,
+  Char__toInt_impl_vasixdnyockrdnmht5 as Char__toInt_impl_vasixd,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/Char.mjs';
+import { equals2v6cggk171b6e as equals } from '../../../../kotlin-kotlin-stdlib/kotlin/text/stringsCode.mjs';
+import { AbstractMutableSetthfi6jds1k2h as AbstractMutableSet } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/AbstractMutableSet.mjs';
+import { AbstractMutableCollections0bg6c40ztuj as AbstractMutableCollection } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/AbstractMutableCollectionJs.mjs';
+import {
+  MutableEntry12w2i19w0igk5 as MutableEntry,
   Entry2xmjmyutzoq3p as Entry,
+  KtMutableMap1kqeifoi36kpz as KtMutableMap,
 } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/Collections.mjs';
-import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
-import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
 import { isInterface3d6p8outrmvmk as isInterface } from '../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
-import { toString30pk9tzaqopn as toString } from '../../../../kotlin-kotlin-stdlib/kotlin/Library.mjs';
+import {
+  equals2au1ep9vhcato as equals_0,
+  getStringHashCode26igk1bx568vk as getStringHashCode,
+  hashCodeq5arwsb9dgti as hashCode,
+  toString1pkumu07cwy4m as toString_0,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import {
+  fill3hcjvebk42tyx as fill,
+  fill2542d4m9l93pn as fill_0,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_ArraysJs.mjs';
 //region block: imports
+var imul = Math.imul;
 //endregion
 //region block: pre-declaration
 //endregion
-function CaseInsensitiveMap$_get_keys_$lambda_ptzlqj($this$DelegatingMutableSet) {
-  return $this$DelegatingMutableSet.b2k_1;
+function advance($this) {
+  $l$loop: while ($this.v2j_1 < $this.x2j_1.c2k_1) {
+    var idx = $this.x2j_1.b2k_1[$this.v2j_1];
+    if (idx >= 0 && !($this.x2j_1.y2j_1[idx] == null))
+      break $l$loop;
+    $this.v2j_1 = $this.v2j_1 + 1 | 0;
+  }
 }
-function CaseInsensitiveMap$_get_keys_$lambda_ptzlqj_0($this$DelegatingMutableSet) {
-  return caseInsensitive($this$DelegatingMutableSet);
+var CaseInsensitiveMap$KeySet$iterator$1Class;
+function CaseInsensitiveMap$KeySet$iterator$1() {
+  if (CaseInsensitiveMap$KeySet$iterator$1Class === VOID) {
+    class $ {
+      constructor(this$0) {
+        this.x2j_1 = this$0;
+        this.v2j_1 = 0;
+        this.w2j_1 = null;
+        advance(this);
+      }
+      m1() {
+        return this.v2j_1 < this.x2j_1.c2k_1;
+      }
+      n1() {
+        if (!this.m1())
+          throw NoSuchElementException().r6();
+        var idx = this.x2j_1.b2k_1[this.v2j_1];
+        this.w2j_1 = ensureNotNull(this.x2j_1.y2j_1[idx]);
+        this.v2j_1 = this.v2j_1 + 1 | 0;
+        advance(this);
+        return ensureNotNull(this.w2j_1);
+      }
+      n6() {
+        var tmp0_elvis_lhs = this.w2j_1;
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          throw IllegalStateException().o('next() must be called before remove()');
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        var key = tmp;
+        this.x2j_1.g2k(key);
+        this.w2j_1 = null;
+      }
+    }
+    initMetadataForClass($);
+    CaseInsensitiveMap$KeySet$iterator$1Class = $;
+  }
+  return CaseInsensitiveMap$KeySet$iterator$1Class;
 }
-function CaseInsensitiveMap$_get_entries_$lambda_r32w19($this$DelegatingMutableSet) {
-  return new (Entry_0())($this$DelegatingMutableSet.b3().b2k_1, $this$DelegatingMutableSet.c3());
+function advance_0($this) {
+  $l$loop: while ($this.h2k_1 < $this.j2k_1.c2k_1) {
+    var idx = $this.j2k_1.b2k_1[$this.h2k_1];
+    if (idx >= 0 && !($this.j2k_1.y2j_1[idx] == null))
+      break $l$loop;
+    $this.h2k_1 = $this.h2k_1 + 1 | 0;
+  }
+}
+var CaseInsensitiveMap$ValueCollection$iterator$1Class;
+function CaseInsensitiveMap$ValueCollection$iterator$1() {
+  if (CaseInsensitiveMap$ValueCollection$iterator$1Class === VOID) {
+    class $ {
+      constructor(this$0) {
+        this.j2k_1 = this$0;
+        this.h2k_1 = 0;
+        this.i2k_1 = null;
+        advance_0(this);
+      }
+      m1() {
+        return this.h2k_1 < this.j2k_1.c2k_1;
+      }
+      n1() {
+        if (!this.m1())
+          throw NoSuchElementException().r6();
+        var idx = this.j2k_1.b2k_1[this.h2k_1];
+        this.i2k_1 = ensureNotNull(this.j2k_1.y2j_1[idx]);
+        var tmp = this.j2k_1.z2j_1[idx];
+        var result = !(tmp == null) ? tmp : THROW_CCE();
+        this.h2k_1 = this.h2k_1 + 1 | 0;
+        advance_0(this);
+        return result;
+      }
+      n6() {
+        var tmp0_elvis_lhs = this.i2k_1;
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          throw IllegalStateException().o('next() must be called before remove()');
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        var key = tmp;
+        this.j2k_1.g2k(key);
+        this.i2k_1 = null;
+      }
+    }
+    initMetadataForClass($);
+    CaseInsensitiveMap$ValueCollection$iterator$1Class = $;
+  }
+  return CaseInsensitiveMap$ValueCollection$iterator$1Class;
 }
-function CaseInsensitiveMap$_get_entries_$lambda_r32w19_0($this$DelegatingMutableSet) {
-  return new (Entry_0())(caseInsensitive($this$DelegatingMutableSet.b3()), $this$DelegatingMutableSet.c3());
+function advance_1($this) {
+  $l$loop: while ($this.k2k_1 < $this.m2k_1.c2k_1) {
+    var idx = $this.m2k_1.b2k_1[$this.k2k_1];
+    if (idx >= 0 && !($this.m2k_1.y2j_1[idx] == null))
+      break $l$loop;
+    $this.k2k_1 = $this.k2k_1 + 1 | 0;
+  }
+}
+var CaseInsensitiveMap$EntrySet$iterator$1Class;
+function CaseInsensitiveMap$EntrySet$iterator$1() {
+  if (CaseInsensitiveMap$EntrySet$iterator$1Class === VOID) {
+    class $ {
+      constructor(this$0) {
+        this.m2k_1 = this$0;
+        this.k2k_1 = 0;
+        this.l2k_1 = null;
+        advance_1(this);
+      }
+      m1() {
+        return this.k2k_1 < this.m2k_1.c2k_1;
+      }
+      n1() {
+        if (!this.m1())
+          throw NoSuchElementException().r6();
+        var idx = this.m2k_1.b2k_1[this.k2k_1];
+        this.l2k_1 = ensureNotNull(this.m2k_1.y2j_1[idx]);
+        var tmp = ensureNotNull(this.l2k_1);
+        var tmp_0 = this.m2k_1.z2j_1[idx];
+        var entry = new (MapEntry())(this.m2k_1, tmp, !(tmp_0 == null) ? tmp_0 : THROW_CCE());
+        this.k2k_1 = this.k2k_1 + 1 | 0;
+        advance_1(this);
+        return entry;
+      }
+      n6() {
+        var tmp0_elvis_lhs = this.l2k_1;
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          throw IllegalStateException().o('next() must be called before remove()');
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        var key = tmp;
+        this.m2k_1.g2k(key);
+        this.l2k_1 = null;
+      }
+    }
+    initMetadataForClass($);
+    CaseInsensitiveMap$EntrySet$iterator$1Class = $;
+  }
+  return CaseInsensitiveMap$EntrySet$iterator$1Class;
+}
+function caseInsensitiveHashCode($this, s) {
+  var h = 0;
+  var inductionVariable = 0;
+  var last = s.length;
+  if (inductionVariable < last)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp = imul(31, h);
+      // Inline function 'kotlin.text.lowercaseChar' call
+      // Inline function 'kotlin.text.lowercase' call
+      var this_0 = charCodeAt(s, i);
+      // Inline function 'kotlin.js.asDynamic' call
+      // Inline function 'kotlin.js.unsafeCast' call
+      var tmp$ret$1 = toString(this_0).toLowerCase();
+      // Inline function 'kotlin.code' call
+      var this_1 = charCodeAt(tmp$ret$1, 0);
+      h = tmp + Char__toInt_impl_vasixd(this_1) | 0;
+    }
+     while (inductionVariable < last);
+  return h;
+}
+function putWithoutTrackingOrderReturnIndex($this, key, value) {
+  var hash = caseInsensitiveHashCode(Companion_getInstance(), key);
+  var index = hash & ($this.y2j_1.length - 1 | 0);
+  while (true) {
+    var existingKey = $this.y2j_1[index];
+    if (existingKey == null) {
+      $this.y2j_1[index] = key;
+      $this.z2j_1[index] = value;
+      $this.a2k_1 = $this.a2k_1 + 1 | 0;
+      return index;
+    }
+    if (equals(existingKey, key, true)) {
+      $this.z2j_1[index] = value;
+      return index;
+    }
+    index = (index + 1 | 0) & ($this.y2j_1.length - 1 | 0);
+  }
+}
+function findIndex($this, key) {
+  if ($this.a2k_1 === 0)
+    return -1;
+  var hash = caseInsensitiveHashCode(Companion_getInstance(), key);
+  var index = hash & ($this.y2j_1.length - 1 | 0);
+  while (true) {
+    var existingKey = $this.y2j_1[index];
+    if (existingKey == null)
+      return -1;
+    if (equals(existingKey, key, true))
+      return index;
+    index = (index + 1 | 0) & ($this.y2j_1.length - 1 | 0);
+  }
+}
+function ensureCapacity($this) {
+  if (imul($this.a2k_1, 4) >= imul($this.y2j_1.length, 3)) {
+    resize($this, imul($this.y2j_1.length, 2));
+  }
+}
+function resize($this, newCapacity) {
+  var oldKeys = $this.y2j_1;
+  var oldValues = $this.z2j_1;
+  var oldInsertionOrder = $this.b2k_1;
+  var oldInsertionCount = $this.c2k_1;
+  var tmp = $this;
+  // Inline function 'kotlin.arrayOfNulls' call
+  tmp.y2j_1 = Array(newCapacity);
+  var tmp_0 = $this;
+  // Inline function 'kotlin.arrayOfNulls' call
+  tmp_0.z2j_1 = Array(newCapacity);
+  var tmp_1 = $this;
+  var tmp_2 = 0;
+  var tmp_3 = new Int32Array(newCapacity);
+  while (tmp_2 < newCapacity) {
+    tmp_3[tmp_2] = -1;
+    tmp_2 = tmp_2 + 1 | 0;
+  }
+  tmp_1.b2k_1 = tmp_3;
+  $this.a2k_1 = 0;
+  $this.c2k_1 = 0;
+  var inductionVariable = 0;
+  if (inductionVariable < oldInsertionCount)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      var oldIndex = oldInsertionOrder[i];
+      if (oldIndex >= 0 && !(oldKeys[oldIndex] == null)) {
+        var tmp_4 = ensureNotNull(oldKeys[oldIndex]);
+        var tmp_5 = oldValues[oldIndex];
+        $this.n2k(tmp_4, !(tmp_5 == null) ? tmp_5 : THROW_CCE());
+      }
+    }
+     while (inductionVariable < oldInsertionCount);
+}
+function compactInsertionOrder($this) {
+  if ($this.c2k_1 === 0)
+    return Unit_instance;
+  var writeIndex = 0;
+  var inductionVariable = 0;
+  var last = $this.c2k_1;
+  if (inductionVariable < last)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      var idx = $this.b2k_1[i];
+      if (idx >= 0 && !($this.y2j_1[idx] == null)) {
+        var tmp = $this.b2k_1;
+        var _unary__edvuaz = writeIndex;
+        writeIndex = _unary__edvuaz + 1 | 0;
+        tmp[_unary__edvuaz] = idx;
+      }
+    }
+     while (inductionVariable < last);
+  var inductionVariable_0 = writeIndex;
+  var last_0 = $this.b2k_1.length;
+  if (inductionVariable_0 < last_0)
+    do {
+      var i_0 = inductionVariable_0;
+      inductionVariable_0 = inductionVariable_0 + 1 | 0;
+      $this.b2k_1[i_0] = -1;
+    }
+     while (inductionVariable_0 < last_0);
+  $this.c2k_1 = writeIndex;
+}
+var KeySetClass;
+function KeySet() {
+  if (KeySetClass === VOID) {
+    class $ extends AbstractMutableSet() {
+      static p2k($outer, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.o2k_1 = $outer;
+        return this.b8($box);
+      }
+      q2() {
+        return this.o2k_1.a2k_1;
+      }
+      q2k(element) {
+        throw UnsupportedOperationException().ka('CaseInsensitiveMap.keys does not support add');
+      }
+      o2(element) {
+        return this.q2k((!(element == null) ? typeof element === 'string' : false) ? element : THROW_CCE());
+      }
+      r2k(element) {
+        return this.o2k_1.s2k(element);
+      }
+      k3(element) {
+        if (!(!(element == null) ? typeof element === 'string' : false))
+          return false;
+        return this.r2k((!(element == null) ? typeof element === 'string' : false) ? element : THROW_CCE());
+      }
+      g2k(element) {
+        return !(this.o2k_1.g2k(element) == null);
+      }
+      t4(element) {
+        if (!(!(element == null) ? typeof element === 'string' : false))
+          return false;
+        return this.g2k((!(element == null) ? typeof element === 'string' : false) ? element : THROW_CCE());
+      }
+      l1() {
+        return new (CaseInsensitiveMap$KeySet$iterator$1())(this.o2k_1);
+      }
+    }
+    initMetadataForClass($, 'KeySet');
+    KeySetClass = $;
+  }
+  return KeySetClass;
+}
+var ValueCollectionClass;
+function ValueCollection() {
+  if (ValueCollectionClass === VOID) {
+    class $ extends AbstractMutableCollection() {
+      static u2k($outer, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.t2k_1 = $outer;
+        return this.k6($box);
+      }
+      q2() {
+        return this.t2k_1.a2k_1;
+      }
+      v2k(element) {
+        throw UnsupportedOperationException().ka('CaseInsensitiveMap.values does not support add');
+      }
+      o2(element) {
+        return this.v2k(!(element == null) ? element : THROW_CCE());
+      }
+      l1() {
+        return new (CaseInsensitiveMap$ValueCollection$iterator$1())(this.t2k_1);
+      }
+    }
+    initMetadataForClass($, 'ValueCollection');
+    ValueCollectionClass = $;
+  }
+  return ValueCollectionClass;
+}
+var EntrySetClass;
+function EntrySet() {
+  if (EntrySetClass === VOID) {
+    class $ extends AbstractMutableSet() {
+      static x2k($outer, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.w2k_1 = $outer;
+        return this.b8($box);
+      }
+      q2() {
+        return this.w2k_1.a2k_1;
+      }
+      y2k(element) {
+        throw UnsupportedOperationException().ka('CaseInsensitiveMap.entries does not support add');
+      }
+      o2(element) {
+        return this.y2k((!(element == null) ? isInterface(element, MutableEntry()) : false) ? element : THROW_CCE());
+      }
+      l1() {
+        return new (CaseInsensitiveMap$EntrySet$iterator$1())(this.w2k_1);
+      }
+    }
+    initMetadataForClass($, 'EntrySet');
+    EntrySetClass = $;
+  }
+  return EntrySetClass;
+}
+var MapEntryClass;
+function MapEntry() {
+  if (MapEntryClass === VOID) {
+    class $ {
+      constructor($outer, key, _value) {
+        this.b2l_1 = $outer;
+        this.z2k_1 = key;
+        this.a2l_1 = _value;
+      }
+      b3() {
+        return this.z2k_1;
+      }
+      c3() {
+        return this.a2l_1;
+      }
+      equals(other) {
+        if (!(!(other == null) ? isInterface(other, Entry()) : false))
+          return false;
+        return equals_0(this.z2k_1, other.b3()) && equals_0(this.c3(), other.c3());
+      }
+      hashCode() {
+        return getStringHashCode(this.z2k_1) ^ hashCode(this.c3());
+      }
+      toString() {
+        return this.z2k_1 + '=' + toString_0(this.c3());
+      }
+    }
+    initMetadataForClass($, 'MapEntry', VOID, VOID, [MutableEntry()]);
+    MapEntryClass = $;
+  }
+  return MapEntryClass;
+}
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance = this;
+        this.c2l_1 = 8;
+        var tmp = this;
+        // Inline function 'kotlin.emptyArray' call
+        tmp.d2l_1 = [];
+        var tmp_0 = this;
+        // Inline function 'kotlin.emptyArray' call
+        tmp_0.e2l_1 = [];
+        this.f2l_1 = new Int32Array(0);
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  if (Companion_instance === VOID)
+    new (Companion())();
+  return Companion_instance;
 }
 var CaseInsensitiveMapClass;
 function CaseInsensitiveMap() {
   if (CaseInsensitiveMapClass === VOID) {
     class $ {
       constructor() {
-        var tmp = this;
-        // Inline function 'kotlin.collections.mutableMapOf' call
-        tmp.d2k_1 = LinkedHashMap().lc();
+        Companion_getInstance();
+        this.y2j_1 = Companion_getInstance().d2l_1;
+        this.z2j_1 = Companion_getInstance().e2l_1;
+        this.a2k_1 = 0;
+        this.b2k_1 = Companion_getInstance().f2l_1;
+        this.c2k_1 = 0;
+        this.d2k_1 = null;
+        this.e2k_1 = null;
+        this.f2k_1 = null;
       }
       q2() {
-        return this.d2k_1.q2();
+        return this.a2k_1;
       }
-      e2k(key) {
-        return this.d2k_1.h4(new (CaseInsensitiveString())(key));
+      s2k(key) {
+        return findIndex(this, key) >= 0;
       }
       h4(key) {
         if (!(!(key == null) ? typeof key === 'string' : false))
           return false;
-        return this.e2k((!(key == null) ? typeof key === 'string' : false) ? key : THROW_CCE());
+        return this.s2k((!(key == null) ? typeof key === 'string' : false) ? key : THROW_CCE());
       }
       zh(key) {
-        return this.d2k_1.j4(caseInsensitive(key));
+        var index = findIndex(this, key);
+        return index >= 0 ? this.z2j_1[index] : null;
       }
       j4(key) {
         if (!(!(key == null) ? typeof key === 'string' : false))
@@ -66,19 +510,69 @@ function CaseInsensitiveMap() {
         return this.zh((!(key == null) ? typeof key === 'string' : false) ? key : THROW_CCE());
       }
       j1() {
-        return this.d2k_1.j1();
+        return this.a2k_1 === 0;
       }
       m4() {
-        this.d2k_1.m4();
+        if (this.a2k_1 > 0) {
+          fill(this.y2j_1, null);
+          fill(this.z2j_1, null);
+          fill_0(this.b2k_1, -1);
+          this.a2k_1 = 0;
+          this.c2k_1 = 0;
+        }
       }
-      f2k(key, value) {
-        return this.d2k_1.q4(caseInsensitive(key), value);
+      n2k(key, value) {
+        if (this.y2j_1 === Companion_getInstance().d2l_1) {
+          var tmp = this;
+          // Inline function 'kotlin.arrayOfNulls' call
+          tmp.y2j_1 = Array(8);
+          var tmp_0 = this;
+          // Inline function 'kotlin.arrayOfNulls' call
+          tmp_0.z2j_1 = Array(8);
+          var tmp_1 = this;
+          var tmp_2 = 0;
+          var tmp_3 = new Int32Array(8);
+          while (tmp_2 < 8) {
+            tmp_3[tmp_2] = -1;
+            tmp_2 = tmp_2 + 1 | 0;
+          }
+          tmp_1.b2k_1 = tmp_3;
+        }
+        var hash = caseInsensitiveHashCode(Companion_getInstance(), key);
+        var index = hash & (this.y2j_1.length - 1 | 0);
+        while (true) {
+          var existingKey = this.y2j_1[index];
+          if (existingKey == null) {
+            ensureCapacity(this);
+            index = hash & (this.y2j_1.length - 1 | 0);
+            while (!(this.y2j_1[index] == null)) {
+              index = (index + 1 | 0) & (this.y2j_1.length - 1 | 0);
+            }
+            if (this.c2k_1 === this.b2k_1.length) {
+              compactInsertionOrder(this);
+            }
+            this.y2j_1[index] = key;
+            this.z2j_1[index] = value;
+            var tmp_4 = this.b2k_1;
+            var _unary__edvuaz = this.c2k_1;
+            this.c2k_1 = _unary__edvuaz + 1 | 0;
+            tmp_4[_unary__edvuaz] = index;
+            this.a2k_1 = this.a2k_1 + 1 | 0;
+            return null;
+          }
+          if (equals(existingKey, key, true)) {
+            var oldValue = this.z2j_1[index];
+            this.z2j_1[index] = value;
+            return oldValue;
+          }
+          index = (index + 1 | 0) & (this.y2j_1.length - 1 | 0);
+        }
       }
       q4(key, value) {
         var tmp = (!(key == null) ? typeof key === 'string' : false) ? key : THROW_CCE();
-        return this.f2k(tmp, !(value == null) ? value : THROW_CCE());
+        return this.n2k(tmp, !(value == null) ? value : THROW_CCE());
       }
-      g2k(from) {
+      g2l(from) {
         // Inline function 'kotlin.collections.forEach' call
         // Inline function 'kotlin.collections.iterator' call
         var _iterator__ex2g4s = from.a3().l1();
@@ -88,46 +582,143 @@ function CaseInsensitiveMap() {
           var key = element.b3();
           // Inline function 'kotlin.collections.component2' call
           var value = element.c3();
-          this.f2k(key, value);
+          this.n2k(key, value);
         }
       }
       s4(from) {
-        return this.g2k(from);
+        return this.g2l(from);
       }
-      h2k(key) {
-        return this.d2k_1.r4(caseInsensitive(key));
+      g2k(key) {
+        var index = findIndex(this, key);
+        if (index < 0)
+          return null;
+        var oldValue = this.z2j_1[index];
+        var inductionVariable = 0;
+        var last = this.c2k_1;
+        if (inductionVariable < last)
+          $l$loop: do {
+            var i = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            if (this.b2k_1[i] === index) {
+              this.b2k_1[i] = -1;
+              break $l$loop;
+            }
+          }
+           while (inductionVariable < last);
+        this.y2j_1[index] = null;
+        this.z2j_1[index] = null;
+        this.a2k_1 = this.a2k_1 - 1 | 0;
+        var nextIndex = (index + 1 | 0) & (this.y2j_1.length - 1 | 0);
+        while (!(this.y2j_1[nextIndex] == null)) {
+          var rehashKey = ensureNotNull(this.y2j_1[nextIndex]);
+          var rehashValue = this.z2j_1[nextIndex];
+          var oldRehashIndex = nextIndex;
+          this.y2j_1[nextIndex] = null;
+          this.z2j_1[nextIndex] = null;
+          this.a2k_1 = this.a2k_1 - 1 | 0;
+          var newIndex = putWithoutTrackingOrderReturnIndex(this, rehashKey, !(rehashValue == null) ? rehashValue : THROW_CCE());
+          var inductionVariable_0 = 0;
+          var last_0 = this.c2k_1;
+          if (inductionVariable_0 < last_0)
+            $l$loop_0: do {
+              var i_0 = inductionVariable_0;
+              inductionVariable_0 = inductionVariable_0 + 1 | 0;
+              if (this.b2k_1[i_0] === oldRehashIndex) {
+                this.b2k_1[i_0] = newIndex;
+                break $l$loop_0;
+              }
+            }
+             while (inductionVariable_0 < last_0);
+          nextIndex = (nextIndex + 1 | 0) & (this.y2j_1.length - 1 | 0);
+        }
+        return oldValue;
       }
       r4(key) {
         if (!(!(key == null) ? typeof key === 'string' : false))
           return null;
-        return this.h2k((!(key == null) ? typeof key === 'string' : false) ? key : THROW_CCE());
+        return this.g2k((!(key == null) ? typeof key === 'string' : false) ? key : THROW_CCE());
       }
       k4() {
-        var tmp = this.d2k_1.k4();
-        var tmp_0 = CaseInsensitiveMap$_get_keys_$lambda_ptzlqj;
-        return new (DelegatingMutableSet())(tmp, tmp_0, CaseInsensitiveMap$_get_keys_$lambda_ptzlqj_0);
+        var tmp0_elvis_lhs = this.d2k_1;
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          // Inline function 'kotlin.also' call
+          var this_0 = KeySet().p2k(this);
+          this.d2k_1 = this_0;
+          tmp = this_0;
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        return tmp;
       }
       a3() {
-        var tmp = this.d2k_1.a3();
-        var tmp_0 = CaseInsensitiveMap$_get_entries_$lambda_r32w19;
-        return new (DelegatingMutableSet())(tmp, tmp_0, CaseInsensitiveMap$_get_entries_$lambda_r32w19_0);
+        var tmp0_elvis_lhs = this.e2k_1;
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          // Inline function 'kotlin.also' call
+          var this_0 = EntrySet().x2k(this);
+          this.e2k_1 = this_0;
+          tmp = this_0;
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        return tmp;
       }
       l4() {
-        return this.d2k_1.l4();
-      }
-      equals(other) {
+        var tmp0_elvis_lhs = this.f2k_1;
         var tmp;
-        if (other == null) {
-          tmp = true;
+        if (tmp0_elvis_lhs == null) {
+          // Inline function 'kotlin.also' call
+          var this_0 = ValueCollection().u2k(this);
+          this.f2k_1 = this_0;
+          tmp = this_0;
         } else {
-          tmp = !(other instanceof CaseInsensitiveMap());
+          tmp = tmp0_elvis_lhs;
         }
-        if (tmp)
+        return tmp;
+      }
+      equals(other) {
+        if (other === this)
+          return true;
+        if (!(other instanceof CaseInsensitiveMap()))
           return false;
-        return equals(other.d2k_1, this.d2k_1);
+        if (!(other.q2() === this.a2k_1))
+          return false;
+        var inductionVariable = 0;
+        var last = this.y2j_1.length - 1 | 0;
+        if (inductionVariable <= last)
+          do {
+            var i = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            var k = this.y2j_1[i];
+            if (!(k == null)) {
+              var v = this.z2j_1[i];
+              if (!equals_0(other.zh(k), v))
+                return false;
+            }
+          }
+           while (inductionVariable <= last);
+        return true;
       }
       hashCode() {
-        return hashCode(this.d2k_1);
+        var result = 0;
+        var inductionVariable = 0;
+        var last = this.y2j_1.length - 1 | 0;
+        if (inductionVariable <= last)
+          do {
+            var i = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            var k = this.y2j_1[i];
+            if (!(k == null)) {
+              var tmp = result;
+              var tmp_0 = caseInsensitiveHashCode(Companion_getInstance(), k);
+              var tmp0_safe_receiver = this.z2j_1[i];
+              var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode(tmp0_safe_receiver);
+              result = tmp + (tmp_0 ^ (tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs)) | 0;
+            }
+          }
+           while (inductionVariable <= last);
+        return result;
       }
     }
     initMetadataForClass($, 'CaseInsensitiveMap', CaseInsensitiveMap, VOID, [KtMutableMap()]);
@@ -135,43 +726,6 @@ function CaseInsensitiveMap() {
   }
   return CaseInsensitiveMapClass;
 }
-var EntryClass;
-function Entry_0() {
-  if (EntryClass === VOID) {
-    class $ {
-      constructor(key, value) {
-        this.i2k_1 = key;
-        this.j2k_1 = value;
-      }
-      b3() {
-        return this.i2k_1;
-      }
-      c3() {
-        return this.j2k_1;
-      }
-      hashCode() {
-        return (527 + hashCode(ensureNotNull(this.i2k_1)) | 0) + hashCode(ensureNotNull(this.j2k_1)) | 0;
-      }
-      equals(other) {
-        var tmp;
-        if (other == null) {
-          tmp = true;
-        } else {
-          tmp = !isInterface(other, Entry());
-        }
-        if (tmp)
-          return false;
-        return equals(other.b3(), this.i2k_1) && equals(other.c3(), this.j2k_1);
-      }
-      toString() {
-        return toString(this.i2k_1) + '=' + toString(this.j2k_1);
-      }
-    }
-    initMetadataForClass($, 'Entry', VOID, VOID, [Entry()]);
-    EntryClass = $;
-  }
-  return EntryClass;
-}
 //region block: exports
 export {
   CaseInsensitiveMap as CaseInsensitiveMap3bv985x2xrppt,