@continuous-excellence/coupling-cli 0.0.0

package/kotlin/kotlinx-io-kotlinx-io-core/kotlinx/io/unsafe/UnsafeBufferOperations.mjs

@@ -0,0 +1,102 @@
+import {
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  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 get_SegmentReadContextImpl() {
+  _init_properties_UnsafeBufferOperations_kt__xw75gy();
+  return SegmentReadContextImpl;
+}
+var SegmentReadContextImpl;
+function get_SegmentWriteContextImpl() {
+  _init_properties_UnsafeBufferOperations_kt__xw75gy();
+  return SegmentWriteContextImpl;
+}
+var SegmentWriteContextImpl;
+var BufferIterationContextImpl;
+var UnsafeBufferOperationsClass;
+function UnsafeBufferOperations() {
+  if (UnsafeBufferOperationsClass === VOID) {
+    class $ {}
+    initMetadataForObject($, 'UnsafeBufferOperations');
+    UnsafeBufferOperationsClass = $;
+  }
+  return UnsafeBufferOperationsClass;
+}
+var UnsafeBufferOperations_instance;
+function UnsafeBufferOperations_getInstance() {
+  return UnsafeBufferOperations_instance;
+}
+var SegmentReadContextImpl$1Class;
+function SegmentReadContextImpl$1() {
+  if (SegmentReadContextImpl$1Class === VOID) {
+    class $ {
+      d1q(segment, offset) {
+        return segment.c1p(offset);
+      }
+    }
+    initMetadataForClass($);
+    SegmentReadContextImpl$1Class = $;
+  }
+  return SegmentReadContextImpl$1Class;
+}
+var SegmentWriteContextImpl$1Class;
+function SegmentWriteContextImpl$1() {
+  if (SegmentWriteContextImpl$1Class === VOID) {
+    class $ {
+      f1r(segment, offset, value) {
+        segment.y1q(offset, value);
+      }
+      e1r(segment, offset, b0, b1) {
+        segment.z1q(offset, b0, b1);
+      }
+      d1r(segment, offset, b0, b1, b2) {
+        segment.a1r(offset, b0, b1, b2);
+      }
+      c1r(segment, offset, b0, b1, b2, b3) {
+        segment.b1r(offset, b0, b1, b2, b3);
+      }
+    }
+    initMetadataForClass($);
+    SegmentWriteContextImpl$1Class = $;
+  }
+  return SegmentWriteContextImpl$1Class;
+}
+var BufferIterationContextImpl$1Class;
+function BufferIterationContextImpl$1() {
+  if (BufferIterationContextImpl$1Class === VOID) {
+    class $ {
+      d1q(segment, offset) {
+        return get_SegmentReadContextImpl().d1q(segment, offset);
+      }
+    }
+    initMetadataForClass($);
+    BufferIterationContextImpl$1Class = $;
+  }
+  return BufferIterationContextImpl$1Class;
+}
+var properties_initialized_UnsafeBufferOperations_kt_2xfgoc;
+function _init_properties_UnsafeBufferOperations_kt__xw75gy() {
+  if (!properties_initialized_UnsafeBufferOperations_kt_2xfgoc) {
+    properties_initialized_UnsafeBufferOperations_kt_2xfgoc = true;
+    SegmentReadContextImpl = new (SegmentReadContextImpl$1())();
+    SegmentWriteContextImpl = new (SegmentWriteContextImpl$1())();
+    BufferIterationContextImpl = new (BufferIterationContextImpl$1())();
+  }
+}
+//region block: init
+UnsafeBufferOperations_instance = new (UnsafeBufferOperations())();
+//endregion
+//region block: exports
+export {
+  UnsafeBufferOperations_instance as UnsafeBufferOperations_instance13tvuha6xx6us,
+  get_SegmentReadContextImpl as get_SegmentReadContextImpl28xxxurlbcmul,
+  get_SegmentWriteContextImpl as get_SegmentWriteContextImpl3givuabmefymf,
+};
+//endregion
+
+//# sourceMappingURL=UnsafeBufferOperations.mjs.map

package/kotlin/kotlinx-io-kotlinx-io-core/kotlinx/io/unsafe/UnsafeBufferOperations.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../.gradle/daemon/9.3.0/Z:/BuildAgent/work/22e3a7db6b861ba7/core/common/src/unsafe/UnsafeBufferOperations.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-SegmentReadContextImpl>","<get-SegmentWriteContextImpl>","getUnchecked","segment","offset","setUnchecked","value","b0","b1","b2","b3","<init properties UnsafeBufferOperations.kt>"],"mappings":";;;;;;;;;mCAkhBAA,CAAAA,EAAA;A;EAAA,6B;AAGsD,C;;oCAItDC,CAAAA,EAAA;A;EAAA,8B;AAGwD,C;;;;;;;;;;;;;;;;;;;;SANpDC,CAA0BC,O,EAAkBC,MAA5CF,EAAiE;A,QAA4B,OAA5B,OAAQ,KAAa,MAAb,C;MAAmB,C;;;;;;;;;;;SAO5FG,CAA0BF,O,EAAkBC,M,EAAaE,KAAzDD,EAAsE;A,QAClE,OAAQ,KAAa,MAAb,EAAqB,KAArB,C;MACZ,C;SAEAA,CAA0BF,O,EAAkBC,M,EAAaG,E,EAAUC,EAAnEH,EAA6E;A,QACzE,OAAQ,KAAa,MAAb,EAAqB,EAArB,EAAyB,EAAzB,C;MACZ,C;SAEAA,CAA0BF,O,EAAkBC,M,EAAaG,E,EAAUC,E,EAAUC,EAA7EJ,EAAuF;A,QACnF,OAAQ,KAAa,MAAb,EAAqB,EAArB,EAAyB,EAAzB,EAA6B,EAA7B,C;MACZ,C;SAEAA,CAA0BF,O,EAAkBC,M,EAAaG,E,EAAUC,E,EAAUC,E,EAAUC,EAAvFL,EAAiG;A,QAC7F,OAAQ,KAAa,MAAb,EAAqB,EAArB,EAAyB,EAAzB,EAA6B,EAA7B,EAAiC,EAAjC,C;MACZ,C;;;;;;;;;;;SASAH,CAA0BC,O,EAAkBC,MAA5CF,EACI;A,QAAoD,OAApD,4BAAuB,KAAa,OAAb,EAAsB,MAAtB,C;MAA4B,C;;;;;;;;2DArjB3DS,CAAAA,E;;;;;;;C;;;;;;;;"}

package/kotlin/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/KSerializer.mjs

@@ -0,0 +1,42 @@
+import { initMetadataForInterface1egvbzx539z91 as initMetadataForInterface } 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 KSerializerClass;
+function KSerializer() {
+  if (KSerializerClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'KSerializer', VOID, VOID, [SerializationStrategy(), DeserializationStrategy()]);
+    KSerializerClass = $;
+  }
+  return KSerializerClass;
+}
+var DeserializationStrategyClass;
+function DeserializationStrategy() {
+  if (DeserializationStrategyClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'DeserializationStrategy');
+    DeserializationStrategyClass = $;
+  }
+  return DeserializationStrategyClass;
+}
+var SerializationStrategyClass;
+function SerializationStrategy() {
+  if (SerializationStrategyClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'SerializationStrategy');
+    SerializationStrategyClass = $;
+  }
+  return SerializationStrategyClass;
+}
+//region block: exports
+export {
+  DeserializationStrategy as DeserializationStrategy1z3z5pj9f7zc8,
+  KSerializer as KSerializerzf77vz1967fq,
+  SerializationStrategy as SerializationStrategyh6ouydnm6hci,
+};
+//endregion
+
+//# sourceMappingURL=KSerializer.mjs.map

