@salesforce/lds-adapters-uiapi 1.114.5 → 1.114.6

package/sfdc/graphqlAdapters.js

@@ -237,6 +237,10 @@ function createPageInfo(edges, startOffset, endOffset, maxOffset, metadata) {
 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);
@@ -368,93 +372,6 @@ function revertPaginationOptimization(variables) {
     }
 }
 
-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$Q = 'de69c0962aca45d77a5bc8d9abacfa7d';
 function keyBuilder$L(luvio, path, data) {
@@ -514,79 +431,18 @@ function selectType$H(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -734,79 +590,18 @@ function selectType$G(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -954,79 +749,18 @@ function selectType$F(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -1256,79 +990,18 @@ function selectType$E(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -1472,79 +1145,18 @@ function selectType$D(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -1764,79 +1376,18 @@ function selectType$C(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -1978,79 +1529,18 @@ function selectType$B(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -2198,79 +1688,18 @@ function selectType$A(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -2412,79 +1841,18 @@ function selectType$z(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -2611,100 +1979,39 @@ function getFieldData$x(source, sel, variables) {
         default: {
             const fieldType = getFieldType$S(sel);
             const fieldKey = getSerializedKeyForField(sel, variables, fieldType);
-            return source.data[fieldKey];
-        }
-    }
-}
-function selectType$y(typename, sel, fieldData, reader, key, sink, variables, fragments) {
-    if (fieldData === null) {
-        reader.assignScalar(key, sink, fieldData);
-        return sink;
-    }
-    switch (typename) {
-        case 'String': {
-            reader.assignScalar(key, sink, fieldData);
-            break;
-        }
-        case 'Date': {
-            reader.assignScalar(key, sink, fieldData);
-            break;
-        }
-    }
-    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 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));
-            });
+            return source.data[fieldKey];
         }
     }
-    if (selectionNode.kind === "Field") {
-        Object.assign(sink, buildSelectionForField$x(source, reader, selectionNode, variables));
+}
+function selectType$y(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    if (fieldData === null) {
+        reader.assignScalar(key, sink, fieldData);
+        return sink;
+    }
+    switch (typename) {
+        case 'String': {
+            reader.assignScalar(key, sink, fieldData);
+            break;
+        }
+        case 'Date': {
+            reader.assignScalar(key, sink, fieldData);
+            break;
+        }
     }
     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$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) => {
@@ -2852,79 +2159,18 @@ function selectType$x(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -3066,79 +2312,18 @@ function selectType$w(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -3280,79 +2465,18 @@ function selectType$v(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -3487,86 +2611,25 @@ function selectType$u(typename, sel, fieldData, reader, key, sink, variables, fr
             reader.assignScalar(key, sink, fieldData);
             break;
         }
-        case 'PhoneNumber': {
-            reader.assignScalar(key, sink, fieldData);
-            break;
-        }
-    }
-    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 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));
-            });
+        case 'PhoneNumber': {
+            reader.assignScalar(key, sink, fieldData);
+            break;
         }
     }
-    if (selectionNode.kind === "Field") {
-        Object.assign(sink, buildSelectionForField$t(source, reader, selectionNode, variables));
-    }
     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$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) => {
@@ -3708,79 +2771,18 @@ function selectType$t(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -3922,79 +2924,18 @@ function selectType$s(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -4136,79 +3077,18 @@ function selectType$r(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -4338,91 +3218,30 @@ function selectType$q(typename, sel, fieldData, reader, key, sink, variables, fr
         reader.assignScalar(key, sink, fieldData);
         return sink;
     }
-    switch (typename) {
-        case 'String': {
-            reader.assignScalar(key, sink, fieldData);
-            break;
-        }
-        case 'Currency': {
-            reader.assignScalar(key, sink, fieldData);
-            break;
-        }
-    }
-    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 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));
-            });
+    switch (typename) {
+        case 'String': {
+            reader.assignScalar(key, sink, fieldData);
+            break;
+        }
+        case 'Currency': {
+            reader.assignScalar(key, sink, fieldData);
+            break;
         }
-    }
-    if (selectionNode.kind === "Field") {
-        Object.assign(sink, buildSelectionForField$p(source, reader, selectionNode, variables));
     }
     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$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) => {
@@ -4570,79 +3389,18 @@ function selectType$p(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -4784,79 +3542,18 @@ function selectType$o(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -4998,79 +3695,18 @@ function selectType$n(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -5208,89 +3844,28 @@ function selectType$m(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     switch (typename) {
         case 'String': {
-            reader.assignScalar(key, sink, fieldData);
-            break;
-        }
-        case 'MultiPicklist': {
-            reader.assignScalar(key, sink, fieldData);
-            break;
-        }
-    }
-    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 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));
-            });
+            reader.assignScalar(key, sink, fieldData);
+            break;
         }
