@attocash/commons-js 5.0.0

package/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/encoding/AbstractEncoder.mjs

@@ -0,0 +1,148 @@
+import {
+  createThis2j2avj17cvnv2 as createThis,
+  toString1pkumu07cwy4m as toString,
+  protoOf180f3jzyo7rfj as protoOf,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { SerializationExceptioneqrdve3ts2n9 as SerializationException } from '../SerializationExceptions.mjs';
+import { getKClassFromExpression3vpejubogshaw as getKClassFromExpression } from '../../../../kotlin-kotlin-stdlib/reflection.mjs';
+import { Char19o2r8palgjof as Char } from '../../../../kotlin-kotlin-stdlib/kotlin/Char.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { NoOpEncoder_getInstance3if0k9o02xdwe as NoOpEncoder_getInstance } from '../internal/NoOpEncoder.mjs';
+import {
+  encodeNotNullMark352dnk5r97tvq as encodeNotNullMark,
+  beginCollection27i47rk9upjw4 as beginCollection,
+  encodeSerializableValue1mu7jsn2oheqi as encodeSerializableValue,
+  shouldEncodeElementDefault1vy568gzcy4z0 as shouldEncodeElementDefault,
+  Encoderqvmrpqtq8hnu as Encoder,
+  CompositeEncoderknecpkexzn3v as CompositeEncoder,
+} from './Encoding.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
+var AbstractEncoderClass;
+function AbstractEncoder() {
+  if (AbstractEncoderClass === VOID) {
+    class $ {
+      static cy() {
+        return createThis(this);
+      }
+      kx(descriptor) {
+        return this;
+      }
+      lx(descriptor) {
+      }
+      dy(descriptor, index) {
+        return true;
+      }
+      ey(value) {
+        throw SerializationException().nu('Non-serializable ' + toString(getKClassFromExpression(value)) + ' is not supported by ' + toString(getKClassFromExpression(this)) + ' encoder');
+      }
+      fy() {
+        throw SerializationException().nu("'null' is not supported by default");
+      }
+      gy(value) {
+        return this.ey(value);
+      }
+      hy(value) {
+        return this.ey(value);
+      }
+      iy(value) {
+        return this.ey(value);
+      }
+      jy(value) {
+        return this.ey(value);
+      }
+      ky(value) {
+        return this.ey(value);
+      }
+      ly(value) {
+        return this.ey(value);
+      }
+      my(value) {
+        return this.ey(value);
+      }
+      ny(value) {
+        return this.ey(new (Char())(value));
+      }
+      oy(value) {
+        return this.ey(value);
+      }
+      py(enumDescriptor, index) {
+        return this.ey(index);
+      }
+      qy(descriptor) {
+        return this;
+      }
+      ry(descriptor, index, value) {
+        if (this.dy(descriptor, index)) {
+          this.gy(value);
+        }
+      }
+      sy(descriptor, index, value) {
+        if (this.dy(descriptor, index)) {
+          this.hy(value);
+        }
+      }
+      ty(descriptor, index, value) {
+        if (this.dy(descriptor, index)) {
+          this.iy(value);
+        }
+      }
+      uy(descriptor, index, value) {
+        if (this.dy(descriptor, index)) {
+          this.jy(value);
+        }
+      }
+      vy(descriptor, index, value) {
+        if (this.dy(descriptor, index)) {
+          this.ky(value);
+        }
+      }
+      wy(descriptor, index, value) {
+        if (this.dy(descriptor, index)) {
+          this.ly(value);
+        }
+      }
+      xy(descriptor, index, value) {
+        if (this.dy(descriptor, index)) {
+          this.my(value);
+        }
+      }
+      yy(descriptor, index, value) {
+        if (this.dy(descriptor, index)) {
+          this.ny(value);
+        }
+      }
+      zy(descriptor, index, value) {
+        if (this.dy(descriptor, index)) {
+          this.oy(value);
+        }
+      }
+      az(descriptor, index) {
+        return this.dy(descriptor, index) ? this.qy(descriptor.vv(index)) : NoOpEncoder_getInstance();
+      }
+      bz(descriptor, index, serializer, value) {
+        if (this.dy(descriptor, index)) {
+          this.cz(serializer, value);
+        }
+      }
+    }
+    protoOf($).dz = encodeNotNullMark;
+    protoOf($).ez = beginCollection;
+    protoOf($).cz = encodeSerializableValue;
+    protoOf($).fz = shouldEncodeElementDefault;
+    initMetadataForClass($, 'AbstractEncoder', VOID, VOID, [Encoder(), CompositeEncoder()]);
+    AbstractEncoderClass = $;
+  }
+  return AbstractEncoderClass;
+}
+//region block: exports
+export {
+  AbstractEncoder as AbstractEncoder2gxtu3xmy3f8j,
+};
+//endregion
+
+//# sourceMappingURL=AbstractEncoder.mjs.map

package/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/encoding/AbstractEncoder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Z:/BuildAgent/work/b2fef8360e1bcf3d/core/commonMain/src/kotlinx/serialization/encoding/AbstractEncoder.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["beginStructure","descriptor","endStructure","encodeElement","index","encodeValue","value","encodeNull","encodeBoolean","encodeByte","encodeShort","encodeInt","encodeLong","encodeFloat","encodeDouble","encodeChar","encodeString","encodeEnum","enumDescriptor","encodeInline","encodeBooleanElement","encodeByteElement","encodeShortElement","encodeIntElement","encodeLongElement","encodeFloatElement","encodeDoubleElement","encodeCharElement","encodeStringElement","encodeInlineElement","encodeSerializableElement","serializer"],"mappings":"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"}

