@continuous-excellence/coupling-cli 1.1.582 → 1.1.583

package/kotlin/apollo-kotlin-apollo-api/com/apollographql/apollo/api/CompiledGraphQL.mjs

@@ -1,5 +1,8 @@
 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 { emptyList1g2z5xcrvp2zy as emptyList } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/CollectionsKt.mjs';
+import { Unit_instancev9v8hjid95df as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { Companion_instance19mvqqhuhhta7 as Companion_instance } from './Optional.mjs';
 //region block: imports
 //endregion
 //region block: pre-declaration
@@ -10,7 +13,7 @@ function CustomScalarType() {
     class $ extends CompiledNamedType() {
       constructor(name, className) {
         super(name);
-        this.c4u_1 = className;
+        this.z4u_1 = className;
       }
     }
     initMetadataForClass($, 'CustomScalarType');
@@ -24,7 +27,7 @@ function CompiledNamedType() {
     class $ extends CompiledType() {
       constructor(name) {
         super();
-        this.d4u_1 = name;
+        this.a4v_1 = name;
       }
     }
     initMetadataForClass($, 'CompiledNamedType');
@@ -41,13 +44,268 @@ function CompiledType() {
   }
   return CompiledTypeClass;
 }
+var BuilderClass;
+function Builder() {
+  if (BuilderClass === VOID) {
+    class $ {
+      constructor(name, type) {
+        this.b4v_1 = name;
+        this.c4v_1 = type;
+        this.d4v_1 = null;
+        this.e4v_1 = emptyList();
+        this.f4v_1 = emptyList();
+        this.g4v_1 = emptyList();
+      }
+      h4v(arguments_0) {
+        // Inline function 'kotlin.apply' call
+        this.f4v_1 = arguments_0;
+        return this;
+      }
+      i4v(selections) {
+        // Inline function 'kotlin.apply' call
+        this.g4v_1 = selections;
+        return this;
+      }
+      p2t() {
+        var tmp0_name = this.b4v_1;
+        var tmp1_alias = this.d4v_1;
+        var tmp2_type = this.c4v_1;
+        var tmp3_condition = this.e4v_1;
+        var tmp4_arguments = this.f4v_1;
+        var tmp5_selections = this.g4v_1;
+        return new (CompiledField())(tmp0_name, tmp2_type, tmp1_alias, tmp3_condition, tmp4_arguments, tmp5_selections);
+      }
+    }
+    initMetadataForClass($, 'Builder');
+    BuilderClass = $;
+  }
+  return BuilderClass;
+}
+var CompiledFieldClass;
+function CompiledField() {
+  if (CompiledFieldClass === VOID) {
+    class $ extends CompiledSelection() {
+      constructor(name, type, alias, condition, arguments_0, selections) {
+        super();
+        this.j4v_1 = name;
+        this.k4v_1 = type;
+        this.l4v_1 = alias;
+        this.m4v_1 = condition;
+        this.n4v_1 = arguments_0;
+        this.o4v_1 = selections;
+      }
+    }
+    initMetadataForClass($, 'CompiledField');
+    CompiledFieldClass = $;
+  }
+  return CompiledFieldClass;
+}
+var CompiledSelectionClass;
+function CompiledSelection() {
+  if (CompiledSelectionClass === VOID) {
+    class $ {}
+    initMetadataForClass($, 'CompiledSelection');
+    CompiledSelectionClass = $;
+  }
+  return CompiledSelectionClass;
+}
+var BuilderClass_0;
+function Builder_0() {
+  if (BuilderClass_0 === VOID) {
+    class $ {
+      constructor(definition) {
+        this.p4v_1 = definition;
+        this.q4v_1 = Companion_instance.r4v();
+      }
+      s4v(value) {
+        // Inline function 'kotlin.apply' call
+        this.q4v_1 = Companion_instance.t4v(value);
+        return this;
+      }
+      p2t() {
+        return new (CompiledArgument())(this.p4v_1, this.q4v_1);
+      }
+    }
+    initMetadataForClass($, 'Builder');
+    BuilderClass_0 = $;
+  }
+  return BuilderClass_0;
+}
+var CompiledArgumentClass;
+function CompiledArgument() {
+  if (CompiledArgumentClass === VOID) {
+    class $ {
+      constructor(definition, value) {
+        this.u4v_1 = definition;
+        this.v4v_1 = value;
+      }
+    }
+    initMetadataForClass($, 'CompiledArgument');
+    CompiledArgumentClass = $;
+  }
+  return CompiledArgumentClass;
+}
+var BuilderClass_1;
+function Builder_1() {
+  if (BuilderClass_1 === VOID) {
+    class $ {
+      constructor(name) {
+        this.w4v_1 = name;
+        this.x4v_1 = false;
+      }
+      p2t() {
+        return new (CompiledArgumentDefinition())(this.w4v_1, this.x4v_1);
+      }
+    }
+    initMetadataForClass($, 'Builder');
+    BuilderClass_1 = $;
+  }
+  return BuilderClass_1;
+}
+var CompiledArgumentDefinitionClass;
+function CompiledArgumentDefinition() {
+  if (CompiledArgumentDefinitionClass === VOID) {
+    class $ {
+      constructor(name, isKey) {
+        this.y4v_1 = name;
+        this.z4v_1 = isKey;
+        this.a4w_1 = false;
+      }
+    }
+    initMetadataForClass($, 'CompiledArgumentDefinition');
+    CompiledArgumentDefinitionClass = $;
+  }
+  return CompiledArgumentDefinitionClass;
+}
+var CompiledVariableClass;
+function CompiledVariable() {
+  if (CompiledVariableClass === VOID) {
+    class $ {
+      constructor(name) {
+        this.b4w_1 = name;
+      }
+    }
+    initMetadataForClass($, 'CompiledVariable');
+    CompiledVariableClass = $;
+  }
+  return CompiledVariableClass;
+}
+var BuilderClass_2;
+function Builder_2() {
+  if (BuilderClass_2 === VOID) {
+    class $ {
+      constructor(name) {
+        this.c4w_1 = name;
+        this.d4w_1 = emptyList();
+        this.e4w_1 = emptyList();
+      }
+      p2t() {
+        return new (ObjectType())(this.c4w_1, this.d4w_1, this.e4w_1);
+      }
+    }
+    initMetadataForClass($, 'Builder');
+    BuilderClass_2 = $;
+  }
+  return BuilderClass_2;
+}
+var ObjectTypeClass;
+function ObjectType() {
+  if (ObjectTypeClass === VOID) {
+    class $ extends CompiledNamedType() {
+      constructor(name, keyFields, implements_0) {
+        super(name);
+        this.g4w_1 = keyFields;
+        this.h4w_1 = implements_0;
+        this.i4w_1 = emptyList();
+      }
+    }
+    initMetadataForClass($, 'ObjectType');
+    ObjectTypeClass = $;
+  }
+  return ObjectTypeClass;
+}
+var CompiledNotNullTypeClass;
+function CompiledNotNullType() {
+  if (CompiledNotNullTypeClass === VOID) {
+    class $ extends CompiledType() {
+      constructor(ofType) {
+        super();
+        this.j4w_1 = ofType;
+      }
+    }
+    initMetadataForClass($, 'CompiledNotNullType');
+    CompiledNotNullTypeClass = $;
+  }
+  return CompiledNotNullTypeClass;
+}
+function notNull(_this__u8e3s4) {
+  return new (CompiledNotNullType())(_this__u8e3s4);
+}
+var BuilderClass_3;
+function Builder_3() {
+  if (BuilderClass_3 === VOID) {
+    class $ {
+      constructor(typeCondition, possibleTypes) {
+        this.k4w_1 = typeCondition;
+        this.l4w_1 = possibleTypes;
+        this.m4w_1 = emptyList();
+        this.n4w_1 = emptyList();
+      }
+      i4v(selections) {
+        // Inline function 'kotlin.apply' call
+        this.n4w_1 = selections;
+        return this;
+      }
+      p2t() {
+        return new (CompiledFragment())(this.k4w_1, this.l4w_1, this.m4w_1, this.n4w_1);
+      }
+    }
+    initMetadataForClass($, 'Builder');
+    BuilderClass_3 = $;
+  }
+  return BuilderClass_3;
+}
+var CompiledFragmentClass;
+function CompiledFragment() {
+  if (CompiledFragmentClass === VOID) {
+    class $ extends CompiledSelection() {
+      constructor(typeCondition, possibleTypes, condition, selections) {
+        super();
+        this.o4w_1 = typeCondition;
+        this.p4w_1 = possibleTypes;
+        this.q4w_1 = condition;
+        this.r4w_1 = selections;
+      }
+    }
+    initMetadataForClass($, 'CompiledFragment');
+    CompiledFragmentClass = $;
+  }
+  return CompiledFragmentClass;
+}
+var CompiledListTypeClass;
+function CompiledListType() {
+  if (CompiledListTypeClass === VOID) {
+    class $ extends CompiledType() {
+      constructor(ofType) {
+        super();
+        this.s4w_1 = ofType;
+      }
+    }
+    initMetadataForClass($, 'CompiledListType');
+    CompiledListTypeClass = $;
+  }
+  return CompiledListTypeClass;
+}
+function list(_this__u8e3s4) {
+  return new (CompiledListType())(_this__u8e3s4);
+}
 var EnumTypeClass;
 function EnumType() {
   if (EnumTypeClass === VOID) {
     class $ extends CompiledNamedType() {
       constructor(name, values) {
         super(name);
-        this.f4u_1 = values;
+        this.u4w_1 = values;
       }
     }
     initMetadataForClass($, 'EnumType');
@@ -57,8 +315,16 @@ function EnumType() {
 }
 //region block: exports
 export {
+  Builder_0 as Builder3t31vflw4km89,
+  Builder_1 as Builderlyags3ldja2y,
+  Builder as Builder320ghmibyd2no,
+  Builder_3 as Builder2iaenv1j4gk4w,
+  CompiledVariable as CompiledVariablecaz6ndkw7us2,
   CustomScalarType as CustomScalarType8w7iuefxipic,
   EnumType as EnumType11cgb4df0n5r9,
+  Builder_2 as Builder3vv3qt9kyowg0,
+  list as lista11lrkbcitk,
+  notNull as notNull3hndh47e9bowl,
 };
 //endregion
 

package/kotlin/apollo-kotlin-apollo-api/com/apollographql/apollo/api/CompiledGraphQL.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../../../Users/runner/work/apollo-kotlin/apollo-kotlin/libraries/apollo-api/src/commonMain/kotlin/com/apollographql/apollo/api/CompiledGraphQL.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["name","className","values"],"mappings":";;;;;;;;;;kBA+QIA,I,EAKAC,S;cACkB,I;QADlB,sB;;;;;;;;;;;;kBArB2BD,I;;QAAA,iB;;;;;;;;;;;;;;;;;;;;;kBA8H3BA,I,EACAE,M;cACkB,I;QADlB,mB;;;;;;;;;;;;"}
+{"version":3,"sources":["../../../../../../../../../../Users/runner/work/apollo-kotlin/apollo-kotlin/libraries/apollo-api/src/commonMain/kotlin/com/apollographql/apollo/api/CompiledGraphQL.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["name","className","type","arguments","selections","build","alias","condition","definition","value","isKey","keyFields","implements","ofType","notNull","<this>","typeCondition","possibleTypes","list","values"],"mappings":";;;;;;;;;;;;;kBA8QIA,I,EAKAC,S;cACkB,I;QADlB,sB;;;;;;;;;;;;kBArB2BD,I;;QAAA,iB;;;;;;;;;;;;;;;;;;;;;kBAvFfA,I,EAAkBE,I;QAAlB,iB;QAAkB,iB;QACD,iB;QACoB,wB;QACD,wB;QACE,wB;;SAiBlDC,CAAcA,WAAdA,EAAmD;A;QAAA,IAC5C,SAAY,W;QAClB,OAFkD,I;MAEnD,C;SAEAC,CAAeA,UAAfA,EAAsD;A;QAAA,IAC/C,SAAa,U;QACnB,OAFqD,I;MAEtD,C;SAEAC,CAAAA,EAA6B;A,YAClB,sB;YACC,uB;YACD,sB;YACK,2B;YACA,2B;YACC,4B;QAChB,6BANU,SAMV,EAJU,SAIV,EALW,UAKX,EAHe,cAGf,EAFe,cAEf,EADgB,eAChB,C;MAAD,C;;;;;;;;;;;kBAxLAL,I,EACAE,I,EACAI,K,EACAC,S,EACAJ,W,EACAC,U;;QALA,iB;QACA,iB;QACA,kB;QACA,sB;QACA,wB;QACA,uB;;;;;;;;;;;;;;;;;;;;;kBAwbUI,U;QAAR,uB;QAEoD,qC;;SAEtDC,CAAUA,KAAVA,EAAkC;A;QAAA,IAC3B,SAAiB,uBAAQ,KAAR,C;QACvB,OAFiC,I;MAElC,C;SAEAJ,CAAAA,EAAgC;A,QAG/B,gCAFgB,IAEhB,CAFgB,KAEhB,EADW,IACX,CADW,KACX,C;MAAD,C;;;;;;;;;;;kBA7BAG,U,EAOAC,K;QAPA,uB;QAOA,kB;;;;;;;;;;;;kBAlCUT,I;QAAR,iB;QAM2B,kB;;SAa7BK,CAAAA,EAA0C;A,QAGzC,0CAFU,IAEV,CAFU,KAEV,EADW,IACX,CADW,KACX,C;MAAD,C;;;;;;;;;;;kBAjCAL,I,EACAU,K;QADA,iB;QACA,kB;QAK0B,kB;;;;;;;;;;;;kBAnBPV,I;QAAA,iB;;;;;;;;;;;;kBAvGEA,I;QAAT,iB;QAC0B,wB;QACQ,wB;;SAsB9CK,CAAAA,EAA0B;A,QAIzB,0BAHU,IAGV,CAHU,KAGV,EAFe,IAEf,CAFe,KAEf,EADgB,IAChB,CADgB,KAChB,C;MAAD,C;;;;;;;;;;;kBAzCAL,I,EACAW,S,EACAC,Y;cACkB,I;QACJ,sB;QACC,yB;QAIkB,wB;;;;;;;;;;;;kBA9CXC,M;;QAAA,mB;;;;;;;;gBAiJ1BC,CAAIC,aAAJD,EAA6B;A,EAAyB,mCAAL,aAAK,C;AAAD,C;;;;;kBA1KrCE,a,EAA2BC,a;QAA3B,0B;QAA2B,0B;QACE,wB;QACC,wB;;SAM1Cb,CAAeA,UAAfA,EAAsD;A;QAAA,IAC/C,SAAa,U;QACnB,OAFqD,I;MAEtD,C;SAEAC,CAAAA,EAAc;A,QAAqE,gCAApD,IAAoD,CAApD,KAAoD,EAArC,IAAqC,CAArC,KAAqC,EAAtB,IAAsB,CAAtB,KAAsB,EAAX,IAAW,CAAX,KAAW,C;MAAD,C;;;;;;;;;;;kBAlBlFW,a,EACAC,a,EACAV,S,EACAH,U;;QAHA,0B;QACA,0B;QACA,sB;QACA,uB;;;;;;;;;;;;kBAkCmBS,M;;QAAA,mB;;;;;;;;aA8IvBK,CAAIH,aAAJG,EAA0B;A,EAAsB,gCAAL,aAAK,C;AAAD,C;;;;;kBAT3ClB,I,EACAmB,M;cACkB,I;QADlB,mB;;;;;;;;;;;;"}

package/kotlin/apollo-kotlin-apollo-api/com/apollographql/apollo/api/CustomScalarAdapters.mjs

@@ -11,7 +11,6 @@ import {
   protoOf180f3jzyo7rfj as protoOf,
 } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
 import {
-  PassThroughAdapterdbgnfuhbpbsv as PassThroughAdapter,
   get_AnyAdapterx2g0krnqn0y9 as get_AnyAdapter,
   get_FloatAdapter8hkphxq3v57l as get_FloatAdapter,
   get_LongAdapter1acs38m0a7icu as get_LongAdapter,
@@ -42,8 +41,7 @@ function Key() {
     class $ {
       constructor() {
         Key_instance = this;
-        this.g4u_1 = (new (Builder())()).j2t();
-        this.h4u_1 = (new (Builder())()).n4u(true).j2t();
+        this.v4w_1 = (new (Builder())()).p2t();
       }
     }
     initMetadataForObject($, 'Key');
@@ -64,42 +62,36 @@ function Builder() {
       constructor() {
         var tmp = this;
         // Inline function 'kotlin.collections.mutableMapOf' call
-        tmp.i4u_1 = LinkedHashMap().lc();
-        this.j4u_1 = false;
-        this.k4u_1 = null;
-        this.l4u_1 = null;
-        this.m4u_1 = null;
+        tmp.w4w_1 = LinkedHashMap().lc();
+        this.x4w_1 = null;
+        this.y4w_1 = null;
+        this.z4w_1 = null;
       }
-      o4u(falseVariables) {
+      a4x(falseVariables) {
         // Inline function 'kotlin.apply' call
-        this.k4u_1 = falseVariables;
+        this.x4w_1 = falseVariables;
         return this;
       }
-      p4u(deferredFragmentIdentifiers) {
+      b4x(deferredFragmentIdentifiers) {
         // Inline function 'kotlin.apply' call
-        this.l4u_1 = deferredFragmentIdentifiers;
+        this.y4w_1 = deferredFragmentIdentifiers;
         return this;
       }
-      q4s(errors) {
+      o4t(errors) {
         // Inline function 'kotlin.apply' call
-        this.m4u_1 = errors;
+        this.z4w_1 = errors;
         return this;
       }
-      q4u(customScalarAdapters) {
+      c4x(customScalarAdapters) {
         // Inline function 'kotlin.apply' call
-        this.i4u_1.s4(customScalarAdapters.v4u_1);
-        return this;
-      }
-      n4u(unsafe) {
-        // Inline function 'kotlin.apply' call
-        this.j4u_1 = unsafe;
+        this.w4w_1.s4(customScalarAdapters.g4x_1);
         return this;
       }
       m4() {
-        this.i4u_1.m4();
+        this.w4w_1.m4();
       }
-      j2t() {
-        return new (CustomScalarAdapters())(this.i4u_1, this.k4u_1, this.l4u_1, this.m4u_1, this.j4u_1);
+      p2t() {
+        return new (CustomScalarAdapters())(this.w4w_1, this.x4w_1, this.y4w_1, this.z4w_1);
       }
     }
     initMetadataForClass($, 'Builder', Builder);
@@ -111,39 +103,36 @@ var CustomScalarAdaptersClass;
 function CustomScalarAdapters() {
   if (CustomScalarAdaptersClass === VOID) {
     class $ {
-      constructor(customScalarAdapters, falseVariables, deferredFragmentIdentifiers, errors, unsafe) {
+      constructor(customScalarAdapters, falseVariables, deferredFragmentIdentifiers, errors) {
         Key_getInstance();
-        this.r4u_1 = falseVariables;
-        this.s4u_1 = deferredFragmentIdentifiers;
-        this.t4u_1 = errors;
-        this.u4u_1 = unsafe;
-        this.v4u_1 = customScalarAdapters;
+        this.d4x_1 = falseVariables;
+        this.e4x_1 = deferredFragmentIdentifiers;
+        this.f4x_1 = errors;
+        this.g4x_1 = customScalarAdapters;
       }
-      w4u(customScalar) {
+      h4x(customScalar) {
         var tmp;
-        if (!(this.v4u_1.j4(customScalar.d4u_1) == null)) {
-          tmp = this.v4u_1.j4(customScalar.d4u_1);
-        } else if (customScalar.c4u_1 === 'com.apollographql.apollo.api.Upload') {
+        if (!(this.g4x_1.j4(customScalar.a4v_1) == null)) {
+          tmp = this.g4x_1.j4(customScalar.a4v_1);
+        } else if (customScalar.z4u_1 === 'com.apollographql.apollo.api.Upload') {
           tmp = get_UploadAdapter();
-        } else if (listOf(['kotlin.String', 'java.lang.String']).k3(customScalar.c4u_1)) {
+        } else if (listOf(['kotlin.String', 'java.lang.String']).k3(customScalar.z4u_1)) {
           tmp = get_StringAdapter();
-        } else if (listOf(['kotlin.Boolean', 'java.lang.Boolean']).k3(customScalar.c4u_1)) {
+        } else if (listOf(['kotlin.Boolean', 'java.lang.Boolean']).k3(customScalar.z4u_1)) {
           tmp = get_BooleanAdapter();
-        } else if (listOf(['kotlin.Int', 'java.lang.Int']).k3(customScalar.c4u_1)) {
+        } else if (listOf(['kotlin.Int', 'java.lang.Int']).k3(customScalar.z4u_1)) {
           tmp = get_IntAdapter();
-        } else if (listOf(['kotlin.Double', 'java.lang.Double']).k3(customScalar.c4u_1)) {
+        } else if (listOf(['kotlin.Double', 'java.lang.Double']).k3(customScalar.z4u_1)) {
           tmp = get_DoubleAdapter();
-        } else if (listOf(['kotlin.Long', 'java.lang.Long']).k3(customScalar.c4u_1)) {
+        } else if (listOf(['kotlin.Long', 'java.lang.Long']).k3(customScalar.z4u_1)) {
           tmp = get_LongAdapter();
-        } else if (listOf(['kotlin.Float', 'java.lang.Float']).k3(customScalar.c4u_1)) {
+        } else if (listOf(['kotlin.Float', 'java.lang.Float']).k3(customScalar.z4u_1)) {
           tmp = get_FloatAdapter();
-        } else if (listOf(['kotlin.Any', 'java.lang.Object']).k3(customScalar.c4u_1)) {
+        } else if (listOf(['kotlin.Any', 'java.lang.Object']).k3(customScalar.z4u_1)) {
           tmp = get_AnyAdapter();
-        } else if (this.u4u_1) {
-          tmp = new (PassThroughAdapter())();
         } else {
           // Inline function 'kotlin.error' call
-          var message = "Can't map GraphQL type: `" + customScalar.d4u_1 + '` to: `' + customScalar.c4u_1 + '`. Did you forget to add a scalar Adapter?';
+          var message = "Can't map GraphQL type: `" + customScalar.a4v_1 + '` to: `' + customScalar.z4u_1 + '`. Did you forget to add a scalar Adapter?';
           throw IllegalStateException().o(toString(message));
         }
         var tmp_0 = tmp;
@@ -152,14 +141,14 @@ function CustomScalarAdapters() {
       b3() {
         return Key_getInstance();
       }
-      b4s() {
-        return (new (Builder())()).q4u(this).o4u(this.r4u_1).p4u(this.s4u_1);
+      z4s() {
+        return (new (Builder())()).c4x(this).a4x(this.d4x_1).b4x(this.e4x_1);
       }
     }
-    protoOf($).x4u = get;
-    protoOf($).y4u = fold;
-    protoOf($).z4u = minusKey;
-    protoOf($).o4s = plus;
+    protoOf($).i4x = get;
+    protoOf($).j4x = fold;
+    protoOf($).k4x = minusKey;
+    protoOf($).m4t = plus;
     initMetadataForClass($, 'CustomScalarAdapters', VOID, VOID, [Element()]);
     CustomScalarAdaptersClass = $;
   }

package/kotlin/apollo-kotlin-apollo-api/com/apollographql/apollo/api/CustomScalarAdapters.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../../../Users/runner/work/apollo-kotlin/apollo-kotlin/libraries/apollo-api/src/commonMain/kotlin/com/apollographql/apollo/api/CustomScalarAdapters.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/apollo-kotlin-apollo-api/com/apollographql/apollo/api/src/kotlin/collections/Maps.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/apollo-kotlin-apollo-api/com/apollographql/apollo/api/src/kotlin/util/Preconditions.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["falseVariables","deferredFragmentIdentifiers","errors","addAll","customScalarAdapters","unsafe","clear","build","responseAdapterFor","customScalar","<get-key>","newBuilder"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA8F0B,sC;QAQmB,aAAb,wBAAO,IAAP,CAAa,M;;;;;;;;;;;;;;;;;;;kBA8BiB,I;;QAAA,YChDF,oB;QDiDnC,kB;QACsB,iB;QACiC,iB;QACzC,iB;;SAEnCA,CAAmBA,cAAnBA,EAAmD;A;QAAA,IAC5C,SAAiB,c;QACvB,OAFkD,I;MAEnD,C;SAEAC,CAAgCA,2BAAhCA,EAAiG;A;QAAA,IAC1F,SAA8B,2B;QACpC,OAFgG,I;MAEjG,C;SAEAC,CAAWA,MAAXA,EAAmC;A;QAAA,IAC5B,SAAS,M;QACf,OAFkC,I;MAEnC,C;SAiBAC,CAAWC,oBAAXD,EAAyD;A;QAAA,IACtC,CAAZ,KAAY,IAAO,oBAAP,CAA4B,KAA5B,C;QAClB,OAFwD,I;MAEzD,C;SAGAE,CAAWA,MAAXA,EAA8B;A;QAAA,IACvB,SAAS,M;QACf,OAF6B,I;MAE9B,C;QAEAC,CAAAA,EAAY;A,QACV,IAAY,CAAZ,KAAY,K;MACd,C;SAEAC,CAAAA,EAAkC;A,QAChC,oCACI,IADJ,CACI,KADJ,EAEI,IAFJ,CAEI,KAFJ,EAGI,IAHJ,CAGI,KAHJ,EAII,IAJJ,CAII,KAJJ,EAKI,IALJ,CAKI,KALJ,C;MAOF,C;;;;;;;;;;;kBA9KAH,oB,EAMAJ,c,EAKAC,2B,EAKAC,M,EAEQG,M;QAnBZ,iB;QAMI,2B;QAKA,wC;QAKA,mB;QAGA,mB;QAGiD,iC;;SAOnDG,CAAiCC,YAAjCD,EAA6E;A;QAGzE,oBAAY,YAAZ,CAAyB,KAAzB,KAAkC,IAAlC,E;gBACE,cAAY,YAAZ,CAAyB,KAAzB,C;eAKF,iBAAa,KAAb,KAA0B,qCAA1B,C;gBACE,mB;eAGF,IAA0B,OAAO,kBAAiB,kBAAjB,CAAP,CAA1B,iBAAa,KAAb,E;gBACE,mB;eAGF,IAA0B,OAAO,mBAAkB,mBAAlB,CAAP,CAA1B,iBAAa,KAAb,E;gBACE,oB;eAGF,IAA0B,OAAO,eAAc,eAAd,CAAP,CAA1B,iBAAa,KAAb,E;gBACE,gB;eAGF,IAA0B,OAAO,kBAAiB,kBAAjB,CAAP,CAA1B,iBAAa,KAAb,E;gBACE,mB;eAGF,IAA0B,OAAO,gBAAe,gBAAf,CAAP,CAA1B,iBAAa,KAAb,E;gBACE,iB;eAGF,IAA0B,OAAO,iBAAgB,iBAAhB,CAAP,CAA1B,iBAAa,KAAb,E;gBACE,kB;eAGF,IAA0B,OAAO,eAAc,kBAAd,CAAP,CAA1B,iBAAa,KAAb,E;gBACE,gB;eAGF,e;;;;wBACe,2BAAD,GAA4B,YAA5B,CAAyC,KAAzC,GAA8C,SAA9C,GAAuD,YAAvD,CAAoE,KAApE,GAA8E,4C;UEkEjD,gCAAoC,SAAR,OAAQ,CAApC,C;;;QF1G7C,OAAO,gF;MA0CT,C;QAGEE,CAAAA,EAAQ;A,QAAG,wB;MAAD,C;SAsCZC,CAAAA,EAA0B;A,QACxB,OAAiB,wBAAO,IAAP,CACZ,KAAe,IAAf,CAAe,KAAf,CACA,KAA4B,IAA5B,CAA4B,KAA5B,C;MACP,C;;;;;;;;;;;;;;;"}
+{"version":3,"sources":["../../../../../../../../../../Users/runner/work/apollo-kotlin/apollo-kotlin/libraries/apollo-api/src/commonMain/kotlin/com/apollographql/apollo/api/CustomScalarAdapters.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/apollo-kotlin-apollo-api/com/apollographql/apollo/api/src/kotlin/collections/Maps.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/apollo-kotlin-apollo-api/com/apollographql/apollo/api/src/kotlin/util/Preconditions.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["falseVariables","deferredFragmentIdentifiers","errors","addAll","customScalarAdapters","clear","build","responseAdapterFor","customScalar","<get-key>","newBuilder"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA4F0B,sC;;;;;;;;;;;;;;;;;;;kBAuCoC,I;;QAAA,YC/CF,oB;QDgDb,iB;QACiC,iB;QACzC,iB;;SAEnCA,CAAmBA,cAAnBA,EAAmD;A;QAAA,IAC5C,SAAiB,c;QACvB,OAFkD,I;MAEnD,C;SAEAC,CAAgCA,2BAAhCA,EAAiG;A;QAAA,IAC1F,SAA8B,2B;QACpC,OAFgG,I;MAEjG,C;SAEAC,CAAWA,MAAXA,EAAmC;A;QAAA,IAC5B,SAAS,M;QACf,OAFkC,I;MAEnC,C;SAiBAC,CAAWC,oBAAXD,EAAyD;A;QAAA,IACtC,CAAZ,KAAY,IAAO,oBAAP,CAA4B,KAA5B,C;QAClB,OAFwD,I;MAEzD,C;QAEAE,CAAAA,EAAY;A,QACV,IAAY,CAAZ,KAAY,K;MACd,C;SAEAC,CAAAA,EAAkC;A,QAChC,oCACI,IADJ,CACI,KADJ,EAEI,IAFJ,CAEI,KAFJ,EAGI,IAHJ,CAGI,KAHJ,EAII,IAJJ,CAII,KAJJ,C;MAMF,C;;;;;;;;;;;kBArKAF,oB,EAMAJ,c,EAKAC,2B,EAKAC,M;QAjBJ,iB;QAMI,2B;QAKA,wC;QAKA,mB;QAIiD,iC;;SAOnDK,CAAiCC,YAAjCD,EAA6E;A;QAGzE,oBAAY,YAAZ,CAAyB,KAAzB,KAAkC,IAAlC,E;gBACE,cAAY,YAAZ,CAAyB,KAAzB,C;eAKF,iBAAa,KAAb,KAA0B,qCAA1B,C;gBACE,mB;eAGF,IAA0B,OAAO,kBAAiB,kBAAjB,CAAP,CAA1B,iBAAa,KAAb,E;gBACE,mB;eAGF,IAA0B,OAAO,mBAAkB,mBAAlB,CAAP,CAA1B,iBAAa,KAAb,E;gBACE,oB;eAGF,IAA0B,OAAO,eAAc,eAAd,CAAP,CAA1B,iBAAa,KAAb,E;gBACE,gB;eAGF,IAA0B,OAAO,kBAAiB,kBAAjB,CAAP,CAA1B,iBAAa,KAAb,E;gBACE,mB;eAGF,IAA0B,OAAO,gBAAe,gBAAf,CAAP,CAA1B,iBAAa,KAAb,E;gBACE,iB;eAGF,IAA0B,OAAO,iBAAgB,iBAAhB,CAAP,CAA1B,iBAAa,KAAb,E;gBACE,kB;eAGF,IAA0B,OAAO,eAAc,kBAAd,CAAP,CAA1B,iBAAa,KAAb,E;gBACE,gB;;;wBAGa,2BAAD,GAA4B,YAA5B,CAAyC,KAAzC,GAA8C,SAA9C,GAAuD,YAAvD,CAAoE,KAApE,GAA8E,4C;UEoEjD,gCAAoC,SAAR,OAAQ,CAApC,C;;;QF3G7C,OAAO,gF;MAyCT,C;QAGEE,CAAAA,EAAQ;A,QAAG,wB;MAAD,C;SAuCZC,CAAAA,EAA0B;A,QACxB,OAAiB,wBAAO,IAAP,CACZ,KAAe,IAAf,CAAe,KAAf,CACA,KAA4B,IAA5B,CAA4B,KAA5B,C;MACP,C;;;;;;;;;;;;;;;"}

package/kotlin/apollo-kotlin-apollo-api/com/apollographql/apollo/api/DeferredFragmentIdentifier.mjs

@@ -1,30 +1,55 @@
+import { emptyList1g2z5xcrvp2zy as emptyList } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/CollectionsKt.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 {
   toString1pkumu07cwy4m as toString,
   hashCodeq5arwsb9dgti as hashCode,
   getStringHashCode26igk1bx568vk as getStringHashCode,
   equals2au1ep9vhcato as equals,
 } 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
 var imul = Math.imul;
 //endregion
 //region block: pre-declaration
 //endregion
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance = this;
+        this.l4x_1 = new (DeferredFragmentIdentifier())(emptyList(), '__pending');
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  if (Companion_instance === VOID)
+    new (Companion())();
+  return Companion_instance;
+}
 var DeferredFragmentIdentifierClass;
 function DeferredFragmentIdentifier() {
   if (DeferredFragmentIdentifierClass === VOID) {
     class $ {
       constructor(path, label) {
-        this.a4v_1 = path;
-        this.b4v_1 = label;
+        Companion_getInstance();
+        this.m4x_1 = path;
+        this.n4x_1 = label;
       }
       toString() {
-        return 'DeferredFragmentIdentifier(path=' + toString(this.a4v_1) + ', label=' + this.b4v_1 + ')';
+        return 'DeferredFragmentIdentifier(path=' + toString(this.m4x_1) + ', label=' + this.n4x_1 + ')';
       }
       hashCode() {
-        var result = hashCode(this.a4v_1);
-        result = imul(result, 31) + (this.b4v_1 == null ? 0 : getStringHashCode(this.b4v_1)) | 0;
+        var result = hashCode(this.m4x_1);
+        result = imul(result, 31) + (this.n4x_1 == null ? 0 : getStringHashCode(this.n4x_1)) | 0;
         return result;
       }
       equals(other) {
@@ -32,9 +57,9 @@ function DeferredFragmentIdentifier() {
           return true;
         if (!(other instanceof DeferredFragmentIdentifier()))
           return false;
-        if (!equals(this.a4v_1, other.a4v_1))
+        if (!equals(this.m4x_1, other.m4x_1))
           return false;
-        if (!(this.b4v_1 == other.b4v_1))
+        if (!(this.n4x_1 == other.n4x_1))
           return false;
         return true;
       }
@@ -47,6 +72,7 @@ function DeferredFragmentIdentifier() {
 //region block: exports
 export {
   DeferredFragmentIdentifier as DeferredFragmentIdentifieryfmj5mbsp1mh,
+  Companion_getInstance as Companion_getInstance1bqyjyqqlppsb,
 };
 //endregion
 

package/kotlin/apollo-kotlin-apollo-api/com/apollographql/apollo/api/DeferredFragmentIdentifier.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../../../Users/runner/work/apollo-kotlin/apollo-kotlin/libraries/apollo-api/src/commonMain/kotlin/com/apollographql/apollo/api/DeferredFragmentIdentifier.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["path","label","result"],"mappings":";;;;;;;;;;;;;;;;;kBAMIA,I,EACAC,K;QADA,iB;QACA,kB;;iBAPJ;A,QAAA,gG;MAAA,C;iBAAA;A,YAAAC,6B;QAAA,wF;QAAA,a;MAAA,C;oBAAA;A,QAAA,mB;UAAA,W;QAAA,qD;UAAA,Y;QAAA,qC;UAAA,Y;QAAA,iC;UAAA,Y;QAAA,W;MAAA,C;;;;;;;;;;;"}
+{"version":3,"sources":["../../../../../../../../../../Users/runner/work/apollo-kotlin/apollo-kotlin/libraries/apollo-api/src/commonMain/kotlin/com/apollographql/apollo/api/DeferredFragmentIdentifier.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["path","label","result"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;QAgBkB,gDAA2B,WAA3B,EAAwC,WAAxC,C;;;;;;;;;;;;;;;;;;kBARdA,I,EACAC,K;QALJ,uB;QAII,iB;QACA,kB;;iBATJ;A,QAAA,gG;MAAA,C;iBAAA;A,YAAAC,6B;QAAA,wF;QAAA,a;MAAA,C;oBAAA;A,QAAA,mB;UAAA,W;QAAA,qD;UAAA,Y;QAAA,qC;UAAA,Y;QAAA,iC;UAAA,Y;QAAA,W;MAAA,C;;;;;;;;;;;"}

package/kotlin/apollo-kotlin-apollo-api/com/apollographql/apollo/api/Error.mjs

@@ -1,3 +1,4 @@
+import { Unit_instancev9v8hjid95df as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.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 { toString30pk9tzaqopn as toString } from '../../../../../kotlin-kotlin-stdlib/kotlin/Library.mjs';
@@ -5,16 +6,56 @@ import { toString30pk9tzaqopn as toString } from '../../../../../kotlin-kotlin-s
 //endregion
 //region block: pre-declaration
 //endregion
+var BuilderClass;
+function Builder() {
+  if (BuilderClass === VOID) {
+    class $ {
+      constructor(message) {
+        this.o4x_1 = message;
+        this.p4x_1 = null;
+        this.q4x_1 = null;
+        this.r4x_1 = null;
+        this.s4x_1 = null;
+      }
+      t4x(locations) {
+        // Inline function 'kotlin.apply' call
+        this.p4x_1 = locations;
+        return this;
+      }
+      u4x(path) {
+        // Inline function 'kotlin.apply' call
+        this.q4x_1 = path;
+        return this;
+      }
+      i4s(extensions) {
+        // Inline function 'kotlin.apply' call
+        this.s4x_1 = extensions;
+        return this;
+      }
+      v4x(nonStandardFields) {
+        // Inline function 'kotlin.apply' call
+        this.r4x_1 = nonStandardFields;
+        return this;
+      }
+      p2t() {
+        return new (Error_0())(this.o4x_1, this.p4x_1, this.q4x_1, this.s4x_1, this.r4x_1);
+      }
+    }
+    initMetadataForClass($, 'Builder');
+    BuilderClass = $;
+  }
+  return BuilderClass;
+}
 var LocationClass;
 function Location() {
   if (LocationClass === VOID) {
     class $ {
       constructor(line, column) {
-        this.c4v_1 = line;
-        this.d4v_1 = column;
+        this.w4x_1 = line;
+        this.x4x_1 = column;
       }
       toString() {
-        return 'Location(line = ' + this.c4v_1 + ', column = ' + this.d4v_1 + ')';
+        return 'Location(line = ' + this.w4x_1 + ', column = ' + this.x4x_1 + ')';
       }
     }
     initMetadataForClass($, 'Location');
@@ -27,14 +68,14 @@ function Error_0() {
   if (ErrorClass === VOID) {
     class $ {
       constructor(message, locations, path, extensions, nonStandardFields) {
-        this.e4v_1 = message;
-        this.f4v_1 = locations;
-        this.g4v_1 = path;
-        this.h4v_1 = extensions;
-        this.i4v_1 = nonStandardFields;
+        this.y4x_1 = message;
+        this.z4x_1 = locations;
+        this.a4y_1 = path;
+        this.b4y_1 = extensions;
+        this.c4y_1 = nonStandardFields;
       }
       toString() {
-        return 'Error(message = ' + this.e4v_1 + ', locations = ' + toString(this.f4v_1) + ', path=' + toString(this.g4v_1) + ', extensions = ' + toString(this.h4v_1) + ', nonStandardFields = ' + toString(this.i4v_1) + ')';
+        return 'Error(message = ' + this.y4x_1 + ', locations = ' + toString(this.z4x_1) + ', path=' + toString(this.a4y_1) + ', extensions = ' + toString(this.b4y_1) + ', nonStandardFields = ' + toString(this.c4y_1) + ')';
       }
     }
     initMetadataForClass($, 'Error');
@@ -44,8 +85,8 @@ function Error_0() {
 }
 //region block: exports
 export {
+  Builder as Builder3gaff1pwujyid,
   Location as Location25t453jk43ktl,
-  Error_0 as Error3q6zoyx198bpg,
 };
 //endregion