@attocash/commons-js 5.0.0

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 { checkStepIsPositive70940ky00dt4 as checkStepIsPositive } from './Ranges.mjs';
+import { Companion_instance2r6wsk1n1bbyk as Companion_instance } from './Progressions.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../exceptions.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().t1_1;
+  return numberRangeToNumber(_this__u8e3s4, to - 1 | 0);
+}
+function step(_this__u8e3s4, step) {
+  checkStepIsPositive(step > 0, step);
+  return Companion_instance.x1(_this__u8e3s4.u1_1, _this__u8e3s4.v1_1, _this__u8e3s4.w1_1 > 0 ? step : -step | 0);
+}
+function coerceAtLeast(_this__u8e3s4, minimumValue) {
+  return _this__u8e3s4 < minimumValue ? minimumValue : _this__u8e3s4;
+}
+function downTo(_this__u8e3s4, to) {
+  return Companion_instance.x1(_this__u8e3s4, to, -1);
+}
+function coerceIn(_this__u8e3s4, minimumValue, maximumValue) {
+  if (minimumValue.a2(maximumValue) > 0)
+    throw IllegalArgumentException().u('Cannot coerce value to an empty range: maximum ' + maximumValue.toString() + ' is less than minimum ' + minimumValue.toString() + '.');
+  if (_this__u8e3s4.a2(minimumValue) < 0)
+    return minimumValue;
+  if (_this__u8e3s4.a2(maximumValue) > 0)
+    return maximumValue;
+  return _this__u8e3s4;
+}
+function coerceAtMost(_this__u8e3s4, maximumValue) {
+  return _this__u8e3s4 > maximumValue ? maximumValue : _this__u8e3s4;
+}
+function coerceIn_0(_this__u8e3s4, minimumValue, maximumValue) {
+  if (minimumValue > maximumValue)
+    throw IllegalArgumentException().u('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 contains(_this__u8e3s4, value) {
+  // Inline function 'kotlin.let' call
+  var it = toIntExactOrNull(value);
+  return !(it == null) ? _this__u8e3s4.b2(it) : false;
+}
+function toIntExactOrNull(_this__u8e3s4) {
+  return ((new (Long())(-2147483648, -1)).a2(_this__u8e3s4) <= 0 ? _this__u8e3s4.a2(new (Long())(2147483647, 0)) <= 0 : false) ? _this__u8e3s4.c2() : null;
+}
+//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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["common/src/generated/_Ranges.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["until","<this>","to","step","coerceAtLeast","minimumValue","downTo","coerceIn","maximumValue","coerceAtMost","contains","value","toIntExactOrNull"],"mappings":";;;;;;;;;;cAumCAA,CAAiBC,a,EAAUC,EAA3BF,EAA8C;A,EACtC,UAAU,WAAV,C;IAAqB,+BAAgB,I;EACzC,OAAO,mCAAS,KAAK,CAAd,K;AACX,C;aAvIAG,CAAiBF,a,EAAoBE,IAArCA,EAAgE;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;sBAuRAC,CAAWH,a,EAAkBI,YAA7BD,EAAqD;A,EACjD,OAAW,gBAAO,YAAP,GAAqB,YAArB,GAAuC,a;AACtD,C;eA9bAE,CAAiBL,a,EAAWC,EAA5BI,EAAqD;A,EACjD,OAAsB,sBAAgB,aAAhB,EAAsB,EAAtB,EAA0B,EAA1B,C;AAC1B,C;iBAinBAC,CAAWN,a,EAAcI,Y,EAAoBG,YAA7CD,EAAuE;A,EAC/D,oBAAe,YAAf,M;IAA6B,mCAAgC,iDAAhC,GAAgF,YAAhF,cAA4F,wBAA5F,GAAmH,YAAnH,cAA+H,GAA/H,C;EAC7B,qBAAO,YAAP,M;IAAqB,OAAO,Y;EAC5B,qBAAO,YAAP,M;IAAqB,OAAO,Y;EAChC,OAAO,a;AACX,C;qBA/GAE,CAAWR,a,EAAiBO,YAA5BC,EAAoD;A,EAChD,OAAW,gBAAO,YAAP,GAAqB,YAArB,GAAuC,a;AACtD,C;mBA0FAF,CAAWN,a,EAAaI,Y,EAAmBG,YAA3CD,EAAmE;A,EAC3D,mBAAe,YAAf,C;IAA6B,mCAAgC,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;iBAv1BAG,CACoBT,a,EAA0BU,KAD9CD,EACoE;A;WACnD,iBAAN,KAAM,C;EAAb,OAA0C,QAAM,IAAN,CAAJ,GAAgB,iBAAS,EAAT,CAAhB,GAAkC,K;AAC5E,C;yBAybAE,CAAaX,aAAbW,EAA2C;A,EACvC,OAAW,eAAsB,WAAtB,EAAsB,EAAtB,0DAA8C,UAA9C,EAA8C,CAA9C,mBAAwD,aAAK,KAA7D,GAA0E,I;AACzF,C;;;;;"}

package/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-stdlib/kotlin/reflect/KClassJs.mjs.map

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

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

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

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

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

package/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-stdlib/kotlin/reflect/KTypeParameter.mjs.map

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

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

@@ -0,0 +1,115 @@
+import { KVariance_INVARIANT_getInstancesuq4f4bi5uun 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 { toString30pk9tzaqopn as toString } from '../Library.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../exceptions.mjs';
+import {
+  toString1pkumu07cwy4m as toString_0,
+  hashCodeq5arwsb9dgti as hashCode,
+  equals2au1ep9vhcato as equals,
+} from '../js/coreRuntime.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../Unit.mjs';
+import {
+  noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+} 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.jg_1 = new (KTypeProjection())(null, null);
+      }
+      kg() {
+        return this.jg_1;
+      }
+      lg(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.mo_1 = variance;
+        this.no_1 = type;
+        // Inline function 'kotlin.require' call
+        if (!(this.mo_1 == null === (this.no_1 == null))) {
+          var message = this.mo_1 == null ? 'Star projection must have no type specified.' : 'The projection variance ' + toString(this.mo_1) + ' requires type to be specified.';
+          throw IllegalArgumentException().u(toString_0(message));
+        }
+      }
+      toString() {
+        var tmp0_subject = this.mo_1;
+        var tmp;
+        switch (tmp0_subject == null ? -1 : tmp0_subject.h3_1) {
+          case -1:
+            tmp = '*';
+            break;
+          case 0:
+            tmp = toString(this.no_1);
+            break;
+          case 1:
+            tmp = 'in ' + toString(this.no_1);
+            break;
+          case 2:
+            tmp = 'out ' + toString(this.no_1);
+            break;
+          default:
+            noWhenBranchMatchedException();
+            break;
+        }
+        return tmp;
+      }
+      hashCode() {
+        var result = this.mo_1 == null ? 0 : this.mo_1.hashCode();
+        result = imul(result, 31) + (this.no_1 == null ? 0 : hashCode(this.no_1)) | 0;
+        return result;
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof KTypeProjection()))
+          return false;
+        var tmp0_other_with_cast = other instanceof KTypeProjection() ? other : THROW_CCE();
+        if (!equals(this.mo_1, tmp0_other_with_cast.mo_1))
+          return false;
+        if (!equals(this.no_1, tmp0_other_with_cast.no_1))
+          return false;
+        return true;
+      }
+    }
+    initMetadataForClass($, 'KTypeProjection');
+    KTypeProjectionClass = $;
+  }
+  return KTypeProjectionClass;
+}
+//region block: exports
+export {
+  Companion_getInstance as Companion_getInstance3g08w0on7qs6d,
+};
+//endregion
+
+//# sourceMappingURL=KTypeProjection.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["src/kotlin/reflect/KTypeProjection.kt","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;QAO5CC,CACqBC,IADrBD,EAEI;A,QAA0C,+BAAhB,iCAAgB,EAAL,IAAK,C;MAAD,C;;;;;;;;;;;;;;;;;kBA5CjDE,Q,EAIAD,I;QATJ,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,YAG8B,IAH9B,CAG8B,IAH9B,IAGsC,iC;UCH1C,mCAAuC,WAAR,OAAQ,CAAvC,C;QACJ,C;;cDMAC,CAAAA,EAAkC;A,YAAM,wB;;QAAN,QAAM,6CAAN,C;eAC9B,E;kBAAQ,G;;eACE,C;kBAAkB,SAAL,IAAK,CAAL,IAAK,C;;eAClB,C;kBAAO,K,YAAI,I,CAAA,I;;eACX,C;kBAAQ,M,YAAK,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;YAAA,+E;QAAA,kD;UAAA,Y;QAAA,kD;UAAA,Y;QAAA,W;MAAA,C;;;;;;;;;;;"}

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

