munchies-user-service-shared 0.11.0

package/kotlin/kotlin-kotlin-stdlib.js

@@ -0,0 +1,683 @@
+//region block: polyfills
+if (typeof ArrayBuffer.isView === 'undefined') {
+  ArrayBuffer.isView = function (a) {
+    return a != null && a.__proto__ != null && a.__proto__.__proto__ === Int8Array.prototype.__proto__;
+  };
+}
+if (typeof Math.imul === 'undefined') {
+  Math.imul = function imul(a, b) {
+    return (a & 4.29490176E9) * (b & 65535) + (a & 65535) * (b | 0) | 0;
+  };
+}
+//endregion
+(function (_) {
+  'use strict';
+  //region block: imports
+  var imul = Math.imul;
+  var isView = ArrayBuffer.isView;
+  //endregion
+  //region block: pre-declaration
+  setMetadataFor(Number_0, 'Number', classMeta);
+  setMetadataFor(Unit, 'Unit', objectMeta);
+  setMetadataFor(IntCompanionObject, 'IntCompanionObject', objectMeta);
+  setMetadataFor(Companion, 'Companion', objectMeta);
+  setMetadataFor(Collection, 'Collection', interfaceMeta);
+  setMetadataFor(Long, 'Long', classMeta, Number_0);
+  setMetadataFor(Exception, 'Exception', classMeta, Error, VOID, Exception_init_$Create$);
+  setMetadataFor(RuntimeException, 'RuntimeException', classMeta, Exception, VOID, RuntimeException_init_$Create$);
+  setMetadataFor(IllegalArgumentException, 'IllegalArgumentException', classMeta, RuntimeException, VOID, IllegalArgumentException_init_$Create$);
+  setMetadataFor(NoSuchElementException, 'NoSuchElementException', classMeta, RuntimeException, VOID, NoSuchElementException_init_$Create$);
+  setMetadataFor(ClassCastException, 'ClassCastException', classMeta, RuntimeException, VOID, ClassCastException_init_$Create$);
+  setMetadataFor(IntIterator, 'IntIterator', classMeta);
+  setMetadataFor(Companion_0, 'Companion', objectMeta);
+  setMetadataFor(IntProgression, 'IntProgression', classMeta);
+  setMetadataFor(IntRange, 'IntRange', classMeta, IntProgression);
+  setMetadataFor(IntProgressionIterator, 'IntProgressionIterator', classMeta, IntIterator);
+  setMetadataFor(Companion_1, 'Companion', objectMeta);
+  //endregion
+  function Number_0() {
+  }
+  function Unit() {
+  }
+  protoOf(Unit).toString = function () {
+    return 'kotlin.Unit';
+  };
+  var Unit_instance;
+  function Unit_getInstance() {
+    return Unit_instance;
+  }
+  function IntCompanionObject() {
+    this.MIN_VALUE = -2147483648;
+    this.MAX_VALUE = 2147483647;
+    this.SIZE_BYTES = 4;
+    this.SIZE_BITS = 32;
+  }
+  protoOf(IntCompanionObject).a = function () {
+    return this.MIN_VALUE;
+  };
+  protoOf(IntCompanionObject).b = function () {
+    return this.MAX_VALUE;
+  };
+  protoOf(IntCompanionObject).c = function () {
+    return this.SIZE_BYTES;
+  };
+  protoOf(IntCompanionObject).d = function () {
+    return this.SIZE_BITS;
+  };
+  var IntCompanionObject_instance;
+  function IntCompanionObject_getInstance() {
+    return IntCompanionObject_instance;
+  }
+  function isWhitespace(_this__u8e3s4) {
+    return isWhitespaceImpl(_this__u8e3s4);
+  }
+  function isBlank(_this__u8e3s4) {
+    var tmp;
+    if (charSequenceLength(_this__u8e3s4) === 0) {
+      tmp = true;
+    } else {
+      var tmp$ret$0;
+      $l$block_0: {
+        // Inline function 'kotlin.collections.all' call
+        var this_0 = get_indices(_this__u8e3s4);
+        var tmp_0;
+        if (isInterface(this_0, Collection)) {
+          tmp_0 = this_0.e();
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp$ret$0 = true;
+          break $l$block_0;
+        }
+        var tmp0_iterator = this_0.f();
+        while (tmp0_iterator.g()) {
+          var element = tmp0_iterator.h();
+          // Inline function 'kotlin.text.isBlank.<anonymous>' call
+          if (!isWhitespace(charSequenceGet(_this__u8e3s4, element))) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+        }
+        tmp$ret$0 = true;
+      }
+      tmp = tmp$ret$0;
+    }
+    return tmp;
+  }
+  function _Char___init__impl__6a9atx(value) {
+    return value;
+  }
+  function _get_value__a43j40($this) {
+    return $this;
+  }
+  function _Char___init__impl__6a9atx_0(code) {
+    // Inline function 'kotlin.UShort.toInt' call
+    var tmp$ret$0 = _UShort___get_data__impl__g0245(code) & 65535;
+    return _Char___init__impl__6a9atx(tmp$ret$0);
+  }
+  function Char__toInt_impl_vasixd($this) {
+    return _get_value__a43j40($this);
+  }
+  function Companion() {
+    Companion_instance = this;
+    this.i_1 = _Char___init__impl__6a9atx(0);
+    this.j_1 = _Char___init__impl__6a9atx(65535);
+    this.k_1 = _Char___init__impl__6a9atx(55296);
+    this.l_1 = _Char___init__impl__6a9atx(56319);
+    this.m_1 = _Char___init__impl__6a9atx(56320);
+    this.n_1 = _Char___init__impl__6a9atx(57343);
+    this.o_1 = _Char___init__impl__6a9atx(55296);
+    this.p_1 = _Char___init__impl__6a9atx(57343);
+    this.q_1 = 2;
+    this.r_1 = 16;
+  }
+  var Companion_instance;
+  function Companion_getInstance() {
+    if (Companion_instance == null)
+      new Companion();
+    return Companion_instance;
+  }
+  function Collection() {
+  }
+  function implement(interfaces) {
+    var maxSize = 1;
+    var masks = [];
+    var inductionVariable = 0;
+    var last = interfaces.length;
+    while (inductionVariable < last) {
+      var i = interfaces[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      var currentSize = maxSize;
+      var tmp1_elvis_lhs = i.prototype.$imask$;
+      var imask = tmp1_elvis_lhs == null ? i.$imask$ : tmp1_elvis_lhs;
+      if (!(imask == null)) {
+        masks.push(imask);
+        currentSize = imask.length;
+      }
+      var iid = i.$metadata$.iid;
+      var tmp;
+      if (iid == null) {
+        tmp = null;
+      } else {
+        // Inline function 'kotlin.let' call
+        // Inline function 'kotlin.contracts.contract' call
+        // Inline function 'kotlin.js.implement.<anonymous>' call
+        tmp = bitMaskWith(iid);
+      }
+      var iidImask = tmp;
+      if (!(iidImask == null)) {
+        masks.push(iidImask);
+        currentSize = Math.max(currentSize, iidImask.length);
+      }
+      if (currentSize > maxSize) {
+        maxSize = currentSize;
+      }
+    }
+    return compositeBitMask(maxSize, masks);
+  }
+  function bitMaskWith(activeBit) {
+    var numberIndex = activeBit >> 5;
+    var intArray = new Int32Array(numberIndex + 1 | 0);
+    var positionInNumber = activeBit & 31;
+    var numberWithSettledBit = 1 << positionInNumber;
+    intArray[numberIndex] = intArray[numberIndex] | numberWithSettledBit;
+    return intArray;
+  }
+  function compositeBitMask(capacity, masks) {
+    var tmp = 0;
+    var tmp_0 = new Int32Array(capacity);
+    while (tmp < capacity) {
+      var tmp_1 = tmp;
+      var result = 0;
+      var inductionVariable = 0;
+      var last = masks.length;
+      while (inductionVariable < last) {
+        var mask = masks[inductionVariable];
+        inductionVariable = inductionVariable + 1 | 0;
+        if (tmp_1 < mask.length) {
+          result = result | mask[tmp_1];
+        }
+      }
+      tmp_0[tmp_1] = result;
+      tmp = tmp + 1 | 0;
+    }
+    return tmp_0;
+  }
+  function isBitSet(_this__u8e3s4, possibleActiveBit) {
+    var numberIndex = possibleActiveBit >> 5;
+    if (numberIndex > _this__u8e3s4.length)
+      return false;
+    var positionInNumber = possibleActiveBit & 31;
+    var numberWithSettledBit = 1 << positionInNumber;
+    return !((_this__u8e3s4[numberIndex] & numberWithSettledBit) === 0);
+  }
+  function charSequenceGet(a, index) {
+    var tmp;
+    if (isString(a)) {
+      // Inline function 'kotlin.Char' call
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      var code = a.charCodeAt(index);
+      var tmp_0;
+      // Inline function 'kotlin.code' call
+      Companion_getInstance();
+      var this_0 = _Char___init__impl__6a9atx(0);
+      if (code < Char__toInt_impl_vasixd(this_0)) {
+        tmp_0 = true;
+      } else {
+        // Inline function 'kotlin.code' call
+        Companion_getInstance();
+        var this_1 = _Char___init__impl__6a9atx(65535);
+        tmp_0 = code > Char__toInt_impl_vasixd(this_1);
+      }
+      if (tmp_0) {
+        throw IllegalArgumentException_init_$Create$_0('Invalid Char code: ' + code);
+      }
+      tmp = numberToChar(code);
+    } else {
+      tmp = a.s(index);
+    }
+    return tmp;
+  }
+  function isString(a) {
+    return typeof a === 'string';
+  }
+  function charSequenceLength(a) {
+    var tmp;
+    if (isString(a)) {
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      tmp = a.length;
+    } else {
+      tmp = a.t();
+    }
+    return tmp;
+  }
+  function toString(o) {
+    var tmp;
+    if (o == null) {
+      tmp = 'null';
+    } else if (isArrayish(o)) {
+      tmp = '[...]';
+    } else if (!(typeof o.toString === 'function')) {
+      tmp = anyToString(o);
+    } else {
+      // Inline function 'kotlin.js.unsafeCast' call
+      tmp = o.toString();
+    }
+    return tmp;
+  }
+  function anyToString(o) {
+    return Object.prototype.toString.call(o);
+  }
+  function getStringHashCode(str) {
+    var hash = 0;
+    var length = str.length;
+    var inductionVariable = 0;
+    var last = length - 1 | 0;
+    if (inductionVariable <= last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        // Inline function 'kotlin.js.asDynamic' call
+        var code = str.charCodeAt(i);
+        hash = imul(hash, 31) + code | 0;
+      }
+       while (!(i === last));
+    return hash;
+  }
+  function captureStack(instance, constructorFunction) {
+    if (Error.captureStackTrace != null) {
+      Error.captureStackTrace(instance, constructorFunction);
+    } else {
+      // Inline function 'kotlin.js.asDynamic' call
+      instance.stack = (new Error()).stack;
+    }
+  }
+  function protoOf(constructor) {
+    return constructor.prototype;
+  }
+  function defineProp(obj, name, getter, setter) {
+    return Object.defineProperty(obj, name, {configurable: true, get: getter, set: setter});
+  }
+  function objectCreate(proto) {
+    return Object.create(proto);
+  }
+  function extendThrowable(this_, message, cause) {
+    Error.call(this_);
+    setPropertiesToThrowableInstance(this_, message, cause);
+  }
+  function setPropertiesToThrowableInstance(this_, message, cause) {
+    var errorInfo = calculateErrorInfo(Object.getPrototypeOf(this_));
+    if ((errorInfo & 1) === 0) {
+      var tmp;
+      if (message == null) {
+        var tmp_0;
+        if (!(message === null)) {
+          var tmp1_elvis_lhs = cause == null ? null : cause.toString();
+          tmp_0 = tmp1_elvis_lhs == null ? VOID : tmp1_elvis_lhs;
+        } else {
+          tmp_0 = VOID;
+        }
+        tmp = tmp_0;
+      } else {
+        tmp = message;
+      }
+      this_.message = tmp;
+    }
+    if ((errorInfo & 2) === 0) {
+      this_.cause = cause;
+    }
+    this_.name = Object.getPrototypeOf(this_).constructor.name;
+  }
+  function THROW_CCE() {
+    throw ClassCastException_init_$Create$();
+  }
+  function Long() {
+  }
+  protoOf(Long).v = function () {
+    return this.u_1;
+  };
+  function classMeta(name, defaultConstructor, associatedObjectKey, associatedObjects, suspendArity) {
+    return createMetadata('class', name, defaultConstructor, associatedObjectKey, associatedObjects, suspendArity, null);
+  }
+  function createMetadata(kind, name, defaultConstructor, associatedObjectKey, associatedObjects, suspendArity, iid) {
+    var undef = VOID;
+    return {kind: kind, simpleName: name, associatedObjectKey: associatedObjectKey, associatedObjects: associatedObjects, suspendArity: suspendArity, $kClass$: undef, defaultConstructor: defaultConstructor, iid: iid};
+  }
+  function setMetadataFor(ctor, name, metadataConstructor, parent, interfaces, defaultConstructor, associatedObjectKey, associatedObjects, suspendArity) {
+    if (!(parent == null)) {
+      ctor.prototype = Object.create(parent.prototype);
+      ctor.prototype.constructor = ctor;
+    }
+    var metadata = metadataConstructor(name, defaultConstructor, associatedObjectKey, associatedObjects, suspendArity == null ? [] : suspendArity);
+    ctor.$metadata$ = metadata;
+    if (!(interfaces == null)) {
+      var receiver = !(metadata.iid == null) ? ctor : ctor.prototype;
+      receiver.$imask$ = implement(interfaces);
+    }
+  }
+  function interfaceMeta(name, defaultConstructor, associatedObjectKey, associatedObjects, suspendArity) {
+    return createMetadata('interface', name, defaultConstructor, associatedObjectKey, associatedObjects, suspendArity, generateInterfaceId());
+  }
+  function generateInterfaceId() {
+    if (iid === VOID) {
+      iid = 0;
+    }
+    // Inline function 'kotlin.js.unsafeCast' call
+    iid = iid + 1 | 0;
+    // Inline function 'kotlin.js.unsafeCast' call
+    return iid;
+  }
+  var iid;
+  function objectMeta(name, defaultConstructor, associatedObjectKey, associatedObjects, suspendArity) {
+    return createMetadata('object', name, defaultConstructor, associatedObjectKey, associatedObjects, suspendArity, null);
+  }
+  function numberToInt(a) {
+    var tmp;
+    if (a instanceof Long) {
+      tmp = a.v();
+    } else {
+      tmp = doubleToInt(a);
+    }
+    return tmp;
+  }
+  function doubleToInt(a) {
+    var tmp;
+    if (a > 2.147483647E9) {
+      tmp = 2147483647;
+    } else if (a < -2.147483648E9) {
+      tmp = -2147483648;
+    } else {
+      // Inline function 'kotlin.js.jsBitwiseOr' call
+      tmp = a | 0;
+    }
+    return tmp;
+  }
+  function toShort(a) {
+    // Inline function 'kotlin.js.unsafeCast' call
+    return a << 16 >> 16;
+  }
+  function numberToChar(a) {
+    // Inline function 'kotlin.toUShort' call
+    var this_0 = numberToInt(a);
+    var tmp$ret$0 = _UShort___init__impl__jigrne(toShort(this_0));
+    return _Char___init__impl__6a9atx_0(tmp$ret$0);
+  }
+  function numberRangeToNumber(start, endInclusive) {
+    return new IntRange(start, endInclusive);
+  }
+  function isArrayish(o) {
+    return isJsArray(o) ? true : 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 calculateErrorInfo(proto) {
+    var tmp0_safe_receiver = proto.constructor;
+    var metadata = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.$metadata$;
+    var tmp2_safe_receiver = metadata == null ? null : metadata.errorInfo;
+    if (tmp2_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      // Inline function 'kotlin.contracts.contract' call
+      return tmp2_safe_receiver;
+    }
+    var result = 0;
+    if (hasProp(proto, 'message'))
+      result = result | 1;
+    if (hasProp(proto, 'cause'))
+      result = result | 2;
+    if (!(result === 3)) {
+      var parentProto = getPrototypeOf(proto);
+      if (parentProto != Error.prototype) {
+        result = result | calculateErrorInfo(parentProto);
+      }
+    }
+    if (!(metadata == null)) {
+      metadata.errorInfo = result;
+    }
+    return result;
+  }
+  function hasProp(proto, propName) {
+    return proto.hasOwnProperty(propName);
+  }
+  function getPrototypeOf(obj) {
+    return Object.getPrototypeOf(obj);
+  }
+  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;
+    }
+  }
+  function isWhitespaceImpl(_this__u8e3s4) {
+    // Inline function 'kotlin.code' call
+    var ch = Char__toInt_impl_vasixd(_this__u8e3s4);
+    return (((9 <= ch ? ch <= 13 : false) ? true : 28 <= ch ? ch <= 32 : false) ? true : ch === 160) ? true : ch > 4096 ? (((((ch === 5760 ? true : 8192 <= ch ? ch <= 8202 : false) ? true : ch === 8232) ? true : ch === 8233) ? true : ch === 8239) ? true : ch === 8287) ? true : ch === 12288 : false;
+  }
+  function Exception_init_$Init$($this) {
+    extendThrowable($this);
+    Exception.call($this);
+    return $this;
+  }
+  function Exception_init_$Create$() {
+    var tmp = Exception_init_$Init$(objectCreate(protoOf(Exception)));
+    captureStack(tmp, Exception_init_$Create$);
+    return tmp;
+  }
+  function Exception_init_$Init$_0(message, $this) {
+    extendThrowable($this, message);
+    Exception.call($this);
+    return $this;
+  }
+  function Exception() {
+    captureStack(this, Exception);
+  }
+  function IllegalArgumentException_init_$Init$($this) {
+    RuntimeException_init_$Init$($this);
+    IllegalArgumentException.call($this);
+    return $this;
+  }
+  function IllegalArgumentException_init_$Create$() {
+    var tmp = IllegalArgumentException_init_$Init$(objectCreate(protoOf(IllegalArgumentException)));
+    captureStack(tmp, IllegalArgumentException_init_$Create$);
+    return tmp;
+  }
+  function IllegalArgumentException_init_$Init$_0(message, $this) {
+    RuntimeException_init_$Init$_0(message, $this);
+    IllegalArgumentException.call($this);
+    return $this;
+  }
+  function IllegalArgumentException_init_$Create$_0(message) {
+    var tmp = IllegalArgumentException_init_$Init$_0(message, objectCreate(protoOf(IllegalArgumentException)));
+    captureStack(tmp, IllegalArgumentException_init_$Create$_0);
+    return tmp;
+  }
+  function IllegalArgumentException() {
+    captureStack(this, IllegalArgumentException);
+  }
+  function RuntimeException_init_$Init$($this) {
+    Exception_init_$Init$($this);
+    RuntimeException.call($this);
+    return $this;
+  }
+  function RuntimeException_init_$Create$() {
+    var tmp = RuntimeException_init_$Init$(objectCreate(protoOf(RuntimeException)));
+    captureStack(tmp, RuntimeException_init_$Create$);
+    return tmp;
+  }
+  function RuntimeException_init_$Init$_0(message, $this) {
+    Exception_init_$Init$_0(message, $this);
+    RuntimeException.call($this);
+    return $this;
+  }
+  function RuntimeException() {
+    captureStack(this, RuntimeException);
+  }
+  function NoSuchElementException_init_$Init$($this) {
+    RuntimeException_init_$Init$($this);
+    NoSuchElementException.call($this);
+    return $this;
+  }
+  function NoSuchElementException_init_$Create$() {
+    var tmp = NoSuchElementException_init_$Init$(objectCreate(protoOf(NoSuchElementException)));
+    captureStack(tmp, NoSuchElementException_init_$Create$);
+    return tmp;
+  }
+  function NoSuchElementException() {
+    captureStack(this, NoSuchElementException);
+  }
+  function ClassCastException_init_$Init$($this) {
+    RuntimeException_init_$Init$($this);
+    ClassCastException.call($this);
+    return $this;
+  }
+  function ClassCastException_init_$Create$() {
+    var tmp = ClassCastException_init_$Init$(objectCreate(protoOf(ClassCastException)));
+    captureStack(tmp, ClassCastException_init_$Create$);
+    return tmp;
+  }
+  function ClassCastException() {
+    captureStack(this, ClassCastException);
+  }
+  function IntIterator() {
+  }
+  protoOf(IntIterator).h = function () {
+    return this.y();
+  };
+  function getProgressionLastElement(start, end, step) {
+    var tmp;
+    if (step > 0) {
+      tmp = start >= end ? end : end - differenceModulo(end, start, step) | 0;
+    } else if (step < 0) {
+      tmp = start <= end ? end : end + differenceModulo(start, end, -step | 0) | 0;
+    } else {
+      throw IllegalArgumentException_init_$Create$_0('Step is zero.');
+    }
+    return tmp;
+  }
+  function differenceModulo(a, b, c) {
+    return mod(mod(a, c) - mod(b, c) | 0, c);
+  }
+  function mod(a, b) {
+    var mod = a % b | 0;
+    return mod >= 0 ? mod : mod + b | 0;
+  }
+  function Companion_0() {
+    Companion_instance_0 = this;
+    this.z_1 = new IntRange(1, 0);
+  }
+  var Companion_instance_0;
+  function Companion_getInstance_0() {
+    if (Companion_instance_0 == null)
+      new Companion_0();
+    return Companion_instance_0;
+  }
+  function IntRange(start, endInclusive) {
+    Companion_getInstance_0();
+    IntProgression.call(this, start, endInclusive, 1);
+  }
+  protoOf(IntRange).toString = function () {
+    return '' + this.a1_1 + '..' + this.b1_1;
+  };
+  function IntProgressionIterator(first, last, step) {
+    IntIterator.call(this);
+    this.d1_1 = step;
+    this.e1_1 = last;
+    this.f1_1 = this.d1_1 > 0 ? first <= last : first >= last;
+    this.g1_1 = this.f1_1 ? first : this.e1_1;
+  }
+  protoOf(IntProgressionIterator).g = function () {
+    return this.f1_1;
+  };
+  protoOf(IntProgressionIterator).y = function () {
+    var value = this.g1_1;
+    if (value === this.e1_1) {
+      if (!this.f1_1)
+        throw NoSuchElementException_init_$Create$();
+      this.f1_1 = false;
+    } else {
+      this.g1_1 = this.g1_1 + this.d1_1 | 0;
+    }
+    return value;
+  };
+  function Companion_1() {
+  }
+  var Companion_instance_1;
+  function Companion_getInstance_1() {
+    return Companion_instance_1;
+  }
+  function IntProgression(start, endInclusive, step) {
+    if (step === 0)
+      throw IllegalArgumentException_init_$Create$_0('Step must be non-zero.');
+    if (step === IntCompanionObject_instance.MIN_VALUE)
+      throw IllegalArgumentException_init_$Create$_0('Step must be greater than Int.MIN_VALUE to avoid overflow on negation.');
+    this.a1_1 = start;
+    this.b1_1 = getProgressionLastElement(start, endInclusive, step);
+    this.c1_1 = step;
+  }
+  protoOf(IntProgression).f = function () {
+    return new IntProgressionIterator(this.a1_1, this.b1_1, this.c1_1);
+  };
+  protoOf(IntProgression).toString = function () {
+    return this.c1_1 > 0 ? '' + this.a1_1 + '..' + this.b1_1 + ' step ' + this.c1_1 : '' + this.a1_1 + ' downTo ' + this.b1_1 + ' step ' + (-this.c1_1 | 0);
+  };
+  function get_indices(_this__u8e3s4) {
+    return numberRangeToNumber(0, charSequenceLength(_this__u8e3s4) - 1 | 0);
+  }
+  function _UShort___init__impl__jigrne(data) {
+    return data;
+  }
+  function _UShort___get_data__impl__g0245($this) {
+    return $this;
+  }
+  //region block: init
+  Unit_instance = new Unit();
+  IntCompanionObject_instance = new IntCompanionObject();
+  Companion_instance_1 = new Companion_1();
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = VOID;
+  _.$_$.b = IllegalArgumentException_init_$Create$_0;
+  _.$_$.c = charSequenceLength;
+  _.$_$.d = classMeta;
+  _.$_$.e = defineProp;
+  _.$_$.f = getStringHashCode;
+  _.$_$.g = interfaceMeta;
+  _.$_$.h = objectMeta;
+  _.$_$.i = protoOf;
+  _.$_$.j = setMetadataFor;
+  _.$_$.k = toString;
+  _.$_$.l = isBlank;
+  _.$_$.m = THROW_CCE;
+  //endregion
+  return _;
+}(module.exports));
+
+//# sourceMappingURL=kotlin-kotlin-stdlib.js.map