@continuous-excellence/coupling-cli 0.0.0

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

@@ -0,0 +1,98 @@
+import { Companion_getInstance31iu7m2vf5l9b as Companion_getInstance } from './PrimitiveRanges.mjs';
+import { numberRangeToNumber25vse2rgp6rs8 as numberRangeToNumber } from '../js/rangeTo.mjs';
+import { Companion_instancern8rzmk6pk4a as Companion_instance } from './Progressions.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../exceptions.mjs';
+import {
+  compare2uud5j30pw5xc as compare,
+  convertToIntofdoxh9bstof as convertToInt,
+} from '../js/internal/boxedLong/boxedLong.mjs';
+import { checkStepIsPositive70940ky00dt4 as checkStepIsPositive } from './Ranges.mjs';
+import { Long2qws0ah9gnpki as Long } from '../Primitives.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function until(_this__u8e3s4, to) {
+  if (to <= -2147483648)
+    return Companion_getInstance().h3_1;
+  return numberRangeToNumber(_this__u8e3s4, to - 1 | 0);
+}
+function downTo(_this__u8e3s4, to) {
+  return Companion_instance.i3(_this__u8e3s4, to, -1);
+}
+function coerceIn(_this__u8e3s4, minimumValue, maximumValue) {
+  if (compare(minimumValue, maximumValue) > 0)
+    throw IllegalArgumentException().r2('Cannot coerce value to an empty range: maximum ' + maximumValue.toString() + ' is less than minimum ' + minimumValue.toString() + '.');
+  if (compare(_this__u8e3s4, minimumValue) < 0)
+    return minimumValue;
+  if (compare(_this__u8e3s4, maximumValue) > 0)
+    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.i3(_this__u8e3s4.j3_1, _this__u8e3s4.k3_1, _this__u8e3s4.l3_1 > 0 ? step : -step | 0);
+}
+function coerceIn_0(_this__u8e3s4, minimumValue, maximumValue) {
+  if (minimumValue > maximumValue)
+    throw IllegalArgumentException().r2('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;
+}
+function coerceAtLeast_0(_this__u8e3s4, minimumValue) {
+  return _this__u8e3s4 < minimumValue ? minimumValue : _this__u8e3s4;
+}
+function coerceAtLeast_1(_this__u8e3s4, minimumValue) {
+  return _this__u8e3s4 < minimumValue ? minimumValue : _this__u8e3s4;
+}
+function coerceIn_1(_this__u8e3s4, minimumValue, maximumValue) {
+  if (minimumValue > maximumValue)
+    throw IllegalArgumentException().r2('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;
+}
+function coerceAtLeast_2(_this__u8e3s4, minimumValue) {
+  return compare(_this__u8e3s4, minimumValue) < 0 ? minimumValue : _this__u8e3s4;
+}
+function contains(_this__u8e3s4, value) {
+  // Inline function 'kotlin.let' call
+  var it = toIntExactOrNull(value);
+  return !(it == null) ? _this__u8e3s4.m3(it) : false;
+}
+function toIntExactOrNull(_this__u8e3s4) {
+  return (compare(new (Long())(-2147483648, -1), _this__u8e3s4) <= 0 ? compare(_this__u8e3s4, new (Long())(2147483647, 0)) <= 0 : false) ? convertToInt(_this__u8e3s4) : null;
+}
+function coerceAtMost_0(_this__u8e3s4, maximumValue) {
+  return compare(_this__u8e3s4, maximumValue) > 0 ? maximumValue : _this__u8e3s4;
+}
+//region block: exports
+export {
+  coerceAtLeast_0 as coerceAtLeastklytehohcpeq,
+  coerceAtLeast_2 as coerceAtLeast3qxv4gros2xti,
+  coerceAtLeast as coerceAtLeast2bkz8m9ik7hep,
+  coerceAtLeast_1 as coerceAtLeast1b3m6f7g22ivr,
+  coerceAtMost_0 as coerceAtMostmgknbongtqt,
+  coerceAtMost as coerceAtMost322komnqp70ag,
+  coerceIn_0 as coerceInlzh524ulyz3c,
+  coerceIn_1 as coerceIn10f36k81le1mm,
+  coerceIn as coerceIn302bduskdb54x,
+  contains as contains2c50nlxg7en7o,
+  downTo as downTo39qhfeycepm1j,
+  step as step18s9qzr5xwxat,
+  until as until1jbpn0z3f8lbg,
+};
+//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/common/src/generated/_Ranges.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["until","<this>","to","downTo","coerceIn","minimumValue","maximumValue","coerceAtLeast","coerceAtMost","step","contains","value","toIntExactOrNull"],"mappings":";;;;;;;;;;;;;;cAwmCaA,CAAIC,a,EAAUC,EAAdF,EAAiC;A,EACtC,UAAU,WAAV,C;IAAqB,+BAAgB,I;EACzC,OAAO,mCAAS,KAAK,CAAd,K;AACX,C;eAzSaG,CAAIF,a,EAAWC,EAAfC,EAAwC;A,EACjD,OAAsB,sBAAgB,aAAhB,EAAsB,EAAtB,EAA0B,EAA1B,C;AAC1B,C;iBAinBOC,CAAIH,a,EAAcI,Y,EAAoBC,YAAtCF,EAAgE;A,EAC/D,0BAAe,YAAf,M;IAA6B,oCAAgC,iDAAhC,GAAgF,YAAhF,cAA4F,wBAA5F,GAAmH,YAAnH,cAA+H,GAA/H,C;EAC7B,2BAAO,YAAP,M;IAAqB,OAAO,Y;EAC5B,2BAAO,YAAP,M;IAAqB,OAAO,Y;EAChC,OAAO,a;AACX,C;sBA5LOG,CAAIN,a,EAAkBI,YAAtBE,EAA8C;A,EACjD,OAAW,gBAAO,YAAP,GAAqB,YAArB,GAAuC,a;AACtD,C;qBA2EOC,CAAIP,a,EAAiBK,YAArBE,EAA6C;A,EAChD,OAAW,gBAAO,YAAP,GAAqB,YAArB,GAAuC,a;AACtD,C;aAzWaC,CAAIR,a,EAAoBQ,IAAxBA,EAAmD;A,EAC5D,oBAAoB,OAAO,CAA3B,EAA8B,IAA9B,C;EACA,OAAsB,sBAAgB,aAAhB,CAAgB,IAAhB,EAAuB,aAAvB,CAAuB,IAAvB,EAAiC,cAAK,IAAL,GAAY,CAAZ,GAAe,IAAf,GAAyB,CAAC,IAA1B,IAAjC,C;AAC1B,C;mBA4dOL,CAAIH,a,EAAeI,Y,EAAqBC,YAAxCF,EAAoE;A,EACnE,mBAAe,YAAf,C;IAA6B,oCAAgC,iDAAhC,GAAgF,YAAhF,GAA4F,wBAA5F,GAAmH,YAAnH,GAA+H,GAA/H,C;EAC7B,oBAAO,YAAP,C;IAAqB,OAAO,Y;EAC5B,oBAAO,YAAP,C;IAAqB,OAAO,Y;EAChC,OAAO,a;AACX,C;wBAzKOG,CAAIN,a,EAAqBI,YAAzBE,EAAuD;A,EAC1D,OAAW,gBAAO,YAAP,GAAqB,YAArB,GAAuC,a;AACtD,C;wBAbOA,CAAIN,a,EAAoBI,YAAxBE,EAAoD;A,EACvD,OAAW,gBAAO,YAAP,GAAqB,YAArB,GAAuC,a;AACtD,C;mBAiJOH,CAAIH,a,EAAaI,Y,EAAmBC,YAApCF,EAA4D;A,EAC3D,mBAAe,YAAf,C;IAA6B,oCAAgC,iDAAhC,GAAgF,YAAhF,GAA4F,wBAA5F,GAAmH,YAAnH,GAA+H,GAA/H,C;EAC7B,oBAAO,YAAP,C;IAAqB,OAAO,Y;EAC5B,oBAAO,YAAP,C;IAAqB,OAAO,Y;EAChC,OAAO,a;AACX,C;wBAnKOG,CAAIN,a,EAAmBI,YAAvBE,EAAiD;A,EACpD,OAAW,uBAAO,YAAP,QAAqB,YAArB,GAAuC,a;AACtD,C;iBArrBgBG,CAAIT,a,EAA0BU,KAA9BD,EAAoD;A;WACnD,iBAAN,KAAM,C;EAAb,OAA0C,QAAM,IAAN,CAAJ,GAAgB,iBAAS,EAAT,CAAhB,GAAkC,K;AAC5E,C;yBAybSE,CAAIX,aAAJW,EAAkC;A,EACvC,OAAW,sBAAsB,WAAtB,EAAsB,EAAtB,6DAA8C,UAA9C,EAA8C,CAA9C,mBAA6D,aAAL,aAAK,CAA7D,GAA0E,I;AACzF,C;uBAmUOJ,CAAIP,a,EAAkBK,YAAtBE,EAAgD;A,EACnD,OAAW,uBAAO,YAAP,QAAqB,YAArB,GAAuC,a;AACtD,C;;;;;"}

package/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/KClassJs.mjs

@@ -0,0 +1,22 @@
+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 KClassClass;
+function KClass() {
+  if (KClassClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'KClass');
+    KClassClass = $;
+  }
+  return KClassClass;
+}
+//region block: exports
+export {
+  KClass as KClass1cc9rfeybg8hs,
+};
+//endregion
+
+//# sourceMappingURL=KClassJs.mjs.map

package/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/KClassJs.mjs.map

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

package/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/KPropertyJs.mjs

@@ -0,0 +1,42 @@
+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 KProperty1Class;
+function KProperty1() {
+  if (KProperty1Class === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'KProperty1');
+    KProperty1Class = $;
+  }
+  return KProperty1Class;
+}
+var KProperty0Class;
+function KProperty0() {
+  if (KProperty0Class === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'KProperty0');
+    KProperty0Class = $;
+  }
+  return KProperty0Class;
+}
+var KMutableProperty1Class;
+function KMutableProperty1() {
+  if (KMutableProperty1Class === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'KMutableProperty1', VOID, VOID, [KProperty1()]);
+    KMutableProperty1Class = $;
+  }
+  return KMutableProperty1Class;
+}
+//region block: exports
+export {
+  KMutableProperty1 as KMutableProperty11e8g1gb0ecb9j,
+  KProperty0 as KProperty02ce7r476m8633,
+  KProperty1 as KProperty1ca4yb4wlo496,
+};
+//endregion
+
+//# sourceMappingURL=KPropertyJs.mjs.map

