@continuous-excellence/coupling-cli 0.0.0

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/selects/Select.mjs

@@ -0,0 +1,268 @@
+import {
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  equals2au1ep9vhcato as equals,
+  toString1pkumu07cwy4m as toString,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { plus20p0vtfmu0596 as plus } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_Collections.mjs';
+import { KtList3hktaavzmj137 as KtList } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/Collections.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { listOfvhqybd2zx248 as listOf } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/collectionJs.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { CancellableContinuationpb2x00mxmcbt as CancellableContinuation } from '../CancellableContinuation.mjs';
+import { CancelHandler3ic7xysezxbm5 as CancelHandler } from '../CancellableContinuationImpl.mjs';
+import { Waiter3lxa2a79zyo0g as Waiter } from '../Waiter.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { Enum3alwj03lh1n41 as Enum } from '../../../../kotlin-kotlin-stdlib/kotlin/Enum.mjs';
+import { Symbol17xuwzgi5g8ve as Symbol } from '../internal/Symbol.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var DUMMY_PROCESS_RESULT_FUNCTION;
+function get_STATE_REG() {
+  _init_properties_Select_kt__zhm2jg();
+  return STATE_REG;
+}
+var STATE_REG;
+function get_STATE_COMPLETED() {
+  _init_properties_Select_kt__zhm2jg();
+  return STATE_COMPLETED;
+}
+var STATE_COMPLETED;
+function get_STATE_CANCELLED() {
+  _init_properties_Select_kt__zhm2jg();
+  return STATE_CANCELLED;
+}
+var STATE_CANCELLED;
+function get_NO_RESULT() {
+  _init_properties_Select_kt__zhm2jg();
+  return NO_RESULT;
+}
+var NO_RESULT;
+var PARAM_CLAUSE_0;
+var SelectInstanceClass;
+function SelectInstance() {
+  if (SelectInstanceClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'SelectInstance');
+    SelectInstanceClass = $;
+  }
+  return SelectInstanceClass;
+}
+function trySelectInternal($this, clauseObject, internalResult) {
+  $l$loop: while (true) {
+    var curState = $this.j1b_1.kotlinx$atomicfu$value;
+    if (isInterface(curState, CancellableContinuation())) {
+      var tmp0_elvis_lhs = findClause($this, clauseObject);
+      var tmp;
+      if (tmp0_elvis_lhs == null) {
+        continue $l$loop;
+      } else {
+        tmp = tmp0_elvis_lhs;
+      }
+      var clause = tmp;
+      var onCancellation = clause.j1l($this, internalResult);
+      if ($this.j1b_1.atomicfu$compareAndSet(curState, clause)) {
+        var cont = isInterface(curState, CancellableContinuation()) ? curState : THROW_CCE();
+        $this.l1b_1 = internalResult;
+        if (tryResume(cont, onCancellation))
+          return 0;
+        $this.l1b_1 = get_NO_RESULT();
+        return 2;
+      }
+    } else {
+      var tmp_0;
+      if (equals(curState, get_STATE_COMPLETED())) {
+        tmp_0 = true;
+      } else {
+        tmp_0 = curState instanceof ClauseData();
+      }
+      if (tmp_0)
+        return 3;
+      else {
+        if (equals(curState, get_STATE_CANCELLED()))
+          return 2;
+        else {
+          if (equals(curState, get_STATE_REG())) {
+            if ($this.j1b_1.atomicfu$compareAndSet(curState, listOf(clauseObject)))
+              return 1;
+          } else {
+            if (isInterface(curState, KtList())) {
+              if ($this.j1b_1.atomicfu$compareAndSet(curState, plus(curState, clauseObject)))
+                return 1;
+            } else {
+              // Inline function 'kotlin.error' call
+              var message = 'Unexpected state: ' + toString(curState);
+              throw IllegalStateException().o(toString(message));
+            }
+          }
+        }
+      }
+    }
+  }
+}
+function findClause($this, clauseObject) {
+  var tmp0_elvis_lhs = $this.k1b_1;
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    return null;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var clauses = tmp;
+  // Inline function 'kotlin.collections.find' call
+  var tmp$ret$1;
+  $l$block: {
+    // Inline function 'kotlin.collections.firstOrNull' call
+    var _iterator__ex2g4s = clauses.q1();
+    while (_iterator__ex2g4s.r1()) {
+      var element = _iterator__ex2g4s.s1();
+      if (element.g1l_1 === clauseObject) {
+        tmp$ret$1 = element;
+        break $l$block;
+      }
+    }
+    tmp$ret$1 = null;
+  }
+  var tmp1_elvis_lhs = tmp$ret$1;
+  var tmp_0;
+  if (tmp1_elvis_lhs == null) {
+    var message = 'Clause with object ' + toString(clauseObject) + ' is not found';
+    throw IllegalStateException().o(toString(message));
+  } else {
+    tmp_0 = tmp1_elvis_lhs;
+  }
+  return tmp_0;
+}
+var ClauseDataClass;
+function ClauseData() {
+  if (ClauseDataClass === VOID) {
+    class $ {
+      j1l(select, internalResult) {
+        var tmp0_safe_receiver = this.i1l_1;
+        return tmp0_safe_receiver == null ? null : tmp0_safe_receiver(select, this.h1l_1, internalResult);
+      }
+    }
+    initMetadataForClass($, 'ClauseData', VOID, VOID, VOID, [1]);
+    ClauseDataClass = $;
+  }
+  return ClauseDataClass;
+}
+var SelectImplementationClass;
+function SelectImplementation() {
+  if (SelectImplementationClass === VOID) {
+    class $ {
+      m1b(clauseObject, result) {
+        return TrySelectDetailedResult_0(trySelectInternal(this, clauseObject, result));
+      }
+    }
+    initMetadataForClass($, 'SelectImplementation', VOID, VOID, [CancelHandler(), SelectInstance(), Waiter()], [0, 2]);
+    SelectImplementationClass = $;
+  }
+  return SelectImplementationClass;
+}
+var TrySelectDetailedResult_SUCCESSFUL_instance;
+var TrySelectDetailedResult_REREGISTER_instance;
+var TrySelectDetailedResult_CANCELLED_instance;
+var TrySelectDetailedResult_ALREADY_SELECTED_instance;
+var TrySelectDetailedResult_entriesInitialized;
+function TrySelectDetailedResult_initEntries() {
+  if (TrySelectDetailedResult_entriesInitialized)
+    return Unit_instance;
+  TrySelectDetailedResult_entriesInitialized = true;
+  TrySelectDetailedResult_SUCCESSFUL_instance = new (TrySelectDetailedResult())('SUCCESSFUL', 0);
+  TrySelectDetailedResult_REREGISTER_instance = new (TrySelectDetailedResult())('REREGISTER', 1);
+  TrySelectDetailedResult_CANCELLED_instance = new (TrySelectDetailedResult())('CANCELLED', 2);
+  TrySelectDetailedResult_ALREADY_SELECTED_instance = new (TrySelectDetailedResult())('ALREADY_SELECTED', 3);
+}
+var TrySelectDetailedResultClass;
+function TrySelectDetailedResult() {
+  if (TrySelectDetailedResultClass === VOID) {
+    class $ extends Enum() {}
+    initMetadataForClass($, 'TrySelectDetailedResult');
+    TrySelectDetailedResultClass = $;
+  }
+  return TrySelectDetailedResultClass;
+}
+function TrySelectDetailedResult_0(trySelectInternalResult) {
+  _init_properties_Select_kt__zhm2jg();
+  var tmp;
+  switch (trySelectInternalResult) {
+    case 0:
+      tmp = TrySelectDetailedResult_SUCCESSFUL_getInstance();
+      break;
+    case 1:
+      tmp = TrySelectDetailedResult_REREGISTER_getInstance();
+      break;
+    case 2:
+      tmp = TrySelectDetailedResult_CANCELLED_getInstance();
+      break;
+    case 3:
+      tmp = TrySelectDetailedResult_ALREADY_SELECTED_getInstance();
+      break;
+    default:
+      var message = 'Unexpected internal result: ' + trySelectInternalResult;
+      throw IllegalStateException().o(toString(message));
+  }
+  return tmp;
+}
+function tryResume(_this__u8e3s4, onCancellation) {
+  _init_properties_Select_kt__zhm2jg();
+  var tmp0_elvis_lhs = _this__u8e3s4.a11(Unit_instance, null, onCancellation);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    return false;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var token = tmp;
+  _this__u8e3s4.gz(token);
+  return true;
+}
+function DUMMY_PROCESS_RESULT_FUNCTION$lambda(_unused_var__etf5q3, _unused_var__etf5q3_0, _unused_var__etf5q3_1) {
+  _init_properties_Select_kt__zhm2jg();
+  return null;
+}
+function TrySelectDetailedResult_SUCCESSFUL_getInstance() {
+  TrySelectDetailedResult_initEntries();
+  return TrySelectDetailedResult_SUCCESSFUL_instance;
+}
+function TrySelectDetailedResult_REREGISTER_getInstance() {
+  TrySelectDetailedResult_initEntries();
+  return TrySelectDetailedResult_REREGISTER_instance;
+}
+function TrySelectDetailedResult_CANCELLED_getInstance() {
+  TrySelectDetailedResult_initEntries();
+  return TrySelectDetailedResult_CANCELLED_instance;
+}
+function TrySelectDetailedResult_ALREADY_SELECTED_getInstance() {
+  TrySelectDetailedResult_initEntries();
+  return TrySelectDetailedResult_ALREADY_SELECTED_instance;
+}
+var properties_initialized_Select_kt_7rpl36;
+function _init_properties_Select_kt__zhm2jg() {
+  if (!properties_initialized_Select_kt_7rpl36) {
+    properties_initialized_Select_kt_7rpl36 = true;
+    DUMMY_PROCESS_RESULT_FUNCTION = DUMMY_PROCESS_RESULT_FUNCTION$lambda;
+    STATE_REG = new (Symbol())('STATE_REG');
+    STATE_COMPLETED = new (Symbol())('STATE_COMPLETED');
+    STATE_CANCELLED = new (Symbol())('STATE_CANCELLED');
+    NO_RESULT = new (Symbol())('NO_RESULT');
+    PARAM_CLAUSE_0 = new (Symbol())('PARAM_CLAUSE_0');
+  }
+}
+//region block: exports
+export {
+  TrySelectDetailedResult_REREGISTER_getInstance as TrySelectDetailedResult_REREGISTER_getInstance37wb4scq4deq9,
+  TrySelectDetailedResult_SUCCESSFUL_getInstance as TrySelectDetailedResult_SUCCESSFUL_getInstancekmsh4z99o2un,
+  SelectImplementation as SelectImplementation59ci94k9x9wm,
+  SelectInstance as SelectInstance2isepgzfsd8ur,
+};
+//endregion
+
+//# sourceMappingURL=Select.mjs.map

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/selects/Select.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/selects/Select.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/selects/src/kotlin/util/Preconditions.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/selects/common/src/generated/_Collections.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-STATE_REG>","<get-STATE_COMPLETED>","<get-STATE_CANCELLED>","<get-NO_RESULT>","trySelectInternal","clauseObject","internalResult","curState","clause","onCancellation","cont","findClause","clauses","element","createOnCancellationAction","select","trySelectDetailed","result","TrySelectDetailedResult","trySelectInternalResult","tryResume","<this>","token","DUMMY_PROCESS_RESULT_FUNCTION$lambda","<init properties Select.kt>"],"mappings":"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"}

