@continuous-excellence/coupling-cli 0.0.0

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

@@ -0,0 +1,102 @@
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../exceptions.mjs';
+import { toString1pkumu07cwy4m as toString } from '../js/coreRuntime.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../Unit.mjs';
+import { Long2qws0ah9gnpki as Long } from '../Primitives.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.pp_1 | $this.qp_1 | $this.rp_1 | $this.sp_1 | $this.tp_1) === 0)) {
+    var message = 'Initial state must have at least one non-zero element.';
+    throw IllegalArgumentException().r2(toString(message));
+  }
+}
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance = this;
+        this.wp_1 = new (Long())(0, 0);
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  if (Companion_instance === VOID)
+    new (Companion())();
+  return Companion_instance;
+}
+var XorWowRandomClass;
+function XorWowRandom() {
+  if (XorWowRandomClass === VOID) {
+    class $ extends Random() {
+      static xp(x, y, z, w, v, addend) {
+        Companion_getInstance();
+        var $this = this.hp();
+        $this.pp_1 = x;
+        $this.qp_1 = y;
+        $this.rp_1 = z;
+        $this.sp_1 = w;
+        $this.tp_1 = v;
+        $this.up_1 = addend;
+        checkInvariants($this);
+        // Inline function 'kotlin.repeat' call
+        var inductionVariable = 0;
+        if (inductionVariable < 64)
+          do {
+            var index = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            $this.gm();
+          }
+           while (inductionVariable < 64);
+        return $this;
+      }
+      static vp(seed1, seed2) {
+        Companion_getInstance();
+        return this.xp(seed1, seed2, 0, 0, ~seed1, seed1 << 10 ^ (seed2 >>> 4 | 0));
+      }
+      gm() {
+        var t = this.pp_1;
+        t = t ^ (t >>> 2 | 0);
+        this.pp_1 = this.qp_1;
+        this.qp_1 = this.rp_1;
+        this.rp_1 = this.sp_1;
+        var v0 = this.tp_1;
+        this.sp_1 = v0;
+        t = t ^ t << 1 ^ v0 ^ v0 << 4;
+        this.tp_1 = t;
+        this.up_1 = this.up_1 + 362437 | 0;
+        return t + this.up_1 | 0;
+      }
+      ip(bitCount) {
+        return takeUpperBits(this.gm(), bitCount);
+      }
+    }
+    initMetadataForClass($, 'XorWowRandom');
+    XorWowRandomClass = $;
+  }
+  return XorWowRandomClass;
+}
+//region block: exports
+export {
+  XorWowRandom as XorWowRandom4dcuf9lla8j1,
+};
+//endregion
+
+//# sourceMappingURL=XorWowRandom.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/random/src/kotlin/random/XorWowRandom.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/random/src/kotlin/util/Preconditions.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/random/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,8B;;;;;;;;;;;;;;;;;;gBA5CvCC,C,EACAC,C,EACAC,C,EACAC,C,EACAC,C,EACAC,M;QANZ,uB;;QACI,c;QACA,c;QACA,c;QACA,c;QACA,c;QACA,mB;QAOI,sB;;YEiIU,qB;QAAd,wBF9HW,EE8HX,C;aAAA;A,gBAAKC,QAAS,iB;YAAA,6C;YF9HW,U;;UE8HzB,4BF9HW,EE8HX,C;;;gBFrIqBC,K,EAAYC,K;QATrC,uB;uBAUiB,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-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__6a9atx1csff5kwtduxl as _Char___init__impl__6a9atx,
+  Char19o2r8palgjof as Char,
+  Char__compareTo_impl_ypi4mb3frsmupst9pih as Char__compareTo_impl_ypi4mb,
+  Char__toInt_impl_vasixd3jl92hthlhyn7 as Char__toInt_impl_vasixd,
+  toString3dhdjl9yf50de 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.h3_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);
+      }
+      l2() {
+        return this.j3_1;
+      }
+      m2() {
+        return this.k3_1;
+      }
+      yp(value) {
+        return this.j3_1 <= value && value <= this.k3_1;
+      }
+      m3(value) {
+        return this.yp(typeof value === 'number' ? value : THROW_CCE());
+      }
+      o1() {
+        return this.j3_1 > this.k3_1;
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof IntRange()) {
+          tmp = this.o1() && other.o1() || (this.j3_1 === other.j3_1 && this.k3_1 === other.k3_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return this.o1() ? -1 : imul(31, this.j3_1) + this.k3_1 | 0;
+      }
+      toString() {
+        return '' + this.j3_1 + '..' + this.k3_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.zp_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);
+      }
+      dq() {
+        return this.eq_1;
+      }
+      l2() {
+        return new (Char())(this.dq());
+      }
+      hq() {
+        return this.fq_1;
+      }
+      m2() {
+        return new (Char())(this.hq());
+      }
+      iq(value) {
+        return Char__compareTo_impl_ypi4mb(this.eq_1, value) <= 0 && Char__compareTo_impl_ypi4mb(value, this.fq_1) <= 0;
+      }
+      m3(value) {
+        return this.iq(value instanceof Char() ? value.x3_1 : THROW_CCE());
+      }
+      o1() {
+        return Char__compareTo_impl_ypi4mb(this.eq_1, this.fq_1) > 0;
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof CharRange()) {
+          tmp = this.o1() && other.o1() || (this.eq_1 === other.eq_1 && this.fq_1 === other.fq_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        var tmp;
+        if (this.o1()) {
+          tmp = -1;
+        } else {
+          // Inline function 'kotlin.code' call
+          var this_0 = this.eq_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.fq_1;
+          tmp = tmp_0 + Char__toInt_impl_vasixd(this_1) | 0;
+        }
+        return tmp;
+      }
+      toString() {
+        return toString(this.eq_1) + '..' + toString(this.fq_1);
+      }
+    }
+    initMetadataForClass($, 'CharRange', VOID, VOID, [CharProgression(), ClosedRange()]);
+    CharRangeClass = $;
+  }
+  return CharRangeClass;
+}
+//region block: exports
+export {
+  Companion_getInstance as Companion_getInstance31iu7m2vf5l9b,
+  CharRange as CharRange1dt3801jgpja5,
+  IntRange as IntRange1cx8zvxgibbj2,
+};
+//endregion
+
+//# sourceMappingURL=PrimitiveRanges.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/ranges/src/kotlin/ranges/PrimitiveRanges.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/ranges/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;;QAC/DC,CAAAA,EAAQ;A,QAAK,OAAL,IAAK,CAAL,I;MAAI,C;QACLC,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;;;QAkDxEC,CAAAA,EAAyB;A,QAAY,OAAZ,YAAQ,IAAR,CAAQ,I;MAAG,C;YAEpCC,CAAWC,KAAXD,EACL;A;QAAA,gC;gBAAsB,S,IAAa,KAAM,K,KACzC,cAAS,KAAT,CAAe,I,IAAS,cAAQ,KAAR,CAAc,I;;gBADhB,K;;QACqB,U;MAAD,C;cAErCE,CAAAA,EACL;A,QAA0C,OAAtC,YAAW,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;;;QAWxEC,CAAAA,EAAyB;A,QAAY,OAAZ,uCAAQ,IAAR,CAAQ,IAAR,K;MAAW,C;YAEpCC,CAAWC,KAAXD,EACL;A;QAAA,iC;gBAAuB,S,IAAa,KAAM,K,KAC1C,cAAS,KAAT,CAAe,I,IAAS,cAAQ,KAAR,CAAc,I;;gBADf,K;;QACoB,U;MAAD,C;cAErCE,CAAAA,EACL;A;QAAI,c;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-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_vasixd3jl92hthlhyn7 as Char__toInt_impl_vasixd,
+  Char__compareTo_impl_ypi4mb3frsmupst9pih 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.jq_1 = step;
+        this.kq_1 = last;
+        this.lq_1 = this.jq_1 > 0 ? first <= last : first >= last;
+        this.mq_1 = this.lq_1 ? first : this.kq_1;
+      }
+      r1() {
+        return this.lq_1;
+      }
+      gm() {
+        var value = this.mq_1;
+        if (value === this.kq_1) {
+          if (!this.lq_1)
+            throw NoSuchElementException().w6();
+          this.lq_1 = false;
+        } else {
+          this.mq_1 = this.mq_1 + this.jq_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.nq_1 = step;
+        var tmp = this;
+        // Inline function 'kotlin.code' call
+        tmp.oq_1 = Char__toInt_impl_vasixd(last);
+        this.pq_1 = this.nq_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.pq_1) {
+          // Inline function 'kotlin.code' call
+          tmp_1 = Char__toInt_impl_vasixd(first);
+        } else {
+          tmp_1 = this.oq_1;
+        }
+        tmp_0.qq_1 = tmp_1;
+      }
+      r1() {
+        return this.pq_1;
+      }
+      im() {
+        var value = this.qq_1;
+        if (value === this.oq_1) {
+          if (!this.pq_1)
+            throw NoSuchElementException().w6();
+          this.pq_1 = false;
+        } else {
+          this.qq_1 = this.qq_1 + this.nq_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-kotlin-stdlib/kotlin/ranges/ProgressionIterators.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/ranges/src/kotlin/ranges/ProgressionIterators.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/ranges/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-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_vasixd3jl92hthlhyn7 as Char__toInt_impl_vasixd,
+  Char__compareTo_impl_ypi4mb3frsmupst9pih as Char__compareTo_impl_ypi4mb,
+  toString3dhdjl9yf50de 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 $ {
+      i3(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().r2('Step must be non-zero.');
+        if (step === -2147483648)
+          throw IllegalArgumentException().r2('Step must be greater than Int.MIN_VALUE to avoid overflow on negation.');
+        this.j3_1 = start;
+        this.k3_1 = getProgressionLastElement(start, endInclusive, step);
+        this.l3_1 = step;
+      }
+      q1() {
+        return new (IntProgressionIterator())(this.j3_1, this.k3_1, this.l3_1);
+      }
+      o1() {
+        return this.l3_1 > 0 ? this.j3_1 > this.k3_1 : this.j3_1 < this.k3_1;
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof IntProgression()) {
+          tmp = this.o1() && other.o1() || (this.j3_1 === other.j3_1 && this.k3_1 === other.k3_1 && this.l3_1 === other.l3_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return this.o1() ? -1 : imul(31, imul(31, this.j3_1) + this.k3_1 | 0) + this.l3_1 | 0;
+      }
+      toString() {
+        return this.l3_1 > 0 ? '' + this.j3_1 + '..' + this.k3_1 + ' step ' + this.l3_1 : '' + this.j3_1 + ' downTo ' + this.k3_1 + ' step ' + (-this.l3_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().r2('Step must be non-zero.');
+        if (step === -2147483648)
+          throw IllegalArgumentException().r2('Step must be greater than Int.MIN_VALUE to avoid overflow on negation.');
+        this.eq_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.fq_1 = numberToChar(getProgressionLastElement(tmp_0, tmp$ret$1, step));
+        this.gq_1 = step;
+      }
+      q1() {
+        return new (CharProgressionIterator())(this.eq_1, this.fq_1, this.gq_1);
+      }
+      o1() {
+        return this.gq_1 > 0 ? Char__compareTo_impl_ypi4mb(this.eq_1, this.fq_1) > 0 : Char__compareTo_impl_ypi4mb(this.eq_1, this.fq_1) < 0;
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof CharProgression()) {
+          tmp = this.o1() && other.o1() || (this.eq_1 === other.eq_1 && this.fq_1 === other.fq_1 && this.gq_1 === other.gq_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        var tmp;
+        if (this.o1()) {
+          tmp = -1;
+        } else {
+          // Inline function 'kotlin.code' call
+          var this_0 = this.eq_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.fq_1;
+          var tmp$ret$1 = Char__toInt_impl_vasixd(this_1);
+          tmp = imul(31, tmp_0 + tmp$ret$1 | 0) + this.gq_1 | 0;
+        }
+        return tmp;
+      }
+      toString() {
+        return this.gq_1 > 0 ? toString(this.eq_1) + '..' + toString(this.fq_1) + ' step ' + this.gq_1 : toString(this.eq_1) + ' downTo ' + toString(this.fq_1) + ' step ' + (-this.gq_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_instancern8rzmk6pk4a,
+  CharProgression as CharProgression45cqq4g7w3uj,
+  IntProgression as IntProgressionfaq59u1bhfih,
+};
+//endregion
+
+//# sourceMappingURL=Progressions.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/ranges/src/kotlin/ranges/Progressions.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/ranges/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-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.l2()) >= 0 && compareTo(value, this.m2()) <= 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-kotlin-stdlib/kotlin/ranges/Range.mjs.map

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

package/kotlin/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().r2('Step must be positive, was: ' + toString(step) + '.');
+}
+//region block: exports
+export {
+  checkStepIsPositive as checkStepIsPositive70940ky00dt4,
+};
+//endregion
+
+//# sourceMappingURL=Ranges.mjs.map

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

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