package/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/KPropertyJs.mjs.map

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

package/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/KTypeImpl.mjs

@@ -0,0 +1,123 @@
+import {
+  equals2au1ep9vhcato as equals,
+  hashCodeq5arwsb9dgti as hashCode,
+  getBooleanHashCode1bbj3u6b3v0a7 as getBooleanHashCode,
+} from '../js/coreRuntime.mjs';
+import { KTypeParameter1s8efufd4mbj5 as KTypeParameter } from './KTypeParameter.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../js/typeCheckUtils.mjs';
+import { KClass1cc9rfeybg8hs as KClass } from './KClassJs.mjs';
+import { StringBuildermazzzhj6kkai as StringBuilder } from '../text/StringBuilderJs.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../Unit.mjs';
+import { _Char___init__impl__6a9atx1csff5kwtduxl as _Char___init__impl__6a9atx } from '../Char.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+//endregion
+var KTypeImplClass;
+function KTypeImpl() {
+  if (KTypeImplClass === VOID) {
+    class $ {
+      constructor(classifier, arguments_0, isMarkedNullable) {
+        this.c1_1 = classifier;
+        this.d1_1 = arguments_0;
+        this.e1_1 = isMarkedNullable;
+      }
+      f1() {
+        return this.c1_1;
+      }
+      g1() {
+        return this.d1_1;
+      }
+      h1() {
+        return this.e1_1;
+      }
+      equals(other) {
+        var tmp;
+        var tmp_0;
+        var tmp_1;
+        if (other instanceof KTypeImpl()) {
+          tmp_1 = equals(this.c1_1, other.c1_1);
+        } else {
+          tmp_1 = false;
+        }
+        if (tmp_1) {
+          tmp_0 = equals(this.d1_1, other.d1_1);
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp = this.e1_1 === other.e1_1;
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        // Inline function 'kotlin.hashCode' call
+        var tmp0_safe_receiver = this.c1_1;
+        var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode(tmp0_safe_receiver);
+        var tmp$ret$0 = tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+        return imul(imul(tmp$ret$0, 31) + hashCode(this.d1_1) | 0, 31) + getBooleanHashCode(this.e1_1) | 0;
+      }
+      toString() {
+        var tmp0_subject = this.c1_1;
+        var tmp;
+        if (!(tmp0_subject == null) ? isInterface(tmp0_subject, KClass()) : false) {
+          var tmp1_elvis_lhs = this.c1_1.j1();
+          tmp = tmp1_elvis_lhs == null ? this.c1_1.k1() : tmp1_elvis_lhs;
+        } else {
+          if (!(tmp0_subject == null) ? isInterface(tmp0_subject, KTypeParameter()) : false) {
+            tmp = this.c1_1.i1();
+          } else {
+            tmp = null;
+          }
+        }
+        var tmp2_elvis_lhs = tmp;
+        var tmp_0;
+        if (tmp2_elvis_lhs == null) {
+          return '???';
+        } else {
+          tmp_0 = tmp2_elvis_lhs;
+        }
+        var classifierString = tmp_0;
+        // Inline function 'kotlin.text.buildString' call
+        // Inline function 'kotlin.apply' call
+        var this_0 = StringBuilder().m1();
+        this_0.n1(classifierString);
+        // Inline function 'kotlin.collections.isNotEmpty' call
+        if (!this.d1_1.o1()) {
+          this_0.p1(_Char___init__impl__6a9atx(60));
+          var iterator = this.d1_1.q1();
+          var index = 0;
+          while (iterator.r1()) {
+            var index_0 = index;
+            index = index + 1 | 0;
+            var argument = iterator.s1();
+            if (index_0 > 0) {
+              this_0.n1(', ');
+            }
+            this_0.t1(argument);
+          }
+          this_0.p1(_Char___init__impl__6a9atx(62));
+        }
+        if (this.e1_1) {
+          this_0.p1(_Char___init__impl__6a9atx(63));
+        }
+        return this_0.toString();
+      }
+    }
+    initMetadataForClass($, 'KTypeImpl');
+    KTypeImplClass = $;
+  }
+  return KTypeImplClass;
+}
+//region block: exports
+export {
+  KTypeImpl as KTypeImpl24ni3lyofhkxw,
+};
+//endregion
+
+//# sourceMappingURL=KTypeImpl.mjs.map

package/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/KTypeImpl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/common-non-jvm/src/kotlin/reflect/KTypeImpl.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/src/kotlin/util/HashCode.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/src/kotlin/text/StringBuilder.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/src/kotlin/collections/Collections.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/src/kotlin/util/Standard.kt"],"sourcesContent":[null,null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["classifier","arguments","isMarkedNullable","<get-classifier>","<get-arguments>","<get-isMarkedNullable>","equals","other","hashCode","toString","classifierString","index","argument"],"mappings":";;;;;;;;;;;;;;;;;;;;;;kBAQaA,U,EACAC,W,EACAC,gB;QAFT,sB;QACA,uB;QACA,4B;;QAFSC,CAAAA,EAAA;A,QAAA,gB;MAA2B,C;QAC3BC,CAAAA,EAAA;A,QAAA,gB;MAAmC,C;QACnCC,CAAAA,EAAA;A,QAAA,gB;MAA4B,C;YAE5BC,CAAWC,KAAXD,EACL;A;;;QAAA,iC;kBACQ,kBAAc,KAAd,CAAoB,IAApB,C;;kBAAA,K;;QADR,U;kBAC0C,kBAAa,KAAb,CAAmB,IAAnB,C;;kBAAA,K;;QAD1C,U;gBAC0E,cAAoB,KAApB,CAA0B,I;;gBAA1B,K;;QAA0C,U;MAAD,C;cAE9GE,CAAAA,EACL;A;YCAiC,qBDAhC,ICAgC,CDAhC,I;YCAgC,iBAAM,6CAAN,kBAAM,C;YAAe,YAArB,yBAAoB,CAApB,iB;QDAqD,OAAtF,KAAC,KAAW,SAAX,EAAwB,EAAxB,IAAuC,SAAV,IAAU,CAAV,IAAU,CAAxC,MAAsD,EAAtD,IAA4E,mBAAjB,IAAiB,CAAjB,IAAiB,CAAU,I;MAAD,C;cAEhFC,CAAAA,EAAuB;A,YACC,wB;;QACzB,0E;cAAgB,iBAAA,IAAW,CAAX,IAAW,K;gBAAX,yBAA4B,IAAW,CAAX,IAAW,KAAvC,iB;;UAChB,kF;kBAAqB,IAAW,CAAX,IAAW,K;;kBACxB,I;;;YAHW,oB;;QAAA,2B;UAIlB,OAAO,K;;kBAJW,c;;YAAvBC,wB;;;qBEmeG,oB;QF5dC,UAAO,gBAAP,C;;QAEI,IGsN4C,CHtN5C,IGsN6C,CHtN7C,IGsN6C,KHtN7C,C,CAAwB;A,UACxB,UAAO,8BAAP,C;cAC0B,yB;cAAA,S;iBAA1B,a,EAAA;A,gBAAMC,UAAoB,K;YAAA,qB;gBAAbC,WAAa,a;YAClB,cAAQ,CAAR,C,CAAW;A,cAAA,UAAO,IAAP,C;;YACf,UAAO,QAAP,C;;UAEJ,UAAO,8BAAP,C;QACJ,C;QAEI,c,CAAkB;A,UAAA,UAAO,8BAAP,C;;QAZ1B,OI6DG,MFgaqC,W;MF/c5C,C;;;;;;;;;;;"}

package/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/KTypeParameter.mjs

@@ -0,0 +1,22 @@
+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 KTypeParameterClass;
+function KTypeParameter() {
+  if (KTypeParameterClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'KTypeParameter');
+    KTypeParameterClass = $;
+  }
+  return KTypeParameterClass;
+}
+//region block: exports
+export {
+  KTypeParameter as KTypeParameter1s8efufd4mbj5,
+};
+//endregion
+
+//# sourceMappingURL=KTypeParameter.mjs.map