package/kotlin/kotlinx-io-kotlinx-io-bytestring/kotlinx/io/bytestring/ByteString.mjs

@@ -0,0 +1,210 @@
+import {
+  toCharArray32huqyw9tt7kx as toCharArray,
+  decodeToString1x4faah2liw2p as decodeToString,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/text/stringJs.mjs';
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { createThis2j2avj17cvnv2 as createThis } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import {
+  copyOfRange3alro60z4hhf8 as copyOfRange,
+  contentEquals1cdp6c846cfdi as contentEquals,
+  contentHashCode25jw6rgkgywwr as contentHashCode,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_ArraysJs.mjs';
+import { getKClassFromExpression348iqjl4fnx2f as getKClassFromExpression } from '../../../../kotlin-kotlin-stdlib/kotlin/reflect/js/internal/reflection.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { IndexOutOfBoundsException1qfr429iumro0 as IndexOutOfBoundsException } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import {
+  _UByte___init__impl__g9hnc418b8pq346rvu4 as _UByte___init__impl__g9hnc4,
+  _UByte___get_data__impl__jof9qrfg5oujomrowy as _UByte___get_data__impl__jof9qr,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/UByte.mjs';
+import { compareTo3ankvs086tmwq as compareTo } from '../../../../kotlin-kotlin-stdlib/kotlin/js/compareTo.mjs';
+import { StringBuildermazzzhj6kkai as StringBuilder } from '../../../../kotlin-kotlin-stdlib/kotlin/text/StringBuilderJs.mjs';
+import { _Char___init__impl__6a9atx1csff5kwtduxl as _Char___init__impl__6a9atx } from '../../../../kotlin-kotlin-stdlib/kotlin/Char.mjs';
+import { Comparable198qfk8pnblz0 as Comparable } from '../../../../kotlin-kotlin-stdlib/kotlin/Comparable.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.m1n_1 = ByteString().q1n(new Int8Array(0), null);
+        this.n1n_1 = toCharArray('0123456789abcdef');
+      }
+      r1n(byteArray) {
+        return ByteString().q1n(byteArray, null);
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  if (Companion_instance === VOID)
+    new (Companion())();
+  return Companion_instance;
+}
+var ByteStringClass;
+function ByteString() {
+  if (ByteStringClass === VOID) {
+    class $ {
+      static q1n(data, dummy) {
+        Companion_getInstance();
+        var $this = createThis(this);
+        $this.o1n_1 = data;
+        $this.p1n_1 = 0;
+        return $this;
+      }
+      static s1n(data, startIndex, endIndex) {
+        Companion_getInstance();
+        startIndex = startIndex === VOID ? 0 : startIndex;
+        endIndex = endIndex === VOID ? data.length : endIndex;
+        return this.q1n(copyOfRange(data, startIndex, endIndex), null);
+      }
+      v2() {
+        return this.o1n_1.length;
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (other == null || !getKClassFromExpression(this).equals(getKClassFromExpression(other)))
+          return false;
+        if (!(other instanceof ByteString()))
+          THROW_CCE();
+        if (!(other.o1n_1.length === this.o1n_1.length))
+          return false;
+        if (!(other.p1n_1 === 0) && !(this.p1n_1 === 0) && !(other.p1n_1 === this.p1n_1))
+          return false;
+        return contentEquals(this.o1n_1, other.o1n_1);
+      }
+      hashCode() {
+        var hc = this.p1n_1;
+        if (hc === 0) {
+          hc = contentHashCode(this.o1n_1);
+          this.p1n_1 = hc;
+        }
+        return hc;
+      }
+      u2(index) {
+        if (index < 0 || index >= this.v2())
+          throw IndexOutOfBoundsException().qe('index (' + index + ') is out of byte string bounds: [0..' + this.v2() + ')');
+        return this.o1n_1[index];
+      }
+      t1n(startIndex, endIndex) {
+        var tmp;
+        if (startIndex === endIndex) {
+          tmp = Companion_getInstance().m1n_1;
+        } else {
+          tmp = ByteString().s1n(this.o1n_1, startIndex, endIndex);
+        }
+        return tmp;
+      }
+      u1n(startIndex, endIndex, $super) {
+        endIndex = endIndex === VOID ? this.v2() : endIndex;
+        return $super === VOID ? this.t1n(startIndex, endIndex) : $super.t1n.call(this, startIndex, endIndex);
+      }
+      v1n(other) {
+        if (other === this)
+          return 0;
+        var localData = this.o1n_1;
+        var otherData = other.o1n_1;
+        var inductionVariable = 0;
+        var tmp0 = this.v2();
+        // Inline function 'kotlin.math.min' call
+        var b = other.v2();
+        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 tmp0_0 = _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(tmp0_0) & 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.v2(), other.v2());
+      }
+      d(other) {
+        return this.v1n(other instanceof ByteString() ? other : THROW_CCE());
+      }
+      toString() {
+        if (isEmpty(this)) {
+          return 'ByteString(size=0)';
+        }
+        var sizeStr = this.v2().toString();
+        var len = (22 + sizeStr.length | 0) + imul(this.v2(), 2) | 0;
+        // Inline function 'kotlin.with' call
+        var $this$with = StringBuilder().gc(len);
+        $this$with.n1('ByteString(size=');
+        $this$with.n1(sizeStr);
+        $this$with.n1(' hex=');
+        var localData = this.o1n_1;
+        var inductionVariable = 0;
+        var last = this.v2();
+        if (inductionVariable < last)
+          do {
+            var i = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            var b = localData[i];
+            $this$with.p1(Companion_getInstance().n1n_1[(b >>> 4 | 0) & 15]);
+            $this$with.p1(Companion_getInstance().n1n_1[b & 15]);
+          }
+           while (inductionVariable < last);
+        return $this$with.p1(_Char___init__impl__6a9atx(41)).toString();
+      }
+      w1n() {
+        return this.o1n_1;
+      }
+    }
+    initMetadataForClass($, 'ByteString', VOID, VOID, [Comparable()]);
+    ByteStringClass = $;
+  }
+  return ByteStringClass;
+}
+function ByteString_0(bytes) {
+  var tmp;
+  // Inline function 'kotlin.collections.isEmpty' call
+  if (bytes.length === 0) {
+    tmp = Companion_getInstance().m1n_1;
+  } else {
+    tmp = Companion_getInstance().r1n(bytes);
+  }
+  return tmp;
+}
+function decodeToString_0(_this__u8e3s4) {
+  return decodeToString(_this__u8e3s4.w1n());
+}
+function isEmpty(_this__u8e3s4) {
+  return _this__u8e3s4.v2() === 0;
+}
+//region block: exports
+export {
+  Companion_getInstance as Companion_getInstance1n5a3xz7n277t,
+  ByteString_0 as ByteString3c9fk8lsh3lvs,
+  ByteString as ByteString10sanmoo66key,
+  decodeToString_0 as decodeToString2ede220pr5xir,
+};
+//endregion
+
+//# sourceMappingURL=ByteString.mjs.map

