@attocash/commons-test 6.0.0

package/kotlin-kotlin-stdlib/kotlin/js/rangeTo.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["js/runtime/rangeTo.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["numberRangeToNumber","start","endInclusive"],"mappings":";;;;;4BAQSA,CAAwBC,K,EAAgBC,YAAxCF,EACL;A,EAA6B,wBAApB,KAAoB,EAAb,YAAa,C;AAAD,C;;;;;"}

package/kotlin-kotlin-stdlib/kotlin/js/reflectRuntime.mjs

@@ -0,0 +1,95 @@
+import { VOID3gxj6tk5isa35 as VOID } from './void.mjs';
+import { createMetadata3unb2gw4d2v4k as createMetadata } from './metadataUtils.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../Unit.mjs';
+import { defineProp3ur6h3slcvq4x as defineProp } from './coreRuntime.mjs';
+import { implementf3b9bp4orre as implement } from './BitMask.mjs';
+import { throwIrLinkageError175icmue6aqas as throwIrLinkageError } from '../internal/IrLinkageError.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function get_propertyRefClassMetadataCache() {
+  _init_properties_reflectRuntime_kt__5r4uu3();
+  return propertyRefClassMetadataCache;
+}
+var propertyRefClassMetadataCache;
+function metadataObject() {
+  _init_properties_reflectRuntime_kt__5r4uu3();
+  return createMetadata('class', VOID, VOID, VOID, VOID, VOID);
+}
+function getPropertyCallableRef(name, paramCount, superType, getter, setter, linkageError) {
+  linkageError = linkageError === VOID ? null : linkageError;
+  _init_properties_reflectRuntime_kt__5r4uu3();
+  getter.get = getter;
+  getter.set = setter;
+  if (!(linkageError == null)) {
+    throwLinkageErrorInCallableName(getter, linkageError);
+  } else {
+    getter.callableName = name;
+  }
+  // Inline function 'kotlin.js.unsafeCast' call
+  return getPropertyRefClass(getter, getKPropMetadata(paramCount, setter), getInterfaceMaskFor(getter, superType));
+}
+function throwLinkageErrorInCallableName(function_0, linkageError) {
+  _init_properties_reflectRuntime_kt__5r4uu3();
+  defineProp(function_0, 'callableName', throwLinkageErrorInCallableName$lambda(linkageError), VOID, true);
+}
+function getPropertyRefClass(obj, metadata, imask) {
+  _init_properties_reflectRuntime_kt__5r4uu3();
+  obj.$metadata$ = metadata;
+  obj.constructor = obj;
+  obj.$imask$ = imask;
+  return obj;
+}
+function getKPropMetadata(paramCount, setter) {
+  _init_properties_reflectRuntime_kt__5r4uu3();
+  return get_propertyRefClassMetadataCache()[paramCount][setter == null ? 0 : 1];
+}
+function getInterfaceMaskFor(obj, superType) {
+  _init_properties_reflectRuntime_kt__5r4uu3();
+  var tmp0_elvis_lhs = obj.$imask$;
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    // Inline function 'kotlin.arrayOf' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    var tmp$ret$2 = [superType];
+    tmp = implement(tmp$ret$2);
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  return tmp;
+}
+function throwLinkageErrorInCallableName$lambda($linkageError) {
+  return () => {
+    throwIrLinkageError($linkageError);
+  };
+}
+var properties_initialized_reflectRuntime_kt_inkhwd;
+function _init_properties_reflectRuntime_kt__5r4uu3() {
+  if (!properties_initialized_reflectRuntime_kt_inkhwd) {
+    properties_initialized_reflectRuntime_kt_inkhwd = true;
+    // Inline function 'kotlin.arrayOf' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    var tmp = [metadataObject(), metadataObject()];
+    // Inline function 'kotlin.arrayOf' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    var tmp_0 = [metadataObject(), metadataObject()];
+    // Inline function 'kotlin.arrayOf' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    // Inline function 'kotlin.arrayOf' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    propertyRefClassMetadataCache = [tmp, tmp_0, [metadataObject(), metadataObject()]];
+  }
+}
+//region block: exports
+export {
+  getPropertyCallableRef as getPropertyCallableRef3hckxc0xueiaj,
+};
+//endregion
+
+//# sourceMappingURL=reflectRuntime.mjs.map

