@salesforce/lwc-adapters-uiapi 1.158.0 → 1.158.1

package/dist/main.js

@@ -364,7 +364,7 @@ var FragmentReadResultState;
 ({
     state: FragmentReadResultState.Missing,
 });
-// engine version: 0.143.2-f0cd3fab
+// engine version: 0.143.4-64dccb30
 
 /**
  * Returns true if the value acts like a Promise, i.e. has a "then" function,
@@ -38451,26 +38451,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$1b(astNode, state) {
@@ -38613,26 +38595,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$1a(astNode, state) {
@@ -38775,26 +38739,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$19(astNode, state) {
@@ -38949,26 +38895,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() {
@@ -38993,10 +38921,10 @@ function getTypeCacheKeys$18(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.
         }
@@ -39291,26 +39219,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$17(astNode, state) {
@@ -39448,26 +39358,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$16(astNode, state) {
@@ -39613,26 +39505,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() {
@@ -39657,10 +39531,10 @@ function getTypeCacheKeys$15(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.
         }
@@ -39972,26 +39846,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() {
@@ -40140,26 +39996,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$13(astNode, state) {
@@ -40318,26 +40156,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() {
@@ -40362,10 +40182,10 @@ function getTypeCacheKeys$12(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.
         }
@@ -40868,26 +40688,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() {
@@ -41086,26 +40888,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$10(astNode, state) {
@@ -41241,26 +41025,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() {
@@ -41285,10 +41051,10 @@ function getTypeCacheKeys$$(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.
         }
@@ -41465,26 +41231,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() {
@@ -41629,26 +41377,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() {
@@ -41826,26 +41556,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() {
@@ -41870,10 +41582,10 @@ function getTypeCacheKeys$Y(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.
         }
@@ -42234,26 +41946,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() {
@@ -42424,26 +42118,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() {
@@ -42468,10 +42144,10 @@ function getTypeCacheKeys$W(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.
         }
@@ -42864,26 +42540,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() {
@@ -42908,10 +42566,10 @@ function getTypeCacheKeys$V(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.
         }
@@ -43075,26 +42733,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$U(astNode, state) {
@@ -43231,26 +42871,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$T(astNode, state) {
@@ -43399,26 +43021,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() {
@@ -43443,10 +43047,10 @@ function getTypeCacheKeys$S(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.
         }
@@ -43760,26 +43364,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$R(astNode, state) {
@@ -43928,26 +43514,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() {
@@ -43972,10 +43540,10 @@ function getTypeCacheKeys$Q(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.
         }
@@ -44245,26 +43813,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$P(astNode, state) {
@@ -44407,26 +43957,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$O(astNode, state) {
@@ -44581,26 +44113,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() {
@@ -44625,10 +44139,10 @@ function getTypeCacheKeys$N(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.
         }
@@ -44923,26 +44437,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$M(astNode, state) {
@@ -45233,26 +44729,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$L(astNode, state) {
@@ -45401,26 +44879,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() {
@@ -45445,10 +44905,10 @@ function getTypeCacheKeys$K(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.
         }
@@ -45718,26 +45178,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$J(astNode, state) {
@@ -45874,26 +45316,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$I(astNode, state) {
@@ -46040,26 +45464,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() {
@@ -46084,10 +45490,10 @@ function getTypeCacheKeys$H(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.
         }
@@ -46261,26 +45667,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$G(astNode, state) {
@@ -46429,26 +45817,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() {
@@ -46473,10 +45843,10 @@ function getTypeCacheKeys$F(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.
         }
@@ -46765,26 +46135,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$E(astNode, state) {
@@ -46933,26 +46285,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() {
@@ -46977,10 +46311,10 @@ function getTypeCacheKeys$D(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.
         }
@@ -47277,26 +46611,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() {
@@ -47321,10 +46637,10 @@ function getTypeCacheKeys$C(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.
         }
@@ -47606,26 +46922,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$B(astNode, state) {
@@ -47774,26 +47072,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() {
@@ -47818,10 +47098,10 @@ function getTypeCacheKeys$A(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.
         }
@@ -48103,26 +47383,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() {
@@ -48147,10 +47409,10 @@ function getTypeCacheKeys$z(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.
         }
@@ -48432,26 +47694,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() {
@@ -48476,10 +47720,10 @@ function getTypeCacheKeys$y(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.
         }
@@ -48749,26 +47993,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$x(astNode, state) {
@@ -48923,26 +48149,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() {
@@ -48967,10 +48175,10 @@ function getTypeCacheKeys$w(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.
         }
@@ -49258,26 +48466,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() {
@@ -49302,10 +48492,10 @@ function getTypeCacheKeys$v(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.
         }
@@ -49619,26 +48809,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$u(astNode, state) {
@@ -49779,26 +48951,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() {
@@ -49823,10 +48977,10 @@ function getTypeCacheKeys$t(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.
         }
@@ -49994,26 +49148,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$s(astNode, state) {
@@ -50150,26 +49286,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$r(astNode, state) {
@@ -50340,26 +49458,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() {
@@ -50520,26 +49620,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() {
@@ -50692,26 +49774,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() {
@@ -50736,10 +49800,10 @@ function getTypeCacheKeys$o(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.
         }
@@ -51224,26 +50288,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() {
@@ -51268,10 +50314,10 @@ function getTypeCacheKeys$m(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.
         }
@@ -51820,26 +50866,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() {
@@ -51864,10 +50892,10 @@ function getTypeCacheKeys$l(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.
         }
@@ -52018,26 +51046,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() {
@@ -52062,10 +51072,10 @@ function getTypeCacheKeys$k(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.
         }
@@ -52223,26 +51233,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() {
@@ -52468,26 +51460,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() {
@@ -52513,10 +51487,10 @@ function getTypeCacheKeys$i(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.
         }
@@ -53050,26 +52024,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() {
@@ -53094,10 +52050,10 @@ function getTypeCacheKeys$h(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.
         }
@@ -53236,26 +52192,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() {
@@ -53574,10 +52512,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.
         }
@@ -53794,18 +52732,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) {
@@ -54410,6 +53358,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;
@@ -54603,26 +53572,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$f(astNode, state) {
@@ -54703,7 +53654,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,
@@ -54732,7 +53683,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.
         }
@@ -54822,9 +53773,8 @@ function convertAstToTrie(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?
@@ -55171,10 +54121,10 @@ function getTypeCacheKeys$e(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.
         }
@@ -55396,28 +54346,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$d(astNode, state) {
@@ -55430,10 +54362,10 @@ function getTypeCacheKeys$d(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.
         }
@@ -56297,26 +55229,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() {
@@ -56341,10 +55255,10 @@ function getTypeCacheKeys$c(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.
         }
@@ -56568,26 +55482,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() {
@@ -56755,26 +55651,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() {
@@ -56799,10 +55677,10 @@ function getTypeCacheKeys$b(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.
         }
@@ -56947,26 +55825,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() {
@@ -56991,10 +55851,10 @@ function getTypeCacheKeys$a(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.
         }
@@ -57253,26 +56113,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() {
@@ -57289,10 +56131,10 @@ function getTypeCacheKeys$9(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.
         }