@attocash/commons-test 6.0.0

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

@@ -0,0 +1,99 @@
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../exceptions.mjs';
+import { toString1pkumu07cwy4m as toString } from '../js/coreRuntime.mjs';
+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 {
+  Random24dxadk52mliy as Random,
+  takeUpperBits23varjnd7v1uz as takeUpperBits,
+} from './Random.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function checkInvariants($this) {
+  // Inline function 'kotlin.require' call
+  if (!!(($this.tl_1 | $this.ul_1 | $this.vl_1 | $this.wl_1 | $this.xl_1) === 0)) {
+    var message = 'Initial state must have at least one non-zero element.';
+    throw IllegalArgumentException().i1(toString(message));
+  }
+}
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        this.am_1 = 0n;
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  return Companion_instance;
+}
+var XorWowRandomClass;
+function XorWowRandom() {
+  if (XorWowRandomClass === VOID) {
+    class $ extends Random() {
+      static bm(x, y, z, w, v, addend) {
+        var $this = this.ol();
+        $this.tl_1 = x;
+        $this.ul_1 = y;
+        $this.vl_1 = z;
+        $this.wl_1 = w;
+        $this.xl_1 = v;
+        $this.yl_1 = addend;
+        checkInvariants($this);
+        // Inline function 'kotlin.repeat' call
+        var inductionVariable = 0;
+        if (inductionVariable < 64)
+          do {
+            var index = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            $this.ak();
+          }
+           while (inductionVariable < 64);
+        return $this;
+      }
+      static zl(seed1, seed2) {
+        return this.bm(seed1, seed2, 0, 0, ~seed1, seed1 << 10 ^ (seed2 >>> 4 | 0));
+      }
+      ak() {
+        var t = this.tl_1;
+        t = t ^ (t >>> 2 | 0);
+        this.tl_1 = this.ul_1;
+        this.ul_1 = this.vl_1;
+        this.vl_1 = this.wl_1;
+        var v0 = this.xl_1;
+        this.wl_1 = v0;
+        t = t ^ t << 1 ^ v0 ^ v0 << 4;
+        this.xl_1 = t;
+        this.yl_1 = this.yl_1 + 362437 | 0;
+        return t + this.yl_1 | 0;
+      }
+      pl(bitCount) {
+        return takeUpperBits(this.ak(), bitCount);
+      }
+    }
+    initMetadataForClass($, 'XorWowRandom');
+    XorWowRandomClass = $;
+  }
+  return XorWowRandomClass;
+}
+//region block: init
+Companion_instance = new (Companion())();
+//endregion
+//region block: exports
+export {
+  XorWowRandom as XorWowRandom4dcuf9lla8j1,
+};
+//endregion
+
+//# sourceMappingURL=XorWowRandom.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["src/kotlin/random/XorWowRandom.kt","src/kotlin/util/Preconditions.kt","src/kotlin/util/Standard.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["checkInvariants","message","x","y","z","w","v","addend","index","seed1","seed2","nextInt","t","v0","nextBits","bitCount"],"mappings":";;;;;;;;;;;;;;;;wBAsCYA,CAAA,KAAAA,EAAsB;A;ECH1B,KDIQ,GAAC,aAAK,KAAL,CAAK,IAAL,GAAU,KAAV,CAAU,IAAV,GAAe,KAAf,CAAe,IAAf,GAAoB,KAApB,CAAoB,IAArB,MAA2B,CAA3B,CCJR,C,CAAQ;A,QACRC,UDGwC,wD;ICFxC,oCAAuC,SAAR,OAAQ,CAAvC,C;EACJ,C;ADEA,C;;;;;;QAwB+C,c;;;;;;;;;;;;;;;;gBA5CvCC,C,EACAC,C,EACAC,C,EACAC,C,EACAC,C,EACAC,M;;QALR,c;QACA,c;QACA,c;QACA,c;QACA,c;QACA,mB;QAOI,sB;;YE2HU,qB;QAAd,wBFxHW,EEwHX,C;aAAA;A,gBAAKC,QAAS,iB;YAAA,6C;YFxHG,U;;UEwHjB,4BFxHW,EEwHX,C;;;gBF/HqBC,K,EAAYC,K;uBACpB,K,EAAO,K,EAAO,C,EAAG,C,EAAS,CAAN,K,EAAc,SAAU,EAAX,IAAoB,UAAW,CAA/B,K;;QAerCC,CAAAA,EAAmB;A,YAGxBC,IAAQ,IAARA,CAAQ,I;QACR,IAAI,KAAO,MAAO,CAAd,K;QACJ,YAAI,IAAJ,CAAI,I;QACJ,YAAI,IAAJ,CAAI,I;QACJ,YAAI,IAAJ,CAAI,I;YACJC,KAAS,IAATA,CAAS,I;QACT,YAAI,E;QACJ,IAAK,IAAO,KAAM,CAAd,GAAsB,EAAtB,GAA8B,MAAO,C;QACzC,YAAI,C;QACJ,wBAAU,MAAV,I;QACA,OAAO,IAAI,IAAJ,CAAI,IAAX,I;MACJ,C;QAESC,CAAaC,QAAbD,EACL;A,QAAiC,OAAvB,cAAV,SAAU,EAAc,QAAd,C;MAAsB,C;;;;;;;;;;;;;;"}