package/kotlin/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/KSerializer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/kotlin/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/PolymorphicSerializer.mjs

@@ -0,0 +1,104 @@
+import {
+  throwSubtypeNotRegistered2cr459177l268 as throwSubtypeNotRegistered,
+  throwSubtypeNotRegistered343gt7v9eqwun as throwSubtypeNotRegistered_0,
+  AbstractPolymorphicSerializer1ccxwp48nfy58 as AbstractPolymorphicSerializer,
+} from './internal/AbstractPolymorphicSerializer.mjs';
+import { getKClassFromExpression348iqjl4fnx2f as getKClassFromExpression } from '../../../kotlin-kotlin-stdlib/kotlin/reflect/js/internal/reflection.mjs';
+import { StringCompanionObject_instance3sox3h548pjra as StringCompanionObject_instance } from '../../../kotlin-kotlin-stdlib/kotlin/js/internal/primitiveCompanionObjects.mjs';
+import { serializer1x79l67jvwntn as serializer } from './builtins/BuiltinSerializers.mjs';
+import {
+  CONTEXTUAL_getInstancelbs8qycmp7lg as CONTEXTUAL_getInstance,
+  OPEN_getInstance32dw6texj4r0o as OPEN_getInstance,
+} from './descriptors/SerialKinds.mjs';
+import { buildSerialDescriptor2873qmkp8r2ib as buildSerialDescriptor } from './descriptors/SerialDescriptors.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { withContext3ge61vpog00ae as withContext } from './descriptors/ContextAware.mjs';
+import { emptyList1g2z5xcrvp2zy as emptyList } from '../../../kotlin-kotlin-stdlib/kotlin/collections/CollectionsKt.mjs';
+import { LazyThreadSafetyMode_PUBLICATION_getInstance1vspt3xrdob1a as LazyThreadSafetyMode_PUBLICATION_getInstance } from '../../../kotlin-kotlin-stdlib/kotlin/Lazy.mjs';
+import { lazy1261dae0bgscp as lazy } from '../../../kotlin-kotlin-stdlib/kotlin/kotlin.mjs';
+import { KProperty1ca4yb4wlo496 as KProperty1 } from '../../../kotlin-kotlin-stdlib/kotlin/reflect/KPropertyJs.mjs';
+import { getPropertyCallableRef3hckxc0xueiaj as getPropertyCallableRef } from '../../../kotlin-kotlin-stdlib/kotlin/js/reflectRuntime.mjs';
+import { toString1pkumu07cwy4m as toString } from '../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.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 findPolymorphicSerializer(_this__u8e3s4, decoder, klassName) {
+  var tmp0_elvis_lhs = _this__u8e3s4.m1w(decoder, klassName);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    throwSubtypeNotRegistered(klassName, _this__u8e3s4.n1w());
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  return tmp;
+}
+function findPolymorphicSerializer_0(_this__u8e3s4, encoder, value) {
+  var tmp0_elvis_lhs = _this__u8e3s4.o1w(encoder, value);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    throwSubtypeNotRegistered_0(getKClassFromExpression(value), _this__u8e3s4.n1w());
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  return tmp;
+}
+function PolymorphicSerializer$descriptor$delegate$lambda$lambda(this$0) {
+  return ($this$buildSerialDescriptor) => {
+    $this$buildSerialDescriptor.x1w('type', serializer(StringCompanionObject_instance).j1w());
+    $this$buildSerialDescriptor.x1w('value', buildSerialDescriptor('kotlinx.serialization.Polymorphic<' + this$0.y1w_1.k1() + '>', CONTEXTUAL_getInstance(), []));
+    $this$buildSerialDescriptor.r1w_1 = this$0.z1w_1;
+    return Unit_instance;
+  };
+}
+function PolymorphicSerializer$descriptor$delegate$lambda(this$0) {
+  return () => {
+    var tmp = OPEN_getInstance();
+    return withContext(buildSerialDescriptor('kotlinx.serialization.Polymorphic', tmp, [], PolymorphicSerializer$descriptor$delegate$lambda$lambda(this$0)), this$0.y1w_1);
+  };
+}
+function PolymorphicSerializer$_get_descriptor_$ref_8tw9if() {
+  return (p0) => p0.j1w();
+}
+var PolymorphicSerializerClass;
+function PolymorphicSerializer() {
+  if (PolymorphicSerializerClass === VOID) {
+    class $ extends AbstractPolymorphicSerializer() {
+      constructor(baseClass) {
+        super();
+        this.y1w_1 = baseClass;
+        this.z1w_1 = emptyList();
+        var tmp = this;
+        var tmp_0 = LazyThreadSafetyMode_PUBLICATION_getInstance();
+        tmp.a1x_1 = lazy(tmp_0, PolymorphicSerializer$descriptor$delegate$lambda(this));
+      }
+      n1w() {
+        return this.y1w_1;
+      }
+      j1w() {
+        var tmp0 = this.a1x_1;
+        var tmp = KProperty1();
+        // Inline function 'kotlin.getValue' call
+        getPropertyCallableRef('descriptor', 1, tmp, PolymorphicSerializer$_get_descriptor_$ref_8tw9if(), null);
+        return tmp0.g3();
+      }
+      toString() {
+        return 'kotlinx.serialization.PolymorphicSerializer(baseClass: ' + toString(this.y1w_1) + ')';
+      }
+    }
+    initMetadataForClass($, 'PolymorphicSerializer');
+    PolymorphicSerializerClass = $;
+  }
+  return PolymorphicSerializerClass;
+}
+//region block: exports
+export {
+  PolymorphicSerializer as PolymorphicSerializer3p3fzpdobi8hh,
+  findPolymorphicSerializer as findPolymorphicSerializer1nm87hvemahcj,
+  findPolymorphicSerializer_0 as findPolymorphicSerializerk638ixyjovk5,
+};
+//endregion
+
+//# sourceMappingURL=PolymorphicSerializer.mjs.map

