@attocash/commons-js 5.0.0

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

@@ -0,0 +1,214 @@
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../Unit.mjs';
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+import { Companion_instanceovl8he3jiijf as Companion_instance } from './AbstractList.mjs';
+import { AbstractMutableList192xfq8ycgofs as AbstractMutableList } from './AbstractMutableListJs.mjs';
+import {
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+  UnsupportedOperationException2tkumpmhredt3 as UnsupportedOperationException,
+} from '../exceptions.mjs';
+import { toString1pkumu07cwy4m as toString } from '../js/coreRuntime.mjs';
+import {
+  copyToArray2j022khrow2yi as copyToArray,
+  checkIndexOverflow3frtmheghr0th as checkIndexOverflow,
+} from './collectionJs.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../hacks.mjs';
+import { get_lastIndex1yw0x4k50k51w as get_lastIndex } from './CollectionsKt.mjs';
+import { indexOf3ic8eacwbbrog as indexOf } from './_Arrays.mjs';
+import { arrayToString1r7op7afgkivw as arrayToString } from './collectionsHacks.mjs';
+import { KtMutableList1beimitadwkna as KtMutableList } from './Collections.mjs';
+import { RandomAccess1jbw8sdogqb8x as RandomAccess } from './RandomAccess.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance_0 = this;
+        var tmp = this;
+        // Inline function 'kotlin.also' call
+        var this_0 = ArrayList().c1(0);
+        this_0.x_1 = true;
+        tmp.o7_1 = this_0;
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance_0;
+function Companion_getInstance() {
+  if (Companion_instance_0 === VOID)
+    new (Companion())();
+  return Companion_instance_0;
+}
+function increaseLength($this, amount) {
+  var previous = $this.i1();
+  // Inline function 'kotlin.js.asDynamic' call
+  $this.w_1.length = $this.i1() + amount | 0;
+  return previous;
+}
+function rangeCheck($this, index) {
+  // Inline function 'kotlin.apply' call
+  Companion_instance.s6(index, $this.i1());
+  return index;
+}
+function insertionRangeCheck($this, index) {
+  // Inline function 'kotlin.apply' call
+  Companion_instance.j6(index, $this.i1());
+  return index;
+}
+var ArrayListClass;
+function ArrayList() {
+  if (ArrayListClass === VOID) {
+    class $ extends AbstractMutableList() {
+      static q5(array) {
+        Companion_getInstance();
+        var $this = this.r6();
+        $this.w_1 = array;
+        $this.x_1 = false;
+        return $this;
+      }
+      static l1() {
+        Companion_getInstance();
+        // Inline function 'kotlin.emptyArray' call
+        var tmp$ret$0 = [];
+        return this.q5(tmp$ret$0);
+      }
+      static c1(initialCapacity) {
+        Companion_getInstance();
+        // Inline function 'kotlin.emptyArray' call
+        var tmp$ret$0 = [];
+        var $this = this.q5(tmp$ret$0);
+        // Inline function 'kotlin.require' call
+        if (!(initialCapacity >= 0)) {
+          var message = 'Negative initial capacity: ' + initialCapacity;
+          throw IllegalArgumentException().u(toString(message));
+        }
+        return $this;
+      }
+      static y(elements) {
+        Companion_getInstance();
+        // Inline function 'kotlin.collections.toTypedArray' call
+        var tmp$ret$0 = copyToArray(elements);
+        return this.q5(tmp$ret$0);
+      }
+      p7() {
+        this.y5();
+        this.x_1 = true;
+        return this.i1() > 0 ? this : Companion_getInstance().o7_1;
+      }
+      q7() {
+      }
+      r7(minCapacity) {
+      }
+      i1() {
+        return this.w_1.length;
+      }
+      j1(index) {
+        var tmp = this.w_1[rangeCheck(this, index)];
+        return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+      }
+      a3(index, element) {
+        this.y5();
+        rangeCheck(this, index);
+        // Inline function 'kotlin.apply' call
+        var this_0 = this.w_1[index];
+        this.w_1[index] = element;
+        var tmp = this_0;
+        return (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+      }
+      m(element) {
+        this.y5();
+        // Inline function 'kotlin.js.asDynamic' call
+        this.w_1.push(element);
+        this.e6_1 = this.e6_1 + 1 | 0;
+        return true;
+      }
+      b3(index, element) {
+        this.y5();
+        // Inline function 'kotlin.js.asDynamic' call
+        this.w_1.splice(insertionRangeCheck(this, index), 0, element);
+        this.e6_1 = this.e6_1 + 1 | 0;
+      }
+      k1(elements) {
+        this.y5();
+        if (elements.j())
+          return false;
+        var offset = increaseLength(this, elements.i1());
+        // Inline function 'kotlin.collections.forEachIndexed' call
+        var index = 0;
+        var _iterator__ex2g4s = elements.d1();
+        while (_iterator__ex2g4s.e1()) {
+          var item = _iterator__ex2g4s.f1();
+          var _unary__edvuaz = index;
+          index = _unary__edvuaz + 1 | 0;
+          var index_0 = checkIndexOverflow(_unary__edvuaz);
+          this.w_1[offset + index_0 | 0] = item;
+        }
+        this.e6_1 = this.e6_1 + 1 | 0;
+        return true;
+      }
+      c3(index) {
+        this.y5();
+        rangeCheck(this, index);
+        this.e6_1 = this.e6_1 + 1 | 0;
+        var tmp;
+        if (index === get_lastIndex(this)) {
+          // Inline function 'kotlin.js.asDynamic' call
+          tmp = this.w_1.pop();
+        } else {
+          // Inline function 'kotlin.js.asDynamic' call
+          tmp = this.w_1.splice(index, 1)[0];
+        }
+        return tmp;
+      }
+      t6(fromIndex, toIndex) {
+        this.y5();
+        this.e6_1 = this.e6_1 + 1 | 0;
+        // Inline function 'kotlin.js.asDynamic' call
+        this.w_1.splice(fromIndex, toIndex - fromIndex | 0);
+      }
+      z2() {
+        this.y5();
+        var tmp = this;
+        // Inline function 'kotlin.emptyArray' call
+        tmp.w_1 = [];
+        this.e6_1 = this.e6_1 + 1 | 0;
+      }
+      s2(element) {
+        return indexOf(this.w_1, element);
+      }
+      toString() {
+        return arrayToString(this.w_1);
+      }
+      s7() {
+        return [].slice.call(this.w_1);
+      }
+      toArray() {
+        return this.s7();
+      }
+      y5() {
+        if (this.x_1)
+          throw UnsupportedOperationException().w7();
+      }
+    }
+    initMetadataForClass($, 'ArrayList', $.l1, VOID, [AbstractMutableList(), KtMutableList(), RandomAccess()]);
+    ArrayListClass = $;
+  }
+  return ArrayListClass;
+}
+//region block: exports
+export {
+  ArrayList as ArrayList3it5z8td81qkl,
+};
+//endregion
+
+//# sourceMappingURL=ArrayListJs.mjs.map

package/kotlin-kotlin-stdlib/kotlin/collections/ArrayListJs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["js/src/kotlin/collections/ArrayList.kt","src/kotlin/util/Standard.kt","js/src/kotlin/kotlin.kt","src/kotlin/util/Preconditions.kt","js/src/kotlin/collectionJs.kt","common/src/generated/_Collections.kt"],"sourcesContent":[null,null,null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["increaseLength","amount","previous","rangeCheck","index","insertionRangeCheck","array","initialCapacity","message","elements","build","trimToSize","ensureCapacity","minCapacity","<get-size>","get","set","element","add","addAll","offset","item","removeAt","removeRange","fromIndex","toIndex","clear","indexOf","toString","toArray","checkIsMutable"],"mappings":"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"}

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

@@ -0,0 +1,128 @@
+import { get_lastIndexx0qsydpfv3mu as get_lastIndex } from './_Arrays.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../Unit.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var _stableSortingIsSupported;
+function sortArrayWith(array, comparator) {
+  if (getStableSortingIsSupported()) {
+    var comparison = sortArrayWith$lambda(comparator);
+    // Inline function 'kotlin.js.asDynamic' call
+    array.sort(comparison);
+  } else {
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    mergeSort(array, 0, get_lastIndex(array), comparator);
+  }
+}
+function getStableSortingIsSupported() {
+  var tmp0_safe_receiver = _stableSortingIsSupported;
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    return tmp0_safe_receiver;
+  }
+  _stableSortingIsSupported = false;
+  // Inline function 'kotlin.js.unsafeCast' call
+  var array = [];
+  var inductionVariable = 0;
+  if (inductionVariable < 600)
+    do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'kotlin.js.asDynamic' call
+      array.push(index);
+    }
+     while (inductionVariable < 600);
+  var comparison = getStableSortingIsSupported$lambda;
+  // Inline function 'kotlin.js.asDynamic' call
+  array.sort(comparison);
+  var inductionVariable_0 = 1;
+  var last = array.length;
+  if (inductionVariable_0 < last)
+    do {
+      var index_0 = inductionVariable_0;
+      inductionVariable_0 = inductionVariable_0 + 1 | 0;
+      var a = array[index_0 - 1 | 0];
+      var b = array[index_0];
+      if ((a & 3) === (b & 3) && a >= b)
+        return false;
+    }
+     while (inductionVariable_0 < last);
+  _stableSortingIsSupported = true;
+  return true;
+}
+function mergeSort(array, start, endInclusive, comparator) {
+  // Inline function 'kotlin.arrayOfNulls' call
+  var size = array.length;
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var buffer = Array(size);
+  var result = mergeSort_0(array, buffer, start, endInclusive, comparator);
+  if (!(result === array)) {
+    var inductionVariable = start;
+    if (inductionVariable <= endInclusive)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        array[i] = result[i];
+      }
+       while (!(i === endInclusive));
+  }
+}
+function mergeSort_0(array, buffer, start, end, comparator) {
+  if (start === end) {
+    return array;
+  }
+  var median = (start + end | 0) / 2 | 0;
+  var left = mergeSort_0(array, buffer, start, median, comparator);
+  var right = mergeSort_0(array, buffer, median + 1 | 0, end, comparator);
+  var target = left === buffer ? array : buffer;
+  var leftIndex = start;
+  var rightIndex = median + 1 | 0;
+  var inductionVariable = start;
+  if (inductionVariable <= end)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      if (leftIndex <= median && rightIndex <= end) {
+        var leftValue = left[leftIndex];
+        var rightValue = right[rightIndex];
+        if (comparator.compare(leftValue, rightValue) <= 0) {
+          target[i] = leftValue;
+          leftIndex = leftIndex + 1 | 0;
+        } else {
+          target[i] = rightValue;
+          rightIndex = rightIndex + 1 | 0;
+        }
+      } else if (leftIndex <= median) {
+        target[i] = left[leftIndex];
+        leftIndex = leftIndex + 1 | 0;
+      } else {
+        target[i] = right[rightIndex];
+        rightIndex = rightIndex + 1 | 0;
+      }
+    }
+     while (!(i === end));
+  return target;
+}
+function sortArrayWith$lambda($comparator) {
+  return function (a, b) {
+    return $comparator.compare(a, b);
+  };
+}
+function getStableSortingIsSupported$lambda(a, b) {
+  return (a & 3) - (b & 3) | 0;
+}
+//region block: init
+_stableSortingIsSupported = null;
+//endregion
+//region block: exports
+export {
+  sortArrayWith as sortArrayWith2peqe6a4xxbw8,
+};
+//endregion
+
+//# sourceMappingURL=ArraySorting.mjs.map

