@attocash/commons-js 5.0.0

package/kotlin-kotlin-stdlib/kotlin/collections/InternalHashMap.mjs

@@ -0,0 +1,726 @@
+import {
+  coerceAtLeast2bkz8m9ik7hep as coerceAtLeast,
+  coerceAtMost322komnqp70ag as coerceAtMost,
+} from '../ranges/_Ranges.mjs';
+import { takeHighestOneBit9p7rdtda63bc as takeHighestOneBit } from '../NumbersJs.mjs';
+import {
+  ConcurrentModificationException3974vl9oonkcj as ConcurrentModificationException,
+  RuntimeException1r3t0zl97011n as RuntimeException,
+  IllegalStateExceptionkoljg5n0nrlr as IllegalStateException,
+  NoSuchElementException679xzhnp5bpj as NoSuchElementException,
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+  UnsupportedOperationException2tkumpmhredt3 as UnsupportedOperationException,
+} from '../exceptions.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../Unit.mjs';
+import { Companion_instanceovl8he3jiijf as Companion_instance } from './AbstractList.mjs';
+import {
+  copyOfUninitializedElements3uqjltwtgc0ej as copyOfUninitializedElements,
+  arrayOfUninitializedElementsg6b068zrcm8j as arrayOfUninitializedElements,
+  resetRangeiqi6axdujnmn as resetRange,
+  resetAt1d0jjdeh7nn7m as resetAt,
+} from './ArrayFunctions.mjs';
+import { copyOf3rutauicler23 as copyOf } from './_ArraysJs.mjs';
+import {
+  hashCodeq5arwsb9dgti as hashCode,
+  equals2au1ep9vhcato as equals,
+  toString1pkumu07cwy4m as toString,
+  createThis2j2avj17cvnv2 as createThis,
+  protoOf180f3jzyo7rfj as protoOf,
+} from '../js/coreRuntime.mjs';
+import {
+  ensureNotNull1e947j3ixpazm as ensureNotNull,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+} from '../hacks.mjs';
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+import { _Char___init__impl__6a9atx2js6krycynjoo as _Char___init__impl__6a9atx } from '../Char.mjs';
+import {
+  Entry2xmjmyutzoq3p as Entry,
+  KtMap140uvy3s5zad8 as KtMap,
+} from './Collections.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../js/typeCheckUtils.mjs';
+import { toString30pk9tzaqopn as toString_0 } from '../Library.mjs';
+import { StringBuildermazzzhj6kkai as StringBuilder } from '../text/StringBuilderJs.mjs';
+import {
+  containsAllEntries1q58uduc9e3y6 as containsAllEntries,
+  InternalMap26d9hvxb47nvz as InternalMap,
+} from './InternalMap.mjs';
+//region block: imports
+var imul = Math.imul;
+var clz32 = Math.clz32;
+//endregion
+//region block: pre-declaration
+//endregion
+function computeHashSize($this, capacity) {
+  return takeHighestOneBit(imul(coerceAtLeast(capacity, 1), 3));
+}
+function computeShift($this, hashSize) {
+  // Inline function 'kotlin.countLeadingZeroBits' call
+  return clz32(hashSize) + 1 | 0;
+}
+function checkForComodification($this) {
+  if (!($this.ca_1.m8_1 === $this.ea_1))
+    throw ConcurrentModificationException().ba('The backing map has been modified after this entry was obtained.');
+}
+function _get_capacity__a9k9f3($this) {
+  return $this.f8_1.length;
+}
+function _get_hashSize__tftcho($this) {
+  return $this.i8_1.length;
+}
+function registerModification($this) {
+  $this.m8_1 = $this.m8_1 + 1 | 0;
+}
+function ensureExtraCapacity($this, n) {
+  if (shouldCompact($this, n)) {
+    compact($this, true);
+  } else {
+    ensureCapacity($this, $this.k8_1 + n | 0);
+  }
+}
+function shouldCompact($this, extraCapacity) {
+  var spareCapacity = _get_capacity__a9k9f3($this) - $this.k8_1 | 0;
+  var gaps = $this.k8_1 - $this.i1() | 0;
+  return spareCapacity < extraCapacity && (gaps + spareCapacity | 0) >= extraCapacity && gaps >= (_get_capacity__a9k9f3($this) / 4 | 0);
+}
+function ensureCapacity($this, minCapacity) {
+  if (minCapacity < 0)
+    throw RuntimeException().ha('too many elements');
+  if (minCapacity > _get_capacity__a9k9f3($this)) {
+    var newSize = Companion_instance.ia(_get_capacity__a9k9f3($this), minCapacity);
+    $this.f8_1 = copyOfUninitializedElements($this.f8_1, newSize);
+    var tmp = $this;
+    var tmp0_safe_receiver = $this.g8_1;
+    tmp.g8_1 = tmp0_safe_receiver == null ? null : copyOfUninitializedElements(tmp0_safe_receiver, newSize);
+    $this.h8_1 = copyOf($this.h8_1, newSize);
+    var newHashSize = computeHashSize(Companion_instance_0, newSize);
+    if (newHashSize > _get_hashSize__tftcho($this)) {
+      rehash($this, newHashSize);
+    }
+  }
+}
+function allocateValuesArray($this) {
+  var curValuesArray = $this.g8_1;
+  if (!(curValuesArray == null))
+    return curValuesArray;
+  var newValuesArray = arrayOfUninitializedElements(_get_capacity__a9k9f3($this));
+  $this.g8_1 = newValuesArray;
+  return newValuesArray;
+}
+function hash($this, key) {
+  return key == null ? 0 : imul(hashCode(key), -1640531527) >>> $this.l8_1 | 0;
+}
+function compact($this, updateHashArray) {
+  var i = 0;
+  var j = 0;
+  var valuesArray = $this.g8_1;
+  while (i < $this.k8_1) {
+    var hash = $this.h8_1[i];
+    if (hash >= 0) {
+      $this.f8_1[j] = $this.f8_1[i];
+      if (!(valuesArray == null)) {
+        valuesArray[j] = valuesArray[i];
+      }
+      if (updateHashArray) {
+        $this.h8_1[j] = hash;
+        $this.i8_1[hash] = j + 1 | 0;
+      }
+      j = j + 1 | 0;
+    }
+    i = i + 1 | 0;
+  }
+  resetRange($this.f8_1, j, $this.k8_1);
+  if (valuesArray == null)
+    null;
+  else {
+    resetRange(valuesArray, j, $this.k8_1);
+  }
+  $this.k8_1 = j;
+}
+function rehash($this, newHashSize) {
+  registerModification($this);
+  if ($this.k8_1 > $this.n8_1) {
+    compact($this, false);
+  }
+  $this.i8_1 = new Int32Array(newHashSize);
+  $this.l8_1 = computeShift(Companion_instance_0, newHashSize);
+  var i = 0;
+  while (i < $this.k8_1) {
+    var _unary__edvuaz = i;
+    i = _unary__edvuaz + 1 | 0;
+    if (!putRehash($this, _unary__edvuaz)) {
+      throw IllegalStateException().o4('This cannot happen with fixed magic multiplier and grow-only hash array. Have object hashCodes changed?');
+    }
+  }
+}
+function putRehash($this, i) {
+  var hash_0 = hash($this, $this.f8_1[i]);
+  var probesLeft = $this.j8_1;
+  while (true) {
+    var index = $this.i8_1[hash_0];
+    if (index === 0) {
+      $this.i8_1[hash_0] = i + 1 | 0;
+      $this.h8_1[i] = hash_0;
+      return true;
+    }
+    probesLeft = probesLeft - 1 | 0;
+    if (probesLeft < 0)
+      return false;
+    var _unary__edvuaz = hash_0;
+    hash_0 = _unary__edvuaz - 1 | 0;
+    if (_unary__edvuaz === 0)
+      hash_0 = _get_hashSize__tftcho($this) - 1 | 0;
+  }
+}
+function findKey($this, key) {
+  var hash_0 = hash($this, key);
+  var probesLeft = $this.j8_1;
+  while (true) {
+    var index = $this.i8_1[hash_0];
+    if (index === 0)
+      return -1;
+    if (index > 0 && equals($this.f8_1[index - 1 | 0], key))
+      return index - 1 | 0;
+    probesLeft = probesLeft - 1 | 0;
+    if (probesLeft < 0)
+      return -1;
+    var _unary__edvuaz = hash_0;
+    hash_0 = _unary__edvuaz - 1 | 0;
+    if (_unary__edvuaz === 0)
+      hash_0 = _get_hashSize__tftcho($this) - 1 | 0;
+  }
+}
+function findValue($this, value) {
+  var i = $this.k8_1;
+  $l$loop: while (true) {
+    i = i - 1 | 0;
+    if (!(i >= 0)) {
+      break $l$loop;
+    }
+    if ($this.h8_1[i] >= 0 && equals(ensureNotNull($this.g8_1)[i], value))
+      return i;
+  }
+  return -1;
+}
+function addKey($this, key) {
+  $this.d9();
+  retry: while (true) {
+    var hash_0 = hash($this, key);
+    var tentativeMaxProbeDistance = coerceAtMost(imul($this.j8_1, 2), _get_hashSize__tftcho($this) / 2 | 0);
+    var probeDistance = 0;
+    while (true) {
+      var index = $this.i8_1[hash_0];
+      if (index <= 0) {
+        if ($this.k8_1 >= _get_capacity__a9k9f3($this)) {
+          ensureExtraCapacity($this, 1);
+          continue retry;
+        }
+        var _unary__edvuaz = $this.k8_1;
+        $this.k8_1 = _unary__edvuaz + 1 | 0;
+        var putIndex = _unary__edvuaz;
+        $this.f8_1[putIndex] = key;
+        $this.h8_1[putIndex] = hash_0;
+        $this.i8_1[hash_0] = putIndex + 1 | 0;
+        $this.n8_1 = $this.n8_1 + 1 | 0;
+        registerModification($this);
+        if (probeDistance > $this.j8_1)
+          $this.j8_1 = probeDistance;
+        return putIndex;
+      }
+      if (equals($this.f8_1[index - 1 | 0], key)) {
+        return -index | 0;
+      }
+      probeDistance = probeDistance + 1 | 0;
+      if (probeDistance > tentativeMaxProbeDistance) {
+        rehash($this, imul(_get_hashSize__tftcho($this), 2));
+        continue retry;
+      }
+      var _unary__edvuaz_0 = hash_0;
+      hash_0 = _unary__edvuaz_0 - 1 | 0;
+      if (_unary__edvuaz_0 === 0)
+        hash_0 = _get_hashSize__tftcho($this) - 1 | 0;
+    }
+  }
+}
+function removeEntryAt($this, index) {
+  resetAt($this.f8_1, index);
+  var tmp0_safe_receiver = $this.g8_1;
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    resetAt(tmp0_safe_receiver, index);
+  }
+  removeHashAt($this, $this.h8_1[index]);
+  $this.h8_1[index] = -1;
+  $this.n8_1 = $this.n8_1 - 1 | 0;
+  registerModification($this);
+}
+function removeHashAt($this, removedHash) {
+  var hash_0 = removedHash;
+  var hole = removedHash;
+  var probeDistance = 0;
+  var patchAttemptsLeft = coerceAtMost(imul($this.j8_1, 2), _get_hashSize__tftcho($this) / 2 | 0);
+  while (true) {
+    var _unary__edvuaz = hash_0;
+    hash_0 = _unary__edvuaz - 1 | 0;
+    if (_unary__edvuaz === 0)
+      hash_0 = _get_hashSize__tftcho($this) - 1 | 0;
+    probeDistance = probeDistance + 1 | 0;
+    if (probeDistance > $this.j8_1) {
+      $this.i8_1[hole] = 0;
+      return Unit_instance;
+    }
+    var index = $this.i8_1[hash_0];
+    if (index === 0) {
+      $this.i8_1[hole] = 0;
+      return Unit_instance;
+    }
+    if (index < 0) {
+      $this.i8_1[hole] = -1;
+      hole = hash_0;
+      probeDistance = 0;
+    } else {
+      var otherHash = hash($this, $this.f8_1[index - 1 | 0]);
+      if (((otherHash - hash_0 | 0) & (_get_hashSize__tftcho($this) - 1 | 0)) >= probeDistance) {
+        $this.i8_1[hole] = index;
+        $this.h8_1[index - 1 | 0] = hole;
+        hole = hash_0;
+        probeDistance = 0;
+      }
+    }
+    patchAttemptsLeft = patchAttemptsLeft - 1 | 0;
+    if (patchAttemptsLeft < 0) {
+      $this.i8_1[hole] = -1;
+      return Unit_instance;
+    }
+  }
+}
+function contentEquals($this, other) {
+  return $this.n8_1 === other.i1() && $this.o9(other.q1());
+}
+function putEntry($this, entry) {
+  var index = addKey($this, entry.r1());
+  var valuesArray = allocateValuesArray($this);
+  if (index >= 0) {
+    valuesArray[index] = entry.s1();
+    return true;
+  }
+  var oldValue = valuesArray[(-index | 0) - 1 | 0];
+  if (!equals(entry.s1(), oldValue)) {
+    valuesArray[(-index | 0) - 1 | 0] = entry.s1();
+    return true;
+  }
+  return false;
+}
+function putAllEntries($this, from) {
+  if (from.j())
+    return false;
+  ensureExtraCapacity($this, from.i1());
+  var it = from.d1();
+  var updated = false;
+  while (it.e1()) {
+    if (putEntry($this, it.f1()))
+      updated = true;
+  }
+  return updated;
+}
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        this.ja_1 = -1640531527;
+        this.ka_1 = 8;
+        this.la_1 = 2;
+        this.ma_1 = -1;
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance_0;
+function Companion_getInstance() {
+  return Companion_instance_0;
+}
+var ItrClass;
+function Itr() {
+  if (ItrClass === VOID) {
+    class $ {
+      constructor(map) {
+        this.na_1 = map;
+        this.oa_1 = 0;
+        this.pa_1 = -1;
+        this.qa_1 = this.na_1.m8_1;
+        this.ra();
+      }
+      ra() {
+        while (this.oa_1 < this.na_1.k8_1 && this.na_1.h8_1[this.oa_1] < 0) {
+          this.oa_1 = this.oa_1 + 1 | 0;
+        }
+      }
+      e1() {
+        return this.oa_1 < this.na_1.k8_1;
+      }
+      z5() {
+        this.sa();
+        // Inline function 'kotlin.check' call
+        if (!!(this.pa_1 === -1)) {
+          var message = 'Call next() before removing element from the iterator.';
+          throw IllegalStateException().o4(toString(message));
+        }
+        this.na_1.d9();
+        removeEntryAt(this.na_1, this.pa_1);
+        this.pa_1 = -1;
+        this.qa_1 = this.na_1.m8_1;
+      }
+      sa() {
+        if (!(this.na_1.m8_1 === this.qa_1))
+          throw ConcurrentModificationException().ta();
+      }
+    }
+    initMetadataForClass($, 'Itr');
+    ItrClass = $;
+  }
+  return ItrClass;
+}
+var KeysItrClass;
+function KeysItr() {
+  if (KeysItrClass === VOID) {
+    class $ extends Itr() {
+      f1() {
+        this.sa();
+        if (this.oa_1 >= this.na_1.k8_1)
+          throw NoSuchElementException().d6();
+        var tmp = this;
+        var _unary__edvuaz = this.oa_1;
+        this.oa_1 = _unary__edvuaz + 1 | 0;
+        tmp.pa_1 = _unary__edvuaz;
+        var result = this.na_1.f8_1[this.pa_1];
+        this.ra();
+        return result;
+      }
+    }
+    initMetadataForClass($, 'KeysItr');
+    KeysItrClass = $;
+  }
+  return KeysItrClass;
+}
+var ValuesItrClass;
+function ValuesItr() {
+  if (ValuesItrClass === VOID) {
+    class $ extends Itr() {
+      f1() {
+        this.sa();
+        if (this.oa_1 >= this.na_1.k8_1)
+          throw NoSuchElementException().d6();
+        var tmp = this;
+        var _unary__edvuaz = this.oa_1;
+        this.oa_1 = _unary__edvuaz + 1 | 0;
+        tmp.pa_1 = _unary__edvuaz;
+        var result = ensureNotNull(this.na_1.g8_1)[this.pa_1];
+        this.ra();
+        return result;
+      }
+    }
+    initMetadataForClass($, 'ValuesItr');
+    ValuesItrClass = $;
+  }
+  return ValuesItrClass;
+}
+var EntriesItrClass;
+function EntriesItr() {
+  if (EntriesItrClass === VOID) {
+    class $ extends Itr() {
+      f1() {
+        this.sa();
+        if (this.oa_1 >= this.na_1.k8_1)
+          throw NoSuchElementException().d6();
+        var tmp = this;
+        var _unary__edvuaz = this.oa_1;
+        this.oa_1 = _unary__edvuaz + 1 | 0;
+        tmp.pa_1 = _unary__edvuaz;
+        var result = new (EntryRef())(this.na_1, this.pa_1);
+        this.ra();
+        return result;
+      }
+      gb() {
+        if (this.oa_1 >= this.na_1.k8_1)
+          throw NoSuchElementException().d6();
+        var tmp = this;
+        var _unary__edvuaz = this.oa_1;
+        this.oa_1 = _unary__edvuaz + 1 | 0;
+        tmp.pa_1 = _unary__edvuaz;
+        // Inline function 'kotlin.hashCode' call
+        var tmp0_safe_receiver = this.na_1.f8_1[this.pa_1];
+        var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode(tmp0_safe_receiver);
+        var tmp_0 = tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+        // Inline function 'kotlin.hashCode' call
+        var tmp0_safe_receiver_0 = ensureNotNull(this.na_1.g8_1)[this.pa_1];
+        var tmp1_elvis_lhs_0 = tmp0_safe_receiver_0 == null ? null : hashCode(tmp0_safe_receiver_0);
+        var result = tmp_0 ^ (tmp1_elvis_lhs_0 == null ? 0 : tmp1_elvis_lhs_0);
+        this.ra();
+        return result;
+      }
+      hb(sb) {
+        if (this.oa_1 >= this.na_1.k8_1)
+          throw NoSuchElementException().d6();
+        var tmp = this;
+        var _unary__edvuaz = this.oa_1;
+        this.oa_1 = _unary__edvuaz + 1 | 0;
+        tmp.pa_1 = _unary__edvuaz;
+        var key = this.na_1.f8_1[this.pa_1];
+        if (equals(key, this.na_1))
+          sb.jb('(this Map)');
+        else
+          sb.ib(key);
+        sb.kb(_Char___init__impl__6a9atx(61));
+        var value = ensureNotNull(this.na_1.g8_1)[this.pa_1];
+        if (equals(value, this.na_1))
+          sb.jb('(this Map)');
+        else
+          sb.ib(value);
+        this.ra();
+      }
+    }
+    initMetadataForClass($, 'EntriesItr');
+    EntriesItrClass = $;
+  }
+  return EntriesItrClass;
+}
+var EntryRefClass;
+function EntryRef() {
+  if (EntryRefClass === VOID) {
+    class $ {
+      constructor(map, index) {
+        this.ca_1 = map;
+        this.da_1 = index;
+        this.ea_1 = this.ca_1.m8_1;
+      }
+      r1() {
+        checkForComodification(this);
+        return this.ca_1.f8_1[this.da_1];
+      }
+      s1() {
+        checkForComodification(this);
+        return ensureNotNull(this.ca_1.g8_1)[this.da_1];
+      }
+      equals(other) {
+        var tmp;
+        var tmp_0;
+        if (!(other == null) ? isInterface(other, Entry()) : false) {
+          tmp_0 = equals(other.r1(), this.r1());
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp = equals(other.s1(), this.s1());
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        // Inline function 'kotlin.hashCode' call
+        var tmp0_safe_receiver = this.r1();
+        var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode(tmp0_safe_receiver);
+        var tmp = tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+        // Inline function 'kotlin.hashCode' call
+        var tmp0_safe_receiver_0 = this.s1();
+        var tmp1_elvis_lhs_0 = tmp0_safe_receiver_0 == null ? null : hashCode(tmp0_safe_receiver_0);
+        return tmp ^ (tmp1_elvis_lhs_0 == null ? 0 : tmp1_elvis_lhs_0);
+      }
+      toString() {
+        return toString_0(this.r1()) + '=' + toString_0(this.s1());
+      }
+    }
+    initMetadataForClass($, 'EntryRef', VOID, VOID, [Entry()]);
+    EntryRefClass = $;
+  }
+  return EntryRefClass;
+}
+var InternalHashMapClass;
+function InternalHashMap() {
+  if (InternalHashMapClass === VOID) {
+    class $ {
+      static lb(keysArray, valuesArray, presenceArray, hashArray, maxProbeDistance, length) {
+        var $this = createThis(this);
+        $this.f8_1 = keysArray;
+        $this.g8_1 = valuesArray;
+        $this.h8_1 = presenceArray;
+        $this.i8_1 = hashArray;
+        $this.j8_1 = maxProbeDistance;
+        $this.k8_1 = length;
+        $this.l8_1 = computeShift(Companion_instance_0, _get_hashSize__tftcho($this));
+        $this.m8_1 = 0;
+        $this.n8_1 = 0;
+        $this.o8_1 = false;
+        return $this;
+      }
+      i1() {
+        return this.n8_1;
+      }
+      static p8() {
+        return this.w9(8);
+      }
+      static w9(initialCapacity) {
+        return this.lb(arrayOfUninitializedElements(initialCapacity), null, new Int32Array(initialCapacity), new Int32Array(computeHashSize(Companion_instance_0, initialCapacity)), 2, 0);
+      }
+      static u8(original) {
+        var $this = this.w9(original.i1());
+        $this.f3(original);
+        return $this;
+      }
+      static r8(initialCapacity, loadFactor) {
+        var $this = this.w9(initialCapacity);
+        // Inline function 'kotlin.require' call
+        if (!(loadFactor > 0)) {
+          var message = 'Non-positive load factor: ' + loadFactor;
+          throw IllegalArgumentException().u(toString(message));
+        }
+        return $this;
+      }
+      v2(value) {
+        return findValue(this, value) >= 0;
+      }
+      w2(key) {
+        var index = findKey(this, key);
+        if (index < 0)
+          return null;
+        return ensureNotNull(this.g8_1)[index];
+      }
+      v8(key) {
+        return findKey(this, key) >= 0;
+      }
+      d3(key, value) {
+        var index = addKey(this, key);
+        var valuesArray = allocateValuesArray(this);
+        if (index < 0) {
+          var oldValue = valuesArray[(-index | 0) - 1 | 0];
+          valuesArray[(-index | 0) - 1 | 0] = value;
+          return oldValue;
+        } else {
+          valuesArray[index] = value;
+          return null;
+        }
+      }
+      f3(from) {
+        this.d9();
+        putAllEntries(this, from.q1());
+      }
+      e3(key) {
+        this.d9();
+        var index = findKey(this, key);
+        if (index < 0)
+          return null;
+        var oldValue = ensureNotNull(this.g8_1)[index];
+        removeEntryAt(this, index);
+        return oldValue;
+      }
+      z2() {
+        this.d9();
+        var inductionVariable = 0;
+        var last = this.k8_1 - 1 | 0;
+        if (inductionVariable <= last)
+          do {
+            var i = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            var hash = this.h8_1[i];
+            if (hash >= 0) {
+              this.i8_1[hash] = 0;
+              this.h8_1[i] = -1;
+            }
+          }
+           while (!(i === last));
+        resetRange(this.f8_1, 0, this.k8_1);
+        var tmp0_safe_receiver = this.g8_1;
+        if (tmp0_safe_receiver == null)
+          null;
+        else {
+          resetRange(tmp0_safe_receiver, 0, this.k8_1);
+        }
+        this.n8_1 = 0;
+        this.k8_1 = 0;
+        registerModification(this);
+      }
+      equals(other) {
+        var tmp;
+        if (other === this) {
+          tmp = true;
+        } else {
+          var tmp_0;
+          if (!(other == null) ? isInterface(other, KtMap()) : false) {
+            tmp_0 = contentEquals(this, other);
+          } else {
+            tmp_0 = false;
+          }
+          tmp = tmp_0;
+        }
+        return tmp;
+      }
+      hashCode() {
+        var result = 0;
+        var it = this.k9();
+        while (it.e1()) {
+          result = result + it.gb() | 0;
+        }
+        return result;
+      }
+      toString() {
+        var sb = StringBuilder().mb(2 + imul(this.n8_1, 3) | 0);
+        sb.jb('{');
+        var i = 0;
+        var it = this.k9();
+        while (it.e1()) {
+          if (i > 0) {
+            sb.jb(', ');
+          }
+          it.hb(sb);
+          i = i + 1 | 0;
+        }
+        sb.jb('}');
+        return sb.toString();
+      }
+      d9() {
+        if (this.o8_1)
+          throw UnsupportedOperationException().w7();
+      }
+      n9(entry) {
+        var index = findKey(this, entry.r1());
+        if (index < 0)
+          return false;
+        return equals(ensureNotNull(this.g8_1)[index], entry.s1());
+      }
+      nb(entry) {
+        return this.n9(isInterface(entry, Entry()) ? entry : THROW_CCE());
+      }
+      c9() {
+        return new (KeysItr())(this);
+      }
+      h9() {
+        return new (ValuesItr())(this);
+      }
+      k9() {
+        return new (EntriesItr())(this);
+      }
+    }
+    protoOf($).o9 = containsAllEntries;
+    initMetadataForClass($, 'InternalHashMap', $.p8, VOID, [InternalMap()]);
+    InternalHashMapClass = $;
+  }
+  return InternalHashMapClass;
+}
+//region block: init
+Companion_instance_0 = new (Companion())();
+//endregion
+//region block: exports
+export {
+  InternalHashMap as InternalHashMapmpvpylj0ut6l,
+};
+//endregion
+
+//# sourceMappingURL=InternalHashMap.mjs.map