package/kotlin/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/PolymorphicSerializer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/b2fef8360e1bcf3d/core/commonMain/src/kotlinx/serialization/PolymorphicSerializer.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/src/kotlin/util/Lazy.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["findPolymorphicSerializer","<this>","decoder","klassName","encoder","value","PolymorphicSerializer$descriptor$delegate$lambda$lambda","PolymorphicSerializer$descriptor$delegate$lambda$lambda$lambda","PolymorphicSerializer$descriptor$delegate$lambda","baseClass","<get-baseClass>","<get-descriptor>","toString"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;kCAgGAA,CACqBC,a,EACjBC,O,EACAC,SAHJH,EAKI;A,MAAA,mCAAgC,OAAhC,EAAyC,SAAzC,C;;EAAA,2B;IAAuD,0BAA0B,SAA1B,EAAqC,mBAArC,C;;UAAvD,c;;EAAsG,U;AAAD,C;oCAEzGA,CACqBC,a,EACjBG,O,EACAC,KAHJL,EAKI;A,MAAA,mCAAgC,OAAhC,EAAyC,KAAzC,C;;EAAA,2B;IAAmD,oDAA0B,KAA1B,GAAwC,mBAAxC,C;;UAAnD,c;;EAAqG,U;AAAD,C;gEA3BfM,CAdzF,MAcyFA,E;SAAAC,CAAA,2BAAAA,KAAA;A,IAC7E,gCAAQ,MAAR,EAAuB,0CAAa,MAApC,C;IACA,gCACI,OADJ,EAEI,sBAAuB,oCAAvB,GAA2D,MAAU,CAAV,KAAU,KAArE,GAAgF,GAAhF,+BAFJ,C;IAIA,oCAAc,MAAd,CAAc,K;IAClB,oB;EAAA,C;C;yDARuFC,CAb/F,MAa+FA,E;SAAAF,CAAAA,KAAA;A;IAQ/D,OAAtB,YAPF,sBAAsB,mCAAtB,WAAiF,+DAAjF,CAOE,EAAY,MAAZ,CAAY,KAAZ,C;EACN,C;C;;iBAToD,Q;;;;;;kBAZZG,S;;QAAA,sB;QAUK,wB;kBAEO,I;oBAA0B,8C;QAA1B,wBAAuC,sDAAvC,C;;SAZZC,CAAAA,EAAA;A,QAAA,iB;MAAgC,C;SAYxEC,CAAAA,EAAoD;A,mBAAA,I,CAAA,K;;;QAAA,uG;QAAA,OC7BoC,S;MDsCxF,C;cAEAC,CAAAA,EAAgC;A,QAC5B,OAAQ,yDAAR,YAAgE,IAAhE,CAAgE,KAAhE,IAAyE,G;MAC7E,C;;;;;;;;;;;"}

package/kotlin/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/SealedSerializer.mjs

@@ -0,0 +1,36 @@
+import { AbstractPolymorphicSerializer1ccxwp48nfy58 as AbstractPolymorphicSerializer } from './internal/AbstractPolymorphicSerializer.mjs';
+import { KProperty1ca4yb4wlo496 as KProperty1 } from '../../../kotlin-kotlin-stdlib/kotlin/reflect/KPropertyJs.mjs';
+import { getPropertyCallableRef3hckxc0xueiaj as getPropertyCallableRef } from '../../../kotlin-kotlin-stdlib/kotlin/js/reflectRuntime.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 SealedClassSerializer$_get_descriptor_$ref_m511rz() {
+  return (p0) => p0.j1w();
+}
+var SealedClassSerializerClass;
+function SealedClassSerializer() {
+  if (SealedClassSerializerClass === VOID) {
+    class $ extends AbstractPolymorphicSerializer() {
+      j1w() {
+        var tmp0 = this.c1x_1;
+        var tmp = KProperty1();
+        // Inline function 'kotlin.getValue' call
+        getPropertyCallableRef('descriptor', 1, tmp, SealedClassSerializer$_get_descriptor_$ref_m511rz(), null);
+        return tmp0.g3();
+      }
+    }
+    initMetadataForClass($, 'SealedClassSerializer');
+    SealedClassSerializerClass = $;
+  }
+  return SealedClassSerializerClass;
+}
+//region block: exports
+export {
+  SealedClassSerializer as SealedClassSerializeriwipiibk55zc,
+};
+//endregion
+
+//# sourceMappingURL=SealedSerializer.mjs.map