package/kotlin-kotlin-stdlib/kotlin/js/reflectRuntime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["js/runtime/reflectRuntime.kt","js/builtins/Library.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-propertyRefClassMetadataCache>","metadataObject","getPropertyCallableRef","name","paramCount","superType","getter","setter","linkageError","throwLinkageErrorInCallableName","function","getPropertyRefClass","obj","metadata","imask","getKPropMetadata","getInterfaceMaskFor","throwLinkageErrorInCallableName$lambda","$linkageError","throwLinkageErrorInCallableName$lambda$lambda","<init properties reflectRuntime.kt>"],"mappings":";;;;;;;;;;0CAoEQA,CAAAA,EAAA;A;EAAA,oC;AAAuD,C;;uBAJvDC,CAAAA,EAA+B;A;EACnC,OAAO,eAAe,OAAf,EAAoC,IAApC,EAA0C,IAA1C,EAAgD,IAAhD,EAAsD,IAAtD,EAA4D,IAA5D,C;AACX,C;+BA9CSC,CACLC,I,EACAC,U,EACAC,S,EACAC,M,EACAC,M,EACAC,YANKN,EAOO;A,yCADY,I;;EAExB,aAAa,M;EACb,aAAa,M;EACT,sBAAgB,IAAhB,E,CAAsB;A,IACtB,gCAAgC,MAAhC,EAAwC,YAAxC,C;EACJ,C,MAAO;A,IACH,sBAAsB,I;EAC1B,C;;EACA,OAIE,oBAHE,MAGF,EAFE,iBAAiB,UAAjB,EAA6B,MAA7B,CAEF,EADE,oBAAoB,MAApB,EAA4B,SAA5B,CACF,C;AACN,C;wCA9BSO,CAAoCC,U,EAAmBF,YAAvDC,EAA6E;A;EAClF,WACI,UADJ,EAEW,cAFX,EAGa,oDAHb,EAIa,IAJb,EAKiB,IALjB,C;AAOJ,C;4BA+BQE,CAAwBC,G,EAAWC,Q,EAAoBC,KAAvDH,EAAgF;A;EACpF,GAAI,cAAe,Q;EACnB,GAAI,eAAc,G;EAClB,GAAI,WAAY,K;EAChB,OAAO,G;AACX,C;yBAMQI,CAAqBX,U,EAAiBG,MAAtCQ,EAA6D;A;EACjE,OAAO,oCAA8B,UAA9B,EAA8C,UAAU,IAAV,GAAgB,CAAhB,GAAuB,CAArE,C;AACX,C;4BANQC,CAAwBJ,G,EAAWP,SAAnCW,EACJ;A;MAAA,qBAAI,O;;EAAJ,2B;;;;QCxBgG,YDwB7D,W;UAAlB,UAAU,SAAV,C;;UAAjB,c;;EAA8C,U;AAAD,C;+CA3ChCC,CAJ+CC,aAI/CD,E;SAAAE,CAAAA,KAAA;A,IAAE,oBAAoB,aAApB,C;EAAkC,C;C;;mDAdrDC,CAAAA,E;;;;;;cAsEqB,mBAAkB,gBAAlB,C;;;;gBACA,mBAAkB,gBAAlB,C;;;;;;;oCADjB,aAEiB,mBAAkB,gBAAlB,CAFjB,C;;C;;;;;"}

package/kotlin-kotlin-stdlib/kotlin/js/regexp.mjs

@@ -0,0 +1,12 @@
+//region block: pre-declaration
+//endregion
+function reset(_this__u8e3s4) {
+  _this__u8e3s4.lastIndex = 0;
+}
+//region block: exports
+export {
+  reset as reset2ep3wdzn2qbpo,
+};
+//endregion
+
+//# sourceMappingURL=regexp.mjs.map

