@salesforce/lds-worker-api 1.114.4 → 1.114.6

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

@@ -3655,7 +3655,7 @@
             return this.environment.buildStructuredKey(namespace, representationName, idValues);
         }
     }
-    // engine version: 0.137.1-cdbdc5cd
+    // engine version: 0.137.4-ec6f5c6d
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -3782,7 +3782,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.114.4-844684b4c
+    // version: 1.114.6-435b32f3e
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -15206,7 +15206,7 @@
         updateReferenceMapWithKnownKey(ast, luvioDocumentNode);
         return luvioDocumentNode;
     }
-    // version: 1.114.4-844684b4c
+    // version: 1.114.6-435b32f3e
 
     function unwrap(data) {
         // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16119,7 +16119,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.114.4-844684b4c
+    // version: 1.114.6-435b32f3e
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -16202,7 +16202,7 @@
     ({
         state: FragmentReadResultState.Missing,
     });
-    // engine version: 0.137.1-cdbdc5cd
+    // engine version: 0.137.4-ec6f5c6d
 
     const { keys: ObjectKeys$3, freeze: ObjectFreeze$3, create: ObjectCreate$3 } = Object;
 
@@ -44353,7 +44353,7 @@
             dropFunction: instrumentation$2.notifyRecordUpdateAvailableDropped,
         });
     });
