@salesforce/lds-worker-api 1.158.0 → 1.158.1

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

@@ -3672,7 +3672,7 @@ class Luvio {
         return this.environment.buildStructuredKey(namespace, representationName, idValues);
     }
 }
-// engine version: 0.143.2-f0cd3fab
+// engine version: 0.143.4-64dccb30
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -3799,7 +3799,7 @@ function withDefaultLuvio(callback) {
     }
     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) {
@@ -15232,7 +15232,7 @@ function parseAndVisit(source) {
     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".
@@ -16145,7 +16145,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     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.,
@@ -16228,7 +16228,7 @@ var FragmentReadResultState;
 ({
     state: FragmentReadResultState.Missing,
 });
-// engine version: 0.143.2-f0cd3fab
+// engine version: 0.143.4-64dccb30
 
 const { keys: ObjectKeys$3, create: ObjectCreate$3 } = Object;
 
@@ -44016,7 +44016,7 @@ withDefaultLuvio((luvio) => {
         dropFunction: instrumentation$2.notifyRecordUpdateAvailableDropped,
     });
 });
-// version: 1.158.0-9275eaa3c
+// version: 1.158.1-63f64c475
 
 var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -60050,7 +60050,7 @@ register({
     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;
@@ -60573,26 +60573,8 @@ function buildSelectionForNode$12(source, reader, parentNode, selectionNode, var
 }
 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) {
@@ -60735,26 +60717,8 @@ function buildSelectionForNode$11(source, reader, parentNode, selectionNode, var
 }
 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) {
@@ -60897,26 +60861,8 @@ function buildSelectionForNode$10(source, reader, parentNode, selectionNode, var
 }
 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) {
@@ -61071,26 +61017,8 @@ function buildSelectionForNode$$(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -61115,10 +61043,10 @@ function getTypeCacheKeys$13(astNode, state) {
         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.
         }
@@ -61413,26 +61341,8 @@ function buildSelectionForNode$_(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -61570,26 +61480,8 @@ function buildSelectionForNode$Z(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -61735,26 +61627,8 @@ function buildSelectionForNode$Y(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -61779,10 +61653,10 @@ function getTypeCacheKeys$10(astNode, state) {
         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.
         }
@@ -62094,26 +61968,8 @@ function buildSelectionForNode$X(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -62262,26 +62118,8 @@ function buildSelectionForNode$W(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -62440,26 +62278,8 @@ function buildSelectionForNode$V(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -62484,10 +62304,10 @@ function getTypeCacheKeys$Z(astNode, state) {
         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.
         }
@@ -62990,26 +62810,8 @@ function buildSelectionForNode$U(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -63208,26 +63010,8 @@ function buildSelectionForNode$T(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -63363,26 +63147,8 @@ function buildSelectionForNode$S(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -63407,10 +63173,10 @@ function getTypeCacheKeys$W(astNode, state) {
         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.
         }
@@ -63587,26 +63353,8 @@ function buildSelectionForNode$R(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -63751,26 +63499,8 @@ function buildSelectionForNode$Q(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -63948,26 +63678,8 @@ function buildSelectionForNode$P(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -63992,10 +63704,10 @@ function getTypeCacheKeys$T(astNode, state) {
         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.
         }
@@ -64356,26 +64068,8 @@ function buildSelectionForNode$O(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -64546,26 +64240,8 @@ function buildSelectionForNode$N(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -64590,10 +64266,10 @@ function getTypeCacheKeys$R(astNode, state) {
         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.
         }
@@ -64986,26 +64662,8 @@ function buildSelectionForNode$M(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -65030,10 +64688,10 @@ function getTypeCacheKeys$Q(astNode, state) {
         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.
         }
@@ -65197,26 +64855,8 @@ function buildSelectionForNode$L(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -65353,26 +64993,8 @@ function buildSelectionForNode$K(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -65521,26 +65143,8 @@ function buildSelectionForNode$J(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -65565,10 +65169,10 @@ function getTypeCacheKeys$N(astNode, state) {
         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.
         }
@@ -65882,26 +65486,8 @@ function buildSelectionForNode$I(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -66050,26 +65636,8 @@ function buildSelectionForNode$H(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -66094,10 +65662,10 @@ function getTypeCacheKeys$L(astNode, state) {
         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.
         }
@@ -66367,26 +65935,8 @@ function buildSelectionForNode$G(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -66529,26 +66079,8 @@ function buildSelectionForNode$F(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -66703,26 +66235,8 @@ function buildSelectionForNode$E(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -66747,10 +66261,10 @@ function getTypeCacheKeys$I(astNode, state) {
         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.
         }
@@ -67045,26 +66559,8 @@ function buildSelectionForNode$D(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -67355,26 +66851,8 @@ function buildSelectionForNode$C(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -67523,26 +67001,8 @@ function buildSelectionForNode$B(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -67567,10 +67027,10 @@ function getTypeCacheKeys$F(astNode, state) {
         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.
         }
@@ -67840,26 +67300,8 @@ function buildSelectionForNode$A(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -67996,26 +67438,8 @@ function buildSelectionForNode$z(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -68162,26 +67586,8 @@ function buildSelectionForNode$y(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -68206,10 +67612,10 @@ function getTypeCacheKeys$C(astNode, state) {
         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.
         }
@@ -68383,26 +67789,8 @@ function buildSelectionForNode$x(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -68551,26 +67939,8 @@ function buildSelectionForNode$w(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -68595,10 +67965,10 @@ function getTypeCacheKeys$A(astNode, state) {
         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.
         }
@@ -68887,26 +68257,8 @@ function buildSelectionForNode$v(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -69055,26 +68407,8 @@ function buildSelectionForNode$u(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -69099,10 +68433,10 @@ function getTypeCacheKeys$y(astNode, state) {
         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.
         }
@@ -69399,26 +68733,8 @@ function buildSelectionForNode$t(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -69443,10 +68759,10 @@ function getTypeCacheKeys$x(astNode, state) {
         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.
         }
@@ -69728,26 +69044,8 @@ function buildSelectionForNode$s(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -69896,26 +69194,8 @@ function buildSelectionForNode$r(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -69940,10 +69220,10 @@ function getTypeCacheKeys$v(astNode, state) {
         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.
         }
@@ -70225,26 +69505,8 @@ function buildSelectionForNode$q(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -70269,10 +69531,10 @@ function getTypeCacheKeys$u(astNode, state) {
         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.
         }
@@ -70554,26 +69816,8 @@ function buildSelectionForNode$p(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -70598,10 +69842,10 @@ function getTypeCacheKeys$t(astNode, state) {
         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.
         }
@@ -70871,26 +70115,8 @@ function buildSelectionForNode$o(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -71045,26 +70271,8 @@ function buildSelectionForNode$n(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -71089,10 +70297,10 @@ function getTypeCacheKeys$r(astNode, state) {
         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.
         }
@@ -71380,26 +70588,8 @@ function buildSelectionForNode$m(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -71424,10 +70614,10 @@ function getTypeCacheKeys$q(astNode, state) {
         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.
         }
@@ -71741,26 +70931,8 @@ function buildSelectionForNode$l(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -71901,26 +71073,8 @@ function buildSelectionForNode$k(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -71945,10 +71099,10 @@ function getTypeCacheKeys$o(astNode, state) {
         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.
         }
@@ -72116,26 +71270,8 @@ function buildSelectionForNode$j(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -72272,26 +71408,8 @@ function buildSelectionForNode$i(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -72462,26 +71580,8 @@ function buildSelectionForNode$h(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -72642,26 +71742,8 @@ function buildSelectionForNode$g(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -72814,26 +71896,8 @@ function buildSelectionForNode$f(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -72858,10 +71922,10 @@ function getTypeCacheKeys$j(astNode, state) {
         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.
         }
@@ -73346,26 +72410,8 @@ function buildSelectionForNode$e(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -73390,10 +72436,10 @@ function getTypeCacheKeys$h(astNode, state) {
         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.
         }
@@ -73942,26 +72988,8 @@ function buildSelectionForNode$d(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -73986,10 +73014,10 @@ function getTypeCacheKeys$g(astNode, state) {
         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.
         }
@@ -74140,26 +73168,8 @@ function buildSelectionForNode$c(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -74184,10 +73194,10 @@ function getTypeCacheKeys$f(astNode, state) {
         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.
         }
@@ -74345,26 +73355,8 @@ function buildSelectionForNode$b(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -74585,26 +73577,8 @@ function buildSelectionForNode$a(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -74630,10 +73604,10 @@ function getTypeCacheKeys$d(astNode, state) {
         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.
         }
@@ -75167,26 +74141,8 @@ function buildSelectionForNode$9(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -75211,10 +74167,10 @@ function getTypeCacheKeys$c(astNode, state) {
         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.
         }
@@ -75353,26 +74309,8 @@ function buildSelectionForNode$8(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -75691,10 +74629,10 @@ function ingestNonCursorConnectionType(astNode, state, specifics) {
 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.
         }
@@ -75907,18 +74845,28 @@ function calculateRequestedFieldsForType(typename, selectionSet, namedFragmentsM
             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) {
@@ -76523,6 +75471,27 @@ function augmentDefaultVariableValues(variableDefinitions, variables) {
         }
     });
 }
+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;
@@ -76710,26 +75679,8 @@ function buildSelectionForNode$6(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -76888,7 +75839,7 @@ function convertGraphQLToRaml(astNode, state) {
     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,
@@ -76917,7 +75868,7 @@ function createFieldsBagAndTrie(data, requestedFields, parentState) {
     };
     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.
         }
@@ -77007,9 +75958,8 @@ function convertAstToTrie$1(astNode, fragments) {
     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?
@@ -77356,10 +76306,10 @@ function getTypeCacheKeys$6(astNode, state) {
     // 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.
         }
@@ -77581,28 +76531,10 @@ function buildSelectionForNode$5(source, reader, parentNode, selectionNode, vari
 }
 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) {
@@ -77615,10 +76547,10 @@ function getTypeCacheKeys$5(astNode, state) {
         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.
         }
@@ -78482,26 +77414,8 @@ function buildSelectionForNode$4(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -78526,10 +77440,10 @@ function getTypeCacheKeys$4(astNode, state) {
         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.
         }
@@ -78748,26 +77662,8 @@ function buildSelectionForNode$3(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -78935,26 +77831,8 @@ function buildSelectionForNode$2(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -78979,10 +77857,10 @@ function getTypeCacheKeys$3(astNode, state) {
         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.
         }
@@ -79127,26 +78005,8 @@ function buildSelectionForNode$1(source, reader, parentNode, selectionNode, vari
 }
 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() {
@@ -79171,10 +78031,10 @@ function getTypeCacheKeys$2(astNode, state) {
         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.
         }
@@ -79433,26 +78293,8 @@ function buildSelectionForNode(source, reader, parentNode, selectionNode, variab
 }
 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() {
@@ -79469,10 +78311,10 @@ function getTypeCacheKeys$1(astNode, state) {
         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.
         }
@@ -80895,7 +79737,7 @@ register({
     configuration: { ...configurationForGraphQLAdapters },
     instrument,
 });
-// version: 1.158.0-9275eaa3c
+// version: 1.158.1-63f64c475
 
 // On core the unstable adapters are re-exported with different names,
 
@@ -83142,7 +81984,7 @@ withDefaultLuvio((luvio) => {
     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,
@@ -83831,4 +82673,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, invokeAdapter, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, subscribeToAdapter };
-// version: 1.158.0-8b4924803
+// version: 1.158.1-276f55e03