-    }
-    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));
-            });
+        case 'MultiPicklist': {
+            reader.assignScalar(key, sink, fieldData);
+            break;
         }
     }
-    if (selectionNode.kind === "Field") {
-        Object.assign(sink, buildSelectionForField$l(source, reader, selectionNode, variables));
-    }
     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$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) => {
@@ -5438,79 +4013,18 @@ function selectType$l(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -5652,79 +4166,18 @@ function selectType$k(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -6725,79 +5178,18 @@ function selectType$i(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -7647,7 +6039,7 @@ function selectType$h(typename, sel, fieldData, reader, key, sink, variables, fr
                     }
                     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);
@@ -7680,85 +6072,24 @@ function selectType$h(typename, sel, fieldData, reader, key, sink, variables, fr
                 reader.markMissingLink(fieldData.__ref);
                 reader.markMissing();
             }
-            break;
-        }
-    }
-    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 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));
-            });
+            break;
         }
     }
-    if (selectionNode.kind === "Field") {
-        Object.assign(sink, buildSelectionForField$h(source, reader, selectionNode, variables, fragments));
-    }
     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$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) => {
         var _a;
         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) => {
@@ -8694,79 +7025,18 @@ function selectType$g(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -9053,81 +7323,18 @@ function selectType$f(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -9385,7 +7592,7 @@ function selectType$e(typename, sel, fieldData, reader, key, sink, variables, fr
                     }
                     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);
@@ -9423,79 +7630,18 @@ function selectType$e(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -9698,93 +7844,32 @@ function selectType$d(typename, sel, fieldData, reader, key, sink, variables, fr
                 },
                 variables: {}
             });
-            reader.markSeenId(fieldData.__ref);
-            if (objectInfoResolvedLink.data !== undefined) {
-                const result = select$f(sel, variables, fragments)(objectInfoResolvedLink.data, reader); // Should probably
-                reader.assignNonScalar(sink, key, result);
-            }
-            else {
-                reader.markMissingLink(fieldData.__ref);
-                reader.markMissing();
-            }
-            break;
-        }
-    }
-    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 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));
-            });
+            reader.markSeenId(fieldData.__ref);
+            if (objectInfoResolvedLink.data !== undefined) {
+                const result = select$f(sel, variables, fragments)(objectInfoResolvedLink.data, reader); // Should probably
+                reader.assignNonScalar(sink, key, result);
+            }
+            else {
+                reader.markMissingLink(fieldData.__ref);
+                reader.markMissing();
+            }
+            break;
         }
     }