package/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/encoding/Decoding.mjs

@@ -0,0 +1,49 @@
+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
+function decodeSerializableValue(deserializer) {
+  return deserializer.zs(this);
+}
+var DecoderClass;
+function Decoder() {
+  if (DecoderClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'Decoder');
+    DecoderClass = $;
+  }
+  return DecoderClass;
+}
+function decodeSequentially() {
+  return false;
+}
+function decodeCollectionSize(descriptor) {
+  return -1;
+}
+function decodeSerializableElement$default(descriptor, index, deserializer, previousValue, $super) {
+  previousValue = previousValue === VOID ? null : previousValue;
+  return $super === VOID ? this.wx(descriptor, index, deserializer, previousValue) : $super.wx.call(this, descriptor, index, deserializer, previousValue);
+}
+var CompositeDecoderClass;
+function CompositeDecoder() {
+  if (CompositeDecoderClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'CompositeDecoder');
+    CompositeDecoderClass = $;
+  }
+  return CompositeDecoderClass;
+}
+//region block: exports
+export {
+  decodeSerializableElement$default as decodeSerializableElement$default2o0k93vobxyld,
+  decodeCollectionSize as decodeCollectionSize3l4gjp9ef5h8u,
+  decodeSequentially as decodeSequentially27kmi8jnnsnbc,
+  CompositeDecoder as CompositeDecoder2tzm7wpwkr0og,
+  decodeSerializableValue as decodeSerializableValue3h7ajfesxzjda,
+  Decoder as Decoder23nde051s631g,
+};
+//endregion
+
+//# sourceMappingURL=Decoding.mjs.map

package/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/encoding/Decoding.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Z:/BuildAgent/work/b2fef8360e1bcf3d/core/commonMain/src/kotlinx/serialization/encoding/Decoding.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["decodeSerializableValue","deserializer","decodeSequentially","decodeCollectionSize","descriptor","decodeSerializableElement$default","index","previousValue"],"mappings":";;;;;;gCAgQIA,CAA8CC,YAA9CD,EACI;A,EAA8B,OAA9B,YAAa,IAAY,IAAZ,C;AAAgB,C;;;;;;;;;;2BA0GjCE,CAAAA,EAC2C;A,EAAK,OAAL,K;AAAI,C;6BA+D/CC,CAAgCC,UAAhCD,EAAqE;A,EAAE,OAAF,E;AAAC,C;0CA+GtEE,CACID,U,EACAE,K,EACAL,Y,EACAM,a,QAJJF,E;2CAIwB,I;;C;;;;;;;;;;;;;;"}

package/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/encoding/Encoding.mjs

