@salesforce/lds-adapters-uiapi 1.114.5 → 1.114.6

package/dist/umd/es2018/uiapi-records-service.js

@@ -5758,6 +5758,10 @@
     function findMaxOffset(metadata) {
         if (metadata === undefined)
             return -1;
+        const endOfList = metadata["__END__"];
+        if (endOfList !== undefined) {
+            return endOfList > 0 ? endOfList - 1 : 0; // Cursor based pagination in gql is off by one :)
+        }
         const { __END__: _, ...cursorMetadata } = metadata;
         const values = Object.values(cursorMetadata).filter((value) => value !== undefined);
         return Math.max(...values);
@@ -31659,93 +31663,6 @@
         buildCachedSnapshotCachePolicy$6, buildNetworkSnapshotCachePolicy$7);
     };
 
-    function applyToSelection$6(selection, directive, variables) {
-        return selection;
-    }
-
-    function applyToSelection$5(selection, directive, variables) {
-        return selection;
-    }
-
-    function applyToSelection$4(selection, directive, variables) {
-        return selection;
-    }
-
-    function applyToSelection$3(selection, directive, variables) {
-        var _a;
-        const ifArg = (_a = directive.arguments) === null || _a === void 0 ? void 0 : _a.find(argument => argument.name.value === "if");
-        if (ifArg && ifArg.value) {
-            if (ifArg.value.kind === "BooleanValue") {
-                return ifArg.value.value ? selection : undefined;
-            }
-            if (ifArg.value.kind === "Variable") {
-                return variables[ifArg.value.name.value] ? selection : undefined;
-            }
-        }
-        return selection;
-    }
-
-    function applyToSelection$2(selection, directive, variables) {
-        var _a;
-        const ifArg = (_a = directive.arguments) === null || _a === void 0 ? void 0 : _a.find(argument => argument.name.value === "if");
-        if (ifArg && ifArg.value) {
-            if (ifArg.value.kind === "BooleanValue") {
-                return ifArg.value.value ? undefined : selection;
-            }
-            if (ifArg.value.kind === "Variable") {
-                return variables[ifArg.value.name.value] ? undefined : selection;
-            }
-        }
-        return selection;
-    }
-
-    function applyToSelection$1(selection, directive, variables) {
-        return selection;
-    }
-
-    function applyToSelection(selection, directive, variables) {
-        return selection;
-    }
-
-    function applyDirectivesForSelection(selection, variables) {
-        let result = selection;
-        if (selection && selection.directives) {
-            // iterate through directives in order. Directives _can_ be stacked.
-            for (var i = 0; i < selection.directives.length; i++) {
-                const directive = selection.directives[i];
-                switch (directive.name.value) {
-                    // Generate Case for each directive in the schema that supports SelectionNodes
-                    case ("generic"):
-                        result = applyToSelection$6(selection);
-                        break;
-                    case ("fieldCategory"):
-                        result = applyToSelection$5(selection);
-                        break;
-                    case ("category"):
-                        result = applyToSelection$4(selection);
-                        break;
-                    case ("include"):
-                        result = applyToSelection$3(selection, directive, variables);
-                        break;
-                    case ("skip"):
-                        result = applyToSelection$2(selection, directive, variables);
-                        break;
-                    case ("deprecated"):
-                        result = applyToSelection$1(selection);
-                        break;
-                    case ("specifiedBy"):
-                        result = applyToSelection(selection);
-                        break;
-                }
-                if (result === undefined) {
-                    // Selection was removed.
-                    break;
-                }
-            }
-        }
-        return result;
-    }
-
     const name$G = 'DoubleValue';
     const VERSION$T = 'de69c0962aca45d77a5bc8d9abacfa7d';
     function keyBuilder$U(luvio, path, data) {
@@ -31805,79 +31722,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$G(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$G(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$11(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$H(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$H(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$H(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$G, getFieldType$11, selectType$H);
     }
-    function buildSelectionForNode$G(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$H(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$G(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$H(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$G(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$G(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$H(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$H, buildSelectionForField$H);
     }
     function select$Q(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$H(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -32025,79 +31881,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$F(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$F(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$10(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$G(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$G(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$G(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$F, getFieldType$10, selectType$G);
     }
-    function buildSelectionForNode$F(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$G(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$F(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$G(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$F(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$F(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$G(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$G, buildSelectionForField$G);
     }
     function select$P(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$G(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -32245,79 +32040,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$E(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$E(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$$(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$F(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$F(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$F(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$E, getFieldType$$, selectType$F);
     }
-    function buildSelectionForNode$E(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$F(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$E(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$F(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$E(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$E(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$F(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$F, buildSelectionForField$F);
     }
     function select$O(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$F(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -32547,79 +32281,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$D(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$D(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$Z(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$E(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$E(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$E(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$D, getFieldType$Z, selectType$E);
     }
-    function buildSelectionForNode$D(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$E(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$D(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$E(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$D(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$D(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$E(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$E, buildSelectionForField$E);
     }
     function select$N(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$E(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -32763,79 +32436,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$C(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$C(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$Y(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$D(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$D(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$D(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$C, getFieldType$Y, selectType$D);
     }
-    function buildSelectionForNode$C(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$D(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$C(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$D(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$C(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$C(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$D(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$D, buildSelectionForField$D);
     }
     function select$M(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$D(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -33055,79 +32667,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$B(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$B(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$W(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$C(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$C(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$C(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$B, getFieldType$W, selectType$C);
     }
-    function buildSelectionForNode$B(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$C(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$B(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$C(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$B(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$B(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$C(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$C, buildSelectionForField$C);
     }
     function select$L(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$C(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -33269,79 +32820,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$A(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$A(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$V(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$B(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$B(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$B(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$A, getFieldType$V, selectType$B);
     }
-    function buildSelectionForNode$A(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$B(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$A(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$B(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$A(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$A(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$B(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$B, buildSelectionForField$B);
     }
     function select$K(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$B(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -33489,79 +32979,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$z(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$z(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$U(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$A(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$A(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$A(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$z, getFieldType$U, selectType$A);
     }
-    function buildSelectionForNode$z(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$A(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$z(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$A(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$z(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$z(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$A(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$A, buildSelectionForField$A);
     }
     function select$J(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$A(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -33703,79 +33132,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$y(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$y(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$T(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$z(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$z(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$z(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$y, getFieldType$T, selectType$z);
     }
-    function buildSelectionForNode$y(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$z(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$y(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$z(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$y(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$y(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$z(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$z, buildSelectionForField$z);
     }
     function select$I(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$z(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -33923,79 +33291,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$x(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$x(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$S(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$y(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$y(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$y(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$x, getFieldType$S, selectType$y);
     }
-    function buildSelectionForNode$x(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$y(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$x(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$y(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$x(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$x(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$y(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$y, buildSelectionForField$y);
     }
     function select$H(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$y(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -34143,79 +33450,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$w(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$w(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$R(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$x(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$x(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$x(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$w, getFieldType$R, selectType$x);
     }
-    function buildSelectionForNode$w(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$x(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$w(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$x(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$w(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$w(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$x(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$x, buildSelectionForField$x);
     }
     function select$G(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$x(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -34357,79 +33603,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$v(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$v(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$Q(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$w(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$w(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$w(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$v, getFieldType$Q, selectType$w);
     }
-    function buildSelectionForNode$v(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$w(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$v(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$w(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$v(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$v(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$w(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$w, buildSelectionForField$w);
     }
     function select$F(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$w(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -34571,79 +33756,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$u(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$u(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$P(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$v(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$v(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$v(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$u, getFieldType$P, selectType$v);
     }
-    function buildSelectionForNode$u(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$v(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$u(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$v(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$u(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$u(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$v(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$v, buildSelectionForField$v);
     }
     function select$E(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$v(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -34785,79 +33909,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$t(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$t(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$O(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$u(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$u(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$u(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$t, getFieldType$O, selectType$u);
     }
-    function buildSelectionForNode$t(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$u(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$t(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$u(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$t(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$t(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$u(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$u, buildSelectionForField$u);
     }
     function select$D(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$u(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -34999,79 +34062,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$s(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$s(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$N(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$t(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$t(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$t(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$s, getFieldType$N, selectType$t);
     }
-    function buildSelectionForNode$s(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$t(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$s(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$t(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$s(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$s(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$t(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$t, buildSelectionForField$t);
     }
     function select$C(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$t(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -35213,79 +34215,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$r(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$r(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$M(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$s(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$s(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$s(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$r, getFieldType$M, selectType$s);
     }
-    function buildSelectionForNode$r(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$s(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$r(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$s(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$r(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$r(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$s(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$s, buildSelectionForField$s);
     }
     function select$B(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$s(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -35427,79 +34368,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$q(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$q(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$L(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$r(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$r(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$r(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$q, getFieldType$L, selectType$r);
     }
-    function buildSelectionForNode$q(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$r(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$q(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$r(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$q(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$q(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$r(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$r, buildSelectionForField$r);
     }
     function select$A(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$r(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -35641,79 +34521,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$p(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$p(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$K(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$q(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$q(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$q(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$p, getFieldType$K, selectType$q);
     }
-    function buildSelectionForNode$p(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$q(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$p(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$q(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$p(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$p(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$q(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$q, buildSelectionForField$q);
     }
     function select$z(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$q(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -35861,79 +34680,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$o(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$o(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$J(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$p(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$p(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$p(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$o, getFieldType$J, selectType$p);
     }
-    function buildSelectionForNode$o(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$p(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$o(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$p(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$o(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$o(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$p(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$p, buildSelectionForField$p);
     }
     function select$y(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$p(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -36075,79 +34833,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$n(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$n(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$I(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$o(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$o(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$o(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$n, getFieldType$I, selectType$o);
     }
-    function buildSelectionForNode$n(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$o(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$n(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$o(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$n(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$n(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$o(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$o, buildSelectionForField$o);
     }
     function select$x(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$o(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -36289,79 +34986,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$m(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$m(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$H(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$n(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$n(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$n(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$m, getFieldType$H, selectType$n);
     }
-    function buildSelectionForNode$m(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$n(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$m(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$n(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$m(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$m(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$n(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$n, buildSelectionForField$n);
     }
     function select$w(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$n(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -36509,79 +35145,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$l(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$l(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$G(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$m(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$m(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$m(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$l, getFieldType$G, selectType$m);
     }
-    function buildSelectionForNode$l(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$m(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$l(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$m(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$l(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$l(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$m(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$m, buildSelectionForField$m);
     }
     function select$v(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$m(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -36729,79 +35304,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$k(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$k(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$F(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$l(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$l(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$l(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$k, getFieldType$F, selectType$l);
     }
-    function buildSelectionForNode$k(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$l(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$k(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$l(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$k(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$k(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$l(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$l, buildSelectionForField$l);
     }
     function select$u(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$l(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -36943,79 +35457,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$j(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$j(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$E(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$k(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$k(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$k(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$j, getFieldType$E, selectType$k);
     }
-    function buildSelectionForNode$j(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$k(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$j(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$k(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$j(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$j(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$k(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$k, buildSelectionForField$k);
     }
     function select$t(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$k(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -37938,79 +36391,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$i(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$h(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$B(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$i(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$i(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$j(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$h, getFieldType$B, selectType$i);
     }
-    function buildSelectionForNode$i(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$j(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$i(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$j(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$i(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$i(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$j(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$j, buildSelectionForField$j);
     }
     function select$r(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$j(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -38860,7 +37252,7 @@
                         }
                         else {
                             trimmedEdges = trimEdges(source.edges, startOffset, endOffset);
-                            maxOffset = !listIsComplete ? findMaxOffset(metadata) : Object.keys(metadata).length - 2;
+                            maxOffset = findMaxOffset(metadata);
                             const listHasEnoughItems = (endOffset - 1 <= maxOffset);
                             if (trimmedEdges === undefined || !listHasEnoughItems) {
                                 reader.markMissingLink(fieldData.__ref);
@@ -38898,72 +37290,11 @@
         }
         return sink;
     }
-    function buildSelectionForField$h(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$i(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$C(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$j(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$j(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$i(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$i, getFieldType$C, selectType$j);
     }
-    function buildSelectionForNode$h(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$i(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$h(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$i(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$h(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$h(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$i(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$i, buildSelectionForField$i);
     }
     function select$q(field, variables, fragments) {
         return (source, reader) => {
@@ -38971,7 +37302,7 @@
             const sink = {};
             source = attachMappedData(source, reader);
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$h(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$i(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -39907,79 +38238,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$g(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$g(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$A(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$g(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$g(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$h(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$g, getFieldType$A, selectType$g);
     }
-    function buildSelectionForNode$g(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$h(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$g(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$h(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$g(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$g(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$h(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$h, buildSelectionForField$h);
     }
     function select$p(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$h(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -40266,81 +38536,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$f(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$f(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        if (requestedFieldName === 'pageInfo')
-            return;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$z(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$f(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$f(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$g(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, true, getFieldData$f, getFieldType$z, selectType$f);
     }
-    function buildSelectionForNode$f(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$g(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$f(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$g(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$f(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$f(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$g(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$g, buildSelectionForField$g);
     }
     function select$o(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$g(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -40598,7 +38805,7 @@
                         }
                         else {
                             trimmedEdges = trimEdges(source.edges, startOffset, endOffset);
-                            maxOffset = !listIsComplete ? findMaxOffset(metadata) : Object.keys(metadata).length - 2;
+                            maxOffset = findMaxOffset(metadata);
                             const listHasEnoughItems = (endOffset - 1 <= maxOffset);
                             if (trimmedEdges === undefined || !listHasEnoughItems) {
                                 reader.markMissingLink(fieldData.__ref);
@@ -40636,79 +38843,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$e(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$e(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$y(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$e(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$e(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$f(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$e, getFieldType$y, selectType$e);
     }
-    function buildSelectionForNode$e(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$f(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$e(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$f(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$e(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$e(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$f(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$f, buildSelectionForField$f);
     }
     function select$n(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$f(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -40925,79 +39071,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$d(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$d(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$x(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$d(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$d(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$e(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$d, getFieldType$x, selectType$d);
     }
-    function buildSelectionForNode$d(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$e(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$d(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$e(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$d(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$d(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$e(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$e, buildSelectionForField$e);
     }
     function select$m(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$e(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -41208,79 +39293,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$c(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$c(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$w(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$c(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$c(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$d(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$c, getFieldType$w, selectType$c);
     }
-    function buildSelectionForNode$c(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$d(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$c(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$d(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$c(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$c(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$d(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$d, buildSelectionForField$d);
     }
     function select$l(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$d(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -41430,79 +39454,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$b(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$b(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$v(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$b(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$b(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$c(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$b, getFieldType$v, selectType$b);
     }
-    function buildSelectionForNode$b(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$c(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$b(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$c(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$b(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$b(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$c(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$c, buildSelectionForField$c);
     }
     function select$k(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$c(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -41680,79 +39643,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$a(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$a(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$u(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$a(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$a(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$b(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$a, getFieldType$u, selectType$a);
     }
-    function buildSelectionForNode$a(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$b(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$a(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$b(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$a(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$a(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$b(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$b, buildSelectionForField$b);
     }
     function select$j(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$b(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -42005,79 +39907,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$9(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$9(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$t(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$9(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$9(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$a(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$9, getFieldType$t, selectType$9);
     }
-    function buildSelectionForNode$9(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$a(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$9(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$a(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$9(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$9(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$a(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$a, buildSelectionForField$a);
     }
     function select$i(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$a(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -42480,79 +40321,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$8(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$8(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$s(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$8(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$8(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$9(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$8, getFieldType$s, selectType$8);
     }
-    function buildSelectionForNode$8(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$9(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$8(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$9(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$8(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$8(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$9(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$9, buildSelectionForField$9);
     }
     function select$h(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$9(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -42724,79 +40504,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$7(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$7(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$r(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$7(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$7(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$8(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$7, getFieldType$r, selectType$7);
     }
-    function buildSelectionForNode$7(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$8(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$7(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$8(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$7(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$7(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$8(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$8, buildSelectionForField$8);
     }
     function select$g(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$7(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$8(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -43061,79 +40780,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$6(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$6(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$q(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$6(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$6(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$7(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$6, getFieldType$q, selectType$6);
     }
-    function buildSelectionForNode$6(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$7(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$6(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$7(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$6(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$6(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$7(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$7, buildSelectionForField$7);
     }
     function select$f(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$7(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -43560,79 +41218,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$5(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$5(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$p(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$5(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$5(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$6(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$5, getFieldType$p, selectType$5);
     }
-    function buildSelectionForNode$5(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$6(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$5(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$6(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$5(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$5(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$6(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$6, buildSelectionForField$6);
     }
     function select$e(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$5(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$6(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -43798,79 +41395,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$4(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$4(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$o(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$4(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$4(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$5(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$4, getFieldType$o, selectType$4);
     }
-    function buildSelectionForNode$4(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$5(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$4(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$5(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$4(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$4(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$5(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$5, buildSelectionForField$5);
     }
     function select$d(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$5(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -44065,79 +41601,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$3(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$3(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$n(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$3(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$3(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$4(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$3, getFieldType$n, selectType$3);
     }
-    function buildSelectionForNode$3(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$4(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$3(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$4(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$3(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$3(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$4(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$4, buildSelectionForField$4);
     }
     function select$c(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$4(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -44454,79 +41929,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$2(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$2(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$m(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$2(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$2(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$3(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$2, getFieldType$m, selectType$2);
     }
-    function buildSelectionForNode$2(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$3(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$2(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$3(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$2(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$2(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$3(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$3, buildSelectionForField$3);
     }
     function select$b(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$3(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -44783,79 +42197,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$1(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$1(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$l(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$1(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$1(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$2(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$1, getFieldType$l, selectType$1);
     }
-    function buildSelectionForNode$1(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$2(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$1(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$2(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$1(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$1(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$2(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$2, buildSelectionForField$2);
     }
     function select$a(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$2(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -45065,79 +42418,18 @@
         }
         return sink;
     }
-    function buildSelectionForField(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$k(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$1(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData, getFieldType$k, selectType);
     }
-    function buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$1(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$1(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$1(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$1, buildSelectionForField$1);
     }
     function select$9(field, variables, fragments) {
         return (source, reader) => {
             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);
+                const builtSelection = buildSelectionForNode$1(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -46910,6 +44202,93 @@
         return sharedGetFragmentType(fragment, fragmentMap);
     }
 
+    function applyToSelection$6(selection, directive, variables) {
+        return selection;
+    }
+
+    function applyToSelection$5(selection, directive, variables) {
+        return selection;
+    }
+
+    function applyToSelection$4(selection, directive, variables) {
+        return selection;
+    }
+
+    function applyToSelection$3(selection, directive, variables) {
+        var _a;
+        const ifArg = (_a = directive.arguments) === null || _a === void 0 ? void 0 : _a.find(argument => argument.name.value === "if");
+        if (ifArg && ifArg.value) {
+            if (ifArg.value.kind === "BooleanValue") {
+                return ifArg.value.value ? selection : undefined;
+            }
+            if (ifArg.value.kind === "Variable") {
+                return variables[ifArg.value.name.value] ? selection : undefined;
+            }
+        }
+        return selection;
+    }
+
+    function applyToSelection$2(selection, directive, variables) {
+        var _a;
+        const ifArg = (_a = directive.arguments) === null || _a === void 0 ? void 0 : _a.find(argument => argument.name.value === "if");
+        if (ifArg && ifArg.value) {
+            if (ifArg.value.kind === "BooleanValue") {
+                return ifArg.value.value ? undefined : selection;
+            }
+            if (ifArg.value.kind === "Variable") {
+                return variables[ifArg.value.name.value] ? undefined : selection;
+            }
+        }
+        return selection;
+    }
+
+    function applyToSelection$1(selection, directive, variables) {
+        return selection;
+    }
+
+    function applyToSelection(selection, directive, variables) {
+        return selection;
+    }
+
+    function applyDirectivesForSelection(selection, variables) {
+        let result = selection;
+        if (selection && selection.directives) {
+            // iterate through directives in order. Directives _can_ be stacked.
+            for (var i = 0; i < selection.directives.length; i++) {
+                const directive = selection.directives[i];
+                switch (directive.name.value) {
+                    // Generate Case for each directive in the schema that supports SelectionNodes
+                    case ("generic"):
+                        result = applyToSelection$6(selection);
+                        break;
+                    case ("fieldCategory"):
+                        result = applyToSelection$5(selection);
+                        break;
+                    case ("category"):
+                        result = applyToSelection$4(selection);
+                        break;
+                    case ("include"):
+                        result = applyToSelection$3(selection, directive, variables);
+                        break;
+                    case ("skip"):
+                        result = applyToSelection$2(selection, directive, variables);
+                        break;
+                    case ("deprecated"):
+                        result = applyToSelection$1(selection);
+                        break;
+                    case ("specifiedBy"):
+                        result = applyToSelection(selection);
+                        break;
+                }
+                if (result === undefined) {
+                    // Selection was removed.
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+
     function createLink(ref) {
         return {
             __ref: engine.serializeStructuredKey(ref),
@@ -47674,6 +45053,76 @@
         const doesImplementInterface = !isUntypedInlineFragment && implementedInterfaces.includes(fragmentNode.typeCondition.name.value);
         const typenameMatchesCondition = typename !== undefined && !isUntypedInlineFragment && typename === fragmentNode.typeCondition.name.value;
         return isUntypedInlineFragment || matchesTypeCondition || doesImplementInterface || typenameMatchesCondition;
+    }
+    function buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable, buildSelectionForField) {
+        const sink = {};
+        if (selectionNode.directives) {
+            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
+            if (selectionWithDirectives === undefined) {
+                return;
+            }
+            selectionNode = selectionWithDirectives;
+        }
+        if (selectionNode.kind === "InlineFragment") {
+            if (isFragmentApplicable(selectionNode, source.data.__typename)) {
+                // Get selections out of the inline fragment
+                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
+                    // Call into field handling with selections
+                    Object.assign(sink, buildSelectionForNode(source, reader, parentNode, fragmentSelection, variables, fragments, isFragmentApplicable, buildSelectionForField));
+                });
+            }
+        }
+        if (selectionNode.kind === "FragmentSpread") {
+            const namedFragment = fragments[selectionNode.name.value];
+            if (namedFragment && isFragmentApplicable(namedFragment, source.data.__typename)) {
+                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
+                    // Call into field handling with selections
+                    Object.assign(sink, buildSelectionForNode(source, reader, parentNode, fragmentSelection, variables, fragments, isFragmentApplicable, buildSelectionForField));
+                });
+            }
+        }
+        if (selectionNode.kind === "Field") {
+            Object.assign(sink, buildSelectionForField(source, reader, selectionNode, variables, fragments));
+        }
+        return sink;
+    }
+    function buildSelectionForField(source, reader, sel, variables, fragments, isCursorConnectionType, getFieldData, getFieldType, selectType) {
+        const sink = {};
+        const fieldData = getFieldData(source, sel, variables);
+        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
+        if (isCursorConnectionType && requestedFieldName === 'pageInfo') {
+            return;
+        }
+        reader.enterPath(requestedFieldName);
+        if (fieldData === undefined) {
+            reader.markMissing();
+            reader.exitPath();
+            return;
+        }
+        if (fieldData === null) {
+            reader.assignScalar(requestedFieldName, sink, fieldData);
+            return sink;
+        }
+        const fieldType = getFieldType(sel);
+        if (fieldType === undefined) {
+            // This field's type is unknown to us. This breaks normalization.
+            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
+            reader.assignNonScalar(sink, requestedFieldName, fieldData);
+        }
+        else if (fieldType.isArray) {
+            const arraySink = [];
+            for (let i = 0, len = fieldData.length; i < len; i += 1) {
+                reader.enterPath(i);
+                selectType(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
+                reader.exitPath();
+            }
+            reader.assignNonScalar(sink, requestedFieldName, arraySink);
+        }
+        else {
+            selectType(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
+        }
+        reader.exitPath();
+        return sink;
     }
 
     const TTL$5 = 900000;