@continuous-excellence/coupling-cli 1.1.729 → 1.1.730

package/kotlin/ktor-ktor-io/io/ktor/utils/io/core/Strings.nonJvm.mjs

@@ -0,0 +1,36 @@
+import { Charsets_getInstance3jooo7e4x0j2x as Charsets_getInstance } from '../charsets/Charset.js.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  readString2nvggcfaijfhd as readString,
+  readString3v6duspiz33tv as readString_0,
+} from '../../../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Utf8.mjs';
+import {
+  fromInt1lka3ktyu79a4 as fromInt,
+  compare2uud5j30pw5xc as compare,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/internal/boxedLong/boxedLong.mjs';
+import { decode1t43jmuxrxpmo as decode } from '../charsets/Encoding.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function readText(_this__u8e3s4, charset, max) {
+  charset = charset === VOID ? Charsets_getInstance().g1w_1 : charset;
+  max = max === VOID ? 2147483647 : max;
+  if (charset.equals(Charsets_getInstance().g1w_1)) {
+    if (max === 2147483647)
+      return readString(_this__u8e3s4);
+    var tmp0 = _this__u8e3s4.h1p().q2();
+    // Inline function 'kotlin.math.min' call
+    var b = fromInt(max);
+    var count = compare(tmp0, b) <= 0 ? tmp0 : b;
+    return readString_0(_this__u8e3s4, count);
+  }
+  return decode(charset.x1w(), _this__u8e3s4, max);
+}
+//region block: exports
+export {
+  readText as readText27783kyxjxi1g,
+};
+//endregion
+
+//# sourceMappingURL=Strings.nonJvm.mjs.map

package/kotlin/ktor-ktor-io/io/ktor/utils/io/core/Strings.nonJvm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-io/nonJvm/src/io/ktor/utils/io/core/Strings.nonJvm.kt","../../../../../../../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/ktor-ktor-io/io/ktor/utils/io/core/js/src/kotlin/math.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["readText","<this>","charset","max","count"],"mappings":";;;;;;;;;;;;;;;iBAecA,CAAIC,a,EAAgBC,O,EAAkBC,GAAtCH,EAAwD;A,sDASs5C,K;uBAAsB,U;EAR1+C,0CAAoB,KAApB,E,CAA2B;A,IACvB,YAAW,UAAX,C;MAAsB,OAAO,yB;eACjB,mBAAO,K;;YAAU,QAAJ,GAAI,C;QAAjCI,QC2wCmD,cAAK,CAAL,gBAAe,C;ID1wClE,OAAO,4BAAW,KAAX,C;EACX,C;EAEA,OAA4B,OAArB,OAAQ,MAAa,EAAO,aAAP,EAAa,GAAb,C;AAChC,C;;;;;"}

package/kotlin/ktor-ktor-io/io/ktor/utils/io/pool/ByteArrayPool.mjs