package/kotlin/kotlinx-io-kotlinx-io-bytestring/kotlinx/io/bytestring/ByteString.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../.gradle/daemon/9.3.0/Z:/BuildAgent/work/22e3a7db6b861ba7/bytestring/common/src/ByteString.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlinx-io-kotlinx-io-bytestring/kotlinx/io/bytestring/js/src/kotlin/math.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlinx-io-kotlinx-io-bytestring/kotlinx/io/bytestring/unsigned/src/kotlin/UByte.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlinx-io-kotlinx-io-bytestring/kotlinx/io/bytestring/common/src/generated/_Arrays.kt"],"sourcesContent":[null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["wrap","byteArray","data","dummy","startIndex","endIndex","<get-size>","equals","other","hashCode","hc","get","index","substring","substring$default","compareTo","localData","otherData","i","cmp","toString","sizeStr","len","b","getBackingArrayReference","ByteString","bytes","decodeToString","<this>","isEmpty"],"mappings":"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"}

package/kotlin/kotlinx-io-kotlinx-io-bytestring/kotlinx/io/bytestring/unsafe/UnsafeByteStringOperations.mjs

@@ -0,0 +1,34 @@
+import { Companion_getInstance1n5a3xz7n277t as Companion_getInstance } from '../ByteString.mjs';
+import { initMetadataForObject1cxne3s9w65el as initMetadataForObject } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var UnsafeByteStringOperationsClass;
+function UnsafeByteStringOperations() {
+  if (UnsafeByteStringOperationsClass === VOID) {
+    class $ {
+      x1n(array) {
+        return Companion_getInstance().r1n(array);
+      }
+    }
+    initMetadataForObject($, 'UnsafeByteStringOperations');
+    UnsafeByteStringOperationsClass = $;
+  }
+  return UnsafeByteStringOperationsClass;
+}
+var UnsafeByteStringOperations_instance;
+function UnsafeByteStringOperations_getInstance() {
+  return UnsafeByteStringOperations_instance;
+}
+//region block: init
+UnsafeByteStringOperations_instance = new (UnsafeByteStringOperations())();
+//endregion
+//region block: exports
+export {
+  UnsafeByteStringOperations_instance as UnsafeByteStringOperations_instance35zx8xrp4hu2p,
+};
+//endregion
+
+//# sourceMappingURL=UnsafeByteStringOperations.mjs.map