package/kotlin-kotlin-stdlib/kotlin/js/regexp.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["js/src/kotlin/regexp.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["reset","<this>"],"mappings":";;cAgCOA,CAAIC,aAAJD,EAAmB;A,EACtB,0BAAY,C;AAChB,C;;;;;"}

package/kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs

@@ -0,0 +1,173 @@
+import { isBitSet256qltnocvnfa as isBitSet } from './BitMask.mjs';
+import { Comparable198qfk8pnblz0 as Comparable } from '../Comparable.mjs';
+import { CharSequence1ceii1xorfwh7 as CharSequence } from '../CharSequence.mjs';
+//region block: imports
+var isView = ArrayBuffer.isView;
+//endregion
+//region block: pre-declaration
+//endregion
+function isArrayish(o) {
+  return isJsArray(o) || isView(o);
+}
+function isJsArray(obj) {
+  // Inline function 'kotlin.js.unsafeCast' call
+  return Array.isArray(obj);
+}
+function isInterface(obj, iface) {
+  return isInterfaceImpl(obj, iface.$metadata$.iid);
+}
+function isInterfaceImpl(obj, iface) {
+  // Inline function 'kotlin.js.unsafeCast' call
+  var tmp0_elvis_lhs = obj.$imask$;
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    return false;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var mask = tmp;
+  return isBitSet(mask, iface);
+}
+function isArray(obj) {
+  var tmp;
+  if (isJsArray(obj)) {
+    // Inline function 'kotlin.js.asDynamic' call
+    tmp = !obj.$type$;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+}
+function isSuspendFunction(obj, arity) {
+  var objTypeOf = typeof obj;
+  if (objTypeOf === 'function') {
+    // Inline function 'kotlin.js.unsafeCast' call
+    return obj.$arity === arity;
+  }
+  // Inline function 'kotlin.js.unsafeCast' call
+  var tmp1_safe_receiver = obj == null ? null : obj.constructor;
+  var tmp2_safe_receiver = tmp1_safe_receiver == null ? null : tmp1_safe_receiver.$metadata$;
+  var tmp3_elvis_lhs = tmp2_safe_receiver == null ? null : tmp2_safe_receiver.suspendArity;
+  var tmp;
+  if (tmp3_elvis_lhs == null) {
+    return false;
+  } else {
+    tmp = tmp3_elvis_lhs;
+  }
+  var suspendArity = tmp;
+  var result = false;
+  var inductionVariable = 0;
+  var last = suspendArity.length;
+  $l$loop: while (inductionVariable < last) {
+    var item = suspendArity[inductionVariable];
+    inductionVariable = inductionVariable + 1 | 0;
+    if (arity === item) {
+      result = true;
+      break $l$loop;
+    }
+  }
+  return result;
+}
+function isNumber(a) {
+  var tmp;
+  if (typeof a === 'number') {
+    tmp = true;
+  } else {
+    tmp = !(a == null) ? typeof a === 'bigint' : false;
+  }
+  return tmp;
+}
+function isComparable(value) {
+  var type = typeof value;
+  return type === 'string' || type === 'boolean' || isNumber(value) || isInterface(value, Comparable());
+}
+function isCharSequence(value) {
+  return typeof value === 'string' || isInterface(value, CharSequence());
+}
+function isBooleanArray(a) {
+  return isJsArray(a) && a.$type$ === 'BooleanArray';
+}
+function isByteArray(a) {
+  // Inline function 'kotlin.js.jsInstanceOf' call
+  return a instanceof Int8Array;
+}
+function isShortArray(a) {
+  // Inline function 'kotlin.js.jsInstanceOf' call
+  return a instanceof Int16Array;
+}
+function isCharArray(a) {
+  var tmp;
+  // Inline function 'kotlin.js.jsInstanceOf' call
+  if (a instanceof Uint16Array) {
+    tmp = a.$type$ === 'CharArray';
+  } else {
+    tmp = false;
+  }
+  return tmp;
+}
+function isIntArray(a) {
+  // Inline function 'kotlin.js.jsInstanceOf' call
+  return a instanceof Int32Array;
+}
+function isFloatArray(a) {
+  // Inline function 'kotlin.js.jsInstanceOf' call
+  return a instanceof Float32Array;
+}
+function isLongArray(a) {
+  return isJsArray(a) && a.$type$ === 'LongArray';
+}
+function isDoubleArray(a) {
+  // Inline function 'kotlin.js.jsInstanceOf' call
+  return a instanceof Float64Array;
+}
+function jsIsType(obj, jsClass) {
+  if (jsClass === Object) {
+    return obj != null;
+  }
+  var objType = typeof obj;
+  var jsClassType = typeof jsClass;
+  if (obj == null || jsClass == null || (!(objType === 'object') && !(objType === 'function'))) {
+    return false;
+  }
+  var constructor = jsClassType === 'object' ? jsGetPrototypeOf(jsClass) : jsClass;
+  var klassMetadata = constructor.$metadata$;
+  if ((klassMetadata == null ? null : klassMetadata.kind) === 'interface') {
+    // Inline function 'kotlin.js.unsafeCast' call
+    var tmp0_elvis_lhs = klassMetadata.iid;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return false;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var iid = tmp;
+    return isInterfaceImpl(obj, iid);
+  }
+  // Inline function 'kotlin.js.jsInstanceOf' call
+  return obj instanceof constructor;
+}
+function jsGetPrototypeOf(jsClass) {
+  return Object.getPrototypeOf(jsClass);
+}
+//region block: exports
+export {
+  isArrayish as isArrayish54psvuvyhrq3,
+  isArray as isArray1hxjqtqy632bc,
+  isBooleanArray as isBooleanArray35llghle4c6w1,
+  isByteArray as isByteArray4nnzfn1x4o3w,
+  isCharArray as isCharArray21auq5hbrg68m,
+  isCharSequence as isCharSequence1ju9jr1w86plq,
+  isComparable as isComparableviyv6ctzm76u,
+  isDoubleArray as isDoubleArray1wyh4nyf7pjxn,
+  isFloatArray as isFloatArrayjjscnqphw92j,
+  isIntArray as isIntArrayeijsubfngq38,
+  isInterface as isInterface3d6p8outrmvmk,
+  isLongArray as isLongArray2fdt3z7yu3ef,
+  isNumber as isNumberiramasdbon0i,
+  isShortArray as isShortArraywz30zxwtqi8h,
+  isSuspendFunction as isSuspendFunction153vlp5l2npj9,
+  jsIsType as jsIsType3jt51kzl8sm7y,
+};
+//endregion
+
+//# sourceMappingURL=typeCheckUtils.mjs.map

package/kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["js/runtime/typeCheckUtils.kt","js/runtime/runtimeForStdLib.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["isArrayish","o","isJsArray","obj","isInterface","iface","isInterfaceImpl","mask","isArray","isSuspendFunction","arity","objTypeOf","suspendArity","result","item","isNumber","a","isComparable","value","type","isCharSequence","isBooleanArray","isByteArray","isShortArray","isCharArray","isIntArray","isFloatArray","isLongArray","isDoubleArray","jsIsType","jsClass","objType","jsClassType","constructor","klassMetadata","iid","jsGetPrototypeOf"],"mappings":"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"}

package/kotlin-kotlin-stdlib/kotlin/js/void.mjs

@@ -0,0 +1,21 @@
+//region block: pre-declaration
+//endregion
+function get_VOID() {
+  _init_properties_void_kt__3zg9as();
+  return VOID;
+}
+var VOID;
+var properties_initialized_void_kt_e4ret2;
+function _init_properties_void_kt__3zg9as() {
+  if (!properties_initialized_void_kt_e4ret2) {
+    properties_initialized_void_kt_e4ret2 = true;
+    VOID = void 0;
+  }
+}
+//region block: exports
+export {
+  VOID as VOID3gxj6tk5isa35,
+};
+//endregion
+
+//# sourceMappingURL=void.mjs.map

package/kotlin-kotlin-stdlib/kotlin/js/void.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["js/runtime/void.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-VOID>","<init properties void.kt>"],"mappings":";;iBAOSA,CAAAA,EAAA;A;EAAA,W;AAAiB,C;;;yCAP1BC,CAAAA,E;;;WAO8B,KAAQ,C;;C;;;;;"}

package/kotlin-kotlin-stdlib/kotlin/kotlin.mjs

@@ -0,0 +1,55 @@
+import { UnsafeLazyImplgpp92xc41v15 as UnsafeLazyImpl } from './Lazy.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from './Unit.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function lazy(mode, initializer) {
+  return new (UnsafeLazyImpl())(initializer);
+}
+function lazy_0(initializer) {
+  return new (UnsafeLazyImpl())(initializer);
+}
+function arrayCopyResize(source, newSize, defaultValue) {
+  // Inline function 'kotlin.js.unsafeCast' call
+  var result = source.slice(0, newSize);
+  // Inline function 'kotlin.copyArrayType' call
+  if (source.$type$ !== undefined) {
+    result.$type$ = source.$type$;
+  }
+  var index = source.length;
+  if (newSize > index) {
+    // Inline function 'kotlin.js.asDynamic' call
+    result.length = newSize;
+    while (index < newSize) {
+      var _unary__edvuaz = index;
+      index = _unary__edvuaz + 1 | 0;
+      result[_unary__edvuaz] = defaultValue;
+    }
+  }
+  return result;
+}
+function fillFrom(src, dst) {
+  var srcLen = src.length;
+  var dstLen = dst.length;
+  var index = 0;
+  // Inline function 'kotlin.js.unsafeCast' call
+  var arr = dst;
+  while (index < srcLen && index < dstLen) {
+    var tmp = index;
+    var _unary__edvuaz = index;
+    index = _unary__edvuaz + 1 | 0;
+    arr[tmp] = src[_unary__edvuaz];
+  }
+  return dst;
+}
+//region block: exports
+export {
+  arrayCopyResize as arrayCopyResize15cxrbbe9vpuk,
+  fillFrom as fillFrom3pz8g2cvpcwer,
+  lazy as lazy1261dae0bgscp,
+  lazy_0 as lazy2hsh8ze7j6ikd,
+};
+//endregion
+
+//# sourceMappingURL=kotlin.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["js/src/kotlin/kotlin.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["lazy","mode","initializer","arrayCopyResize","source","newSize","defaultValue","result","index","fillFrom","src","dst","srcLen","dstLen","arr"],"mappings":";;;;;;aAuBcA,CAAaC,I,EAA4BC,WAAzCF,EAA0E;A,EAA2B,8BAAZ,WAAY,C;AAAD,C;eANpGA,CAAaE,WAAbF,EAA8C;A,EAA2B,8BAAZ,WAAY,C;AAAD,C;wBA4B7EG,CAAoBC,M,EAAiBC,O,EAAcC,YAAnDH,EAAgF;A;MACrFI,SAAa,MAAyB,CAAlB,KAAkB,CAAZ,CAAY,EAAT,OAAS,C;;EAoBlC,IAnBU,MAmBV,CAAK,MAAL,KAAkB,SAAlB,C,CAA6B;A,IAnBX,MAoBlB,UApBU,MAoBV,CAAmB,M;EACvB,C;MApBAC,QAAiB,MAAjBA,CAAwB,M;EACpB,cAAU,KAAV,C,CAAiB;A;IACjB,gBAA4B,O;WACrB,QAAQ,O,EAAS;A,UAAO,sB;MAAA,QAAA,cAAK,IAAL,I;MAAP,OAAO,cAAP,IAAkB,Y;IAAW,C;EACzD,C;EACA,OAAO,M;AACX,C;iBAnBSC,CAAaC,G,EAAcC,GAA3BF,EAAkD;A,MACvDG,SAAkB,GAAlBA,CAAsB,M;MACtBC,SAAkB,GAAlBA,CAAsB,M;MACtBL,QAAiB,C;;MACjBM,MAAc,G;SACP,QAAQ,M,IAAU,QAAQ,M,EAAQ;A,cAAI,K;QAAa,sB;IAAA,QAAA,cAAK,IAAL,I;IAAjB,WAAa,IAAI,cAAJ,C;EAAW,C;EACjE,OAAO,G;AACX,C;;;;;"}

package/kotlin-kotlin-stdlib/kotlin/math/math.mjs

@@ -0,0 +1,49 @@
+import { numberToInt1ygmcfwhs2fkq as numberToInt } from '../js/numberConversion.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../exceptions.mjs';
+import { isNaNymqb93xtq8w8 as isNaN_0 } from '../NumbersJs.mjs';
+import {
+  numberToLong2pakxeg38estk as numberToLong,
+  toNumber2e2hj9zugjwi2 as toNumber,
+} from '../js/internal/longAsBigInt/longAsBigInt.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function abs(n) {
+  return n < 0 ? -n | 0 | 0 : n;
+}
+function roundToInt(_this__u8e3s4) {
+  var tmp;
+  if (isNaN_0(_this__u8e3s4)) {
+    throw IllegalArgumentException().i1('Cannot round NaN value.');
+  } else if (_this__u8e3s4 > 2147483647) {
+    tmp = 2147483647;
+  } else if (_this__u8e3s4 < -2147483648) {
+    tmp = -2147483648;
+  } else {
+    tmp = numberToInt(Math.round(_this__u8e3s4));
+  }
+  return tmp;
+}
+function roundToLong(_this__u8e3s4) {
+  var tmp;
+  if (isNaN_0(_this__u8e3s4)) {
+    throw IllegalArgumentException().i1('Cannot round NaN value.');
+  } else if (_this__u8e3s4 > toNumber(9223372036854775807n)) {
+    tmp = 9223372036854775807n;
+  } else if (_this__u8e3s4 < toNumber(-9223372036854775808n)) {
+    tmp = -9223372036854775808n;
+  } else {
+    tmp = numberToLong(Math.round(_this__u8e3s4));
+  }
+  return tmp;
+}
+//region block: exports
+export {
+  abs as abs1kdzbjes1idip,
+  roundToInt as roundToInt1ue8x8yshtznx,
+  roundToLong as roundToLong2s902lrwaad4n,
+};
+//endregion
+
+//# sourceMappingURL=math.mjs.map

package/kotlin-kotlin-stdlib/kotlin/math/math.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["js/src/kotlin/math.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["abs","n","roundToInt","<this>","roundToLong"],"mappings":";;;;;;;;;;;YAikCcA,CAAQC,CAARD,EAAuB;A,EAA2B,OAAvB,IAAI,CAAJ,GAAQ,CAAC,CAAD,OAAM,CAAd,GAAsB,C;AAAA,C;mBA5hBjDE,CAAIC,aAAJD,EAA+B;A;EACzC,2B;IAAW,oCAA+B,yBAA/B,C;SACX,oBAAW,UAAX,C;UAA4B,U;SAC5B,oBAAW,WAAX,C;UAA4B,W;;UACG,YAAvB,IAAW,OAAM,aAAN,CAAY,C;;EAClC,U;AAAD,C;oBAccE,CAAID,aAAJC,EAAiC;A;EAC3C,2B;IAAW,oCAA+B,yBAA/B,C;SACX,oBAAY,8BAAZ,C;UAA8B,oB;SAC9B,oBAAY,+BAAZ,C;UAA8B,qB;;UACC,aAAvB,IAAW,OAAM,aAAN,CAAY,C;;EAClC,U;AAAD,C;;;;;"}

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

@@ -0,0 +1,30 @@
+import { Random2w0u2xak2xaqi as Random } from './Random.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var INV_2_26;
+var INV_2_53;
+function defaultPlatformRandom() {
+  _init_properties_PlatformRandom_kt__6kjv62();
+  // Inline function 'kotlin.js.unsafeCast' call
+  var tmp$ret$0 = Math.random() * Math.pow(2, 32) | 0;
+  return Random(tmp$ret$0);
+}
+var properties_initialized_PlatformRandom_kt_uibhw8;
+function _init_properties_PlatformRandom_kt__6kjv62() {
+  if (!properties_initialized_PlatformRandom_kt_uibhw8) {
+    properties_initialized_PlatformRandom_kt_uibhw8 = true;
+    // Inline function 'kotlin.math.pow' call
+    INV_2_26 = Math.pow(2.0, -26);
+    // Inline function 'kotlin.math.pow' call
+    INV_2_53 = Math.pow(2.0, -53);
+  }
+}
+//region block: exports
+export {
+  defaultPlatformRandom as defaultPlatformRandom1jhqtnj1rulyk,
+};
+//endregion
+
+//# sourceMappingURL=PlatformRandom.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["js/src/kotlin/random/PlatformRandom.kt","js/src/kotlin/dynamic.kt","js/src/kotlin/math.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["defaultPlatformRandom","<init properties PlatformRandom.kt>"],"mappings":";;;;;;;8BASgBA,CAAAA,EACZ;A;;MCeyE,YDf9D,IAAW,CAAN,MAAM,EAAG,GAAE,IAAQ,CAAH,GAAG,CAAC,CAAD,EAAI,EAAJ,CAAgB,GAAL,C;EAAuB,OAArE,OAAmD,SAAnD,C;AAAoE,C;;mDAVxEC,CAAAA,E;;;;eEmbsD,IAAW,KFtalC,GEsakC,EFta1B,GEsa0B,C;;eAAX,IAAW,KFralC,GEqakC,EFra1B,GEqa0B,C;;C;;;;;"}

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

@@ -0,0 +1,166 @@
+import { defaultPlatformRandom1jhqtnj1rulyk as defaultPlatformRandom } from './PlatformRandom.mjs';
+import {
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+import {
+  createThis2j2avj17cvnv2 as createThis,
+  toString1pkumu07cwy4m as toString,
+} from '../js/coreRuntime.mjs';
+import {
+  fromInt2ii0rejb1w62w as fromInt,
+  shiftLeft3tsh2sstjchzn as shiftLeft,
+  add2suhfggl4zvkk as add,
+  subtract2orl8z9upxd9l as subtract,
+  shiftRightUnsigned1ga7wnvbv2qur as shiftRightUnsigned,
+  modulooi4g1kq3dmtt as modulo,
+  convertToInty04h231mmjoh as convertToInt,
+  negate13xrbakfwasjy as negate,
+} from '../js/internal/longAsBigInt/longAsBigInt.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../exceptions.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../Unit.mjs';
+import { XorWowRandom4dcuf9lla8j1 as XorWowRandom } from './XorWowRandom.mjs';
+//region block: imports
+var clz32 = Math.clz32;
+//endregion
+//region block: pre-declaration
+//endregion
+var DefaultClass;
+function Default() {
+  if (DefaultClass === VOID) {
+    class $ extends Random() {
+      static nl() {
+        Default_instance = null;
+        var $this = this.ol();
+        Default_instance = $this;
+        $this.ml_1 = defaultPlatformRandom();
+        return $this;
+      }
+      pl(bitCount) {
+        return this.ml_1.pl(bitCount);
+      }
+      ak() {
+        return this.ml_1.ak();
+      }
+      ql() {
+        return this.ml_1.ql();
+      }
+      rl(until) {
+        return this.ml_1.rl(until);
+      }
+      sl(from, until) {
+        return this.ml_1.sl(from, until);
+      }
+    }
+    initMetadataForObject($, 'Default');
+    DefaultClass = $;
+  }
+  return DefaultClass;
+}
+var Default_instance;
+function Default_getInstance() {
+  if (Default_instance === VOID)
+    Default().nl();
+  return Default_instance;
+}
+var RandomClass;
+function Random() {
+  if (RandomClass === VOID) {
+    class $ {
+      static ol() {
+        Default_getInstance();
+        return createThis(this);
+      }
+      ak() {
+        return this.pl(32);
+      }
+      ql() {
+        var tmp0 = shiftLeft(fromInt(this.ak()), 32);
+        // Inline function 'kotlin.Long.plus' call
+        var other = this.ak();
+        return add(tmp0, fromInt(other));
+      }
+      rl(until) {
+        return this.sl(0n, until);
+      }
+      sl(from, until) {
+        checkRangeBounds(from, until);
+        var n = subtract(until, from);
+        if (n > 0n) {
+          var rnd;
+          if ((n & negate(n)) === n) {
+            var nLow = convertToInt(n);
+            var nHigh = convertToInt(shiftRightUnsigned(n, 32));
+            var tmp;
+            if (!(nLow === 0)) {
+              var bitCount = fastLog2(nLow);
+              tmp = fromInt(this.pl(bitCount)) & 4294967295n;
+            } else if (nHigh === 1) {
+              tmp = fromInt(this.ak()) & 4294967295n;
+            } else {
+              var bitCount_0 = fastLog2(nHigh);
+              tmp = add(shiftLeft(fromInt(this.pl(bitCount_0)), 32), fromInt(this.ak()) & 4294967295n);
+            }
+            rnd = tmp;
+          } else {
+            var v;
+            $l$1: do {
+              $l$0: do {
+                var bits = shiftRightUnsigned(this.ql(), 1);
+                v = modulo(bits, n);
+              }
+               while (false);
+              var tmp_0 = subtract(bits, v);
+              // Inline function 'kotlin.Long.minus' call
+              var tmp$ret$0 = subtract(n, fromInt(1));
+            }
+             while (add(tmp_0, tmp$ret$0) < 0n);
+            rnd = v;
+          }
+          return add(from, rnd);
+        } else {
+          while (true) {
+            var rnd_0 = this.ql();
+            if (from <= rnd_0 ? rnd_0 < until : false)
+              return rnd_0;
+          }
+        }
+      }
+    }
+    initMetadataForClass($, 'Random');
+    RandomClass = $;
+  }
+  return RandomClass;
+}
+function fastLog2(value) {
+  // Inline function 'kotlin.countLeadingZeroBits' call
+  return 31 - clz32(value) | 0;
+}
+function checkRangeBounds(from, until) {
+  // Inline function 'kotlin.require' call
+  if (!(until > from)) {
+    var message = boundsErrorMessage(from, until);
+    throw IllegalArgumentException().i1(toString(message));
+  }
+  return Unit_instance;
+}
+function boundsErrorMessage(from, until) {
+  return 'Random range is empty: [' + toString(from) + ', ' + toString(until) + ').';
+}
+function Random_0(seed) {
+  return XorWowRandom().zl(seed, seed >> 31);
+}
+function takeUpperBits(_this__u8e3s4, bitCount) {
+  return (_this__u8e3s4 >>> (32 - bitCount | 0) | 0) & (-bitCount | 0) >> 31;
+}
+//region block: exports
+export {
+  Default_getInstance as Default_getInstance3u4i6y54ri5cn,
+  Random_0 as Random2w0u2xak2xaqi,
+  Random as Random24dxadk52mliy,
+  takeUpperBits as takeUpperBits23varjnd7v1uz,
+};
+//endregion
+
+//# sourceMappingURL=Random.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["src/kotlin/random/Random.kt","js/builtins/Primitives.kt","js/src/kotlin/NumbersJs.kt","src/kotlin/util/Preconditions.kt"],"sourcesContent":[null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["nextBits","bitCount","nextInt","nextLong","until","from","n","rnd","nLow","nHigh","v","bits","fastLog2","value","checkRangeBounds","message","boundsErrorMessage","Random","seed","takeUpperBits","<this>"],"mappings":"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"}