package/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/KTypeParameter.mjs.map

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

package/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/KTypeParameterBase.mjs

@@ -0,0 +1,63 @@
+import { noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException } from '../hacks.mjs';
+import { getStringHashCode26igk1bx568vk as getStringHashCode } from '../js/coreRuntime.mjs';
+import { KTypeParameter1s8efufd4mbj5 as KTypeParameter } from './KTypeParameter.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+//endregion
+var KTypeParameterBaseClass;
+function KTypeParameterBase() {
+  if (KTypeParameterBaseClass === VOID) {
+    class $ {
+      toString() {
+        var tmp;
+        switch (this.v1().x1_1) {
+          case 0:
+            tmp = '';
+            break;
+          case 1:
+            tmp = 'in ';
+            break;
+          case 2:
+            tmp = 'out ';
+            break;
+          default:
+            noWhenBranchMatchedException();
+            break;
+        }
+        return tmp + this.i1();
+      }
+      equals(other) {
+        var tmp;
+        var tmp_0;
+        if (other instanceof KTypeParameterBase()) {
+          tmp_0 = this.i1() === other.i1();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp = this.u1() === other.u1();
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return imul(getStringHashCode(this.u1()), 31) + getStringHashCode(this.i1()) | 0;
+      }
+    }
+    initMetadataForClass($, 'KTypeParameterBase', VOID, VOID, [KTypeParameter()]);
+    KTypeParameterBaseClass = $;
+  }
+  return KTypeParameterBaseClass;
+}
+//region block: exports
+export {
+  KTypeParameterBase as KTypeParameterBase70dfo08xyjmg,
+};
+//endregion
+
+//# sourceMappingURL=KTypeParameterBase.mjs.map

package/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/KTypeParameterBase.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/common-non-jvm/src/kotlin/reflect/KTypeParameterBase.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["toString","equals","other","hashCode"],"mappings":";;;;;;;;;;;;;;cAUmBA,CAAAA,EAAyB;A;QAAA,QAAM,SAAN,CAAM,IAAN,C;eAC1B,C;kBAAa,E;;eACb,C;kBAAM,K;;eACN,C;kBAAO,M;;;YAHmB,8B;;;QAIhC,OAJgC,MAIpC,S;MAAG,C;YAEQC,CAAWC,KAAXD,EACX;A;;QAAA,0C;kBAA+B,cAAQ,KAAM,K;;kBAAd,K;;QAA/B,U;gBAAqD,cAAmB,KAAM,K;;gBAAzB,K;;QAAwC,U;MAAD,C;cAEjFE,CAAAA,EAAiB;A,QAAiD,OAAjD,KAAgB,kBAAhB,SAAgB,CAAhB,EAA6B,EAA7B,IAAuC,kBAAL,SAAK,CAAU,I;MAAD,C;;;;;;;;;;;"}