package/kotlin-kotlin-stdlib/kotlin/ranges/PrimitiveRanges.mjs

@@ -0,0 +1,178 @@
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+import {
+  IntProgressionfaq59u1bhfih as IntProgression,
+  CharProgression45cqq4g7w3uj as CharProgression,
+} from './Progressions.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../hacks.mjs';
+import { ClosedRangehokgr73im9z3 as ClosedRange } from './Range.mjs';
+import {
+  _Char___init__impl__6a9atx2js6krycynjoo as _Char___init__impl__6a9atx,
+  Char19o2r8palgjof as Char,
+  Char__compareTo_impl_ypi4mbdrkik40uwhqc as Char__compareTo_impl_ypi4mb,
+  Char__toInt_impl_vasixd1agw9q2fuvclj as Char__toInt_impl_vasixd,
+  toString3o7ifthqydp6e as toString,
+} from '../Char.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+//endregion
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance = this;
+        this.a2_1 = new (IntRange())(1, 0);
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  if (Companion_instance === VOID)
+    new (Companion())();
+  return Companion_instance;
+}
+var IntRangeClass;
+function IntRange() {
+  if (IntRangeClass === VOID) {
+    class $ extends IntProgression() {
+      constructor(start, endInclusive) {
+        Companion_getInstance();
+        super(start, endInclusive, 1);
+      }
+      p() {
+        return this.c2_1;
+      }
+      q() {
+        return this.d2_1;
+      }
+      cm(value) {
+        return this.c2_1 <= value && value <= this.d2_1;
+      }
+      f2(value) {
+        return this.cm(typeof value === 'number' ? value : THROW_CCE());
+      }
+      o() {
+        return this.c2_1 > this.d2_1;
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof IntRange()) {
+          tmp = this.o() && other.o() || (this.c2_1 === other.c2_1 && this.d2_1 === other.d2_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return this.o() ? -1 : imul(31, this.c2_1) + this.d2_1 | 0;
+      }
+      toString() {
+        return '' + this.c2_1 + '..' + this.d2_1;
+      }
+    }
+    initMetadataForClass($, 'IntRange', VOID, VOID, [IntProgression(), ClosedRange()]);
+    IntRangeClass = $;
+  }
+  return IntRangeClass;
+}
+var CompanionClass_0;
+function Companion_0() {
+  if (CompanionClass_0 === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance_0 = this;
+        this.dm_1 = new (CharRange())(_Char___init__impl__6a9atx(1), _Char___init__impl__6a9atx(0));
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass_0 = $;
+  }
+  return CompanionClass_0;
+}
+var Companion_instance_0;
+function Companion_getInstance_0() {
+  if (Companion_instance_0 === VOID)
+    new (Companion_0())();
+  return Companion_instance_0;
+}
+var CharRangeClass;
+function CharRange() {
+  if (CharRangeClass === VOID) {
+    class $ extends CharProgression() {
+      constructor(start, endInclusive) {
+        Companion_getInstance_0();
+        super(start, endInclusive, 1);
+      }
+      hm() {
+        return this.im_1;
+      }
+      p() {
+        return new (Char())(this.hm());
+      }
+      lm() {
+        return this.jm_1;
+      }
+      q() {
+        return new (Char())(this.lm());
+      }
+      mm(value) {
+        return Char__compareTo_impl_ypi4mb(this.im_1, value) <= 0 && Char__compareTo_impl_ypi4mb(value, this.jm_1) <= 0;
+      }
+      f2(value) {
+        return this.mm(value instanceof Char() ? value.q2_1 : THROW_CCE());
+      }
+      o() {
+        return Char__compareTo_impl_ypi4mb(this.im_1, this.jm_1) > 0;
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof CharRange()) {
+          tmp = this.o() && other.o() || (this.im_1 === other.im_1 && this.jm_1 === other.jm_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        var tmp;
+        if (this.o()) {
+          tmp = -1;
+        } else {
+          // Inline function 'kotlin.code' call
+          var this_0 = this.im_1;
+          var tmp$ret$0 = Char__toInt_impl_vasixd(this_0);
+          var tmp_0 = imul(31, tmp$ret$0);
+          // Inline function 'kotlin.code' call
+          var this_1 = this.jm_1;
+          tmp = tmp_0 + Char__toInt_impl_vasixd(this_1) | 0;
+        }
+        return tmp;
+      }
+      toString() {
+        return toString(this.im_1) + '..' + toString(this.jm_1);
+      }
+    }
+    initMetadataForClass($, 'CharRange', VOID, VOID, [CharProgression(), ClosedRange()]);
+    CharRangeClass = $;
+  }
+  return CharRangeClass;
+}
+//region block: exports
+export {
+  Companion_getInstance as Companion_getInstance1a3oieudzv4l4,
+  CharRange as CharRange1dt3801jgpja5,
+  IntRange as IntRange1cx8zvxgibbj2,
+};
+//endregion
+
+//# sourceMappingURL=PrimitiveRanges.mjs.map

package/kotlin-kotlin-stdlib/kotlin/ranges/PrimitiveRanges.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["src/kotlin/ranges/PrimitiveRanges.kt","src/kotlin/CharCode.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["start","endInclusive","<get-start>","<get-endInclusive>","contains","value","isEmpty","equals","other","hashCode","toString"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAqFqC,6BAAS,CAAT,EAAY,CAAZ,C;;;;;;;;;;;;;;;;;;kBAhCfA,K,EAAYC,Y;QAAlC,uB;cAAsE,K,EAAO,Y,EAAc,C;;OAC/DC,CAAAA,EAAQ;A,QAAK,OAAL,IAAK,CAAL,I;MAAI,C;OACLC,CAAAA,EAAQ;A,QAAI,OAAJ,IAAI,CAAJ,I;MAAG,C;QAUjCC,CAAaC,KAAbD,EAAoC;A,QAA+B,OAA/B,aAAS,KAAsB,IAAb,SAAS,IAAT,CAAS,I;MAAG,C;SA3CMC,K;;;OAkDxEC,CAAAA,EAAyB;A,QAAY,OAAZ,YAAQ,IAAR,CAAQ,I;MAAG,C;YAEpCC,CAAWC,KAAXD,EACL;A;QAAA,gC;gBAAsB,Q,IAAa,KAAM,I,KACzC,cAAS,KAAT,CAAe,I,IAAS,cAAQ,KAAR,CAAc,I;;gBADhB,K;;QACqB,U;MAAD,C;cAErCE,CAAAA,EACL;A,QAA0C,OAAtC,WAAW,EAAX,GAAoB,SAAK,IAAL,CAAK,IAAL,IAAa,IAAb,CAAa,IAAjC,I;MAAqC,C;cAEpCC,CAAAA,EAAyB;A,QAAe,YAAb,IAAa,CAAb,IAAa,GAAR,IAAQ,GAAL,IAAK,CAAL,I;MAAI,C;;;;;;;;;;;;;QAnCd,8BAAY,6BAAZ,EAAwB,6BAAxB,C;;;;;;;;;;;;;;;;;;kBAhCfV,K,EAAaC,Y;QAApC,yB;cAA0E,K,EAAO,Y,EAAc,C;;QAClEC,CAAAA,EAAQ;A,QAAK,OAAL,IAAK,CAAL,I;MAAI,C;;;;QACLC,CAAAA,EAAQ;A,QAAI,OAAJ,IAAI,CAAJ,I;MAAG,C;;;;QAUlCC,CAAaC,KAAbD,EAAqC;A,QAA+B,OAA/B,uCAAS,KAAT,MAA+B,IAAb,mCAAS,IAAT,CAAS,IAAT,M;MAAY,C;SAJKC,K;;;OAWxEC,CAAAA,EAAyB;A,QAAY,OAAZ,uCAAQ,IAAR,CAAQ,IAAR,K;MAAW,C;YAEpCC,CAAWC,KAAXD,EACL;A;QAAA,iC;gBAAuB,Q,IAAa,KAAM,I,KAC1C,cAAS,KAAT,CAAe,I,IAAS,cAAQ,KAAR,CAAc,I;;gBADf,K;;QACoB,U;MAAD,C;cAErCE,CAAAA,EACL;A;QAAI,a;gBAAW,E;;;uBAAc,I,CAAA,I;cCKgB,YAAP,wBAAL,MAAK,C;sBDLd,SAAW,SAAX,C;;uBAAkB,I,CAAA,I;gBAAlB,QCKc,wBAAL,MAAK,C;;QDLc,U;MAAD,C;cAE9CC,CAAAA,EAAyB;A,QAAe,gBAAb,IAAa,CAAb,IAAa,IAAR,IAAQ,YAAL,IAAK,CAAL,IAAK,C;MAAD,C;;;;;;;;;;;"}

package/kotlin-kotlin-stdlib/kotlin/ranges/ProgressionIterators.mjs

@@ -0,0 +1,96 @@
+import {
+  IntIteratordtlvcwxsuu5a as IntIterator,
+  CharIterator2h6gbyxoj1es2 as CharIterator,
+} from '../collections/PrimitiveIterators.mjs';
+import { NoSuchElementException679xzhnp5bpj as NoSuchElementException } from '../exceptions.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+import {
+  Char__toInt_impl_vasixd1agw9q2fuvclj as Char__toInt_impl_vasixd,
+  Char__compareTo_impl_ypi4mbdrkik40uwhqc as Char__compareTo_impl_ypi4mb,
+} from '../Char.mjs';
+import { numberToChar93r9buh19yek as numberToChar } from '../js/numberConversion.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var IntProgressionIteratorClass;
+function IntProgressionIterator() {
+  if (IntProgressionIteratorClass === VOID) {
+    class $ extends IntIterator() {
+      constructor(first, last, step) {
+        super();
+        this.nm_1 = step;
+        this.om_1 = last;
+        this.pm_1 = this.nm_1 > 0 ? first <= last : first >= last;
+        this.qm_1 = this.pm_1 ? first : this.om_1;
+      }
+      l1() {
+        return this.pm_1;
+      }
+      ak() {
+        var value = this.qm_1;
+        if (value === this.om_1) {
+          if (!this.pm_1)
+            throw NoSuchElementException().i6();
+          this.pm_1 = false;
+        } else {
+          this.qm_1 = this.qm_1 + this.nm_1 | 0;
+        }
+        return value;
+      }
+    }
+    initMetadataForClass($, 'IntProgressionIterator');
+    IntProgressionIteratorClass = $;
+  }
+  return IntProgressionIteratorClass;
+}
+var CharProgressionIteratorClass;
+function CharProgressionIterator() {
+  if (CharProgressionIteratorClass === VOID) {
+    class $ extends CharIterator() {
+      constructor(first, last, step) {
+        super();
+        this.rm_1 = step;
+        var tmp = this;
+        // Inline function 'kotlin.code' call
+        tmp.sm_1 = Char__toInt_impl_vasixd(last);
+        this.tm_1 = this.rm_1 > 0 ? Char__compareTo_impl_ypi4mb(first, last) <= 0 : Char__compareTo_impl_ypi4mb(first, last) >= 0;
+        var tmp_0 = this;
+        var tmp_1;
+        if (this.tm_1) {
+          // Inline function 'kotlin.code' call
+          tmp_1 = Char__toInt_impl_vasixd(first);
+        } else {
+          tmp_1 = this.sm_1;
+        }
+        tmp_0.um_1 = tmp_1;
+      }
+      l1() {
+        return this.tm_1;
+      }
+      ck() {
+        var value = this.um_1;
+        if (value === this.sm_1) {
+          if (!this.tm_1)
+            throw NoSuchElementException().i6();
+          this.tm_1 = false;
+        } else {
+          this.um_1 = this.um_1 + this.rm_1 | 0;
+        }
+        return numberToChar(value);
+      }
+    }
+    initMetadataForClass($, 'CharProgressionIterator');
+    CharProgressionIteratorClass = $;
+  }
+  return CharProgressionIteratorClass;
+}
+//region block: exports
+export {
+  CharProgressionIterator as CharProgressionIterator34nq4ujuknl08,
+  IntProgressionIterator as IntProgressionIterator2ovd1ctrmu51n,
+};
+//endregion
+
+//# sourceMappingURL=ProgressionIterators.mjs.map

package/kotlin-kotlin-stdlib/kotlin/ranges/ProgressionIterators.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["src/kotlin/ranges/ProgressionIterators.kt","src/kotlin/CharCode.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["first","last","step","hasNext","nextInt","value","nextChar"],"mappings":";;;;;;;;;;;;;;;;;;;;kBAuCsCA,K,EAAYC,I,EAAWC,I;;QAAA,gB;QACzB,gB;QACD,YAAI,YAAO,CAAP,GAAU,SAAS,IAAnB,GAA6B,SAAS,I;QACjD,YAAI,YAAS,KAAT,GAAoB,IAApB,CAAoB,I;;QAEvCC,CAAAA,EAAyB;A,QAAO,OAAP,IAAO,CAAP,I;MAAM,C;QAE/BC,CAAAA,EAAmB;A,YACxBC,QAAY,IAAZA,CAAY,I;QACR,cAAS,IAAT,CAAS,IAAT,C,CAAuB;A,UACnB,KAAC,IAAD,CAAC,IAAD,C;YAAU,mC;UACd,YAAU,K;QACd,C,MACK;A,UACD,wBAAQ,IAAR,CAAQ,IAAR,I;QACJ,C;QACA,OAAO,K;MACX,C;;;;;;;;;;;kBAzCmCL,K,EAAaC,I,EAAYC,I;;QAAA,gB;kBACvB,I;;QAAA,WC6BK,wBD7BV,IC6BU,C;QD5BX,YAAI,YAAO,CAAP,GAAU,mCAAS,IAAT,MAAV,GAA6B,mCAAS,IAAT,M;oBACxC,I;;QAAI,c;;kBC2Bc,wBD3BL,KC2BK,C;;kBD3BW,I,CAAA,I;;QAA7B,kB;;QAEfC,CAAAA,EAAyB;A,QAAO,OAAP,IAAO,CAAP,I;MAAM,C;QAE/BG,CAAAA,EAAqB;A,YAC1BD,QAAY,IAAZA,CAAY,I;QACR,cAAS,IAAT,CAAS,IAAT,C,CAAuB;A,UACnB,KAAC,IAAD,CAAC,IAAD,C;YAAU,mC;UACd,YAAU,K;QACd,C,MACK;A,UACD,wBAAQ,IAAR,CAAQ,IAAR,I;QACJ,C;QACA,OAAa,aAAN,KAAM,C;MACjB,C;;;;;;;;;;;"}

package/kotlin-kotlin-stdlib/kotlin/ranges/Progressions.mjs

@@ -0,0 +1,163 @@
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../exceptions.mjs';
+import { getProgressionLastElement2w30kdy2w5nkt as getProgressionLastElement } from '../internal/progressionUtil.mjs';
+import {
+  IntProgressionIterator2ovd1ctrmu51n as IntProgressionIterator,
+  CharProgressionIterator34nq4ujuknl08 as CharProgressionIterator,
+} from './ProgressionIterators.mjs';
+import {
+  Char__toInt_impl_vasixd1agw9q2fuvclj as Char__toInt_impl_vasixd,
+  Char__compareTo_impl_ypi4mbdrkik40uwhqc as Char__compareTo_impl_ypi4mb,
+  toString3o7ifthqydp6e as toString,
+} from '../Char.mjs';
+import { numberToChar93r9buh19yek as numberToChar } from '../js/numberConversion.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+//endregion
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      b2(rangeStart, rangeEnd, step) {
+        return new (IntProgression())(rangeStart, rangeEnd, step);
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  return Companion_instance;
+}
+var IntProgressionClass;
+function IntProgression() {
+  if (IntProgressionClass === VOID) {
+    class $ {
+      constructor(start, endInclusive, step) {
+        if (step === 0)
+          throw IllegalArgumentException().i1('Step must be non-zero.');
+        if (step === -2147483648)
+          throw IllegalArgumentException().i1('Step must be greater than Int.MIN_VALUE to avoid overflow on negation.');
+        this.c2_1 = start;
+        this.d2_1 = getProgressionLastElement(start, endInclusive, step);
+        this.e2_1 = step;
+      }
+      k1() {
+        return new (IntProgressionIterator())(this.c2_1, this.d2_1, this.e2_1);
+      }
+      o() {
+        return this.e2_1 > 0 ? this.c2_1 > this.d2_1 : this.c2_1 < this.d2_1;
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof IntProgression()) {
+          tmp = this.o() && other.o() || (this.c2_1 === other.c2_1 && this.d2_1 === other.d2_1 && this.e2_1 === other.e2_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return this.o() ? -1 : imul(31, imul(31, this.c2_1) + this.d2_1 | 0) + this.e2_1 | 0;
+      }
+      toString() {
+        return this.e2_1 > 0 ? '' + this.c2_1 + '..' + this.d2_1 + ' step ' + this.e2_1 : '' + this.c2_1 + ' downTo ' + this.d2_1 + ' step ' + (-this.e2_1 | 0);
+      }
+    }
+    initMetadataForClass($, 'IntProgression');
+    IntProgressionClass = $;
+  }
+  return IntProgressionClass;
+}
+var CompanionClass_0;
+function Companion_0() {
+  if (CompanionClass_0 === VOID) {
+    class $ {}
+    initMetadataForCompanion($);
+    CompanionClass_0 = $;
+  }
+  return CompanionClass_0;
+}
+var Companion_instance_0;
+function Companion_getInstance_0() {
+  return Companion_instance_0;
+}
+var CharProgressionClass;
+function CharProgression() {
+  if (CharProgressionClass === VOID) {
+    class $ {
+      constructor(start, endInclusive, step) {
+        if (step === 0)
+          throw IllegalArgumentException().i1('Step must be non-zero.');
+        if (step === -2147483648)
+          throw IllegalArgumentException().i1('Step must be greater than Int.MIN_VALUE to avoid overflow on negation.');
+        this.im_1 = start;
+        var tmp = this;
+        // Inline function 'kotlin.code' call
+        var tmp_0 = Char__toInt_impl_vasixd(start);
+        // Inline function 'kotlin.code' call
+        var tmp$ret$1 = Char__toInt_impl_vasixd(endInclusive);
+        tmp.jm_1 = numberToChar(getProgressionLastElement(tmp_0, tmp$ret$1, step));
+        this.km_1 = step;
+      }
+      k1() {
+        return new (CharProgressionIterator())(this.im_1, this.jm_1, this.km_1);
+      }
+      o() {
+        return this.km_1 > 0 ? Char__compareTo_impl_ypi4mb(this.im_1, this.jm_1) > 0 : Char__compareTo_impl_ypi4mb(this.im_1, this.jm_1) < 0;
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof CharProgression()) {
+          tmp = this.o() && other.o() || (this.im_1 === other.im_1 && this.jm_1 === other.jm_1 && this.km_1 === other.km_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        var tmp;
+        if (this.o()) {
+          tmp = -1;
+        } else {
+          // Inline function 'kotlin.code' call
+          var this_0 = this.im_1;
+          var tmp$ret$0 = Char__toInt_impl_vasixd(this_0);
+          var tmp_0 = imul(31, tmp$ret$0);
+          // Inline function 'kotlin.code' call
+          var this_1 = this.jm_1;
+          var tmp$ret$1 = Char__toInt_impl_vasixd(this_1);
+          tmp = imul(31, tmp_0 + tmp$ret$1 | 0) + this.km_1 | 0;
+        }
+        return tmp;
+      }
+      toString() {
+        return this.km_1 > 0 ? toString(this.im_1) + '..' + toString(this.jm_1) + ' step ' + this.km_1 : toString(this.im_1) + ' downTo ' + toString(this.jm_1) + ' step ' + (-this.km_1 | 0);
+      }
+    }
+    initMetadataForClass($, 'CharProgression');
+    CharProgressionClass = $;
+  }
+  return CharProgressionClass;
+}
+//region block: init
+Companion_instance = new (Companion())();
+Companion_instance_0 = new (Companion_0())();
+//endregion
+//region block: exports
+export {
+  Companion_instance as Companion_instance2r6wsk1n1bbyk,
+  CharProgression as CharProgression45cqq4g7w3uj,
+  IntProgression as IntProgressionfaq59u1bhfih,
+};
+//endregion
+
+//# sourceMappingURL=Progressions.mjs.map

package/kotlin-kotlin-stdlib/kotlin/ranges/Progressions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["src/kotlin/ranges/Progressions.kt","src/kotlin/CharCode.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["fromClosedRange","rangeStart","rangeEnd","step","start","endInclusive","iterator","isEmpty","equals","other","hashCode","toString"],"mappings":"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"}

package/kotlin-kotlin-stdlib/kotlin/ranges/Range.mjs

@@ -0,0 +1,26 @@
+import { compareTo3ankvs086tmwq as compareTo } from '../js/compareTo.mjs';
+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
+function contains(value) {
+  return compareTo(value, this.p()) >= 0 && compareTo(value, this.q()) <= 0;
+}
+var ClosedRangeClass;
+function ClosedRange() {
+  if (ClosedRangeClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'ClosedRange');
+    ClosedRangeClass = $;
+  }
+  return ClosedRangeClass;
+}
+//region block: exports
+export {
+  ClosedRange as ClosedRangehokgr73im9z3,
+};
+//endregion
+
+//# sourceMappingURL=Range.mjs.map

package/kotlin-kotlin-stdlib/kotlin/ranges/Range.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["src/kotlin/ranges/Range.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["contains","value"],"mappings":";;;;;;;iBA+BoBA,CAAaC,KAAbD,EAAkC;A,EAAuC,OAAvC,iBAAS,QAAT,MAAuC,IAArB,iBAAS,QAAT,M;AAAoB,C;;;;;;;;;;;;;;"}

package/kotlin-kotlin-stdlib/kotlin/ranges/Ranges.mjs

@@ -0,0 +1,17 @@
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../exceptions.mjs';
+import { toString1pkumu07cwy4m as toString } from '../js/coreRuntime.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function checkStepIsPositive(isPositive, step) {
+  if (!isPositive)
+    throw IllegalArgumentException().i1('Step must be positive, was: ' + toString(step) + '.');
+}
+//region block: exports
+export {
+  checkStepIsPositive as checkStepIsPositive70940ky00dt4,
+};
+//endregion
+
+//# sourceMappingURL=Ranges.mjs.map

package/kotlin-kotlin-stdlib/kotlin/ranges/Ranges.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["src/kotlin/ranges/Ranges.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["checkStepIsPositive","isPositive","step"],"mappings":";;;;;;4BAgRSA,CAAwBC,U,EAAqBC,IAA7CF,EAA2D;A,EAC5D,KAAC,UAAD,C;IAAa,oCAAgC,8BAAhC,YAA6D,IAA7D,IAAiE,GAAjE,C;AACrB,C;;;;;"}

package/kotlin-kotlin-stdlib/kotlin/ranges/_Ranges.mjs

@@ -0,0 +1,68 @@
+import { Companion_getInstance1a3oieudzv4l4 as Companion_getInstance } from './PrimitiveRanges.mjs';
+import { numberRangeToNumber25vse2rgp6rs8 as numberRangeToNumber } from '../js/rangeTo.mjs';
+import { Companion_instance2r6wsk1n1bbyk as Companion_instance } from './Progressions.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../exceptions.mjs';
+import { checkStepIsPositive70940ky00dt4 as checkStepIsPositive } from './Ranges.mjs';
+import { convertToInty04h231mmjoh as convertToInt } from '../js/internal/longAsBigInt/longAsBigInt.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function until(_this__u8e3s4, to) {
+  if (to <= -2147483648)
+    return Companion_getInstance().a2_1;
+  return numberRangeToNumber(_this__u8e3s4, to - 1 | 0);
+}
+function downTo(_this__u8e3s4, to) {
+  return Companion_instance.b2(_this__u8e3s4, to, -1);
+}
+function coerceIn(_this__u8e3s4, minimumValue, maximumValue) {
+  if (minimumValue > maximumValue)
+    throw IllegalArgumentException().i1('Cannot coerce value to an empty range: maximum ' + maximumValue.toString() + ' is less than minimum ' + minimumValue.toString() + '.');
+  if (_this__u8e3s4 < minimumValue)
+    return minimumValue;
+  if (_this__u8e3s4 > maximumValue)
+    return maximumValue;
+  return _this__u8e3s4;
+}
+function coerceAtLeast(_this__u8e3s4, minimumValue) {
+  return _this__u8e3s4 < minimumValue ? minimumValue : _this__u8e3s4;
+}
+function coerceAtMost(_this__u8e3s4, maximumValue) {
+  return _this__u8e3s4 > maximumValue ? maximumValue : _this__u8e3s4;
+}
+function step(_this__u8e3s4, step) {
+  checkStepIsPositive(step > 0, step);
+  return Companion_instance.b2(_this__u8e3s4.c2_1, _this__u8e3s4.d2_1, _this__u8e3s4.e2_1 > 0 ? step : -step | 0);
+}
+function contains(_this__u8e3s4, value) {
+  // Inline function 'kotlin.let' call
+  var it = toIntExactOrNull(value);
+  return !(it == null) ? _this__u8e3s4.f2(it) : false;
+}
+function toIntExactOrNull(_this__u8e3s4) {
+  return (-2147483648n <= _this__u8e3s4 ? _this__u8e3s4 <= 2147483647n : false) ? convertToInt(_this__u8e3s4) : null;
+}
+function coerceIn_0(_this__u8e3s4, minimumValue, maximumValue) {
+  if (minimumValue > maximumValue)
+    throw IllegalArgumentException().i1('Cannot coerce value to an empty range: maximum ' + maximumValue + ' is less than minimum ' + minimumValue + '.');
+  if (_this__u8e3s4 < minimumValue)
+    return minimumValue;
+  if (_this__u8e3s4 > maximumValue)
+    return maximumValue;
+  return _this__u8e3s4;
+}
+//region block: exports
+export {
+  coerceAtLeast as coerceAtLeast2bkz8m9ik7hep,
+  coerceAtMost as coerceAtMost322komnqp70ag,
+  coerceIn_0 as coerceIn10f36k81le1mm,
+  coerceIn as coerceIn302bduskdb54x,
+  contains as contains2c50nlxg7en7o,
+  downTo as downTo39qhfeycepm1j,
+  step as step18s9qzr5xwxat,
+  until as until1jbpn0z3f8lbg,
+};
+//endregion
+
+//# sourceMappingURL=_Ranges.mjs.map