@salesforce/lds-worker-api 1.158.0 → 1.158.1

package/dist/standalone/umd/lds-worker-api.js

@@ -3678,7 +3678,7 @@
             return this.environment.buildStructuredKey(namespace, representationName, idValues);
         }
     }
-    // engine version: 0.143.2-f0cd3fab
+    // engine version: 0.143.4-64dccb30
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -3805,7 +3805,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.158.0-8b4924803
+    // version: 1.158.1-276f55e03
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -15238,7 +15238,7 @@
         updateReferenceMapWithKnownKey(ast, luvioDocumentNode);
         return luvioDocumentNode;
     }
-    // version: 1.158.0-8b4924803
+    // version: 1.158.1-276f55e03
 
     function unwrap(data) {
         // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16151,7 +16151,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.158.0-8b4924803
+    // version: 1.158.1-276f55e03
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -16234,7 +16234,7 @@
     ({
         state: FragmentReadResultState.Missing,
     });
-    // engine version: 0.143.2-f0cd3fab
+    // engine version: 0.143.4-64dccb30
 
     const { keys: ObjectKeys$3, create: ObjectCreate$3 } = Object;
 
@@ -44022,7 +44022,7 @@
             dropFunction: instrumentation$2.notifyRecordUpdateAvailableDropped,
         });
     });
-    // version: 1.158.0-9275eaa3c
+    // version: 1.158.1-63f64c475
 
     var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -60056,7 +60056,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$1,
     });