package/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/KTypeProjection.mjs

@@ -0,0 +1,111 @@
+import { KVariance_INVARIANT_getInstance1g63j82gx5hpl as KVariance_INVARIANT_getInstance } from './KVariance.mjs';
+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 {
+  toString1pkumu07cwy4m as toString,
+  hashCodeq5arwsb9dgti as hashCode,
+  equals2au1ep9vhcato as equals,
+} from '../js/coreRuntime.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../Unit.mjs';
+import { toString30pk9tzaqopn as toString_0 } from '../Library.mjs';
+import { noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException } from '../hacks.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.tf_1 = new (KTypeProjection())(null, null);
+      }
+      uf() {
+        return this.tf_1;
+      }
+      vf(type) {
+        return new (KTypeProjection())(KVariance_INVARIANT_getInstance(), type);
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  if (Companion_instance === VOID)
+    new (Companion())();
+  return Companion_instance;
+}
+var KTypeProjectionClass;
+function KTypeProjection() {
+  if (KTypeProjectionClass === VOID) {
+    class $ {
+      constructor(variance, type) {
+        Companion_getInstance();
+        this.rq_1 = variance;
+        this.sq_1 = type;
+        // Inline function 'kotlin.require' call
+        if (!(this.rq_1 == null === (this.sq_1 == null))) {
+          var message = this.rq_1 == null ? 'Star projection must have no type specified.' : 'The projection variance ' + this.rq_1.toString() + ' requires type to be specified.';
+          throw IllegalArgumentException().r2(toString(message));
+        }
+      }
+      toString() {
+        var tmp0_subject = this.rq_1;
+        var tmp;
+        switch (tmp0_subject == null ? -1 : tmp0_subject.x1_1) {
+          case -1:
+            tmp = '*';
+            break;
+          case 0:
+            tmp = toString_0(this.sq_1);
+            break;
+          case 1:
+            tmp = 'in ' + toString_0(this.sq_1);
+            break;
+          case 2:
+            tmp = 'out ' + toString_0(this.sq_1);
+            break;
+          default:
+            noWhenBranchMatchedException();
+            break;
+        }
+        return tmp;
+      }
+      hashCode() {
+        var result = this.rq_1 == null ? 0 : this.rq_1.hashCode();
+        result = imul(result, 31) + (this.sq_1 == null ? 0 : hashCode(this.sq_1)) | 0;
+        return result;
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof KTypeProjection()))
+          return false;
+        if (!equals(this.rq_1, other.rq_1))
+          return false;
+        if (!equals(this.sq_1, other.sq_1))
+          return false;
+        return true;
+      }
+    }
+    initMetadataForClass($, 'KTypeProjection');
+    KTypeProjectionClass = $;
+  }
+  return KTypeProjectionClass;
+}
+//region block: exports
+export {
+  Companion_getInstance as Companion_getInstance223f8btky47x5,
+};
+//endregion
+
+//# sourceMappingURL=KTypeProjection.mjs.map