@@ -0,0 +1,50 @@
+import { Unit_instance1fbcbse1fwigr 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_getInstancesuq4f4bi5uun,
+  KVariance_IN_getInstance as KVariance_IN_getInstance1uylrm5a2m9el,
+  KVariance_OUT_getInstance as KVariance_OUT_getInstance10ihzp27e1gd4,
+};
+//endregion
+
+//# sourceMappingURL=KVariance.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["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;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/kotlin-kotlin-stdlib/kotlin/reflect/js/internal/KClassImpl.mjs

@@ -0,0 +1,183 @@
+import {
+  equals2au1ep9vhcato as equals,
+  getStringHashCode26igk1bx568vk as getStringHashCode,
+  toString1pkumu07cwy4m as toString,
+} from '../../../js/coreRuntime.mjs';
+import { KClass1cc9rfeybg8hs as KClass } from '../../KClassJs.mjs';
+import {
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+} from '../../../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../js/void.mjs';
+import {
+  UnsupportedOperationException2tkumpmhredt3 as UnsupportedOperationException,
+  IllegalStateExceptionkoljg5n0nrlr as IllegalStateException,
+} from '../../../exceptions.mjs';
+import { jsIsType3jt51kzl8sm7y as jsIsType } from '../../../js/typeCheckUtils.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var KClassImplClass;
+function KClassImpl() {
+  if (KClassImplClass === VOID) {
+    class $ {
+      constructor(jClass) {
+        this.yf_1 = jClass;
+      }
+      zf() {
+        return this.yf_1;
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof NothingKClassImpl()) {
+          tmp = false;
+        } else {
+          if (other instanceof ErrorKClass()) {
+            tmp = false;
+          } else {
+            if (other instanceof KClassImpl()) {
+              tmp = equals(this.zf(), other.zf());
+            } else {
+              tmp = false;
+            }
+          }
+        }
+        return tmp;
+      }
+      hashCode() {
+        var tmp0_safe_receiver = this.ag();
+        var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : getStringHashCode(tmp0_safe_receiver);
+        return tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+      }
+      toString() {
+        return 'class ' + this.ag();
+      }
+    }
+    initMetadataForClass($, 'KClassImpl', VOID, VOID, [KClass()]);
+    KClassImplClass = $;
+  }
+  return KClassImplClass;
+}
+var NothingKClassImplClass;
+function NothingKClassImpl() {
+  if (NothingKClassImplClass === VOID) {
+    class $ extends KClassImpl() {
+      constructor() {
+        NothingKClassImpl_instance = null;
+        super(Object);
+        NothingKClassImpl_instance = this;
+        this.dg_1 = 'Nothing';
+      }
+      ag() {
+        return this.dg_1;
+      }
+      bg(value) {
+        return false;
+      }
+      zf() {
+        throw UnsupportedOperationException().r9("There's no native JS class for Nothing type");
+      }
+      equals(other) {
+        return other === this;
+      }
+      hashCode() {
+        return 0;
+      }
+    }
+    initMetadataForObject($, 'NothingKClassImpl');
+    NothingKClassImplClass = $;
+  }
+  return NothingKClassImplClass;
+}
+var NothingKClassImpl_instance;
+function NothingKClassImpl_getInstance() {
+  if (NothingKClassImpl_instance === VOID)
+    new (NothingKClassImpl())();
+  return NothingKClassImpl_instance;
+}
+var ErrorKClassClass;
+function ErrorKClass() {
+  if (ErrorKClassClass === VOID) {
+    class $ {
+      ag() {
+        var message = 'Unknown simpleName for ErrorKClass';
+        throw IllegalStateException().o4(toString(message));
+      }
+      bg(value) {
+        var message = "Can's check isInstance on ErrorKClass";
+        throw IllegalStateException().o4(toString(message));
+      }
+      equals(other) {
+        return other === this;
+      }
+      hashCode() {
+        return 0;
+      }
+    }
+    initMetadataForClass($, 'ErrorKClass', ErrorKClass, VOID, [KClass()]);
+    ErrorKClassClass = $;
+  }
+  return ErrorKClassClass;
+}
+var PrimitiveKClassImplClass;
+function PrimitiveKClassImpl() {
+  if (PrimitiveKClassImplClass === VOID) {
+    class $ extends KClassImpl() {
+      constructor(jClass, givenSimpleName, isInstanceFunction) {
+        super(jClass);
+        this.fg_1 = givenSimpleName;
+        this.gg_1 = isInstanceFunction;
+      }
+      equals(other) {
+        if (!(other instanceof PrimitiveKClassImpl()))
+          return false;
+        return super.equals(other) && this.fg_1 === other.fg_1;
+      }
+      ag() {
+        return this.fg_1;
+      }
+      bg(value) {
+        return this.gg_1(value);
+      }
+    }
+    initMetadataForClass($, 'PrimitiveKClassImpl');
+    PrimitiveKClassImplClass = $;
+  }
+  return PrimitiveKClassImplClass;
+}
+var SimpleKClassImplClass;
+function SimpleKClassImpl() {
+  if (SimpleKClassImplClass === VOID) {
+    class $ extends KClassImpl() {
+      constructor(jClass) {
+        super(jClass);
+        var tmp = this;
+        // Inline function 'kotlin.js.asDynamic' call
+        var tmp0_safe_receiver = jClass.$metadata$;
+        // Inline function 'kotlin.js.unsafeCast' call
+        tmp.ig_1 = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.simpleName;
+      }
+      ag() {
+        return this.ig_1;
+      }
+      bg(value) {
+        return jsIsType(value, this.zf());
+      }
+    }
+    initMetadataForClass($, 'SimpleKClassImpl');
+    SimpleKClassImplClass = $;
+  }
+  return SimpleKClassImplClass;
+}
+//region block: exports
+export {
+  NothingKClassImpl_getInstance as NothingKClassImpl_getInstance1v9lrhbzi4zr5,
+  ErrorKClass as ErrorKClass1nb38m008xhla,
+  KClassImpl as KClassImpl3o7kfo8v13fhm,
+  PrimitiveKClassImpl as PrimitiveKClassImpl1fv46nzfav2pd,
+  SimpleKClassImpl as SimpleKClassImpl1arbnmvef0y44,
+};
+//endregion
+
+//# sourceMappingURL=KClassImpl.mjs.map