-    // version: 1.114.4-efecf667d
+    // version: 1.114.6-f2429e60e
 
     var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -49574,11 +49574,11 @@
         mergeActions(targetActionId, sourceActionId) {
             // ids must be unique
             if (targetActionId === sourceActionId) {
-                return Promise.reject(new Error('target and source action ids cannot be the same'));
+                return Promise.reject(new Error('targetActionId and sourceActionId cannot be the same.'));
             }
             // cannot have a replace action already in progress
             if (this.replacingAction !== undefined) {
-                return Promise.reject(new Error('Cannot replace actions while a replace action is in progress'));
+                return Promise.reject(new Error('Cannot merge actions while a replace/merge action operation is in progress.'));
             }
             this.stopQueueManually();
             const promise = this.getQueueActions().then(async (actions) => {
@@ -49586,13 +49586,13 @@
                 if (target === undefined) {
                     this.replacingAction = undefined;
                     await this.startQueueSafe();
-                    throw Error('No action to replace');
+                    throw Error('targetActionId not found in the draft queue.');
                 }
                 const source = actions.find((action) => action.id === sourceActionId);
                 if (source === undefined) {
                     this.replacingAction = undefined;
                     await this.startQueueSafe();
-                    throw Error('No action to replace');
+                    throw Error('sourceActionId not found in the draft queue.');
                 }
                 // put in a try/finally block so we don't leave this.replacingAction
                 // indefinitely set
@@ -55940,28 +55940,28 @@
             const { method: sourceMethod, body: sourceBody } = sourceData;
             // pre-requisites
             if (targetCacheKey !== sourceCacheKey) {
-                throw Error('Cannot merge actions for different targetIds');
+                throw Error('Cannot merge actions for different targetIds.');
             }
             if (targetTag !== sourceTag) {
-                throw Error('Cannot merge actions for different tags');
+                throw Error('Cannot merge actions for different tags.');
             }
             if (targetStatus === DraftActionStatus.Completed ||
                 targetStatus === DraftActionStatus.Uploading) {
-                throw Error(`cannot merge actions when targetAction is in ${targetStatus} status`);
+                throw Error(`Cannot merge actions when targetAction is in ${targetStatus} status.`);
             }
             if (sourceStatus === DraftActionStatus.Completed ||
                 sourceStatus === DraftActionStatus.Uploading) {
-                throw Error(`cannot merge actions when sourceAction is in ${sourceStatus} status`);
+                throw Error(`Cannot merge actions when sourceAction is in ${sourceStatus} status.`);
             }
             if (targetMethod.toLowerCase() === 'delete' || sourceMethod.toLowerCase() === 'delete') {
-                throw Error('cannot merge DELETE actions');
+                throw Error('Cannot merge DELETE actions.');
             }
             if (targetMethod.toLowerCase() === 'patch' && sourceMethod.toLowerCase() === 'post') {
                 // overlaying a POST over a PATCH is not supported
-                throw Error('cannot merge a POST action over top of a PATCH action');
+                throw Error('Cannot merge a POST action over top of a PATCH action.');
             }
             if (targetVersion !== sourceVersion) {
-                throw Error('cannot merge actions with different versions');
+                throw Error('Cannot merge actions with different versions.');
             }
             // overlay top-level properties, maintain target's timestamp and id
             const merged = {
@@ -59845,7 +59845,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$1,
     });
-    // version: 1.114.4-844684b4c
+    // version: 1.114.6-435b32f3e
 
     const { create: create$2, keys: keys$2 } = Object;
     const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -60049,6 +60049,10 @@
     function findMaxOffset(metadata) {
         if (metadata === undefined)
             return -1;
+        const endOfList = metadata["__END__"];
+        if (endOfList !== undefined) {
+            return endOfList > 0 ? endOfList - 1 : 0; // Cursor based pagination in gql is off by one :)
+        }
         const { __END__: _, ...cursorMetadata } = metadata;
         const values = Object.values(cursorMetadata).filter((value) => value !== undefined);
         return Math.max(...values);
@@ -60180,93 +60184,6 @@
         }
     }
 
-    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) {
@@ -60326,79 +60243,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$G(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$G(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$11(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$H(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$H(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$H(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$G, getFieldType$11, selectType$H);
     }
-    function buildSelectionForNode$G(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$H(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$G(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$H(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$G(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$G(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$H(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$H, buildSelectionForField$H);
     }
     function select$Q(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$G(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$H(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -60546,79 +60402,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$F(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$F(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$10(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$G(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$G(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$G(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$F, getFieldType$10, selectType$G);
     }
-    function buildSelectionForNode$F(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$G(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$F(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$G(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$F(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$F(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$G(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$G, buildSelectionForField$G);
     }
     function select$P(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$F(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$G(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -60766,79 +60561,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$E(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$E(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$$(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$F(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$F(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$F(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$E, getFieldType$$, selectType$F);
     }
-    function buildSelectionForNode$E(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$F(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$E(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$F(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$E(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$E(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$F(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$F, buildSelectionForField$F);
     }
     function select$O(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$E(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$F(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -61068,79 +60802,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$D(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$D(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$Z(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$E(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$E(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$E(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$D, getFieldType$Z, selectType$E);
     }
-    function buildSelectionForNode$D(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$E(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$D(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$E(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$D(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$D(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$E(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$E, buildSelectionForField$E);
     }
     function select$N(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$D(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$E(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -61284,79 +60957,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$C(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$C(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$Y(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$D(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$D(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$D(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$C, getFieldType$Y, selectType$D);
     }
-    function buildSelectionForNode$C(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$D(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$C(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$D(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$C(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$C(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$D(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$D, buildSelectionForField$D);
     }
     function select$M(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$C(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$D(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -61576,79 +61188,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$B(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$B(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$W(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$C(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$C(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$C(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$B, getFieldType$W, selectType$C);
     }
-    function buildSelectionForNode$B(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$C(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$B(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$C(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$B(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$B(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$C(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$C, buildSelectionForField$C);
     }
     function select$L(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$B(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$C(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -61790,79 +61341,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$A(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$A(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$V(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$B(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$B(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$B(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$A, getFieldType$V, selectType$B);
     }
-    function buildSelectionForNode$A(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$B(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$A(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$B(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$A(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$A(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$B(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$B, buildSelectionForField$B);
     }
     function select$K(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$A(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$B(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -62010,79 +61500,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$z(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$z(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$U(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$A(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$A(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$A(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$z, getFieldType$U, selectType$A);
     }
-    function buildSelectionForNode$z(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$A(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$z(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$A(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$z(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$z(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$A(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$A, buildSelectionForField$A);
     }
     function select$J(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$z(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$A(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -62224,79 +61653,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$y(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$y(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$T(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$z(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$z(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$z(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$y, getFieldType$T, selectType$z);
     }
-    function buildSelectionForNode$y(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$z(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$y(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$z(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$y(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$y(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$z(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$z, buildSelectionForField$z);
     }
     function select$I(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$y(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$z(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -62444,79 +61812,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$x(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$x(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$S(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$y(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$y(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$y(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$x, getFieldType$S, selectType$y);
     }
-    function buildSelectionForNode$x(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$y(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$x(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$y(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$x(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$x(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$y(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$y, buildSelectionForField$y);
     }
     function select$H(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$x(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$y(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -62664,79 +61971,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$w(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$w(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$R(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$x(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$x(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$x(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$w, getFieldType$R, selectType$x);
     }
-    function buildSelectionForNode$w(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$x(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$w(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$x(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$w(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$w(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$x(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$x, buildSelectionForField$x);
     }
     function select$G(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$w(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$x(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -62878,79 +62124,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$v(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$v(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$Q(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$w(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$w(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$w(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$v, getFieldType$Q, selectType$w);
     }
-    function buildSelectionForNode$v(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$w(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$v(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$w(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$v(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$v(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$w(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$w, buildSelectionForField$w);
     }
     function select$F(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$v(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$w(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -63092,79 +62277,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$u(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$u(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$P(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$v(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$v(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$v(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$u, getFieldType$P, selectType$v);
     }
-    function buildSelectionForNode$u(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$v(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$u(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$v(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$u(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$u(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$v(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$v, buildSelectionForField$v);
     }
     function select$E(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$u(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$v(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -63306,79 +62430,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$t(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$t(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$O(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$u(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$u(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$u(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$t, getFieldType$O, selectType$u);
     }
-    function buildSelectionForNode$t(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$u(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$t(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$u(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$t(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$t(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$u(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$u, buildSelectionForField$u);
     }
     function select$D(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$t(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$u(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -63520,79 +62583,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$s(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$s(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$N(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$t(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$t(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$t(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$s, getFieldType$N, selectType$t);
     }
-    function buildSelectionForNode$s(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$t(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$s(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$t(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$s(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$s(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$t(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$t, buildSelectionForField$t);
     }
     function select$C(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$s(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$t(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -63734,79 +62736,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$r(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$r(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$M(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$s(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$s(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$s(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$r, getFieldType$M, selectType$s);
     }
-    function buildSelectionForNode$r(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$s(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$r(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$s(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$r(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$r(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$s(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$s, buildSelectionForField$s);
     }
     function select$B(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$r(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$s(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -63948,79 +62889,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$q(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$q(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$L(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$r(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$r(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$r(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$q, getFieldType$L, selectType$r);
     }
-    function buildSelectionForNode$q(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$r(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$q(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$r(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$q(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$q(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$r(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$r, buildSelectionForField$r);
     }
     function select$A(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$q(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$r(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -64162,79 +63042,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$p(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$p(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$K(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$q(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$q(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$q(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$p, getFieldType$K, selectType$q);
     }
-    function buildSelectionForNode$p(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$q(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$p(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$q(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$p(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$p(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$q(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$q, buildSelectionForField$q);
     }
     function select$z(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$p(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$q(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -64382,79 +63201,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$o(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$o(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$J(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$p(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$p(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$p(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$o, getFieldType$J, selectType$p);
     }
-    function buildSelectionForNode$o(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$p(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$o(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$p(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$o(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$o(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$p(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$p, buildSelectionForField$p);
     }
     function select$y(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$o(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$p(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -64596,79 +63354,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$n(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$n(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$I(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$o(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$o(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$o(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$n, getFieldType$I, selectType$o);
     }
-    function buildSelectionForNode$n(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$o(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$n(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$o(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$n(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$n(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$o(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$o, buildSelectionForField$o);
     }
     function select$x(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$n(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$o(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -64810,79 +63507,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$m(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$m(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$H(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$n(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$n(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$n(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$m, getFieldType$H, selectType$n);
     }
-    function buildSelectionForNode$m(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$n(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$m(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$n(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$m(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$m(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$n(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$n, buildSelectionForField$n);
     }
     function select$w(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$m(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$n(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -65030,79 +63666,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$l(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$l(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$G(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$m(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$m(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$m(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$l, getFieldType$G, selectType$m);
     }
-    function buildSelectionForNode$l(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$m(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$l(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$m(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$l(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$l(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$m(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$m, buildSelectionForField$m);
     }
     function select$v(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$l(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$m(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -65250,79 +63825,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$k(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$k(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$F(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$l(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$l(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$l(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$k, getFieldType$F, selectType$l);
     }
-    function buildSelectionForNode$k(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$l(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$k(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$l(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$k(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$k(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$l(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$l, buildSelectionForField$l);
     }
     function select$u(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$k(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$l(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -65464,79 +63978,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$j(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$j(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$E(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$k(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$k(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$k(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$j, getFieldType$E, selectType$k);
     }
-    function buildSelectionForNode$j(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$k(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$j(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$k(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$j(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$j(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$k(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$k, buildSelectionForField$k);
     }
     function select$t(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$j(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$k(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -66537,79 +64990,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$i(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$h(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$B(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$i(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$i(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$j(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$h, getFieldType$B, selectType$i);
     }
-    function buildSelectionForNode$i(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$j(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$i(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$j(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$i(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$i(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$j(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$j, buildSelectionForField$j);
     }
     function select$r(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$i(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$j(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -67453,7 +65845,7 @@
                         }
                         else {
                             trimmedEdges = trimEdges(source.edges, startOffset, endOffset);
-                            maxOffset = !listIsComplete ? findMaxOffset(metadata) : Object.keys(metadata).length - 2;
+                            maxOffset = findMaxOffset(metadata);
                             const listHasEnoughItems = (endOffset - 1 <= maxOffset);
                             if (trimmedEdges === undefined || !listHasEnoughItems) {
                                 reader.markMissingLink(fieldData.__ref);
@@ -67491,72 +65883,11 @@
         }
         return sink;
     }
-    function buildSelectionForField$h(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$i(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$C(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$j(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$j(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$i(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$i, getFieldType$C, selectType$j);
     }
-    function buildSelectionForNode$h(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$i(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$h(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$i(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$h(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$h(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$i(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$i, buildSelectionForField$i);
     }
     function select$q(field, variables, fragments) {
         return (source, reader) => {
@@ -67564,7 +65895,7 @@
             const sink = {};
             source = attachMappedData(source, reader);
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$h(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$i(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -68500,79 +66831,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$g(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$g(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$A(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$g(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$g(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$h(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$g, getFieldType$A, selectType$g);
     }
-    function buildSelectionForNode$g(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$h(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$g(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$h(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$g(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$g(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$h(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$h, buildSelectionForField$h);
     }
     function select$p(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$g(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$h(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -68853,81 +67123,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$f(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$f(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        if (requestedFieldName === 'pageInfo')
-            return;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$z(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$f(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$f(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$g(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, true, getFieldData$f, getFieldType$z, selectType$f);
     }
-    function buildSelectionForNode$f(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$g(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$f(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$g(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$f(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$f(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$g(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$g, buildSelectionForField$g);
     }
     function select$o(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$f(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$g(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -69179,7 +67386,7 @@
                         }
                         else {
                             trimmedEdges = trimEdges(source.edges, startOffset, endOffset);
-                            maxOffset = !listIsComplete ? findMaxOffset(metadata) : Object.keys(metadata).length - 2;
+                            maxOffset = findMaxOffset(metadata);
                             const listHasEnoughItems = (endOffset - 1 <= maxOffset);
                             if (trimmedEdges === undefined || !listHasEnoughItems) {
                                 reader.markMissingLink(fieldData.__ref);
@@ -69217,79 +67424,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$e(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$e(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$y(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$e(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$e(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$f(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$e, getFieldType$y, selectType$e);
     }
-    function buildSelectionForNode$e(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$f(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$e(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$f(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$e(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$e(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$f(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$f, buildSelectionForField$f);
     }
     function select$n(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$e(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$f(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -69506,79 +67652,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$d(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$d(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$x(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$d(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$d(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$e(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$d, getFieldType$x, selectType$d);
     }
-    function buildSelectionForNode$d(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$e(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$d(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$e(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$d(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$d(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$e(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$e, buildSelectionForField$e);
     }
     function select$m(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$d(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$e(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -69789,79 +67874,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$c(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$c(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$w(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$c(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$c(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$d(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$c, getFieldType$w, selectType$c);
     }
-    function buildSelectionForNode$c(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$d(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$c(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$d(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$c(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$c(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$d(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$d, buildSelectionForField$d);
     }
     function select$l(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$c(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$d(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -70011,79 +68035,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$b(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$b(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$v(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$b(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$b(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$c(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$b, getFieldType$v, selectType$b);
     }
-    function buildSelectionForNode$b(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$c(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$b(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$c(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$b(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$b(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$c(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$c, buildSelectionForField$c);
     }
     function select$k(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$b(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$c(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -70261,79 +68224,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$a(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$a(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$u(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$a(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$a(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$b(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$a, getFieldType$u, selectType$a);
     }
-    function buildSelectionForNode$a(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$b(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$a(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$b(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$a(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$a(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$b(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$b, buildSelectionForField$b);
     }
     function select$j(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$a(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$b(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -70586,79 +68488,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$9(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$9(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$t(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$9(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$9(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$a(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$9, getFieldType$t, selectType$9);
     }
-    function buildSelectionForNode$9(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$a(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$9(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$a(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$9(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$9(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$a(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$a, buildSelectionForField$a);
     }
     function select$i(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$9(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$a(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -71061,79 +68902,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$8(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$8(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$s(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$8(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$8(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$9(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$8, getFieldType$s, selectType$8);
     }
-    function buildSelectionForNode$8(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$9(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$8(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$9(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$8(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$8(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$9(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$9, buildSelectionForField$9);
     }
     function select$h(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$8(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$9(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -71305,79 +69085,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$7(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$7(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$r(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$7(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$7(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$8(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$7, getFieldType$r, selectType$7);
     }
-    function buildSelectionForNode$7(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$8(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$7(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$8(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$7(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$7(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$8(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$8, buildSelectionForField$8);
     }
     function select$g(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$7(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$8(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -71642,79 +69361,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$6(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$6(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$q(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$6(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$6(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$7(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$6, getFieldType$q, selectType$6);
     }
-    function buildSelectionForNode$6(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$7(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$6(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$7(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$6(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$6(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$7(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$7, buildSelectionForField$7);
     }
     function select$f(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$6(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$7(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -72141,79 +69799,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$5(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$5(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$p(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$5(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$5(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$6(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$5, getFieldType$p, selectType$5);
     }
-    function buildSelectionForNode$5(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$6(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$5(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$6(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$5(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$5(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$6(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$6, buildSelectionForField$6);
     }
     function select$e(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$5(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$6(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -72379,79 +69976,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$4(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$4(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$o(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$4(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$4(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$5(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$4, getFieldType$o, selectType$4);
     }
-    function buildSelectionForNode$4(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$5(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$4(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$5(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$4(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$4(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$5(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$5, buildSelectionForField$5);
     }
     function select$d(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$4(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$5(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -72646,79 +70182,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$3(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$3(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$n(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$3(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$3(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$4(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$3, getFieldType$n, selectType$3);
     }
-    function buildSelectionForNode$3(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$4(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$3(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$4(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$3(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$3(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$4(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$4, buildSelectionForField$4);
     }
     function select$c(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$3(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$4(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -73035,79 +70510,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$2(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$2(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$m(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$2(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$2(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$3(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$2, getFieldType$m, selectType$2);
     }
-    function buildSelectionForNode$2(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$3(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$2(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$3(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$2(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$2(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$3(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$3, buildSelectionForField$3);
     }
     function select$b(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$2(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$3(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -73364,79 +70778,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$1(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData$1(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$l(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType$1(fieldType.typename, sel, fieldData[i], reader, i, arraySink);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType$1(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$2(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$1, getFieldType$l, selectType$1);
     }
-    function buildSelectionForNode$1(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$2(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$1(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$2(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode$1(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField$1(source, reader, selectionNode, variables));
-        }
-        return sink;
+    function buildSelectionForNode$2(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$2, buildSelectionForField$2);
     }
     function select$a(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$1(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$2(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -73646,79 +70999,18 @@
         }
         return sink;
     }
-    function buildSelectionForField(source, reader, sel, variables, fragments) {
-        const sink = {};
-        const fieldData = getFieldData(source, sel, variables);
-        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
-        reader.enterPath(requestedFieldName);
-        if (fieldData === undefined) {
-            reader.markMissing();
-            reader.exitPath();
-            return;
-        }
-        if (fieldData === null) {
-            reader.assignScalar(requestedFieldName, sink, fieldData);
-            return sink;
-        }
-        const fieldType = getFieldType$k(sel);
-        if (fieldType === undefined) {
-            // This field's type is unknown to us. This breaks normalization.
-            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
-            reader.assignNonScalar(sink, requestedFieldName, fieldData);
-        }
-        else if (fieldType.isArray) {
-            const arraySink = [];
-            for (let i = 0, len = fieldData.length; i < len; i += 1) {
-                reader.enterPath(i);
-                selectType(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
-                reader.exitPath();
-            }
-            reader.assignNonScalar(sink, requestedFieldName, arraySink);
-        }
-        else {
-            selectType(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
-        }
-        reader.exitPath();
-        return sink;
+    function buildSelectionForField$1(source, reader, sel, variables, fragments) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData, getFieldType$k, selectType);
     }
-    function buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments) {
-        const sink = {};
-        if (selectionNode.directives) {
-            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
-            if (selectionWithDirectives === undefined) {
-                return;
-            }
-            selectionNode = selectionWithDirectives;
-        }
-        if (selectionNode.kind === "InlineFragment") {
-            if (isFragmentApplicable$1(selectionNode, source.data.__typename)) {
-                // Get selections out of the inline fragment
-                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "FragmentSpread") {
-            const namedFragment = fragments[selectionNode.name.value];
-            if (namedFragment && isFragmentApplicable$1(namedFragment, source.data.__typename)) {
-                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
-                    // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode(source, reader, parentNode, fragmentSelection, variables, fragments));
-                });
-            }
-        }
-        if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField(source, reader, selectionNode, variables, fragments));
-        }
-        return sink;
+    function buildSelectionForNode$1(source, reader, parentNode, selectionNode, variables, fragments) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$1, buildSelectionForField$1);
     }
     function select$9(field, variables, fragments) {
         return (source, reader) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$1(source, reader, field, sel, variables, fragments);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -75491,6 +72783,93 @@
         return sharedGetFragmentType(fragment, fragmentMap);
     }
 
+    function applyToSelection$6(selection, directive, variables) {
+        return selection;
+    }
+
+    function applyToSelection$5(selection, directive, variables) {
+        return selection;
+    }
+
+    function applyToSelection$4(selection, directive, variables) {
+        return selection;
+    }
+
+    function applyToSelection$3(selection, directive, variables) {
+        var _a;
+        const ifArg = (_a = directive.arguments) === null || _a === void 0 ? void 0 : _a.find(argument => argument.name.value === "if");
+        if (ifArg && ifArg.value) {
+            if (ifArg.value.kind === "BooleanValue") {
+                return ifArg.value.value ? selection : undefined;
+            }
+            if (ifArg.value.kind === "Variable") {
+                return variables[ifArg.value.name.value] ? selection : undefined;
+            }
+        }
+        return selection;
+    }
+
+    function applyToSelection$2(selection, directive, variables) {
+        var _a;
+        const ifArg = (_a = directive.arguments) === null || _a === void 0 ? void 0 : _a.find(argument => argument.name.value === "if");
+        if (ifArg && ifArg.value) {
+            if (ifArg.value.kind === "BooleanValue") {
+                return ifArg.value.value ? undefined : selection;
+            }
+            if (ifArg.value.kind === "Variable") {
+                return variables[ifArg.value.name.value] ? undefined : selection;
+            }
+        }
+        return selection;
+    }
+
+    function applyToSelection$1(selection, directive, variables) {
+        return selection;
+    }
+
+    function applyToSelection(selection, directive, variables) {
+        return selection;
+    }
+
+    function applyDirectivesForSelection(selection, variables) {
+        let result = selection;
+        if (selection && selection.directives) {
+            // iterate through directives in order. Directives _can_ be stacked.
+            for (var i = 0; i < selection.directives.length; i++) {
+                const directive = selection.directives[i];
+                switch (directive.name.value) {
+                    // Generate Case for each directive in the schema that supports SelectionNodes
+                    case ("generic"):
+                        result = applyToSelection$6(selection);
+                        break;
+                    case ("fieldCategory"):
+                        result = applyToSelection$5(selection);
+                        break;
+                    case ("category"):
+                        result = applyToSelection$4(selection);
+                        break;
+                    case ("include"):
+                        result = applyToSelection$3(selection, directive, variables);
+                        break;
+                    case ("skip"):
+                        result = applyToSelection$2(selection, directive, variables);
+                        break;
+                    case ("deprecated"):
+                        result = applyToSelection$1(selection);
+                        break;
+                    case ("specifiedBy"):
+                        result = applyToSelection(selection);
+                        break;
+                }
+                if (result === undefined) {
+                    // Selection was removed.
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+
     function createLink(ref) {
         return {
             __ref: serializeStructuredKey(ref),
@@ -76251,6 +73630,76 @@
         const doesImplementInterface = !isUntypedInlineFragment && implementedInterfaces.includes(fragmentNode.typeCondition.name.value);
         const typenameMatchesCondition = typename !== undefined && !isUntypedInlineFragment && typename === fragmentNode.typeCondition.name.value;
         return isUntypedInlineFragment || matchesTypeCondition || doesImplementInterface || typenameMatchesCondition;
+    }
+    function buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable, buildSelectionForField) {
+        const sink = {};
+        if (selectionNode.directives) {
+            const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
+            if (selectionWithDirectives === undefined) {
+                return;
+            }
+            selectionNode = selectionWithDirectives;
+        }
+        if (selectionNode.kind === "InlineFragment") {
+            if (isFragmentApplicable(selectionNode, source.data.__typename)) {
+                // Get selections out of the inline fragment
+                selectionNode.selectionSet.selections.forEach(fragmentSelection => {
+                    // Call into field handling with selections
+                    Object.assign(sink, buildSelectionForNode(source, reader, parentNode, fragmentSelection, variables, fragments, isFragmentApplicable, buildSelectionForField));
+                });
+            }
+        }
+        if (selectionNode.kind === "FragmentSpread") {
+            const namedFragment = fragments[selectionNode.name.value];
+            if (namedFragment && isFragmentApplicable(namedFragment, source.data.__typename)) {
+                namedFragment.selectionSet.selections.forEach(fragmentSelection => {
+                    // Call into field handling with selections
+                    Object.assign(sink, buildSelectionForNode(source, reader, parentNode, fragmentSelection, variables, fragments, isFragmentApplicable, buildSelectionForField));
+                });
+            }
+        }
+        if (selectionNode.kind === "Field") {
+            Object.assign(sink, buildSelectionForField(source, reader, selectionNode, variables, fragments));
+        }
+        return sink;
+    }
+    function buildSelectionForField(source, reader, sel, variables, fragments, isCursorConnectionType, getFieldData, getFieldType, selectType) {
+        const sink = {};
+        const fieldData = getFieldData(source, sel, variables);
+        const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
+        if (isCursorConnectionType && requestedFieldName === 'pageInfo') {
+            return;
+        }
+        reader.enterPath(requestedFieldName);
+        if (fieldData === undefined) {
+            reader.markMissing();
+            reader.exitPath();
+            return;
+        }
+        if (fieldData === null) {
+            reader.assignScalar(requestedFieldName, sink, fieldData);
+            return sink;
+        }
+        const fieldType = getFieldType(sel);
+        if (fieldType === undefined) {
+            // This field's type is unknown to us. This breaks normalization.
+            console.warn(`Unknown Field: ${requestedFieldName}. This field or nested fields cannot participate in normalization`);
+            reader.assignNonScalar(sink, requestedFieldName, fieldData);
+        }
+        else if (fieldType.isArray) {
+            const arraySink = [];
+            for (let i = 0, len = fieldData.length; i < len; i += 1) {
+                reader.enterPath(i);
+                selectType(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
+                reader.exitPath();
+            }
+            reader.assignNonScalar(sink, requestedFieldName, arraySink);
+        }
+        else {
+            selectType(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
+        }
+        reader.exitPath();
+        return sink;
     }
 
     const TTL = 900000;
@@ -77571,7 +75020,7 @@
         configuration: { ...configurationForGraphQLAdapters },
         instrument,
     });
-    // version: 1.114.4-efecf667d
+    // version: 1.114.6-f2429e60e
 
     // On core the unstable adapters are re-exported with different names,
 
@@ -79700,7 +77149,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.114.4-efecf667d
+    // version: 1.114.6-f2429e60e
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -80115,7 +77564,9 @@
                 return item.id;
             });
             invokeDmlAdapter(adapter, parse$1(config), (responseValue) => {
-                if (responseValue.error === undefined && responseValue.data === undefined) {
+                if (responseValue.error === undefined &&
+                    responseValue.errors === undefined &&
+                    responseValue.data === undefined) {
                     draftManager.getQueue().then((newState) => {
                         const draftIdsToFilter = priorDraftIds ? priorDraftIds : [];
                         const newDrafts = newState.items;
@@ -80125,9 +77576,9 @@
                             return isNew && targetIdMatches;
                         });
                         if (addedDrafts.length !== 1) {
-                            let response = responseValue;
-                            response.error =
-                                createNativeFetchErrorResponse(NO_DRAFT_CREATED_MESSAGE);
+                            let response = {
+                                error: createNativeFetchErrorResponse(NO_DRAFT_CREATED_MESSAGE),
+                            };
                             onResponse(response);
                         }
                         else {
@@ -80159,7 +77610,9 @@
                 return item.id;
             });
             invokeDmlAdapter(adapter, parse$1(config), (responseValue) => {
-                if (responseValue.error === undefined && responseValue.data === undefined) {
+                if (responseValue.error === undefined &&
+                    responseValue.errors === undefined &&
+                    responseValue.data === undefined) {
                     draftManager.getQueue().then((newState) => {
                         const draftIdsToFilter = priorDraftIds ? priorDraftIds : [];
                         const newDrafts = newState.items;
@@ -80169,9 +77622,9 @@
                             return isNew && targetIdMatches;
                         });
                         if (addedDrafts.length !== 1) {
-                            let response = responseValue;
-                            response.error =
-                                createNativeFetchErrorResponse(NO_DRAFT_CREATED_MESSAGE);
+                            let response = {
+                                error: createNativeFetchErrorResponse(NO_DRAFT_CREATED_MESSAGE),
+                            };
                             onResponse(response);
                         }
                         else {
@@ -80395,4 +77848,4 @@
     Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-// version: 1.114.4-844684b4c
+// version: 1.114.6-435b32f3e