@@ -0,0 +1,47 @@
+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
+function encodeNotNullMark() {
+}
+function beginCollection(descriptor, collectionSize) {
+  return this.kx(descriptor);
+}
+function encodeSerializableValue(serializer, value) {
+  serializer.ys(this, value);
+}
+var EncoderClass;
+function Encoder() {
+  if (EncoderClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'Encoder');
+    EncoderClass = $;
+  }
+  return EncoderClass;
+}
+function shouldEncodeElementDefault(descriptor, index) {
+  return true;
+}
+var CompositeEncoderClass;
+function CompositeEncoder() {
+  if (CompositeEncoderClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'CompositeEncoder');
+    CompositeEncoderClass = $;
+  }
+  return CompositeEncoderClass;
+}
+//region block: exports
+export {
+  shouldEncodeElementDefault as shouldEncodeElementDefault1vy568gzcy4z0,
+  CompositeEncoder as CompositeEncoderknecpkexzn3v,
+  beginCollection as beginCollection27i47rk9upjw4,
+  encodeNotNullMark as encodeNotNullMark352dnk5r97tvq,
+  encodeSerializableValue as encodeSerializableValue1mu7jsn2oheqi,
+  Encoder as Encoderqvmrpqtq8hnu,
+};
+//endregion
+
+//# sourceMappingURL=Encoding.mjs.map

package/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/encoding/Encoding.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Z:/BuildAgent/work/b2fef8360e1bcf3d/core/commonMain/src/kotlinx/serialization/encoding/Encoding.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["encodeNotNullMark","beginCollection","descriptor","collectionSize","encodeSerializableValue","serializer","value","shouldEncodeElementDefault","index"],"mappings":";;;;;;0BAsIIA,CAAAA,EAC+B;AAAC,C;wBAqIhCC,CACIC,U,EACAC,cAFJF,EAGsB;A,EAA0B,OAA1B,QAAe,UAAf,C;AAAyB,C;gCAO/CG,CAA8CC,U,EAAsCC,KAApFF,EAA8F;A,EAC1F,UAAW,IAAU,IAAV,EAAgB,KAAhB,C;AACf,C;;;;;;;;;;mCAuEAG,CACsCL,U,EAA8BM,KADpED,EAC2F;A,EAAI,OAAJ,I;AAAG,C;;;;;;;;;;;;;;"}

package/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/internal/AbstractPolymorphicSerializer.mjs