package/kotlin-kotlin-stdlib/kotlin/reflect/js/internal/KClassImpl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["js/src/kotlin/reflect/KClassImpl.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["jClass","<get-jClass>","equals","other","hashCode","toString","<get-simpleName>","isInstance","value","givenSimpleName","isInstanceFunction"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;kBAUIA,M;QAAA,kB;;QAAAC,CAAAA,EAAA;A,QAAA,gB;MAAmC,C;YAMnCC,CAAoBC,KAApBD,EAA0C;A;QAIlC,IAHS,KAGT,gC;gBAAwB,K;;UACxB,IAJS,KAIT,0B;kBAAkB,K;;YAClB,IALS,KAKT,yB;oBAAoB,kBAAU,KAAM,KAAhB,C;;oBACZ,K;;;;QANZ,U;MAQJ,C;cAGAE,CAAAA,EAA+B;A,YAAA,8B;YAAA,iBAAY,sDAAZ,kBAAY,C;QAAe,OAA3B,yBAA0B,CAA1B,iB;MAA0B,C;cAEzDC,CAAAA,EAAgC;A,QAE5B,OAAQ,QAAR,GAAe,S;MACnB,C;;;;;;;;;;;;;cA4BoD,M;;QAClB,qB;;QAAlCC,CAAAA,EAAA;A,QAAA,gB;MAA8B,C;QAE9BC,CAAwBC,KAAxBD,EAAgD;A,QAAK,OAAL,K;MAAI,C;QAGhDN,CAAAA,EAAQ;A,QAAA,yCAAoC,6CAApC,C;MAAiF,C;YAE7FC,CAAoBC,KAApBD,EAA4C;A,QAAc,OAAd,UAAU,I;MAAG,C;cAEzDE,CAAAA,EAA+B;A,QAAC,OAAD,C;MAAA,C;;;;;;;;;;;;;;;;;QAIEE,CAAAA,EAAQ;A,sBAAM,oC;QASokC,iCAAoC,SAAR,OAAQ,CAApC,C;MAThiC,C;QAGnFC,CAAwBC,KAAxBD,EAAgD;A,sBAAM,uC;QAM6jC,iCAAoC,SAAR,OAAQ,CAApC,C;MANthC,C;YAE7FL,CAAoBC,KAApBD,EAA4C;A,QAAc,OAAd,UAAU,I;MAAG,C;cAEzDE,CAAAA,EAA+B;A,QAAC,OAAD,C;MAAA,C;;;;;;;;;;;kBArC/BJ,M,EACAS,e,EACAC,kB;cACc,M;QAFd,2B;QACA,8B;;YAEAR,CAAoBC,KAApBD,EAA0C;A,QAClC,8C;UAAkC,OAAO,K;QAC7C,OAAa,aAAO,KAAP,CAAb,IAA8B,cAAmB,KAAnB,CAAyB,I;MAC3D,C;QAEiCI,CAAAA,EAAQ;A,QAAe,OAAf,IAAe,CAAf,I;MAAc,C;QAEvDC,CAAwBC,KAAxBD,EAA8C;A,QAC1C,OAAO,UAAmB,KAAnB,C;MACX,C;;;;;;;;;;;kBAtBqCP,M;cAAoC,M;kBACM,I;;YAAzB,qBAAnB,MAAmB,W;;QAAyB,WAAX,0BAAW,GAAX,IAAW,GAA5C,kBAA4C,CAAX,U;;QAApEM,CAAAA,EAAA;A,QAAA,gB;MAA+B,C;QAE/BC,CAAwBC,KAAxBD,EAA8C;A,QAC1C,OAAO,SAAS,KAAT,EAAgB,SAAhB,C;MACX,C;;;;;;;;;;;"}

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