package/kotlin/kotlinx-io-kotlinx-io-bytestring/kotlinx/io/bytestring/unsafe/UnsafeByteStringOperations.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../.gradle/daemon/9.3.0/Z:/BuildAgent/work/22e3a7db6b861ba7/bytestring/common/src/unsafe/UnsafeByteStringOperations.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["wrapUnsafe","array"],"mappings":";;;;;;;;;;;SA6BIA,CAAsBC,KAAtBD,EAAsD;A,QAAsB,OAAX,4BAAK,KAAL,C;MAAU,C;;;;;;;;;;;;;;;;;;"}

package/kotlin/kotlinx-io-kotlinx-io-core/kotlinx/io/-PlatformJs.mjs

@@ -0,0 +1,67 @@
+import { captureStack1fzi4aczwc4hg as captureStack } from '../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { Exceptiondt2hlxn7j7vw as Exception } from '../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function init_kotlinx_io_IOException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.h1r_1);
+}
+var IOExceptionClass;
+function IOException() {
+  if (IOExceptionClass === VOID) {
+    class $ extends Exception() {
+      static i1r() {
+        var $this = this.ke();
+        init_kotlinx_io_IOException($this);
+        return $this;
+      }
+      static j1r(message) {
+        var $this = this.l5(message);
+        init_kotlinx_io_IOException($this);
+        return $this;
+      }
+      static k1r(message, cause) {
+        var $this = this.le(message, cause);
+        init_kotlinx_io_IOException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'IOException', $.i1r);
+    IOExceptionClass = $;
+  }
+  return IOExceptionClass;
+}
+function init_kotlinx_io_EOFException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.d1o_1);
+}
+var EOFExceptionClass;
+function EOFException() {
+  if (EOFExceptionClass === VOID) {
+    class $ extends IOException() {
+      static l1r() {
+        var $this = this.i1r();
+        init_kotlinx_io_EOFException($this);
+        return $this;
+      }
+      static e1o(message) {
+        var $this = this.j1r(message);
+        init_kotlinx_io_EOFException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'EOFException', $.l1r);
+    EOFExceptionClass = $;
+  }
+  return EOFExceptionClass;
+}
+//region block: exports
+export {
+  EOFException as EOFExceptionh831u25jcq9n,
+  IOException as IOException1wyutdmfe71nu,
+};
+//endregion
+
+//# sourceMappingURL=-PlatformJs.mjs.map

package/kotlin/kotlinx-io-kotlinx-io-core/kotlinx/io/-PlatformJs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../.gradle/daemon/9.3.0/Z:/BuildAgent/work/22e3a7db6b861ba7/core/js/src/-PlatformJs.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["message","cause"],"mappings":";;;;;;;;qCAOA,a,EAAA;A;AAQA,C;;;;;;;;;;iBAL8BA,O;4BAA0B,O;;;;iBAI1BA,O,EAAkBC,K;4BAA2B,O,EAAS,K;;;;;;;;;;sCAGpF,a,EAAA;A;AAMA,C;;;;;;;;;;iBAH8BD,O;6BAA0B,O;;;;;;;;;;;;;;"}