package/kotlin/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/SealedSerializer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/b2fef8360e1bcf3d/core/commonMain/src/kotlinx/serialization/SealedSerializer.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/src/kotlin/util/Lazy.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-descriptor>"],"mappings":";;;;;;;;;;iBAsGiD,Q;;;;;;SAA7CA,CAAAA,EAA6C;A,mBAAA,I,CAAA,K;;;QAAA,uG;QAAA,OCnD2C,S;MDgExF,C;;;;;;;;;;;"}

package/kotlin/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/SerialFormat.mjs

@@ -0,0 +1,32 @@
+import { initMetadataForInterface1egvbzx539z91 as initMetadataForInterface } 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 StringFormatClass;
+function StringFormat() {
+  if (StringFormatClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'StringFormat');
+    StringFormatClass = $;
+  }
+  return StringFormatClass;
+}
+var BinaryFormatClass;
+function BinaryFormat() {
+  if (BinaryFormatClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'BinaryFormat');
+    BinaryFormatClass = $;
+  }
+  return BinaryFormatClass;
+}
+//region block: exports
+export {
+  BinaryFormat as BinaryFormat3f3aelhmz0ro1,
+  StringFormat as StringFormat2r2ka8mzcb3mi,
+};
+//endregion
+
+//# sourceMappingURL=SerialFormat.mjs.map