package/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/KTypeProjection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/src/kotlin/reflect/KTypeProjection.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/src/kotlin/util/Preconditions.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-STAR>","invariant","type","variance","message","toString","result"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;QAuD6C,oCAAgB,IAAhB,EAAsB,IAAtB,C;;QAQJA,CAAAA,EAAQ;A,QAAI,OAAJ,IAAI,CAAJ,I;MAAG,C;QAQrCC,CAAcC,IAAdD,EACH;A,QAA0C,+BAAhB,iCAAgB,EAAL,IAAK,C;MAAD,C;;;;;;;;;;;;;;;;;kBA5C1CE,Q,EAIAD,I;QATX,uB;QAKI,oB;QAIA,gB;;QCGI,MDCS,aAAY,IAAb,MAAuB,aAAQ,IAA/B,CCDR,E,CAAQ;A,cACRE,UDCQ,aAAY,IAAhB,GACI,8CADJ,GAGK,0BAHL,GAG8B,IAH9B,CAG8B,IAH9B,cAGsC,iC;UCH1C,oCAAuC,SAAR,OAAQ,CAAvC,C;QACJ,C;;cDMSC,CAAAA,EAAyB;A,YAAM,wB;;QAAN,QAAM,6CAAN,C;eAC9B,E;kBAAQ,G;;eACE,C;kBAAkB,WAAL,IAAK,CAAL,IAAK,C;;eAClB,C;kBAAO,K,cAAI,I,CAAA,I;;eACX,C;kBAAQ,M,cAAK,I,CAAA,I;;;YAJO,8B;;;QAKjC,U;MAAD,C;iBAjDJ;A,YAAAC,qD;QAAA,6E;QAAA,a;MAAA,C;oBAAA;A,QAAA,mB;UAAA,W;QAAA,0C;UAAA,Y;QAAA,mC;UAAA,Y;QAAA,mC;UAAA,Y;QAAA,W;MAAA,C;;;;;;;;;;;"}