package/kotlin/kotlinx-io-kotlinx-io-core/kotlinx/io/-Util.mjs

@@ -0,0 +1,52 @@
+import {
+  IndexOutOfBoundsException1qfr429iumro0 as IndexOutOfBoundsException,
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+} from '../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { Long2qws0ah9gnpki as Long } from '../../../kotlin-kotlin-stdlib/kotlin/Primitives.mjs';
+import {
+  compare2uud5j30pw5xc as compare,
+  subtract16cg4lfi29fq9 as subtract,
+} from '../../../kotlin-kotlin-stdlib/kotlin/js/internal/boxedLong/boxedLong.mjs';
+import { _Char___init__impl__6a9atx1csff5kwtduxl as _Char___init__impl__6a9atx } from '../../../kotlin-kotlin-stdlib/kotlin/Char.mjs';
+import { charArrayOf27f4r3dozbrk1 as charArrayOf } from '../../../kotlin-kotlin-stdlib/kotlin/js/arrays.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function get_HEX_DIGIT_CHARS() {
+  _init_properties__Util_kt__g8tcl9();
+  return HEX_DIGIT_CHARS;
+}
+var HEX_DIGIT_CHARS;
+function checkBounds(size, startIndex, endIndex) {
+  _init_properties__Util_kt__g8tcl9();
+  if (compare(startIndex, new (Long())(0, 0)) < 0 || compare(endIndex, size) > 0) {
+    throw IndexOutOfBoundsException().qe('startIndex (' + startIndex.toString() + ') and endIndex (' + endIndex.toString() + ') are not within the range [0..size(' + size.toString() + '))');
+  }
+  if (compare(startIndex, endIndex) > 0) {
+    throw IllegalArgumentException().r2('startIndex (' + startIndex.toString() + ') > endIndex (' + endIndex.toString() + ')');
+  }
+}
+function checkOffsetAndCount(size, offset, byteCount) {
+  _init_properties__Util_kt__g8tcl9();
+  if (compare(offset, new (Long())(0, 0)) < 0 || compare(offset, size) > 0 || compare(subtract(size, offset), byteCount) < 0 || compare(byteCount, new (Long())(0, 0)) < 0) {
+    throw IllegalArgumentException().r2('offset (' + offset.toString() + ') and byteCount (' + byteCount.toString() + ') are not within the range [0..size(' + size.toString() + '))');
+  }
+}
+var properties_initialized__Util_kt_67kc5b;
+function _init_properties__Util_kt__g8tcl9() {
+  if (!properties_initialized__Util_kt_67kc5b) {
+    properties_initialized__Util_kt_67kc5b = true;
+    // Inline function 'kotlin.charArrayOf' call
+    HEX_DIGIT_CHARS = charArrayOf([_Char___init__impl__6a9atx(48), _Char___init__impl__6a9atx(49), _Char___init__impl__6a9atx(50), _Char___init__impl__6a9atx(51), _Char___init__impl__6a9atx(52), _Char___init__impl__6a9atx(53), _Char___init__impl__6a9atx(54), _Char___init__impl__6a9atx(55), _Char___init__impl__6a9atx(56), _Char___init__impl__6a9atx(57), _Char___init__impl__6a9atx(97), _Char___init__impl__6a9atx(98), _Char___init__impl__6a9atx(99), _Char___init__impl__6a9atx(100), _Char___init__impl__6a9atx(101), _Char___init__impl__6a9atx(102)]);
+  }
+}
+//region block: exports
+export {
+  get_HEX_DIGIT_CHARS as get_HEX_DIGIT_CHARS28oau3fmf5vf6,
+  checkBounds as checkBoundsw7d8y6z7j2xc,
+  checkOffsetAndCount as checkOffsetAndCountazlu23xkuwoi,
+};
+//endregion
+
+//# sourceMappingURL=-Util.mjs.map