package/kotlin/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/SerialFormat.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/kotlin/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/SerializationExceptions.mjs

@@ -0,0 +1,85 @@
+import {
+  captureStack1fzi4aczwc4hg as captureStack,
+  toString1pkumu07cwy4m as toString,
+} from '../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.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';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var MissingFieldExceptionClass;
+function MissingFieldException() {
+  if (MissingFieldExceptionClass === VOID) {
+    class $ extends SerializationException() {
+      static n1x(missingFields, message, cause) {
+        var $this = this.s1x(message, cause);
+        captureStack($this, $this.m1x_1);
+        $this.l1x_1 = missingFields;
+        return $this;
+      }
+      static t1x(missingFields, serialName) {
+        return this.n1x(missingFields, missingFields.v2() === 1 ? "Field '" + missingFields.u2(0) + "' is required for type with serial name '" + serialName + "', but it was missing" : 'Fields ' + toString(missingFields) + " are required for type with serial name '" + serialName + "', but they were missing", null);
+      }
+    }
+    initMetadataForClass($, 'MissingFieldException');
+    MissingFieldExceptionClass = $;
+  }
+  return MissingFieldExceptionClass;
+}
+function init_kotlinx_serialization_SerializationException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.r1x_1);
+}
+var SerializationExceptionClass;
+function SerializationException() {
+  if (SerializationExceptionClass === VOID) {
+    class $ extends IllegalArgumentException() {
+      static u1x() {
+        var $this = this.ie();
+        init_kotlinx_serialization_SerializationException($this);
+        return $this;
+      }
+      static v1x(message) {
+        var $this = this.r2(message);
+        init_kotlinx_serialization_SerializationException($this);
+        return $this;
+      }
+      static s1x(message, cause) {
+        var $this = this.je(message, cause);
+        init_kotlinx_serialization_SerializationException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'SerializationException', $.u1x);
+    SerializationExceptionClass = $;
+  }
+  return SerializationExceptionClass;
+}
+var UnknownFieldExceptionClass;
+function UnknownFieldException() {
+  if (UnknownFieldExceptionClass === VOID) {
+    class $ extends SerializationException() {
+      static b1y(message) {
+        var $this = this.v1x(message);
+        captureStack($this, $this.a1y_1);
+        return $this;
+      }
+      static c1y(index) {
+        return this.b1y('An unknown field for index ' + index);
+      }
+    }
+    initMetadataForClass($, 'UnknownFieldException');
+    UnknownFieldExceptionClass = $;
+  }
+  return UnknownFieldExceptionClass;
+}
+//region block: exports
+export {
+  MissingFieldException as MissingFieldException24tqif29emcmi,
+  SerializationException as SerializationExceptioneqrdve3ts2n9,
+  UnknownFieldException as UnknownFieldExceptiona60e3a6v1xqo,
+};
+//endregion
+
+//# sourceMappingURL=SerializationExceptions.mjs.map

package/kotlin/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/SerializationExceptions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/b2fef8360e1bcf3d/core/commonMain/src/kotlinx/serialization/SerializationExceptions.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["missingFields","message","cause","serialName","index"],"mappings":";;;;;;;;;;;;;;;iBAiFIA,a,EAA6BC,O,EAAkBC,K;6BACxB,O,EAAS,K;;QAMS,2B;;;iBAOrCF,a,EACAG,U;wBAEA,a,EACI,aAAc,KAAd,KAAsB,CAAtB,GAA0B,SAA1B,GAAmC,iBAAc,CAAd,CAAnC,GAAoD,2CAApD,GAA8F,UAA9F,GAAwG,uBAAxG,GACE,SADF,YACU,aADV,IACuB,2CADvB,GACiE,UADjE,GAC2E,0B,EAC/E,I;;;;;;;;2DA7DR,a,EAAA;A;AAqBA,C;;;;;;;;;;iBAXuBF,O;4BAA0B,O;;;;iBAK1BA,O,EAAkBC,K;4BAA2B,O,EAAS,K;;;;;;;;;;;;;;iBA8ExDD,O;6BAA2C,O;;;;iBAEhDG,K;wBAAoB,6B,GAA4B,K;;;;;;;;;;;;"}