package/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/KVariance.mjs

@@ -0,0 +1,50 @@
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../Unit.mjs';
+import { Enum3alwj03lh1n41 as Enum } from '../Enum.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var KVariance_INVARIANT_instance;
+var KVariance_IN_instance;
+var KVariance_OUT_instance;
+var KVariance_entriesInitialized;
+function KVariance_initEntries() {
+  if (KVariance_entriesInitialized)
+    return Unit_instance;
+  KVariance_entriesInitialized = true;
+  KVariance_INVARIANT_instance = new (KVariance())('INVARIANT', 0);
+  KVariance_IN_instance = new (KVariance())('IN', 1);
+  KVariance_OUT_instance = new (KVariance())('OUT', 2);
+}
+var KVarianceClass;
+function KVariance() {
+  if (KVarianceClass === VOID) {
+    class $ extends Enum() {}
+    initMetadataForClass($, 'KVariance');
+    KVarianceClass = $;
+  }
+  return KVarianceClass;
+}
+function KVariance_INVARIANT_getInstance() {
+  KVariance_initEntries();
+  return KVariance_INVARIANT_instance;
+}
+function KVariance_IN_getInstance() {
+  KVariance_initEntries();
+  return KVariance_IN_instance;
+}
+function KVariance_OUT_getInstance() {
+  KVariance_initEntries();
+  return KVariance_OUT_instance;
+}
+//region block: exports
+export {
+  KVariance_INVARIANT_getInstance as KVariance_INVARIANT_getInstance1g63j82gx5hpl,
+  KVariance_IN_getInstance as KVariance_IN_getInstance30mmrn73xu2m7,
+  KVariance_OUT_getInstance as KVariance_OUT_getInstance3c0gn7ej9xw2l,
+};
+//endregion
+
+//# sourceMappingURL=KVariance.mjs.map

package/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/KVariance.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlin-kotlin-stdlib/kotlin/reflect/src/kotlin/reflect/KVariance.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;;;;mDAAA,W,EAAA,C;4CAAA,I,EAAA,C;6CAAA,K,EAAA,C;;;;;;;;;;;;;;;;;;;;;;;;;;;"}