package/kotlin/kotlinx-io-kotlinx-io-core/kotlinx/io/-Util.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../.gradle/daemon/9.3.0/Z:/BuildAgent/work/22e3a7db6b861ba7/core/common/src/-Util.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-HEX_DIGIT_CHARS>","checkBounds","size","startIndex","endIndex","checkOffsetAndCount","offset","byteCount","<init properties -Util.kt>"],"mappings":";;;;;;;;;;;;;;;4BAyBAA,CAAAA,EAAA;A;EAAA,sB;AAA2B,C;;oBAc3BC,CAAyBC,I,EAAYC,U,EAAkBC,QAAvDH,EAAuE;A;EAC/D,qCAAa,CAAb,EAAa,CAAb,UAAkB,kBAAW,IAAX,KAAlB,C,CAAmC;A,IACnC,qCACK,cADL,GACkB,UADlB,cAC4B,kBAD5B,GAC6C,QAD7C,cACqD,sCADrD,GAC0F,IAD1F,cAC8F,IAD9F,C;EAGJ,C;EACI,wBAAa,QAAb,M,CAAuB;A,IACvB,oCAAgC,cAAhC,GAA6C,UAA7C,cAAuD,gBAAvD,GAAsE,QAAtE,cAA8E,GAA9E,C;EACJ,C;AACJ,C;4BApBAI,CAAiCH,I,EAAYI,M,EAAcC,SAA3DF,EAA4E;A;EACpE,iCAAS,CAAT,EAAS,CAAT,UAAc,gBAAS,IAAT,KAAd,IAA+B,uBAAO,MAAP,GAAgB,SAAhB,KAA/B,IAA4D,gCAAY,CAAZ,EAAY,CAAZ,MAA5D,C,CAA2E;A,IAC3E,oCACK,UADL,GACc,MADd,cACoB,mBADpB,GACsC,SADtC,cAC+C,sCAD/C,GACoF,IADpF,cACwF,IADxF,C;EAGJ,C;AACJ,C;;0CAlCAG,CAAAA,E;;;;sBA0BgB,6CAAK,8BAAL,EAAU,8BAAV,EAAe,8BAAf,EAAoB,8BAApB,EAAyB,8BAAzB,EAA8B,8BAA9B,EAAmC,8BAAnC,EAAwC,8BAAxC,EAA6C,8BAA7C,EAAkD,8BAAlD,EAAuD,8BAAvD,EAA4D,8BAA5D,EAAiE,+BAAjE,EAAsE,+BAAtE,EAA2E,+BAA3E,E;;C;;;;;"}