@@ -0,0 +1,80 @@
+import {
+  equals2au1ep9vhcato as equals,
+  hashCodeq5arwsb9dgti as hashCode,
+  getBooleanHashCode1bbj3u6b3v0a7 as getBooleanHashCode,
+  toString1pkumu07cwy4m as toString,
+} from '../../../js/coreRuntime.mjs';
+import { KClass1cc9rfeybg8hs as KClass } from '../../KClassJs.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../js/typeCheckUtils.mjs';
+import { joinToString1cxrrlmo0chqs as joinToString } from '../../../collections/_Collections.mjs';
+import { plus17rl43at52ays as plus } from '../../../Library.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.mg_1 = classifier;
+        this.ng_1 = arguments_0;
+        this.og_1 = isMarkedNullable;
+      }
+      pg() {
+        return this.mg_1;
+      }
+      qg() {
+        return this.ng_1;
+      }
+      rg() {
+        return this.og_1;
+      }
+      equals(other) {
+        var tmp;
+        var tmp_0;
+        var tmp_1;
+        if (other instanceof KTypeImpl()) {
+          tmp_1 = equals(this.mg_1, other.mg_1);
+        } else {
+          tmp_1 = false;
+        }
+        if (tmp_1) {
+          tmp_0 = equals(this.ng_1, other.ng_1);
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp = this.og_1 === other.og_1;
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return imul(imul(hashCode(this.mg_1), 31) + hashCode(this.ng_1) | 0, 31) + getBooleanHashCode(this.og_1) | 0;
+      }
+      toString() {
+        var tmp = this.mg_1;
+        var kClass = isInterface(tmp, KClass()) ? tmp : null;
+        var classifierName = kClass == null ? toString(this.mg_1) : !(kClass.ag() == null) ? kClass.ag() : '(non-denotable type)';
+        var args = this.ng_1.j() ? '' : joinToString(this.ng_1, ', ', '<', '>');
+        var nullable = this.og_1 ? '?' : '';
+        return plus(classifierName, args) + nullable;
+      }
+    }
+    initMetadataForClass($, 'KTypeImpl');
+    KTypeImplClass = $;
+  }
+  return KTypeImplClass;
+}
+//region block: exports
+export {
+  KTypeImpl as KTypeImpl31l2cx2hil3il,
+};
+//endregion
+
+//# sourceMappingURL=KTypeImpl.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["js/src/kotlin/reflect/KTypeImpl.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["classifier","arguments","isMarkedNullable","<get-classifier>","<get-arguments>","<get-isMarkedNullable>","equals","other","hashCode","toString","kClass","classifierName","args","nullable"],"mappings":";;;;;;;;;;;;;;;;;;;;;kBAUIA,U,EACAC,W,EACAC,gB;QAFA,sB;QACA,uB;QACA,4B;;QAFAC,CAAAA,EAAA;A,QAAA,gB;MAAmC,C;QACnCC,CAAAA,EAAA;A,QAAA,gB;MAA4C,C;QAC5CC,CAAAA,EAAA;A,QAAA,gB;MAAqC,C;YAErCC,CAAoBC,KAApBD,EACI;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;cAEvHE,CAAAA,EACI;A,QAAsF,OAAtF,KAAC,KAAW,SAAX,IAAW,CAAX,IAAW,CAAX,EAAwB,EAAxB,IAAuC,SAAV,IAAU,CAAV,IAAU,CAAxC,MAAsD,EAAtD,IAA4E,mBAAjB,IAAiB,CAAjB,IAAiB,CAAU,I;MAAD,C;cAEzFC,CAAAA,EAAgC;A,kBACd,I,CAAA,I;YAAdC,sCAAc,GAAdA,O;YACAC,iBACI,UAAU,IAAV,GAA6B,SAAX,IAAW,CAAX,IAAW,CAA7B,GACA,EAAA,MAAO,KAAP,IAAqB,IAArB,IAA6B,MAAO,KAApC,GACQ,sB;YAGZC,OACQ,IAAU,CAAV,IAAU,IAAV,GAAqB,EAArB,GACW,aAAV,IAAU,CAAV,IAAU,EAAa,IAAb,EAAmB,GAAnB,EAAwB,GAAxB,C;YACnBC,WAAmB,YAAkB,GAAlB,GAA2B,E;QAE9C,OAAO,qBAAiB,IAAjB,IAAwB,Q;MACnC,C;;;;;;;;;;;"}