@@ -17,7 +17,7 @@ function ByteArrayPool$1() {
       constructor() {
         super(128);
       }
-      o1w() {
+      n1w() {
         return new Int8Array(4096);
       }
     }

package/kotlin/ktor-ktor-io/io/ktor/utils/io/pool/DefaultPool.mjs

@@ -16,54 +16,54 @@ function DefaultPool() {
   if (DefaultPoolClass === VOID) {
     class $ {
       constructor(capacity) {
-        this.p1w_1 = capacity;
+        this.o1w_1 = capacity;
         var tmp = this;
         // Inline function 'kotlin.arrayOfNulls' call
-        var size = this.p1w_1;
-        tmp.q1w_1 = Array(size);
-        this.r1w_1 = 0;
+        var size = this.o1w_1;
+        tmp.p1w_1 = Array(size);
+        this.q1w_1 = 0;
       }
-      s1w(instance) {
+      r1w(instance) {
       }
-      t1w(instance) {
+      s1w(instance) {
         return instance;
       }
-      u1w(instance) {
+      t1w(instance) {
       }
-      v1w() {
-        if (this.r1w_1 === 0)
-          return this.o1w();
-        this.r1w_1 = this.r1w_1 - 1 | 0;
-        var idx = this.r1w_1;
-        var tmp = this.q1w_1[idx];
+      u1w() {
+        if (this.q1w_1 === 0)
+          return this.n1w();
+        this.q1w_1 = this.q1w_1 - 1 | 0;
+        var idx = this.q1w_1;
+        var tmp = this.p1w_1[idx];
         var instance = !(tmp == null) ? tmp : THROW_CCE();
-        this.q1w_1[idx] = null;
-        return this.t1w(instance);
+        this.p1w_1[idx] = null;
+        return this.s1w(instance);
       }
-      w1w(instance) {
-        this.u1w(instance);
-        if (this.r1w_1 === this.p1w_1) {
-          this.s1w(instance);
+      v1w(instance) {
+        this.t1w(instance);
+        if (this.q1w_1 === this.o1w_1) {
+          this.r1w(instance);
         } else {
-          var _unary__edvuaz = this.r1w_1;
-          this.r1w_1 = _unary__edvuaz + 1 | 0;
-          this.q1w_1[_unary__edvuaz] = instance;
+          var _unary__edvuaz = this.q1w_1;
+          this.q1w_1 = _unary__edvuaz + 1 | 0;
+          this.p1w_1[_unary__edvuaz] = instance;
         }
       }
       m10() {
         var inductionVariable = 0;
-        var last = this.r1w_1;
+        var last = this.q1w_1;
         if (inductionVariable < last)
           do {
             var i = inductionVariable;
             inductionVariable = inductionVariable + 1 | 0;
-            var tmp = this.q1w_1[i];
+            var tmp = this.p1w_1[i];
             var instance = !(tmp == null) ? tmp : THROW_CCE();
-            this.q1w_1[i] = null;
-            this.s1w(instance);
+            this.p1w_1[i] = null;
+            this.r1w(instance);
           }
            while (inductionVariable < last);
-        this.r1w_1 = 0;
+        this.q1w_1 = 0;
       }
     }
     protoOf($).j6 = close;

package/kotlin/ktor-ktor-io/io/ktor/utils/io/pool/Pool.mjs

@@ -26,7 +26,7 @@ var NoPoolImplClass;
 function NoPoolImpl() {
   if (NoPoolImplClass === VOID) {
     class $ {
-      w1w(instance) {
+      v1w(instance) {
         return Unit_instance;
       }
       m10() {

package/kotlin/ktor-ktor-serialization-kotlinx/io/ktor/serialization/kotlinx/Extensions.mjs

@@ -14,7 +14,7 @@ function extensions(format) {
   var _iterator__ex2g4s = tmp0.l1();
   while (_iterator__ex2g4s.m1()) {
     var element = _iterator__ex2g4s.n1();
-    var tmp0_safe_receiver = element.d49(format);
+    var tmp0_safe_receiver = element.e49(format);
     if (tmp0_safe_receiver == null)
       null;
     else {

package/kotlin/ktor-ktor-serialization-kotlinx/io/ktor/serialization/kotlinx/KotlinxSerializationConverter.mjs

@@ -35,7 +35,7 @@ import { readRemaining1kbpbgdrq25q1 as readRemaining } from '../../../../../ktor
 import { ByteReadChannel2ndu7k90iil3s as ByteReadChannel } from '../../../../../ktor-ktor-io/io/ktor/utils/io/ByteChannelCtor.mjs';
 import { discard3ugntd47xyll6 as discard } from '../../../../../ktor-ktor-io/io/ktor/utils/io/core/ByteReadPacket.mjs';
 import { readByteArray1ri21h2rciakw as readByteArray } from '../../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Sources.mjs';
-import { readText27783kyxjxi1g as readText } from '../../../../../ktor-ktor-io/io/ktor/utils/io/core/Strings.mjs';
+import { readText27783kyxjxi1g as readText } from '../../../../../ktor-ktor-io/io/ktor/utils/io/core/Strings.nonJvm.mjs';
 import { JsonConvertExceptiongnc5x6xwaf77 as JsonConvertException } from '../../../../../ktor-ktor-serialization/io/ktor/serialization/ContentConvertException.mjs';
 //region block: imports
 //endregion
@@ -47,7 +47,7 @@ function serialization(_this__u8e3s4, contentType, format) {
 function KotlinxSerializationConverter$serialize$o$collect$slambda($$this$unsafeFlow, $contentType, $charset, $typeInfo, $value) {
   return constructCallableReference(function *(value, $completion) {
     var $this$transform = $$this$unsafeFlow;
-    var tmp$ret$1 = yield* value.f3v($contentType, $charset, $typeInfo, $value, $completion);
+    var tmp$ret$1 = yield* value.g3v($contentType, $charset, $typeInfo, $value, $completion);
     yield* $this$transform.h1g(tmp$ret$1, $completion);
     return Unit_instance;
   }, 1);
@@ -74,13 +74,13 @@ function sam$kotlinx_coroutines_flow_FlowCollector$0() {
   if (sam$kotlinx_coroutines_flow_FlowCollector$0Class === VOID) {
     class $ {
       constructor(function_0) {
-        this.e49_1 = function_0;
+        this.f49_1 = function_0;
       }
       *h1g(value, $completion) {
-        return yield* this.e49_1(value, $completion);
+        return yield* this.f49_1(value, $completion);
       }
       c5() {
-        return this.e49_1;
+        return this.f49_1;
       }
       equals(other) {
         var tmp;
@@ -111,15 +111,15 @@ function KotlinxSerializationConverter$serialize$$inlined$map$1() {
   if (KotlinxSerializationConverter$serialize$$inlined$map$1Class === VOID) {
     class $ {
       constructor($this, $contentType, $charset, $typeInfo, $value) {
-        this.f49_1 = $this;
-        this.g49_1 = $contentType;
-        this.h49_1 = $charset;
-        this.i49_1 = $typeInfo;
-        this.j49_1 = $value;
+        this.g49_1 = $this;
+        this.h49_1 = $contentType;
+        this.i49_1 = $charset;
+        this.j49_1 = $typeInfo;
+        this.k49_1 = $value;
       }
       *g1g(collector, $completion) {
-        var tmp = KotlinxSerializationConverter$serialize$o$collect$slambda(collector, this.g49_1, this.h49_1, this.i49_1, this.j49_1);
-        yield* this.f49_1.k1f(new (sam$kotlinx_coroutines_flow_FlowCollector$0())(tmp), $completion);
+        var tmp = KotlinxSerializationConverter$serialize$o$collect$slambda(collector, this.h49_1, this.i49_1, this.j49_1, this.k49_1);
+        yield* this.g49_1.k1f(new (sam$kotlinx_coroutines_flow_FlowCollector$0())(tmp), $completion);
         return Unit_instance;
       }
       k1f(collector, $completion) {
@@ -141,26 +141,26 @@ function KotlinxSerializationConverter() {
   if (KotlinxSerializationConverterClass === VOID) {
     class $ {
       constructor(format) {
-        this.k49_1 = format;
-        this.l49_1 = extensions(this.k49_1);
+        this.l49_1 = format;
+        this.m49_1 = extensions(this.l49_1);
         var tmp;
-        var tmp_0 = this.k49_1;
+        var tmp_0 = this.l49_1;
         if (isInterface(tmp_0, BinaryFormat())) {
           tmp = true;
         } else {
-          var tmp_1 = this.k49_1;
+          var tmp_1 = this.l49_1;
           tmp = isInterface(tmp_1, StringFormat());
         }
         // Inline function 'kotlin.require' call
         if (!tmp) {
-          var message = 'Only binary and string formats are supported, ' + toString(this.k49_1) + ' is not supported.';
+          var message = 'Only binary and string formats are supported, ' + toString(this.l49_1) + ' is not supported.';
           throw IllegalArgumentException().m2(toString(message));
         }
       }
-      *m49(contentType, charset, typeInfo, value, $completion) {
+      *n49(contentType, charset, typeInfo, value, $completion) {
         // Inline function 'kotlinx.coroutines.flow.map' call
         // Inline function 'kotlinx.coroutines.flow.unsafeTransform' call
-        var this_0 = asFlow(this.l49_1);
+        var this_0 = asFlow(this.m49_1);
         // Inline function 'kotlinx.coroutines.flow.internal.unsafeFlow' call
         var tmp = new (KotlinxSerializationConverter$serialize$$inlined$map$1())(this_0, contentType, charset, typeInfo, value);
         var fromExtension = yield* firstOrNull(tmp, KotlinxSerializationConverter$serialize$slambda(), $completion);
@@ -168,26 +168,26 @@ function KotlinxSerializationConverter() {
           return fromExtension;
         var tmp_0;
         try {
-          tmp_0 = serializerForTypeInfo(this.k49_1.a22(), typeInfo);
+          tmp_0 = serializerForTypeInfo(this.l49_1.a22(), typeInfo);
         } catch ($p) {
           var tmp_1;
           if ($p instanceof SerializationException()) {
             var cause = $p;
-            tmp_1 = guessSerializer(value, this.k49_1.a22());
+            tmp_1 = guessSerializer(value, this.l49_1.a22());
           } else {
             throw $p;
           }
           tmp_0 = tmp_1;
         }
         var serializer = tmp_0;
-        return serializeContent(this, serializer, this.k49_1, value, contentType, charset);
+        return serializeContent(this, serializer, this.l49_1, value, contentType, charset);
       }
-      f3v(contentType, charset, typeInfo, value, $completion) {
-        return this.m49(contentType, charset, typeInfo, value, $completion);
+      g3v(contentType, charset, typeInfo, value, $completion) {
+        return this.n49(contentType, charset, typeInfo, value, $completion);
       }
       *e3c(charset, typeInfo, content, $completion) {
         var contentPacket = yield* readRemaining(content, $completion);
-        var _iterator__ex2g4s = this.l49_1.l1();
+        var _iterator__ex2g4s = this.m49_1.l1();
         $l$loop: while (_iterator__ex2g4s.m1()) {
           var ext = _iterator__ex2g4s.n1();
           var tmp0_elvis_lhs = yield* ext.e3c(charset, typeInfo, ByteReadChannel(contentPacket), $completion);
@@ -199,19 +199,19 @@ function KotlinxSerializationConverter() {
           }
           return tmp;
         }
-        var serializer = serializerForTypeInfo(this.k49_1.a22(), typeInfo);
+        var serializer = serializerForTypeInfo(this.l49_1.a22(), typeInfo);
         try {
-          var tmp1_subject = this.k49_1;
+          var tmp1_subject = this.l49_1;
           var tmp_0;
           if (isInterface(tmp1_subject, StringFormat())) {
-            tmp_0 = this.k49_1.c1y(serializer, readText(contentPacket, charset));
+            tmp_0 = this.l49_1.c1y(serializer, readText(contentPacket, charset));
           } else {
             if (isInterface(tmp1_subject, BinaryFormat())) {
-              tmp_0 = this.k49_1.e1y(serializer, readByteArray(contentPacket));
+              tmp_0 = this.l49_1.e1y(serializer, readByteArray(contentPacket));
             } else {
               discard(contentPacket);
               // Inline function 'kotlin.error' call
-              var message = 'Unsupported format ' + toString(this.k49_1);
+              var message = 'Unsupported format ' + toString(this.l49_1);
               throw IllegalStateException().o(toString(message));
             }
           }

package/kotlin/ktor-ktor-serialization-kotlinx-json/io/ktor/serialization/kotlinx/json/JsonSupport.mjs

@@ -20,12 +20,12 @@ function json(_this__u8e3s4, json, contentType) {
 }
 function DefaultJson$lambda($this$Json) {
   _init_properties_JsonSupport_kt__yf438r();
-  $this$Json.a3w_1 = true;
-  $this$Json.d3w_1 = true;
-  $this$Json.o3w_1 = true;
+  $this$Json.b3w_1 = true;
+  $this$Json.e3w_1 = true;
   $this$Json.p3w_1 = true;
-  $this$Json.e3w_1 = false;
-  $this$Json.q3w_1 = false;
+  $this$Json.q3w_1 = true;
+  $this$Json.f3w_1 = false;
+  $this$Json.r3w_1 = false;
   return Unit_instance;
 }
 var properties_initialized_JsonSupport_kt_9cgd93;

package/kotlin/ktor-ktor-utils/io/ktor/util/ByteChannels.mjs

@@ -54,7 +54,7 @@ function split$slambda$slambda_0($second, $buffer, $read) {
 }
 function split$slambda($this_split, $first, $second) {
   return constructCallableReference(function *($this$launch, $completion) {
-    var buffer = get_ByteArrayPool().v1w();
+    var buffer = get_ByteArrayPool().u1w();
     try {
       $l$loop: while (!$this_split.e1u()) {
         var read = yield* readAvailable($this_split, buffer, VOID, VOID, $completion);
@@ -81,7 +81,7 @@ function split$slambda($this_split, $first, $second) {
       }
     }
     finally {
-      get_ByteArrayPool().w1w(buffer);
+      get_ByteArrayPool().v1w(buffer);
       $first.j6();
       $second.j6();
     }

package/kotlin/ktor-ktor-websockets/io/ktor/websocket/CloseReason.mjs

@@ -15,6 +15,8 @@ import {
   toString1pkumu07cwy4m as toString,
   getStringHashCode26igk1bx568vk as getStringHashCode,
 } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { utf8Size2vilcxlxicj31 as utf8Size } from './ControlFrames.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
 //region block: imports
 var imul = Math.imul;
 //endregion
@@ -111,6 +113,19 @@ function Codes() {
   }
   return CodesClass;
 }
+var CompanionClass_0;
+function Companion_0() {
+  if (CompanionClass_0 === VOID) {
+    class $ {}
+    initMetadataForCompanion($);
+    CompanionClass_0 = $;
+  }
+  return CompanionClass_0;
+}
+var Companion_instance_0;
+function Companion_getInstance_0() {
+  return Companion_instance_0;
+}
 function Codes_NORMAL_getInstance() {
   Codes_initEntries();
   return Codes_NORMAL_instance;
@@ -170,6 +185,12 @@ function CloseReason() {
         var $this = createThis(this);
         $this.g37_1 = code;
         $this.h37_1 = message;
+        var size = utf8Size($this.h37_1);
+        // Inline function 'kotlin.require' call
+        if (!(size <= 123)) {
+          var message_0 = 'Close reason message is too long: ' + size + ' bytes, but must not exceed ' + '123 bytes when UTF-8-encoded';
+          throw IllegalArgumentException().m2(toString(message_0));
+        }
         return $this;
       }
       static j37(code, message) {
@@ -204,6 +225,9 @@ function CloseReason() {
   }
   return CloseReasonClass;
 }
+//region block: init
+Companion_instance_0 = new (Companion_0())();
+//endregion
 //region block: exports
 export {
   Companion_getInstance as Companion_getInstanceo8cazic5dguk,

package/kotlin/ktor-ktor-websockets/io/ktor/websocket/CloseReason.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-shared/ktor-websockets/common/src/io/ktor/websocket/CloseReason.kt","../../../../../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/ktor-ktor-websockets/io/ktor/websocket/common/src/generated/_Collections.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["capacity","element","byCode","code","values","<get-entries>","<init>","message","<get-knownReason>","toString","result"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAyD4C,I;;qBAAR,a;YCmyChCA,WAAwD,cAAzC,YAAY,gCAAwB,EAAxB,CAAZ,CAAyC,EAAc,EAAd,C;;0BACnC,mBAAoB,QAApB,C;YA4BL,oBA5BT,MA4BS,K;eAAA,sB,EAAM;A,cAAjBC,UAAW,sB;cDh0C6C,YCi0C7B,ODj0C6B,CAAJ,K;UCi0CrD,WAAY,IAAI,SAAJ,EAA0B,OAA1B,C;QAChB,C;QDl0CwC,YCm0CjC,W;QDvzC0C,+C;;SASlCC,CAAWC,IAAXD,EAAkC;A,QAAe,OAAf,cAAU,IAAV,C;MAAc,C;;;;;;;;;;;;;;eA9EnEE,CAAAA,E;;C;oBAAAC,CAAAA,E;;;;C;;;;;;wCAAA,Q,EAAA,C,EAwCe,I;4CAxCf,Y,EAAA,C,EAyCmB,I;gDAzCnB,gB,EAAA,C,EA0CuB,I;+CA1CvB,e,EAAA,C,EA2CsB,I;mDA3CtB,mB,EAAA,C,EA+C0B,I;gDA/C1B,gB,EAAA,C,EAgDuB,I;iDAhDvB,iB,EAAA,C,EAiDwB,I;yCAjDxB,S,EAAA,C,EAkDgB,I;8CAlDhB,c,EAAA,C,EAmDqB,I;gDAnDrB,gB,EAAA,C,EAoDuB,I;iDApDvB,iB,EAAA,E,EAqDwB,I;iDArDxB,iB,EAAA,E,EAsDwB,I;;;;;;;;iCAfWF,I;;QAAP,iB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAtBCG,CAACH,I,EAAiBI,OAAlBD,EAAA;A;MAAA,C;iBAACH,I,EAAiBI,O;;QAAjB,kB;QAAiB,qB;;;iBACxBJ,I,EAAaI,O;wBAAwB,I,CAAK,K,EAAM,O;;SAQ/DC,CAAAA,EAAQ;A,QAAkB,OAAZ,4BAAO,IAAP,CAAO,KAAP,C;MAAW,C;cAEpBC,CAAAA,EAAuB;A,YACC,2B;QAA7B,OAAQ,qBAAR,YAA6B,yBAAe,IAAf,CAAe,KAAf,iBAA7B,IAAiD,YAAjD,GAA4D,IAA5D,CAA4D,KAA5D,GAAmE,G;MACvE,C;iBA9BJ;A,YAAAC,mB;QAAA,6D;QAAA,a;MAAA,C;oBAAA;A,QAAA,mB;UAAA,W;QAAA,sC;UAAA,Y;QAAA,kC;UAAA,Y;QAAA,kC;UAAA,Y;QAAA,W;MAAA,C;;;;;;;;;;;"}
+{"version":3,"sources":["../../../../../../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-shared/ktor-websockets/common/src/io/ktor/websocket/CloseReason.kt","../../../../../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/ktor-ktor-websockets/io/ktor/websocket/common/src/generated/_Collections.kt","../../../../../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/ktor-ktor-websockets/io/ktor/websocket/src/kotlin/util/Preconditions.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["capacity","element","byCode","code","values","<get-entries>","<init>","message","size","<get-knownReason>","toString","result"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkE4C,I;;qBAAR,a;YC0xChCA,WAAwD,cAAzC,YAAY,gCAAwB,EAAxB,CAAZ,CAAyC,EAAc,EAAd,C;;0BACnC,mBAAoB,QAApB,C;YA4BL,oBA5BT,MA4BS,K;eAAA,sB,EAAM;A,cAAjBC,UAAW,sB;cDvzC6C,YCwzC7B,ODxzC6B,CAAJ,K;UCwzCrD,WAAY,IAAI,SAAJ,EAA0B,OAA1B,C;QAChB,C;QDzzCwC,YC0zCjC,W;QD9yC0C,+C;;SASlCC,CAAWC,IAAXD,EAAkC;A,QAAe,OAAf,cAAU,IAAV,C;MAAc,C;;;;;;;;;;;;;;eAvFnEE,CAAAA,E;;C;oBAAAC,CAAAA,E;;;;C;;;;;;wCAAA,Q,EAAA,C,EAiDe,I;4CAjDf,Y,EAAA,C,EAkDmB,I;gDAlDnB,gB,EAAA,C,EAmDuB,I;+CAnDvB,e,EAAA,C,EAoDsB,I;mDApDtB,mB,EAAA,C,EAwD0B,I;gDAxD1B,gB,EAAA,C,EAyDuB,I;iDAzDvB,iB,EAAA,C,EA0DwB,I;yCA1DxB,S,EAAA,C,EA2DgB,I;8CA3DhB,c,EAAA,C,EA4DqB,I;gDA5DrB,gB,EAAA,C,EA6DuB,I;iDA7DvB,iB,EAAA,E,EA8DwB,I;iDA9DxB,iB,EAAA,E,EA+DwB,I;;;;;;;;iCAfWF,I;;QAAP,iB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA9BCG,CAACH,I,EAAiBI,OAAlBD,EAAA;A;MAAA,C;iBAACH,I,EAAiBI,O;;QAAjB,kB;QAAiB,qB;YAEvCC,OAAmB,SAAR,KAAQ,CAAR,KAAQ,C;;QEenB,MFdQ,QAAQ,GEchB,E,CAAQ;A,cACRD,YFdK,oCAAD,GAAoC,IAApC,GAAwC,8BAAxC,GACI,8B;UEcR,oCAAuC,SAAR,SAAQ,CAAvC,C;QACJ,C;;;iBFXmBJ,I,EAAaI,O;wBAAwB,I,CAAK,K,EAAM,O;;SAQ/DE,CAAAA,EAAQ;A,QAAkB,OAAZ,4BAAO,IAAP,CAAO,KAAP,C;MAAW,C;cAEpBC,CAAAA,EAAuB;A,YACC,2B;QAA7B,OAAQ,qBAAR,YAA6B,yBAAe,IAAf,CAAe,KAAf,iBAA7B,IAAiD,YAAjD,GAA4D,IAA5D,CAA4D,KAA5D,GAAmE,G;MACvE,C;iBAvCJ;A,YAAAC,mB;QAAA,6D;QAAA,a;MAAA,C;oBAAA;A,QAAA,mB;UAAA,W;QAAA,sC;UAAA,Y;QAAA,kC;UAAA,Y;QAAA,kC;UAAA,Y;QAAA,W;MAAA,C;;;;;;;;;;;;;;"}

package/kotlin/ktor-ktor-websockets/io/ktor/websocket/ControlFrames.mjs

@@ -0,0 +1,58 @@
+import { substringiqarkczpya5m as substring } from '../../../../kotlin-kotlin-stdlib/kotlin/text/stringJs.mjs';
+import { charCodeAt1yspne1d8erbm as charCodeAt } from '../../../../kotlin-kotlin-stdlib/kotlin/js/charSequenceJs.mjs';
+import { Char__toInt_impl_vasixd1ka89vowck9tn as Char__toInt_impl_vasixd } from '../../../../kotlin-kotlin-stdlib/kotlin/Char.mjs';
+import {
+  isHighSurrogate11jfjw70ar0zf as isHighSurrogate,
+  isLowSurrogateujxcv7hjn4ma as isLowSurrogate,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/text/charJs.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { toString1pkumu07cwy4m as toString } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { Unit_instance3vdlo4e4f5ggx as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function utf8Size(_this__u8e3s4) {
+  var size = 0;
+  var index = 0;
+  while (index < _this__u8e3s4.length) {
+    var bytes = utf8ByteCountAt(_this__u8e3s4, index);
+    size = size + bytes | 0;
+    index = index + (bytes === 4 ? 2 : 1) | 0;
+  }
+  return size;
+}
+function utf8Truncate(_this__u8e3s4, maxSize) {
+  var size = 0;
+  var index = 0;
+  $l$loop: while (index < _this__u8e3s4.length) {
+    var bytes = utf8ByteCountAt(_this__u8e3s4, index);
+    if ((size + bytes | 0) > maxSize)
+      break $l$loop;
+    size = size + bytes | 0;
+    index = index + (bytes === 4 ? 2 : 1) | 0;
+  }
+  return index === _this__u8e3s4.length ? _this__u8e3s4 : substring(_this__u8e3s4, 0, index);
+}
+function utf8ByteCountAt(_this__u8e3s4, index) {
+  // Inline function 'kotlin.code' call
+  var this_0 = charCodeAt(_this__u8e3s4, index);
+  var code = Char__toInt_impl_vasixd(this_0);
+  return code < 128 ? 1 : code < 2048 ? 2 : isHighSurrogate(charCodeAt(_this__u8e3s4, index)) && (index + 1 | 0) < _this__u8e3s4.length && isLowSurrogate(charCodeAt(_this__u8e3s4, index + 1 | 0)) ? 4 : 3;
+}
+function validateSize(_this__u8e3s4) {
+  // Inline function 'kotlin.require' call
+  if (!(!_this__u8e3s4.q37_1.n37_1 || _this__u8e3s4.r37_1.length <= 125)) {
+    var message = 'Control frames must not exceed 125 bytes per RFC 6455, ' + ('but ' + _this__u8e3s4.q37_1.toString() + ' frame has ' + _this__u8e3s4.r37_1.length + ' bytes');
+    throw IllegalArgumentException().m2(toString(message));
+  }
+}
+//region block: exports
+export {
+  utf8Size as utf8Size2vilcxlxicj31,
+  utf8Truncate as utf8Truncate258zdrrdcuqgj,
+  validateSize as validateSize23lir9ygeqvey,
+};
+//endregion
+
+//# sourceMappingURL=ControlFrames.mjs.map

package/kotlin/ktor-ktor-websockets/io/ktor/websocket/ControlFrames.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-shared/ktor-websockets/common/src/io/ktor/websocket/ControlFrames.kt","../../../../../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/ktor-ktor-websockets/io/ktor/websocket/src/kotlin/CharCode.kt","../../../../../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/ktor-ktor-websockets/io/ktor/websocket/src/kotlin/util/Preconditions.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["utf8Size","<this>","size","index","bytes","utf8Truncate","maxSize","utf8ByteCountAt","code","validateSize","message"],"mappings":";;;;;;;;;;;;;;iBAuDSA,CAAIC,aAAJD,EAA2B;A,MAChCE,OAAW,C;MACXC,QAAY,C;SACL,QAAQ,aAAR,CAAQ,M,EAAQ;A,QACnBC,QAAY,+BAAgB,KAAhB,C;IACZ,cAAQ,KAAR,I;IACA,iBAAa,UAAS,CAAT,GAAY,CAAZ,GAAmB,CAAhC,K;EACJ,C;EACA,OAAO,I;AACX,C;qBAOSC,CAAIJ,a,EAAoBK,OAAxBD,EAA8C;A,MACnDH,OAAW,C;MACXC,QAAY,C;kBACL,QAAQ,aAAR,CAAQ,M,EAAQ;A,QACnBC,QAAY,+BAAgB,KAAhB,C;IACR,YAAO,KAAP,QAAe,OAAf,C;MAAwB,a;IAC5B,cAAQ,KAAR,I;IACA,iBAAa,UAAS,CAAT,GAAY,CAAZ,GAAmB,CAAhC,K;EACJ,C;EACA,OAAW,UAAS,aAAT,CAAS,MAAT,GAAiB,aAAjB,GAA2B,yBAAU,CAAV,EAAa,KAAb,C;AAC1C,C;wBAxCQG,CAAIN,a,EAAuBE,KAA3BI,EAA4C;A;eACrC,0BAAK,KAAL,C;MAAXC,OCG0C,wBAAL,MAAK,C;EDF1C,OACI,OAAO,GAAP,GAAe,CAAf,GACA,OAAO,IAAP,GAAgB,CAAhB,GACY,gBAAZ,0BAAK,KAAL,CAAY,CAAZ,IAAiC,SAAQ,CAAR,QAAY,aAAZ,CAAY,MAA7C,IAAuE,eAAhB,0BAAK,QAAQ,CAAb,KAAgB,CAAvE,GAA2F,CAA3F,GACQ,C;AAEhB,C;qBArBSC,CAAIR,aAAJQ,EAAyB;A;EEO1B,MFNI,CAAC,aAAD,CAAC,KAAD,CAAW,KEMf,IFN+B,oBAAK,MAAL,IAAa,GEM5C,E,CAAQ;A,QACRC,UFNA,6DACK,MADL,GACU,aADV,CACU,KADV,cACmB,aADnB,GACgC,aADhC,CACgC,KADhC,CACqC,MADrC,GAC0C,QAD1C,C;IEOA,oCAAuC,SAAR,OAAQ,CAAvC,C;EACJ,C;AFLJ,C;;;;;"}