-    // version: 1.158.0-8b4924803
+    // version: 1.158.1-276f55e03
 
     const { create: create$2, keys: keys$2 } = Object;
     const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -60579,26 +60579,8 @@
     }
     function select$1b(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$12(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$12, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$16(astNode, state) {
@@ -60741,26 +60723,8 @@
     }
     function select$1a(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$11(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$11, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$15(astNode, state) {
@@ -60903,26 +60867,8 @@
     }
     function select$19(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$10(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$10, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$14(astNode, state) {
@@ -61077,26 +61023,8 @@
     }
     function select$18(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$$(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$$, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$L() {
@@ -61121,10 +61049,10 @@
             representationName: name$_
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$$) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$$) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -61419,26 +61347,8 @@
     }
     function select$17(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$_(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$_, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$12(astNode, state) {
@@ -61576,26 +61486,8 @@
     }
     function select$16(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$Z(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$Z, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$11(astNode, state) {
@@ -61741,26 +61633,8 @@
     }
     function select$15(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$Y(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$Y, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$K() {
@@ -61785,10 +61659,10 @@
             representationName: name$X
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$Y) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$Y) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -62100,26 +61974,8 @@
     }
     function select$14(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$X(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$X, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$I() {
@@ -62268,26 +62124,8 @@
     }
     function select$13(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$W(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$W, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$_(astNode, state) {
@@ -62446,26 +62284,8 @@
     }
     function select$12(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$V(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$V, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$H() {
@@ -62490,10 +62310,10 @@
             representationName: name$U
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$V) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$V) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -62996,26 +62816,8 @@
     }
     function select$11(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$U(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$U, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$G() {
@@ -63214,26 +63016,8 @@
     }
     function select$10(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$T(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$T, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$X(astNode, state) {
@@ -63369,26 +63153,8 @@
     }
     function select$$(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$S(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$S, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$E() {
@@ -63413,10 +63179,10 @@
             representationName: name$R
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$S) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$S) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -63593,26 +63359,8 @@
     }
     function select$_(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$R(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$R, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$D() {
@@ -63757,26 +63505,8 @@
     }
     function select$Z(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$Q(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$Q, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$C() {
@@ -63954,26 +63684,8 @@
     }
     function select$Y(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$P(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$P, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$B() {
@@ -63998,10 +63710,10 @@
             representationName: name$O
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$P) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$P) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -64362,26 +64074,8 @@
     }
     function select$X(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$O(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$O, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$A() {
@@ -64552,26 +64246,8 @@
     }
     function select$W(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$N(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$N, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$z() {
@@ -64596,10 +64272,10 @@
             representationName: name$M
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$N) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$N) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -64992,26 +64668,8 @@
     }
     function select$V(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$M(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$M, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$y() {
@@ -65036,10 +64694,10 @@
             representationName: name$L
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$M) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$M) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -65203,26 +64861,8 @@
     }
     function select$U(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$L(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$L, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$P(astNode, state) {
@@ -65359,26 +64999,8 @@
     }
     function select$T(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$K(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$K, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$O(astNode, state) {
@@ -65527,26 +65149,8 @@
     }
     function select$S(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$J(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$J, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$x() {
@@ -65571,10 +65175,10 @@
             representationName: name$I
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$J) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$J) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -65888,26 +65492,8 @@
     }
     function select$R(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$I(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$I, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$M(astNode, state) {
@@ -66056,26 +65642,8 @@
     }
     function select$Q(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$H(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$H, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$w() {
@@ -66100,10 +65668,10 @@
             representationName: name$G
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$H) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$H) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -66373,26 +65941,8 @@
     }
     function select$P(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$G(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$G, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$K(astNode, state) {
@@ -66535,26 +66085,8 @@
     }
     function select$O(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$F(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$F, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$J(astNode, state) {
@@ -66709,26 +66241,8 @@
     }
     function select$N(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$E(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$E, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$v() {
@@ -66753,10 +66267,10 @@
             representationName: name$D
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$E) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$E) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -67051,26 +66565,8 @@
     }
     function select$M(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$D(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$D, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$H(astNode, state) {
@@ -67361,26 +66857,8 @@
     }
     function select$L(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$C(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$C, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$G(astNode, state) {
@@ -67529,26 +67007,8 @@
     }
     function select$K(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$B(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$B, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$t() {
@@ -67573,10 +67033,10 @@
             representationName: name$A
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$B) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$B) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -67846,26 +67306,8 @@
     }
     function select$J(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$A(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$A, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$E(astNode, state) {
@@ -68002,26 +67444,8 @@
     }
     function select$I(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$z(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$z, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$D(astNode, state) {
@@ -68168,26 +67592,8 @@
     }
     function select$H(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$y(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$y, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$s() {
@@ -68212,10 +67618,10 @@
             representationName: name$x
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$y) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$y) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -68389,26 +67795,8 @@
     }
     function select$G(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$x(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$x, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$B(astNode, state) {
@@ -68557,26 +67945,8 @@
     }
     function select$F(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$w(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$w, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$r() {
@@ -68601,10 +67971,10 @@
             representationName: name$v
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$w) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$w) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -68893,26 +68263,8 @@
     }
     function select$E(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$v(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$v, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$z(astNode, state) {
@@ -69061,26 +68413,8 @@
     }
     function select$D(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$u(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$u, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$q() {
@@ -69105,10 +68439,10 @@
             representationName: name$t
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$u) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$u) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -69405,26 +68739,8 @@
     }
     function select$C(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$t(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$t, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$p() {
@@ -69449,10 +68765,10 @@
             representationName: name$s
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$t) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$t) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -69734,26 +69050,8 @@
     }
     function select$B(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$s(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$s, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$w(astNode, state) {
@@ -69902,26 +69200,8 @@
     }
     function select$A(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$r(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$r, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$o() {
@@ -69946,10 +69226,10 @@
             representationName: name$q
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$r) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$r) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -70231,26 +69511,8 @@
     }
     function select$z(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$q(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$q, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$n() {
@@ -70275,10 +69537,10 @@
             representationName: name$p
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$q) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$q) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -70560,26 +69822,8 @@
     }
     function select$y(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$p(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$p, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$m() {
@@ -70604,10 +69848,10 @@
             representationName: name$o
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$p) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$p) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -70877,26 +70121,8 @@
     }
     function select$x(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$o(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$o, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$s(astNode, state) {
@@ -71051,26 +70277,8 @@
     }
     function select$w(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$n(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$n, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$l() {
@@ -71095,10 +70303,10 @@
             representationName: name$m
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$n) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$n) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -71386,26 +70594,8 @@
     }
     function select$v(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$m(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$m, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$k() {
@@ -71430,10 +70620,10 @@
             representationName: name$l
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$m) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$m) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -71747,26 +70937,8 @@
     }
     function select$u(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$l(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$l, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$p(astNode, state) {
@@ -71907,26 +71079,8 @@
     }
     function select$t(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$k(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$k, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$j() {
@@ -71951,10 +71105,10 @@
             representationName: name$j
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$k) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$k) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -72122,26 +71276,8 @@
     }
     function select$s(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$j(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$j, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$n(astNode, state) {
@@ -72278,26 +71414,8 @@
     }
     function select$r(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$i(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$i, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$m(astNode, state) {
@@ -72468,26 +71586,8 @@
     }
     function select$q(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$h(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$h, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$h() {
@@ -72648,26 +71748,8 @@
     }
     function select$p(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$g(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$g, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$g() {
@@ -72820,26 +71902,8 @@
     }
     function select$o(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$f(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$f, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$f() {
@@ -72864,10 +71928,10 @@
             representationName: name$e
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$f) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$f) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -73352,26 +72416,8 @@
     }
     function select$m(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$e(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$e, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$d() {
@@ -73396,10 +72442,10 @@
             representationName: name$d
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$e) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$e) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -73948,26 +72994,8 @@
     }
     function select$l(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$d(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$d, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$c() {
@@ -73992,10 +73020,10 @@
             representationName: name$c
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$d) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$d) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -74146,26 +73174,8 @@
     }
     function select$k(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$c(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$c, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$b() {
@@ -74190,10 +73200,10 @@
             representationName: name$b
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$c) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$c) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -74351,26 +73361,8 @@
     }
     function select$j(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$b(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$b, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$a() {
@@ -74591,26 +73583,8 @@
     }
     function select$i(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$a(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$a, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$9() {
@@ -74636,10 +73610,10 @@
             representationName: name$9
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$a) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$a) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -75173,26 +74147,8 @@
     }
     function select$h(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$9(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$9, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$7() {
@@ -75217,10 +74173,10 @@
             representationName: name$8
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$9) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$9) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -75359,26 +74315,8 @@
     }
     function select$g(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$8(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$8, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$6() {
@@ -75697,10 +74635,10 @@
     function ingestTypeWithStrategy(astNode, state, isCursorConnectionType, { key, isFragmentApplicable, isMappedFieldImport, getFieldType, ramlIngestBlock, ingestPaginatedMetadata, mergeData, storeMetadataParams, createLink, }, strategy) {
         const { data, variables, luvio, store } = state;
         const sink = {};
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // TODO: (W-11132802) We got a field back we didn't ask for. Call handleUnknownField.
             }
@@ -75913,18 +74851,28 @@
                 selections.push(selection);
             }
             if (selection.kind === "InlineFragment" && isFragmentApplicable(selection, typename)) {
+                // loops over the map to get the values.
                 getRequestedFieldsForType(typename, selection.selectionSet, namedFragmentsMap, isFragmentApplicable)
                     .forEach(fragmentFieldSelection => { mergeFragmentWithExistingSelections(fragmentFieldSelection, selections); });
             }
             if (selection.kind === "FragmentSpread") {
                 const namedFragment = namedFragmentsMap[selection.name.value];
                 if (namedFragment && isFragmentApplicable(namedFragment, typename)) {
+                    // loops over the map to get the values.
                     getRequestedFieldsForType(typename, namedFragment.selectionSet, namedFragmentsMap, isFragmentApplicable)
                         .forEach(fragmentFieldSelection => { mergeFragmentWithExistingSelections(fragmentFieldSelection, selections); });
                 }
             }
         });
-        return selections;
+        // Needs to happen after the selections are merged.
+        return selections.reduce((acc, fieldNode) => {
+            const fieldName = fieldNode.alias ? fieldNode.alias.value : fieldNode.name.value;
+            // TODO: W-13485835. Some fields are not being merged, and this logic reproduces the current behavior in which the first field with name is being used.
+            if (!acc.has(fieldName)) {
+                acc.set(fieldName, fieldNode);
+            }
+            return acc;
+        }, new Map());
     }
     let selectionSetRequestedFieldsWeakMap = new WeakMap();
     function getRequestedFieldsForType(typename, selectionSet, namedFragmentsMap, isFragmentApplicable) {
@@ -76529,6 +75477,27 @@
             }
         });
     }
+    function selectCalculateSink(sink, field, buildSelectionForNodeFn, source, reader, variables, fragments, parentRecordId) {
+        var _a;
+        (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
+            const builtSelection = buildSelectionForNodeFn(source, reader, field, sel, variables, fragments, parentRecordId);
+            if (builtSelection !== undefined) {
+                if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
+                    Object.keys(builtSelection).forEach((key, value) => {
+                        // We only assign a field selection in the fragment if it doesn't already exist in sink
+                        // The non-fragment selection already got the merged selections in getRequestedFieldsForType
+                        if (sink[key] === undefined) {
+                            sink[key] = builtSelection[key];
+                        }
+                    });
+                }
+                else {
+                    Object.assign(sink, builtSelection);
+                }
+            }
+        });
+        return sink;
+    }
     function selectTypeLinkWithPagination(resolvedLink, sel, fieldData, reader, key, sink, variables, fragments, selectFn) {
         var _a, _b, _c, _d, _e;
         const source = resolvedLink.data.data;
@@ -76716,26 +75685,8 @@
     }
     function select$f(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$6(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$6, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$a(astNode, state) {
@@ -76894,7 +75845,7 @@
         const { data } = state;
         const requestedFields = astNode.selectionSet
             ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$5)
-            : [];
+            : new Map();
         const { fieldsBag, trie } = createFieldsBagAndTrie(data, requestedFields, state);
         const recordRepresentation = {
             apiName: data.ApiName,
@@ -76923,7 +75874,7 @@
         };
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // We got a field back we didn't ask for. Skip.
             }
@@ -77013,9 +75964,8 @@
         const requestedFields = astNode.selectionSet
             ? getRequestedFieldsForType('', // data is null here
             astNode.selectionSet, fragments, isFragmentApplicable$5)
-            : [];
-        for (let i = 0, len = requestedFields.length; i < len; i += 1) {
-            const field = requestedFields[i];
+            : new Map();
+        for (const [, field] of requestedFields) {
             const fieldType = getFieldType$9(field);
             const fieldName = field.name.value;
             //Untyped field - Adapter forwarded request?
@@ -77362,10 +76312,10 @@
         // get all cache keys from normalizable fields
         const requestedFields = astNode.selectionSet
             ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$3)
-            : [];
+            : new Map();
         for (const fieldDataKey of ObjectKeys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -77587,28 +76537,10 @@
     }
     function select$e(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
             source = attachMappedData(source, reader);
             reader.markSeenId(parentRecordId); // Always mark identifiable types as seen
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$5(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$5, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getTypeCacheKeys$5(astNode, state) {
@@ -77621,10 +76553,10 @@
             representationName: name$5
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$5) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$5) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -78488,26 +77420,8 @@
     }
     function select$d(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$4(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$4, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$4() {
@@ -78532,10 +77446,10 @@
             representationName: name$4
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$4) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$4) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -78754,26 +77668,8 @@
     }
     function select$c(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$3(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$3, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$3() {
@@ -78941,26 +77837,8 @@
     }
     function select$b(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$2(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$2, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$2() {
@@ -78985,10 +77863,10 @@
             representationName: name$2
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$2) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$2) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -79133,26 +78011,8 @@
     }
     function select$a(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$1(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode$1, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections$1() {
@@ -79177,10 +78037,10 @@
             representationName: name$1
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$1) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable$1) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -79439,26 +78299,8 @@
     }
     function select$9(field, variables, fragments) {
         return (source, reader, parentRecordId) => {
-            var _a;
             const sink = {};
-            (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode(source, reader, field, sel, variables, fragments, parentRecordId);
-                if (builtSelection !== undefined) {
-                    if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
-                        Object.keys(builtSelection).forEach((key, value) => {
-                            // We only assign a field selection in the fragment if it doesn't already exist in sink
-                            // The non-fragment selection already got the merged selections in getRequestedFieldsForType
-                            if (sink[key] === undefined) {
-                                sink[key] = builtSelection[key];
-                            }
-                        });
-                    }
-                    else {
-                        Object.assign(sink, builtSelection);
-                    }
-                }
-            });
-            return sink;
+            return selectCalculateSink(sink, field, buildSelectionForNode, source, reader, variables, fragments, parentRecordId);
         };
     }
     function getMinimumSelections() {
@@ -79475,10 +78317,10 @@
             representationName: name
         });
         // get all cache keys from normalizable fields
-        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable) : [];
+        const requestedFields = astNode.selectionSet ? getRequestedFieldsForType(data.__typename, astNode.selectionSet, state.fragments, isFragmentApplicable) : new Map();
         for (const fieldDataKey of Object.keys(data)) {
             const fieldData = data[fieldDataKey];
-            const requestedField = getRequestedField(fieldDataKey, requestedFields);
+            const requestedField = requestedFields.get(fieldDataKey);
             if (requestedField === undefined) {
                 continue; // Skip unknown field.
             }
@@ -80901,7 +79743,7 @@
         configuration: { ...configurationForGraphQLAdapters },
         instrument,
     });
-    // version: 1.158.0-9275eaa3c
+    // version: 1.158.1-63f64c475
 
     // On core the unstable adapters are re-exported with different names,
 
@@ -83148,7 +81990,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.158.0-9275eaa3c
+    // version: 1.158.1-63f64c475
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -83854,4 +82696,4 @@
     Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-// version: 1.158.0-8b4924803
+// version: 1.158.1-276f55e03