-    if (selectionNode.kind === "Field") {
-        Object.assign(sink, buildSelectionForField$d(source, reader, selectionNode, variables, fragments));
-    }
     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$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) => {
@@ -9995,79 +8080,18 @@ function selectType$c(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -10217,79 +8241,18 @@ function selectType$b(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -10467,79 +8430,18 @@ function selectType$a(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -10792,79 +8694,18 @@ function selectType$9(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -11267,79 +9108,18 @@ function selectType$8(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -11511,79 +9291,18 @@ function selectType$7(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -11848,79 +9567,18 @@ function selectType$6(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -12325,101 +9983,40 @@ function getFieldData$5(source, sel, variables) {
     switch (sel.name.value) {
         default: {
             const fieldType = getFieldType$p(sel);
-            const fieldKey = getSerializedKeyForField(sel, variables, fieldType);
-            return source.data[fieldKey];
-        }
-    }
-}
-function selectType$5(typename, sel, fieldData, reader, key, sink, variables, fragments) {
-    if (fieldData === null) {
-        reader.assignScalar(key, sink, fieldData);
-        return sink;
-    }
-    switch (typename) {
-        case 'String': {
-            reader.assignScalar(key, sink, fieldData);
-            break;
-        }
-        case 'Boolean': {
-            reader.assignScalar(key, sink, fieldData);
-            break;
-        }
-    }
-    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 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));
-            });
+            const fieldKey = getSerializedKeyForField(sel, variables, fieldType);
+            return source.data[fieldKey];
         }
     }
-    if (selectionNode.kind === "Field") {
-        Object.assign(sink, buildSelectionForField$5(source, reader, selectionNode, variables));
+}
+function selectType$5(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    if (fieldData === null) {
+        reader.assignScalar(key, sink, fieldData);
+        return sink;
+    }
+    switch (typename) {
+        case 'String': {
+            reader.assignScalar(key, sink, fieldData);
+            break;
+        }
+        case 'Boolean': {
+            reader.assignScalar(key, sink, fieldData);
+            break;
+        }
     }
     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$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) => {
@@ -12585,79 +10182,18 @@ function selectType$4(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -12852,79 +10388,18 @@ function selectType$3(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -13241,79 +10716,18 @@ function selectType$2(typename, sel, fieldData, reader, key, sink, variables, fr
     }
     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) => {
@@ -13545,104 +10959,43 @@ function getFieldData$1(source, sel, variables) {
         default: {
             const fieldType = getFieldType$l(sel);
             const fieldKey = getSerializedKeyForField(sel, variables, fieldType);
-            return source.data[fieldKey];
-        }
-    }
-}
-function selectType$1(typename, sel, fieldData, reader, key, sink, variables, fragments) {
-    if (fieldData === null) {
-        reader.assignScalar(key, sink, fieldData);
-        return sink;
-    }
-    switch (typename) {
-        case 'String': {
-            reader.assignScalar(key, sink, fieldData);
-            break;
-        }
-        case 'Long': {
-            reader.assignScalar(key, sink, fieldData);
-            break;
-        }
-        case 'DateTime': {
-            reader.assignScalar(key, sink, fieldData);
-            break;
-        }
-    }
-    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);
+            return source.data[fieldKey];
+        }
     }
-    reader.exitPath();
-    return sink;
 }
-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;
+function selectType$1(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    if (fieldData === null) {
+        reader.assignScalar(key, sink, fieldData);
+        return sink;
     }
-    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));
-            });
+    switch (typename) {
+        case 'String': {
+            reader.assignScalar(key, sink, fieldData);
+            break;
         }
-    }
-    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));
-            });
+        case 'Long': {
+            reader.assignScalar(key, sink, fieldData);
+            break;
+        }
+        case 'DateTime': {
+            reader.assignScalar(key, sink, fieldData);
+            break;
         }
-    }
-    if (selectionNode.kind === "Field") {
-        Object.assign(sink, buildSelectionForField$1(source, reader, selectionNode, variables));
     }
     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$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) => {
@@ -13852,79 +11205,18 @@ function selectType(typename, sel, fieldData, reader, key, sink, variables, frag
     }
     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) => {
@@ -15697,6 +12989,93 @@ function getInContextFragmentType(fragment, fragmentMap) {
     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: serializeStructuredKey(ref),
@@ -16461,6 +13840,76 @@ function isFragmentApplicable(fragmentNode, implementedInterfaces, graphqlTypeNa
     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 = 900000;
@@ -17815,4 +15264,4 @@ register({
 });
 
 export { configurationForGraphQLAdapters as configuration, graphql, factory$1 as graphqlAdapterFactory, graphqlBatch, graphqlBatch_imperative, graphql_imperative };
-// version: 1.114.5-f7ec91a8d
+// version: 1.114.6-f2429e60e