@@ -0,0 +1,141 @@
+import {
+  findPolymorphicSerializer1nm87hvemahcj as findPolymorphicSerializer,
+  findPolymorphicSerializerk638ixyjovk5 as findPolymorphicSerializer_0,
+} from '../PolymorphicSerializer.mjs';
+import {
+  createThis2j2avj17cvnv2 as createThis,
+  toString1pkumu07cwy4m as toString,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import {
+  SerializationStrategyh6ouydnm6hci as SerializationStrategy,
+  KSerializerzf77vz1967fq as KSerializer,
+} from '../KSerializer.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { SerializationExceptioneqrdve3ts2n9 as SerializationException } from '../SerializationExceptions.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 decodeSequentially($this, compositeDecoder) {
+  var klassName = compositeDecoder.ux($this.xs(), 0);
+  var serializer = findPolymorphicSerializer($this, compositeDecoder, klassName);
+  return compositeDecoder.xx($this.xs(), 1, serializer);
+}
+var AbstractPolymorphicSerializerClass;
+function AbstractPolymorphicSerializer() {
+  if (AbstractPolymorphicSerializerClass === VOID) {
+    class $ {
+      static nt() {
+        return createThis(this);
+      }
+      pt(encoder, value) {
+        var actualSerializer = findPolymorphicSerializer_0(this, encoder, value);
+        // Inline function 'kotlinx.serialization.encoding.encodeStructure' call
+        var descriptor = this.xs();
+        var composite = encoder.kx(descriptor);
+        composite.zy(this.xs(), 0, actualSerializer.xs().au());
+        var tmp = this.xs();
+        // Inline function 'kotlinx.serialization.internal.cast' call
+        var tmp$ret$0 = isInterface(actualSerializer, SerializationStrategy()) ? actualSerializer : THROW_CCE();
+        composite.bz(tmp, 1, tmp$ret$0, value);
+        composite.lx(descriptor);
+      }
+      ys(encoder, value) {
+        return this.pt(encoder, !(value == null) ? value : THROW_CCE());
+      }
+      zs(decoder) {
+        // Inline function 'kotlinx.serialization.encoding.decodeStructure' call
+        var descriptor = this.xs();
+        var composite = decoder.kx(descriptor);
+        var tmp$ret$0;
+        $l$block: {
+          var klassName = null;
+          var value = null;
+          if (composite.zx()) {
+            tmp$ret$0 = decodeSequentially(this, composite);
+            break $l$block;
+          }
+          mainLoop: while (true) {
+            var index = composite.ay(this.xs());
+            switch (index) {
+              case -1:
+                break mainLoop;
+              case 0:
+                klassName = composite.ux(this.xs(), index);
+                break;
+              case 1:
+                var tmp0 = klassName;
+                var tmp$ret$2;
+                $l$block_0: {
+                  // Inline function 'kotlin.requireNotNull' call
+                  if (tmp0 == null) {
+                    var message = 'Cannot read polymorphic value before its type token';
+                    throw IllegalArgumentException().u(toString(message));
+                  } else {
+                    tmp$ret$2 = tmp0;
+                    break $l$block_0;
+                  }
+                }
+
+                klassName = tmp$ret$2;
+                var serializer = findPolymorphicSerializer(this, composite, klassName);
+                value = composite.xx(this.xs(), index, serializer);
+                break;
+              default:
+                var tmp0_elvis_lhs = klassName;
+                throw SerializationException().nu('Invalid index in polymorphic deserialization of ' + (tmp0_elvis_lhs == null ? 'unknown class' : tmp0_elvis_lhs) + ('\n Expected 0, 1 or DECODE_DONE(-1), but found ' + index));
+            }
+          }
+          var tmp0_0 = value;
+          var tmp$ret$4;
+          $l$block_1: {
+            // Inline function 'kotlin.requireNotNull' call
+            if (tmp0_0 == null) {
+              var message_0 = 'Polymorphic value has not been read for class ' + klassName;
+              throw IllegalArgumentException().u(toString(message_0));
+            } else {
+              tmp$ret$4 = tmp0_0;
+              break $l$block_1;
+            }
+          }
+          var tmp = tmp$ret$4;
+          tmp$ret$0 = !(tmp == null) ? tmp : THROW_CCE();
+        }
+        var result = tmp$ret$0;
+        composite.lx(descriptor);
+        return result;
+      }
+      qt(decoder, klassName) {
+        return decoder.yx().gz(this.ot(), klassName);
+      }
+      rt(encoder, value) {
+        return encoder.yx().hz(this.ot(), value);
+      }
+    }
+    initMetadataForClass($, 'AbstractPolymorphicSerializer', VOID, VOID, [KSerializer()]);
+    AbstractPolymorphicSerializerClass = $;
+  }
+  return AbstractPolymorphicSerializerClass;
+}
+function throwSubtypeNotRegistered(subClass, baseClass) {
+  var tmp0_elvis_lhs = subClass.ag();
+  throwSubtypeNotRegistered_0(tmp0_elvis_lhs == null ? toString(subClass) : tmp0_elvis_lhs, baseClass);
+}
+function throwSubtypeNotRegistered_0(subClassName, baseClass) {
+  var scope = "in the polymorphic scope of '" + baseClass.ag() + "'";
+  throw SerializationException().nu(subClassName == null ? 'Class discriminator was missing and no default serializers were registered ' + scope + '.' : "Serializer for subclass '" + subClassName + "' is not found " + scope + '.\n' + ("Check if class with serial name '" + subClassName + "' exists and serializer is registered in a corresponding SerializersModule.\n") + ("To be registered automatically, class '" + subClassName + "' has to be '@Serializable', and the base class '" + baseClass.ag() + "' has to be sealed and '@Serializable'."));
+}
+//region block: exports
+export {
+  AbstractPolymorphicSerializer as AbstractPolymorphicSerializer1ccxwp48nfy58,
+  throwSubtypeNotRegistered_0 as throwSubtypeNotRegistered2cr459177l268,
+  throwSubtypeNotRegistered as throwSubtypeNotRegistered343gt7v9eqwun,
+};
+//endregion
+
+//# sourceMappingURL=AbstractPolymorphicSerializer.mjs.map

package/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/internal/AbstractPolymorphicSerializer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Z:/BuildAgent/work/b2fef8360e1bcf3d/core/commonMain/src/kotlinx/serialization/internal/AbstractPolymorphicSerializer.kt","Z:/BuildAgent/work/b2fef8360e1bcf3d/core/commonMain/src/kotlinx/serialization/encoding/Encoding.kt","Z:/BuildAgent/work/b2fef8360e1bcf3d/core/commonMain/src/kotlinx/serialization/internal/Platform.common.kt","Z:/BuildAgent/work/b2fef8360e1bcf3d/core/commonMain/src/kotlinx/serialization/encoding/Decoding.kt","src/kotlin/util/Preconditions.kt"],"sourcesContent":[null,null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["decodeSequentially","compositeDecoder","klassName","serializer","serialize","encoder","value","actualSerializer","composite","deserialize","decoder","index","message","result","findPolymorphicSerializerOrNull","throwSubtypeNotRegistered","subClass","baseClass","subClassName","scope"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;2BAqEIA,CAAA,K,EAA+BC,gBAA/BD,EAAsE;A,MAClEE,YAAgB,gBAAiB,IAAoB,UAApB,EAAgC,CAAhC,C;MACjCC,aAAiB,iCAA0B,gBAA1B,EAA4C,SAA5C,C;EACjB,OAAO,gBAAiB,IAA0B,UAA1B,EAAsC,CAAtC,EAAyC,UAAzC,C;AAC5B,C;;;;;;;;QA3CAC,CAAoCC,O,EAAkBC,KAAtDF,EAAgE;A,YAC5DG,mBAAuB,kCAA0B,OAA1B,EAAmC,KAAnC,C;;yBACC,S;YC2b5BC,YD3bI,OC2bY,IAAe,UAAf,C;QAChB,SD3bQ,IAAoB,SAApB,EAAgC,CAAhC,EAAmC,gBAAiB,KAAW,KAA/D,C;kBAC0B,S;;wBE+C8C,YF/C/B,gBE+C+B,6BF/C/B,gBE+C+B,c;QD2YhF,SD1bQ,SAAsC,CAAtC,EAA0D,SAA1D,EAAkE,KAAlE,C;QC2bR,SAAU,IAAa,UAAb,C;MDzbV,C;SA8EqvDH,O,EAAkBC,K;;;QA5EvwDG,CAAsCC,OAAtCD,EAA6D;A;yBAAwB,S;YGohBrFD,YHphB6D,OGohB7C,IAAe,UAAf,C;;;cHnhBZN,YAAyB,I;cACzBI,QAAkB,I;UACd,IGkhBK,SHlhBL,M,CAAsB;A,YACtB,YAAuB,yBGihBlB,SHjhBkB,C;;UAC3B,C;2BAEiB,I,EAAM;A,gBACbK,QG6gBD,SH7gBa,IAAmB,SAAnB,C;YAAlB,c;mBACqB,E;gBACb,c;mBAEJ,C;gBACI,YGwgBH,SHxgBe,IAAoB,SAApB,EAAgC,KAAhC,C;;mBAEhB,C;2BAC+B,S;;;;kBIUvC,YAAS,IAAT,C;wBACAC,UJXoD,qD;oBIYpD,mCAAuC,SAAR,OAAQ,CAAvC,C;;oBAEA,gB;;;;;gBJdY,YAAY,S;oBACZT,aAAiB,gCGogBpB,SHpgBoB,EAAgC,SAAhC,C;gBACjB,QGmgBH,SHngBW,IAA0B,SAA1B,EAAsC,KAAtC,EAA6C,UAA7C,C;;;oBAIH,0B;gBAFD,kCACJ,sDACK,yBAAa,eAAb,iBADL,KAEK,iDAFL,GAEqD,KAFrD,CADI,C;;UAMhB,C;uBAEe,K;;;;YIFf,cAAS,IAAT,C;kBACAS,YJCyB,gDAAD,GAAgD,S;cIAxE,mCAAuC,SAAR,SAAQ,CAAvC,C;;cAEA,kB;;;;oBJFA,S;UAAyF,YAAzF,kC;;YGyfJC,SAAuB,S;QACvB,SAAU,IAAa,UAAb,C;QHzfT,OG0fM,M;MH1fP,C;QAYAC,CAEIJ,O,EACAR,SAHJY,EAIiC;A,QAA8D,OAA9D,OAAQ,KAAkB,IAAe,SAAf,EAA0B,SAA1B,C;MAAmC,C;QAO9FA,CAEIT,O,EACAC,KAHJQ,EAKI;A,QAA0D,OAA1D,OAAQ,KAAkB,IAAe,SAAf,EAA0B,KAA1B,C;MAA+B,C;;;;;;;kCAgBjEC,CACuCC,Q,EAAqBC,SAD5DF,EAEI;A,MAA0B,iBAAA,QAAS,K;EAAnC,4BAA0B,kCAAyB,QAAzB,kBAA1B,EAA8D,SAA9D,C;AAAuE,C;oCAf3EA,CACuCG,Y,EAAuBD,SAD9DF,EAC6F;A,MACzFI,QAAa,+BAAbA,GAA4C,SAAU,KAAtDA,GAAiE,G;EACjE,kCACQ,gBAAgB,IAAhB,GACC,6EADD,GAC6E,KAD7E,GACkF,GADlF,GAGC,2BAHD,GAG2B,YAH3B,GAGuC,iBAHvC,GAGuD,KAHvD,GAG4D,KAH5D,IAIK,mCAJL,GAIuC,YAJvC,GAImD,+EAJnD,KAKK,yCALL,GAK6C,YAL7C,GAKyD,mDALzD,GAK4G,SAAU,KALtH,GAKiI,yCALjI,CADR,C;AAQJ,C;;;;;"}