package/kotlin-kotlin-stdlib/kotlin/collections/ArraySorting.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["js/src/kotlin/collections/ArraySorting.kt","src/kotlin/util/Standard.kt","js/builtins/Library.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["sortArrayWith","array","comparator","comparison","getStableSortingIsSupported","index","a","b","mergeSort","start","endInclusive","buffer","result","i","end","median","left","right","target","leftIndex","rightIndex","leftValue","rightValue","sortArrayWith$lambda","$comparator","sortArrayWith$lambda$lambda","getStableSortingIsSupported$lambda"],"mappings":"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"}

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

@@ -0,0 +1,92 @@
+import { initMetadataForInterface1egvbzx539z91 as initMetadataForInterface } from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var KtListClass;
+function KtList() {
+  if (KtListClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'List', VOID, VOID, [Collection()]);
+    KtListClass = $;
+  }
+  return KtListClass;
+}
+var CollectionClass;
+function Collection() {
+  if (CollectionClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'Collection');
+    CollectionClass = $;
+  }
+  return CollectionClass;
+}
+var KtSetClass;
+function KtSet() {
+  if (KtSetClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'Set', VOID, VOID, [Collection()]);
+    KtSetClass = $;
+  }
+  return KtSetClass;
+}
+var EntryClass;
+function Entry() {
+  if (EntryClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'Entry');
+    EntryClass = $;
+  }
+  return EntryClass;
+}
+var KtMapClass;
+function KtMap() {
+  if (KtMapClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'Map');
+    KtMapClass = $;
+  }
+  return KtMapClass;
+}
+var KtMutableListClass;
+function KtMutableList() {
+  if (KtMutableListClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'MutableList', VOID, VOID, [KtList(), Collection()]);
+    KtMutableListClass = $;
+  }
+  return KtMutableListClass;
+}
+var KtMutableSetClass;
+function KtMutableSet() {
+  if (KtMutableSetClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'MutableSet', VOID, VOID, [KtSet(), Collection()]);
+    KtMutableSetClass = $;
+  }
+  return KtMutableSetClass;
+}
+var KtMutableMapClass;
+function KtMutableMap() {
+  if (KtMutableMapClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'MutableMap', VOID, VOID, [KtMap()]);
+    KtMutableMapClass = $;
+  }
+  return KtMutableMapClass;
+}
+//region block: exports
+export {
+  Collection as Collection1k04j3hzsbod0,
+  KtList as KtList3hktaavzmj137,
+  Entry as Entry2xmjmyutzoq3p,
+  KtMap as KtMap140uvy3s5zad8,
+  KtMutableList as KtMutableList1beimitadwkna,
+  KtMutableMap as KtMutableMap1kqeifoi36kpz,
+  KtMutableSet as KtMutableSetwuwn7k5m570a,
+  KtSet as KtSetjrjc7fhfd6b9,
+};
+//endregion
+
+//# sourceMappingURL=Collections.mjs.map

package/kotlin-kotlin-stdlib/kotlin/collections/Collections.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}