@doordeck/doordeck-headless-sdk 0.68.0 → 0.71.0

package/kotlin/kotlinx-io-kotlinx-io-bytestring.js

@@ -1,6 +1,202 @@
-(function (_) {
+(function (_, kotlin_kotlin) {
   'use strict';
+  //region block: imports
+  var imul = Math.imul;
+  var VOID = kotlin_kotlin.$_$.h;
+  var copyOfRange = kotlin_kotlin.$_$.k6;
+  var protoOf = kotlin_kotlin.$_$.sb;
+  var objectCreate = kotlin_kotlin.$_$.rb;
+  var toCharArray = kotlin_kotlin.$_$.zd;
+  var initMetadataForCompanion = kotlin_kotlin.$_$.sa;
+  var getKClassFromExpression = kotlin_kotlin.$_$.e;
+  var THROW_CCE = kotlin_kotlin.$_$.lf;
+  var Unit_instance = kotlin_kotlin.$_$.j5;
+  var contentEquals = kotlin_kotlin.$_$.g6;
+  var contentHashCode = kotlin_kotlin.$_$.h6;
+  var IndexOutOfBoundsException_init_$Create$ = kotlin_kotlin.$_$.d2;
+  var _UByte___init__impl__g9hnc4 = kotlin_kotlin.$_$.e3;
+  var _UByte___get_data__impl__jof9qr = kotlin_kotlin.$_$.f3;
+  var compareTo = kotlin_kotlin.$_$.ha;
+  var StringBuilder_init_$Create$ = kotlin_kotlin.$_$.i1;
+  var _Char___init__impl__6a9atx = kotlin_kotlin.$_$.s2;
+  var Comparable = kotlin_kotlin.$_$.we;
+  var initMetadataForClass = kotlin_kotlin.$_$.ra;
+  var decodeToString = kotlin_kotlin.$_$.pc;
+  var initMetadataForObject = kotlin_kotlin.$_$.xa;
+  //endregion
   //region block: pre-declaration
+  initMetadataForCompanion(Companion);
+  initMetadataForClass(ByteString, 'ByteString', VOID, VOID, [Comparable]);
+  initMetadataForObject(UnsafeByteStringOperations, 'UnsafeByteStringOperations');
+  //endregion
+  function ByteString_init_$Init$(data, startIndex, endIndex, $this) {
+    startIndex = startIndex === VOID ? 0 : startIndex;
+    endIndex = endIndex === VOID ? data.length : endIndex;
+    ByteString.call($this, copyOfRange(data, startIndex, endIndex), null);
+    return $this;
+  }
+  function ByteString_init_$Create$(data, startIndex, endIndex) {
+    return ByteString_init_$Init$(data, startIndex, endIndex, objectCreate(protoOf(ByteString)));
+  }
+  function Companion() {
+    Companion_instance = this;
+    this.s1d_1 = new ByteString(new Int8Array(0), null);
+    this.t1d_1 = toCharArray('0123456789abcdef');
+  }
+  protoOf(Companion).u1d = function (byteArray) {
+    return new ByteString(byteArray, null);
+  };
+  var Companion_instance;
+  function Companion_getInstance() {
+    if (Companion_instance == null)
+      new Companion();
+    return Companion_instance;
+  }
+  function ByteString(data, dummy) {
+    Companion_getInstance();
+    this.v1d_1 = data;
+    this.w1d_1 = 0;
+  }
+  protoOf(ByteString).s = function () {
+    return this.v1d_1.length;
+  };
+  protoOf(ByteString).equals = function (other) {
+    if (this === other)
+      return true;
+    if (other == null || !getKClassFromExpression(this).equals(getKClassFromExpression(other)))
+      return false;
+    if (!(other instanceof ByteString))
+      THROW_CCE();
+    if (!(other.v1d_1.length === this.v1d_1.length))
+      return false;
+    if (!(other.w1d_1 === 0) && !(this.w1d_1 === 0) && !(other.w1d_1 === this.w1d_1))
+      return false;
+    return contentEquals(this.v1d_1, other.v1d_1);
+  };
+  protoOf(ByteString).hashCode = function () {
+    var hc = this.w1d_1;
+    if (hc === 0) {
+      hc = contentHashCode(this.v1d_1);
+      this.w1d_1 = hc;
+    }
+    return hc;
+  };
+  protoOf(ByteString).u = function (index) {
+    if (index < 0 || index >= this.s())
+      throw IndexOutOfBoundsException_init_$Create$('index (' + index + ') is out of byte string bounds: [0..' + this.s() + ')');
+    return this.v1d_1[index];
+  };
+  protoOf(ByteString).x1d = function (startIndex, endIndex) {
+    var tmp;
+    if (startIndex === endIndex) {
+      tmp = Companion_getInstance().s1d_1;
+    } else {
+      tmp = ByteString_init_$Create$(this.v1d_1, startIndex, endIndex);
+    }
+    return tmp;
+  };
+  protoOf(ByteString).y1d = function (startIndex, endIndex, $super) {
+    endIndex = endIndex === VOID ? this.s() : endIndex;
+    return $super === VOID ? this.x1d(startIndex, endIndex) : $super.x1d.call(this, startIndex, endIndex);
+  };
+  protoOf(ByteString).z1d = function (other) {
+    if (other === this)
+      return 0;
+    var localData = this.v1d_1;
+    var otherData = other.v1d_1;
+    var inductionVariable = 0;
+    var tmp0 = this.s();
+    // Inline function 'kotlin.math.min' call
+    var b = other.s();
+    var last = Math.min(tmp0, b);
+    if (inductionVariable < last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        // Inline function 'kotlin.toUByte' call
+        var this_0 = localData[i];
+        var tmp4 = _UByte___init__impl__g9hnc4(this_0);
+        // Inline function 'kotlin.toUByte' call
+        var this_1 = otherData[i];
+        // Inline function 'kotlin.UByte.compareTo' call
+        var other_0 = _UByte___init__impl__g9hnc4(this_1);
+        // Inline function 'kotlin.UByte.toInt' call
+        var tmp = _UByte___get_data__impl__jof9qr(tmp4) & 255;
+        // Inline function 'kotlin.UByte.toInt' call
+        var tmp$ret$4 = _UByte___get_data__impl__jof9qr(other_0) & 255;
+        var cmp = compareTo(tmp, tmp$ret$4);
+        if (!(cmp === 0))
+          return cmp;
+      }
+       while (inductionVariable < last);
+    return compareTo(this.s(), other.s());
+  };
+  protoOf(ByteString).d = function (other) {
+    return this.z1d(other instanceof ByteString ? other : THROW_CCE());
+  };
+  protoOf(ByteString).toString = function () {
+    if (isEmpty(this)) {
+      return 'ByteString(size=0)';
+    }
+    var sizeStr = this.s().toString();
+    var len = (22 + sizeStr.length | 0) + imul(this.s(), 2) | 0;
+    // Inline function 'kotlin.with' call
+    // Inline function 'kotlinx.io.bytestring.ByteString.toString.<anonymous>' call
+    var $this$with = StringBuilder_init_$Create$(len);
+    $this$with.r8('ByteString(size=');
+    $this$with.r8(sizeStr);
+    $this$with.r8(' hex=');
+    var localData = this.v1d_1;
+    var inductionVariable = 0;
+    var last = this.s();
+    if (inductionVariable < last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var b = localData[i];
+        $this$with.s8(Companion_getInstance().t1d_1[(b >>> 4 | 0) & 15]);
+        $this$with.s8(Companion_getInstance().t1d_1[b & 15]);
+      }
+       while (inductionVariable < last);
+    return $this$with.s8(_Char___init__impl__6a9atx(41)).toString();
+  };
+  protoOf(ByteString).a1e = function () {
+    return this.v1d_1;
+  };
+  function ByteString_0(bytes) {
+    var tmp;
+    // Inline function 'kotlin.collections.isEmpty' call
+    if (bytes.length === 0) {
+      tmp = Companion_getInstance().s1d_1;
+    } else {
+      tmp = Companion_getInstance().u1d(bytes);
+    }
+    return tmp;
+  }
+  function isEmpty(_this__u8e3s4) {
+    return _this__u8e3s4.s() === 0;
+  }
+  function decodeToString_0(_this__u8e3s4) {
+    return decodeToString(_this__u8e3s4.a1e());
+  }
+  function UnsafeByteStringOperations() {
+  }
+  protoOf(UnsafeByteStringOperations).b1e = function (array) {
+    return Companion_getInstance().u1d(array);
+  };
+  var UnsafeByteStringOperations_instance;
+  function UnsafeByteStringOperations_getInstance() {
+    return UnsafeByteStringOperations_instance;
+  }
+  //region block: init
+  UnsafeByteStringOperations_instance = new UnsafeByteStringOperations();
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = ByteString_init_$Create$;
+  _.$_$.b = UnsafeByteStringOperations_instance;
+  _.$_$.c = ByteString_0;
+  _.$_$.d = decodeToString_0;
   //endregion
   return _;
-}(module.exports));
+}(module.exports, require('./kotlin-kotlin-stdlib.js')));