package/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/internal/BuiltInSerializers.mjs

@@ -0,0 +1,135 @@
+import { NothingSerialDescriptor_getInstance39ckonyn56mmu as NothingSerialDescriptor_getInstance } from './NothingSerialDescriptor.mjs';
+import { SerializationExceptioneqrdve3ts2n9 as SerializationException } from '../SerializationExceptions.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { KSerializerzf77vz1967fq as KSerializer } from '../KSerializer.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';
+import { STRING_getInstance2ou4lro9xn2qn as STRING_getInstance } from '../descriptors/SerialKinds.mjs';
+import { PrimitiveSerialDescriptorkwnwsc78b2on as PrimitiveSerialDescriptor } from './Primitives.mjs';
+import {
+  Duration__toIsoString_impl_9h6wsm3b9pty5ms72ij as Duration__toIsoString_impl_9h6wsm,
+  Duration5ynfiptaqcrg as Duration,
+  Companion_getInstance3vz87v4c01z2t as Companion_getInstance,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/time/Duration.mjs';
+import {
+  Uuid1zxgztb7abqxx as Uuid,
+  Companion_getInstance1cdckxf15vkye as Companion_getInstance_0,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/uuid/Uuid.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var NothingSerializerClass;
+function NothingSerializer() {
+  if (NothingSerializerClass === VOID) {
+    class $ {
+      constructor() {
+        NothingSerializer_instance = this;
+        this.iz_1 = NothingSerialDescriptor_getInstance();
+      }
+      xs() {
+        return this.iz_1;
+      }
+      jz(encoder, value) {
+        throw SerializationException().nu("'kotlin.Nothing' cannot be serialized");
+      }
+      ys(encoder, value) {
+        var tmp;
+        if (false) {
+          tmp = value;
+        } else {
+          tmp = THROW_CCE();
+        }
+        return this.jz(encoder, tmp);
+      }
+      zs(decoder) {
+        throw SerializationException().nu("'kotlin.Nothing' does not have instances");
+      }
+    }
+    initMetadataForObject($, 'NothingSerializer', VOID, VOID, [KSerializer()]);
+    NothingSerializerClass = $;
+  }
+  return NothingSerializerClass;
+}
+var NothingSerializer_instance;
+function NothingSerializer_getInstance() {
+  if (NothingSerializer_instance === VOID)
+    new (NothingSerializer())();
+  return NothingSerializer_instance;
+}
+var DurationSerializerClass;
+function DurationSerializer() {
+  if (DurationSerializerClass === VOID) {
+    class $ {
+      constructor() {
+        DurationSerializer_instance = this;
+        this.kz_1 = new (PrimitiveSerialDescriptor())('kotlin.time.Duration', STRING_getInstance());
+      }
+      xs() {
+        return this.kz_1;
+      }
+      lz(encoder, value) {
+        encoder.oy(Duration__toIsoString_impl_9h6wsm(value));
+      }
+      ys(encoder, value) {
+        return this.lz(encoder, value instanceof Duration() ? value.jq_1 : THROW_CCE());
+      }
+      mz(decoder) {
+        return Companion_getInstance().iq(decoder.fx());
+      }
+      zs(decoder) {
+        return new (Duration())(this.mz(decoder));
+      }
+    }
+    initMetadataForObject($, 'DurationSerializer', VOID, VOID, [KSerializer()]);
+    DurationSerializerClass = $;
+  }
+  return DurationSerializerClass;
+}
+var DurationSerializer_instance;
+function DurationSerializer_getInstance() {
+  if (DurationSerializer_instance === VOID)
+    new (DurationSerializer())();
+  return DurationSerializer_instance;
+}
+var UuidSerializerClass;
+function UuidSerializer() {
+  if (UuidSerializerClass === VOID) {
+    class $ {
+      constructor() {
+        UuidSerializer_instance = this;
+        this.nz_1 = new (PrimitiveSerialDescriptor())('kotlin.uuid.Uuid', STRING_getInstance());
+      }
+      xs() {
+        return this.nz_1;
+      }
+      oz(encoder, value) {
+        encoder.oy(value.toString());
+      }
+      ys(encoder, value) {
+        return this.oz(encoder, value instanceof Uuid() ? value : THROW_CCE());
+      }
+      zs(decoder) {
+        return Companion_getInstance_0().ar(decoder.fx());
+      }
+    }
+    initMetadataForObject($, 'UuidSerializer', VOID, VOID, [KSerializer()]);
+    UuidSerializerClass = $;
+  }
+  return UuidSerializerClass;
+}
+var UuidSerializer_instance;
+function UuidSerializer_getInstance() {
+  if (UuidSerializer_instance === VOID)
+    new (UuidSerializer())();
+  return UuidSerializer_instance;
+}
+//region block: exports
+export {
+  DurationSerializer_getInstance as DurationSerializer_getInstanceo50ej00g6vz5,
+  NothingSerializer_getInstance as NothingSerializer_getInstancejqk7fqid1kug,
+  UuidSerializer_getInstance as UuidSerializer_getInstance1ils3vei9gjnd,
+};
+//endregion
+
+//# sourceMappingURL=BuiltInSerializers.mjs.map

package/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/internal/BuiltInSerializers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Z:/BuildAgent/work/b2fef8360e1bcf3d/core/commonMain/src/kotlinx/serialization/internal/BuiltInSerializers.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-descriptor>","serialize","encoder","value","deserialize","decoder"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;QA8BgD,iD;;QAA5CA,CAAAA,EAAA;A,QAAA,gB;MAAwC,C;QAExCC,CAAuBC,O,EAAkBC,KAAzCF,EAAyD;A,QACrD,kCAA6B,uCAA7B,C;MACJ,C;SAoB06JC,O,EAAkBC,K;;;;;;;;;QAlB57JC,CAAyBC,OAAzBD,EAAoD;A,QAChD,kCAA6B,0CAA7B,C;MACJ,C;;;;;;;;;;;;;;;;;;;QArB4C,8CAA0B,sBAA1B,uB;;QAA5CJ,CAAAA,EAAA;A,QAAA,gB;MAAwC,C;QAExCC,CAAuBC,O,EAAkBC,KAAzCF,EAA0D;A,QACtD,OAAQ,IAAmB,kCAAN,KAAM,CAAnB,C;MACZ,C;SAiC06JC,O,EAAkBC,K;;;QA/B57JC,CAAyBC,OAAzBD,EAAqD;A,QACjD,OAAgB,2BAAe,OAAQ,KAAvB,C;MACpB,C;SA6B2+QC,O;;;;;;;;;;;;;;;;;;;;;QAV/7Q,8CAA0B,kBAA1B,uB;;QAA5CL,CAAAA,EAAA;A,QAAA,gB;MAAwC,C;QAExCC,CAAuBC,O,EAAkBC,KAAzCF,EAAsD;A,QAClD,OAAQ,IAAa,KAAM,WAAnB,C;MACZ,C;SAM06JC,O,EAAkBC,K;;;QAJ57JC,CAAyBC,OAAzBD,EAAiD;A,QAC7C,OAAY,6BAAM,OAAQ,KAAd,C;MAChB,C;;;;;;;;;;;;;;;;;"}

package/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/internal/CachedNames.mjs

@@ -0,0 +1,22 @@
+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 CachedNamesClass;
+function CachedNames() {
+  if (CachedNamesClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'CachedNames');
+    CachedNamesClass = $;
+  }
+  return CachedNamesClass;
+}
+//region block: exports
+export {
+  CachedNames as CachedNames2minxlyafeo07,
+};
+//endregion
+
+//# sourceMappingURL=CachedNames.mjs.map

package/kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/internal/CachedNames.mjs.map

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