local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = {};
local v3 = require(l_Parent_1.LuauPolyfill);
local l_Boolean_0 = v3.Boolean;
local l_Object_0 = v3.Object;
local l_Set_0 = v3.Set;
local l_setTimeout_0 = v3.setTimeout;
local l_clearTimeout_0 = v3.clearTimeout;
local v9 = require(l_Parent_0.luaUtils.isCallable);
local v10 = require(l_Parent_1.Promise);
local l_invariant_0 = require(l_Parent_0.jsutils.invariant).invariant;
local v12 = require(l_Parent_0.jsutils.equal);
local v13 = require(script.Parent.networkStatus);
local l_NetworkStatus_0 = v13.NetworkStatus;
local l_isNetworkRequestInFlight_0 = v13.isNetworkRequestInFlight;
local v16 = require(script.Parent.Parent.utilities);
local l_compact_0 = v16.compact;
local l_cloneDeep_0 = v16.cloneDeep;
local l_getOperationDefinition_0 = v16.getOperationDefinition;
local l_Observable_0 = v16.Observable;
local l_iterateObserversSafely_0 = v16.iterateObserversSafely;
local l_isNonEmptyArray_0 = v16.isNonEmptyArray;
local l_fixObservableSubclass_0 = v16.fixObservableSubclass;
local l_ApolloError_0 = require(script.Parent.Parent.errors).ApolloError;
local _ = require(script.Parent.types);
local _ = require(script.Parent.watchQueryOptions_types);
local _ = require(script.Parent.QueryInfo);
local _ = require(script.Parent.ObservableQuery_types);
local v29 = nil;
local v30 = false;
local v31 = setmetatable({}, {
    __index = l_Observable_0
});
v31.__index = function(v32, v33)
    if v33 == "variables" then
        return v32.options.variables;
    elseif not rawget(v32, v33) then
        if not rawget(v31, v33) then
            return getmetatable(v31).__index[v33];
        else
            return (rawget(v31, v33));
        end;
    else
        return (rawget(v32, v33));
    end;
end;
v31.__newindex = function(v34, v35, v36)
    if v35 == "variables" then
        error("setting getter-only property 'variables'");
    end;
    rawset(v34, v35, v36);
end;
v31.new = function(v37)
    local l_queryManager_0 = v37.queryManager;
    local l_queryInfo_0 = v37.queryInfo;
    local l_options_0 = v37.options;
    local v41 = nil;
    v41 = setmetatable(l_Observable_0.new(function(v42)
        xpcall(function()
            local l__observer_0 = v42._subscription._observer;
            if not (not l_Boolean_0.toJSBoolean(l__observer_0) or l_Boolean_0.toJSBoolean(l__observer_0.error)) then
                l__observer_0.error = v29;
            end;
        end, function()
        end);
        local v44 = not l_Boolean_0.toJSBoolean(v41.observers.size);
        v41.observers:add(v42);
        if not l_Boolean_0.toJSBoolean(v41.lastError) then
            if not (not l_Boolean_0.toJSBoolean(v41.lastResult) or not l_Boolean_0.toJSBoolean(v42.next)) then
                v42:next(v41.lastResult);
            end;
        elseif l_Boolean_0.toJSBoolean(v42.error) then
            v42:error(v41.lastError);
        end;
        if v44 then
            v41:reobserve():catch(function()
            end);
        end;
        return function()
            if not (not v41.observers:delete(v42) or l_Boolean_0.toJSBoolean(v41.observers.size)) then
                v41:tearDownQuery();
            end;
        end;
    end), v31);
    v41.observers = l_Set_0.new();
    v41.subscriptions = l_Set_0.new();
    v41.observer = {
        next = function(_, v46)
            if not (not l_Boolean_0.toJSBoolean(v41.lastError) and not v41:isDifferentFromLastResult(v46)) then
                v41:updateLastResult(v46);
                l_iterateObserversSafely_0(v41.observers, "next", v46);
            end;
        end,
        error = function(_, v48)
            v41:updateLastResult((l_Object_0.assign({}, v41.lastResult, {
                error = v48,
                errors = v48.graphQLErrors,
                networkStatus = l_NetworkStatus_0.error,
                loading = false
            })));
            v41.lastError = v48;
            l_iterateObserversSafely_0(v41.observers, "error", v41.lastError);
        end
    };
    v41.isTornDown = false;
    v41.options = l_options_0;
    v41.queryId = l_queryManager_0:generateQueryId();
    local v49 = l_getOperationDefinition_0(l_options_0.query);
    if l_Boolean_0.toJSBoolean(v49) then
        if l_Boolean_0.toJSBoolean(v49.name) then
            v41.queryName = v49.name.value;
        else
            v41.queryName = v49.name;
        end;
    else
        v41.queryName = v49;
    end;
    v41.initialFetchPolicy = not not l_Boolean_0.toJSBoolean(l_options_0.fetchPolicy) and l_options_0.fetchPolicy or "cache-first";
    v41.queryManager = l_queryManager_0;
    v41.queryInfo = l_queryInfo_0;
    return v41;
end;
v31.result = function(v50)
    return v10.new(function(v51, v52)
        local v53 = nil;
        local v54 = nil;
        v54 = {
            next = function(_, v56)
                v51(v56);
                v50.observers:delete(v54);
                if not l_Boolean_0.toJSBoolean(v50.observers.size) then
                    v50.queryManager:removeQuery(v50.queryId);
                end;
                l_setTimeout_0(function()
                    v53:unsubscribe();
                end, 0);
            end,
            error = function(_, v58)
                v52(v58);
            end
        };
        v53 = v50:subscribe(v54);
    end);
end;
v31.getCurrentResult = function(v59, v60)
    if v60 == nil then
        v60 = true;
    end;
    local l_lastResult_0 = v59.lastResult;
    local v62 = nil;
    v62 = v59.options.fetchPolicy == nil and "cache-first" or v59.options.fetchPolicy;
    local v63 = nil;
    v63 = if not l_Boolean_0.toJSBoolean(v59.queryInfo.networkStatus) then if l_Boolean_0.toJSBoolean(l_lastResult_0) and l_Boolean_0.toJSBoolean(l_lastResult_0.networkStatus) then l_lastResult_0.networkStatus else l_NetworkStatus_0.ready else v59.queryInfo.networkStatus;
    local v64 = l_Object_0.assign({}, l_lastResult_0, {
        loading = l_isNetworkRequestInFlight_0(v63),
        networkStatus = v63
    });
    if not v59.queryManager:transform(v59.options.query).hasForcedResolvers then
        local v65 = v59.queryInfo:getDiff();
        if not l_Boolean_0.toJSBoolean(v65.complete) and not l_Boolean_0.toJSBoolean(v59.options.returnPartialData) then
            v64.data = nil;
        else
            v64.data = v65.result;
        end;
        if not l_Boolean_0.toJSBoolean(v65.complete) then
            if v62 ~= "no-cache" then
                v64.partial = true;
            end;
        else
            if v64.networkStatus == l_NetworkStatus_0.loading and (not (v62 ~= "cache-first") or v62 == "cache-only") then
                v64.networkStatus = l_NetworkStatus_0.ready;
                v64.loading = false;
            end;
            v64.partial = nil;
        end;
        if not ((((l_Boolean_0.toJSBoolean(v65.complete) or l_Boolean_0.toJSBoolean(v59.options.partialRefetch)) or l_Boolean_0.toJSBoolean(v64.loading)) or l_Boolean_0.toJSBoolean(v64.data)) or l_Boolean_0.toJSBoolean(v64.error)) then
            v64.error = l_ApolloError_0.new({
                clientErrors = v65.missing
            });
        end;
    end;
    if v60 then
        v59:updateLastResult(v64);
    end;
    return v64;
end;
v31.isDifferentFromLastResult = function(v66, v67)
    return not v12(v66.lastResultSnapshot, v67);
end;
v31.getLastResult = function(v68)
    return v68.lastResult;
end;
v31.getLastError = function(v69)
    return v69.lastError;
end;
v31.resetLastResults = function(v70)
    v70.lastResult = nil;
    v70.lastResultSnapshot = nil;
    v70.lastError = nil;
    v70.isTornDown = false;
end;
v31.resetQueryStoreErrors = function(v71)
    v71.queryManager:resetErrors(v71.queryId);
end;
v31.refetch = function(v72, v73)
    local v74 = {
        pollInterval = 0
    };
    local l_fetchPolicy_0 = v72.options.fetchPolicy;
    if l_fetchPolicy_0 == "no-cache" then
        v74.fetchPolicy = "no-cache";
    elseif l_fetchPolicy_0 ~= "cache-and-network" then
        v74.fetchPolicy = "network-only";
    end;
    if not (not l_Boolean_0.toJSBoolean(v73) or v12(v72.options.variables, v73)) then
        v72.options.variables = l_Object_0.assign({}, v72.options.variables, v73);
        v74.variables = v72.options.variables;
    end;
    v72.queryInfo:resetLastWrite();
    return v72:reobserve(v74, l_NetworkStatus_0.refetch);
end;
v31.fetchMore = function(v76, v77)
    local v78 = l_Object_0.assign({}, (function()
        if not l_Boolean_0.toJSBoolean(v77.query) then
            return l_Object_0.assign({}, v76.options, v77, {
                variables = l_Object_0.assign({}, v76.options.variables, v77.variables)
            });
        else
            return v77;
        end;
    end)(), {
        fetchPolicy = "no-cache"
    });
    local v79 = v76.queryManager:generateQueryId();
    if l_Boolean_0.toJSBoolean(v78.notifyOnNetworkStatusChange) then
        v76.queryInfo.networkStatus = l_NetworkStatus_0.fetchMore;
        v76:observe();
    end;
    return v76.queryManager:fetchQuery(v79, v78, l_NetworkStatus_0.fetchMore):andThen(function(v80)
        local l_data_0 = v80.data;
        local l_updateQuery_0 = v77.updateQuery;
        if not l_Boolean_0.toJSBoolean(l_updateQuery_0) then
            v76.queryManager.cache:writeQuery({
                query = v78.query,
                variables = v78.variables,
                data = l_data_0
            });
            return v80;
        else
            if not (not _G.__DEV__ or v30 and _G.__WARNED_ABOUT_OBSERVABLE_QUERY_UPDATE_QUERY__) then
                l_invariant_0.warn("The updateQuery callback for fetchMore is deprecated, and will be removed\nin the next major version of Apollo Client.\n\nPlease convert updateQuery functions to field policies with appropriate\nread and merge functions, or use/adapt a helper function (such as\nconcatPagination, offsetLimitPagination, or relayStylePagination) from\n@apollo/client/utilities.\n\nThe field policy system handles pagination more effectively than a\nhand-written updateQuery function, and you only need to define the policy\nonce, rather than every time you call fetchMore.");
                v30 = true;
                _G.__WARNED_ABOUT_OBSERVABLE_QUERY_UPDATE_QUERY__ = v30;
            end;
            v76:updateQuery(function(v83)
                return l_updateQuery_0(v77, v83, {
                    fetchMoreResult = l_data_0,
                    variables = v78.variables
                });
            end);
            return v80;
        end;
    end):andThen(function(v84)
        v76.queryManager:stopQuery(v79);
        v76:reobserve();
        return v84;
    end):catch(function(v85)
        v76.queryManager:stopQuery(v79);
        v76:reobserve();
        error(v85);
    end);
end;
v31.subscribeToMore = function(v86, v87)
    local v95 = v86.queryManager:startGraphQLSubscription({
        query = v87.document,
        variables = v87.variables,
        context = v87.context
    }):subscribe({
        next = function(_, v89)
            local l_updateQuery_1 = v87.updateQuery;
            if l_Boolean_0.toJSBoolean(l_updateQuery_1) then
                v86:updateQuery(function(v91, v92)
                    return l_updateQuery_1(v91, {
                        subscriptionData = v89,
                        variables = v92.variables
                    });
                end);
            end;
        end,
        error = function(_, v94)
            if not l_Boolean_0.toJSBoolean(v87.onError) then
                l_invariant_0.error("Unhandled GraphQL subscription error", v94);
                return ;
            else
                v87:onError(v94);
                return ;
            end;
        end
    });
    v86.subscriptions:add(v95);
    return function()
        if l_Boolean_0.toJSBoolean(v86.subscriptions:delete(v95)) then
            v95:unsubscribe();
        end;
    end;
end;
v31.setOptions = function(v96, v97)
    return v96:reobserve(v97);
end;
v31.setVariables = function(v98, v99)
    if not v12(v98.variables, v99) then
        v98.options.variables = v99;
        if l_Boolean_0.toJSBoolean(v98.observers.size) then
            return v98:reobserve({
                fetchPolicy = v98.initialFetchPolicy,
                variables = v99
            }, l_NetworkStatus_0.setVariables);
        else
            return v10.resolve();
        end;
    elseif not l_Boolean_0.toJSBoolean(v98.observers.size) then
        return v10.resolve();
    else
        return v98:result();
    end;
end;
v31.updateQuery = function(v100, v101)
    local l_queryManager_1 = v100.queryManager;
    local _ = nil;
    local v104 = v101(l_queryManager_1.cache:diff({
        query = v100.options.query,
        variables = v100.variables,
        previousResult = not not l_Boolean_0.toJSBoolean(v100.lastResult) and v100.lastResult.data or nil,
        returnPartialData = true,
        optimistic = false
    }).result, {
        variables = v100.variables
    });
    if l_Boolean_0.toJSBoolean(v104) then
        l_queryManager_1.cache:writeQuery({
            query = v100.options.query,
            data = v104,
            variables = v100.variables
        });
        l_queryManager_1:broadcastQueries();
    end;
end;
v31.startPolling = function(v105, v106)
    v105.options.pollInterval = v106;
    v105:updatePolling();
end;
v31.stopPolling = function(v107)
    v107.options.pollInterval = 0;
    v107:updatePolling();
end;
v31.fetch = function(v108, v109, v110)
    v108.queryManager:setObservableQuery(v108);
    return v108.queryManager:fetchQueryObservable(v108.queryId, v109, v110);
end;
v31.updatePolling = function(v111)
    local v112 = nil;
    if not l_Boolean_0.toJSBoolean(v111.queryManager.ssrMode) then
        local l_pollingInfo_0 = v111.pollingInfo;
        local l_pollInterval_0 = v111.options.pollInterval;
        if l_Boolean_0.toJSBoolean(l_pollInterval_0) then
            if l_Boolean_0.toJSBoolean(l_pollingInfo_0) and l_pollingInfo_0.interval == l_pollInterval_0 then
                return ;
            else
                l_invariant_0(l_pollInterval_0, "Attempted to start a polling query without a polling interval.");
                local v115;
                if l_Boolean_0.toJSBoolean(l_pollingInfo_0) then
                    v115 = l_pollingInfo_0;
                    if v115 then
                        goto label0;
                    end;
                end;
                v111.pollingInfo = {};
                v115 = v111.pollingInfo;
                ::label0::;
                v115.interval = l_pollInterval_0;
                local function v116()
                    if l_Boolean_0.toJSBoolean(v111.pollingInfo) then
                        if l_isNetworkRequestInFlight_0(v111.queryInfo.networkStatus) then
                            v112();
                        else
                            v111:reobserve({
                                fetchPolicy = "network-only"
                            }, l_NetworkStatus_0.poll):andThen(v112, v112);
                            return ;
                        end;
                    end;
                end;
                v112 = function()
                    local l_pollingInfo_1 = v111.pollingInfo;
                    if l_Boolean_0.toJSBoolean(l_pollingInfo_1) then
                        if l_pollingInfo_1.timeout then
                            l_clearTimeout_0(l_pollingInfo_1.timeout);
                        end;
                        l_pollingInfo_1.timeout = l_setTimeout_0(v116, l_pollingInfo_1.interval);
                    end;
                end;
                v112();
                return ;
            end;
        else
            if l_Boolean_0.toJSBoolean(l_pollingInfo_0) then
                l_clearTimeout_0(l_pollingInfo_0.timeout);
                v111.pollingInfo = nil;
            end;
            return ;
        end;
    else
        return ;
    end;
end;
v31.updateLastResult = function(v118, v119)
    local l_lastResult_1 = v118.lastResult;
    v118.lastResult = v119;
    if not l_Boolean_0.toJSBoolean(v118.queryManager.assumeImmutableResults) then
        v118.lastResultSnapshot = l_cloneDeep_0(v119);
    else
        v118.lastResultSnapshot = v119;
    end;
    if not l_isNonEmptyArray_0(v119.errors) then
        v118.lastError = nil;
    end;
    return l_lastResult_1;
end;
v31.reobserve = function(v121, v122, v123)
    v121.isTornDown = false;
    local v124 = true;
    if v123 ~= l_NetworkStatus_0.refetch then
        v124 = true;
        if v123 ~= l_NetworkStatus_0.fetchMore then
            v124 = v123 == l_NetworkStatus_0.poll;
        end;
    end;
    local l_variables_0 = v121.options.variables;
    local v126 = if not v124 then l_Object_0.assign(v121.options, l_compact_0(v122)) else l_compact_0(v121.options, v122);
    if not v124 then
        v121:updatePolling();
        if not (((not (v122 ~= nil) or not l_Boolean_0.toJSBoolean(v122.variables)) or l_Boolean_0.toJSBoolean(v122.fetchPolicy)) or v12(v122.variables, l_variables_0)) then
            v126.fetchPolicy = v121.initialFetchPolicy;
            if v123 == nil then
                v123 = l_NetworkStatus_0.setVariables;
            end;
        end;
    end;
    local v127 = v121:fetch(v126, v123);
    if not v124 then
        if v121.concast then
            v121.concast:removeObserver(v121.observer, true);
        end;
        v121.concast = v127;
    end;
    v127:addObserver(v121.observer);
    return v127.promise;
end;
v31.observe = function(v128)
    v128.observer:next(v128:getCurrentResult(false));
end;
v31.hasObservers = function(v129)
    return v129.observers.size > 0;
end;
v31.tearDownQuery = function(v130)
    if not l_Boolean_0.toJSBoolean(v130.isTornDown) then
        if l_Boolean_0.toJSBoolean(v130.concast) then
            v130.concast:removeObserver(v130.observer);
            v130.concast = nil;
        end;
        v130:stopPolling();
        v130.subscriptions:forEach(function(v131)
            return v131:unsubscribe();
        end);
        v130.subscriptions:clear();
        v130.queryManager:stopQuery(v130.queryId);
        v130.observers:clear();
        v130.isTornDown = true;
        return ;
    else
        return ;
    end;
end;
l_fixObservableSubclass_0(v31);
v2.ObservableQuery = v31;
v29 = function(_, v133)
    l_invariant_0.error("Unhandled error", v133.message, v133.stack);
end;
v2.applyNextFetchPolicy = function(v134)
    local v135 = nil;
    v135 = v134.fetchPolicy == nil and "cache-first" or v134.fetchPolicy;
    local l_nextFetchPolicy_0 = v134.nextFetchPolicy;
    if l_Boolean_0.toJSBoolean(l_nextFetchPolicy_0) then
        if not v9(l_nextFetchPolicy_0) then
            v134.fetchPolicy = l_nextFetchPolicy_0;
        else
            v134.fetchPolicy = l_nextFetchPolicy_0(v134, v135);
            return ;
        end;
    end;
end;
return v2;


local l_Parent_0 = script.Parent.Parent.Parent;
local _ = require(l_Parent_0.LuauPolyfill);
local _ = require(l_Parent_0.GraphQL);
local _ = require(script.Parent.networkStatus);
local _ = require(script.Parent.Parent.utilities);
local _ = require(script.Parent.Parent.errors);
local _ = require(script.Parent.watchQueryOptions_types);
return {};


local v0 = {};
local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v3 = require(l_Parent_1.LuauPolyfill);
local l_Boolean_0 = v3.Boolean;
local l_clearTimeout_0 = v3.clearTimeout;
local l_Map_0 = v3.Map;
local l_Object_0 = v3.Object;
local l_Set_0 = v3.Set;
local l_setTimeout_0 = v3.setTimeout;
local l_WeakMap_0 = v3.WeakMap;
local _ = require(l_Parent_1.GraphQL);
local v12 = require(l_Parent_0.jsutils.equal);
local _ = require(l_Parent_0.cache);
local _ = require(script.Parent.watchQueryOptions_types);
local _ = require(script.Parent.ObservableQuery_types);
local _ = require(script.Parent.Parent.link.core);
local v17 = require(script.Parent.Parent.utilities);
local l_isNonEmptyArray_0 = v17.isNonEmptyArray;
local l_graphQLResultHasError_0 = v17.graphQLResultHasError;
local l_canUseWeakMap_0 = v17.canUseWeakMap;
local v21 = require(script.Parent.networkStatus);
local l_NetworkStatus_0 = v21.NetworkStatus;
local l_isNetworkRequestInFlight_0 = v21.isNetworkRequestInFlight;
local _ = require(script.Parent.Parent.errors);
local v25 = {
    FORBID = 0,
    OVERWRITE = 1,
    MERGE = 2
};
v0.CacheWriteBehavior = v25;
local v26 = if not l_canUseWeakMap_0 then l_Map_0.new(nil) else l_WeakMap_0.new();
local function _(v27, v28)
    local v29 = v27[v28];
    if typeof(v29) == "function" then
        v27[v28] = function(...)
            v26:set(v27, (v26:get(v27) + 1) % 1000000000000000);
            return v29(...);
        end;
    end;
end;
local function _(v31)
    if l_Boolean_0.toJSBoolean(v31.notifyTimeout) then
        l_clearTimeout_0(v31.notifyTimeout);
        v31.notifyTimeout = nil;
    end;
end;
local v33 = {};
v33.__index = v33;
v33.new = function(v34)
    local v35 = {
        listeners = l_Set_0.new(),
        document = nil,
        lastRequestId = 1,
        subscriptions = l_Set_0.new(),
        stopped = false,
        cache = v34,
        dirty = false,
        observableQuery = nil
    };
    if not v26:has(v34) then
        v26:set(v34, 0);
        local l_evict_0 = v34.evict;
        if typeof(l_evict_0) == "function" then
            local l_l_evict_0_0 = l_evict_0 --[[ copy: 2 -> 4 ]];
            v34.evict = function(...)
                v26:set(v34, (v26:get(v34) + 1) % 1000000000000000);
                return l_l_evict_0_0(...);
            end;
        end;
        l_evict_0 = v34.modify;
        if typeof(l_evict_0) == "function" then
            local l_l_evict_0_1 = l_evict_0 --[[ copy: 2 -> 3 ]];
            v34.modify = function(...)
                v26:set(v34, (v26:get(v34) + 1) % 1000000000000000);
                return l_l_evict_0_1(...);
            end;
        end;
        l_evict_0 = v34.reset;
        if typeof(l_evict_0) == "function" then
            v34.reset = function(...)
                v26:set(v34, (v26:get(v34) + 1) % 1000000000000000);
                return l_evict_0(...);
            end;
        end;
    end;
    return (setmetatable(v35, v33));
end;
v33.init = function(v39, v40)
    local v41 = not not l_Boolean_0.toJSBoolean(v40.networkStatus) and v40.networkStatus or l_NetworkStatus_0.loading;
    if not (not (l_Boolean_0.toJSBoolean(v39.variables) and v39.networkStatus ~= l_NetworkStatus_0.loading) or v12(v39.variables, v40.variables)) then
        v41 = l_NetworkStatus_0.setVariables;
    end;
    if not v12(v40.variables, v39.variables) then
        v39.lastDiff = nil;
    end;
    l_Object_0.assign(v39, {
        document = v40.document,
        variables = v40.variables,
        networkError = l_Object_0.None,
        graphQLErrors = not not l_Boolean_0.toJSBoolean(v39.graphQLErrors) and v39.graphQLErrors or {},
        networkStatus = v41
    });
    if l_Boolean_0.toJSBoolean(v40.observableQuery) then
        v39:setObservableQuery(v40.observableQuery);
    end;
    if l_Boolean_0.toJSBoolean(v40.lastRequestId) then
        v39.lastRequestId = v40.lastRequestId;
    end;
    return v39;
end;
v33.reset = function(v42)
    if l_Boolean_0.toJSBoolean(v42.notifyTimeout) then
        l_clearTimeout_0(v42.notifyTimeout);
        v42.notifyTimeout = nil;
    end;
    v42.lastDiff = nil;
    v42.dirty = false;
end;
v33.getDiff = function(v43, v44)
    if v44 == nil then
        v44 = v43.variables;
    end;
    local v45 = v43:getDiffOptions(v44);
    if not l_Boolean_0.toJSBoolean(v43.lastDiff) or not v12(v45, v43.lastDiff.options) then
        v43.variables = v44;
        v43:updateWatch(v43.variables);
        local l_observableQuery_0 = v43.observableQuery;
        if l_Boolean_0.toJSBoolean(l_observableQuery_0) and l_observableQuery_0.options.fetchPolicy == "no-cache" then
            return {
                complete = false
            };
        else
            local v47 = v43.cache:diff(v45);
            v43:updateLastDiff(v47, v45);
            return v47;
        end;
    else
        return v43.lastDiff.diff;
    end;
end;
v33.updateLastDiff = function(v48, v49, v50)
    v48.lastDiff = not not l_Boolean_0.toJSBoolean(v49) and {
        diff = v49,
        options = not not l_Boolean_0.toJSBoolean(v50) and v50 or v48:getDiffOptions()
    } or nil;
end;
v33.getDiffOptions = function(v51, v52)
    if v52 == nil then
        v52 = v51.variables;
    end;
    local l_observableQuery_1 = v51.observableQuery;
    return {
        query = v51.document,
        variables = v52,
        returnPartialData = true,
        optimistic = true,
        canonizeResults = not l_Boolean_0.toJSBoolean(l_observableQuery_1) or l_observableQuery_1.options.canonizeResults ~= false
    };
end;
v33.setDiff = function(v54, v55)
    local v56 = nil;
    v56 = if not l_Boolean_0.toJSBoolean(v54.lastDiff) then v54.lastDiff else v54.lastDiff.diff;
    v54:updateLastDiff(v55);
    local v57 = nil;
    local v58 = nil;
    v57 = if not l_Boolean_0.toJSBoolean(v56) then v56 else v56.result;
    v58 = if not l_Boolean_0.toJSBoolean(v55) then v55 else v55.result;
    if not (v54.dirty or v12(v57, v58)) then
        v54.dirty = true;
        if not l_Boolean_0.toJSBoolean(v54.notifyTimeout) then
            v54.notifyTimeout = l_setTimeout_0(function()
                return v54:notify();
            end, 0);
        end;
    end;
end;
v33.setObservableQuery = function(v59, v60)
    if v60 == v59.observableQuery then
        return ;
    else
        if l_Boolean_0.toJSBoolean(v59.oqListener) then
            v59.listeners:delete(v59.oqListener);
        end;
        v59.observableQuery = v60;
        if l_Boolean_0.toJSBoolean(v60) and v60 ~= nil then
            v60.queryInfo = v59;
            v59.oqListener = function()
                if not l_Boolean_0.toJSBoolean(v59:getDiff().fromOptimisticTransaction) then
                    v60:reobserve();
                    return ;
                else
                    v60.observe(v60);
                    return ;
                end;
            end;
            v59.listeners:add(v59.oqListener);
            return ;
        else
            v59.oqListener = nil;
            return ;
        end;
    end;
end;
v33.notify = function(v61)
    if l_Boolean_0.toJSBoolean(v61.notifyTimeout) then
        l_clearTimeout_0(v61.notifyTimeout);
        v61.notifyTimeout = nil;
    end;
    if v61:shouldNotify() then
        v61.listeners:forEach(function(v62)
            return v62(v61);
        end);
    end;
    v61.dirty = false;
end;
v33.shouldNotify = function(v63)
    if v63.dirty and l_Boolean_0.toJSBoolean(v63.listeners.size) then
        if not (not l_isNetworkRequestInFlight_0(v63.networkStatus) or not l_Boolean_0.toJSBoolean(v63.observableQuery)) then
            local l_fetchPolicy_0 = v63.observableQuery.options.fetchPolicy;
            if l_fetchPolicy_0 ~= "cache-only" and l_fetchPolicy_0 ~= "cache-and-network" then
                return false;
            end;
        end;
        return true;
    else
        return false;
    end;
end;
v33.stop = function(v65)
    if not v65.stopped then
        v65.stopped = true;
        v65:reset();
        v65:cancel();
        v65.cancel = v33.cancel;
        v65.subscriptions:forEach(function(v66)
            return v66:unsubscribe();
        end);
        local l_observableQuery_2 = v65.observableQuery;
        if l_Boolean_0.toJSBoolean(l_observableQuery_2) then
            l_observableQuery_2:stopPolling();
        end;
    end;
end;
v33.cancel = function(_)
end;
v33.updateWatch = function(v69, v70)
    if v70 == nil then
        v70 = v69.variables;
    end;
    local l_observableQuery_3 = v69.observableQuery;
    if l_Boolean_0.toJSBoolean(l_observableQuery_3) and l_observableQuery_3.options.fetchPolicy == "no-cache" then
        return ;
    else
        local v74 = l_Object_0.assign({}, v69:getDiffOptions(v70), {
            watcher = v69,
            callback = function(_, v73)
                return v69:setDiff(v73);
            end
        });
        local v75 = l_Object_0.assign({}, v74, {
            callback = l_Object_0.None
        });
        local v76 = l_Object_0.assign({}, v69.lastWatch, {
            callback = l_Object_0.None
        });
        if not (l_Boolean_0.toJSBoolean(v69.lastWatch) and v12(v75, v76)) then
            v69:cancel();
            v69.lastWatch = v74;
            v69.cancel = v69.cache:watch(v69.lastWatch);
        end;
        return ;
    end;
end;
v33.resetLastWrite = function(v77)
    v77.lastWrite = nil;
end;
v33.shouldWrite = function(v78, v79, v80)
    local l_lastWrite_0 = v78.lastWrite;
    local v82 = l_Boolean_0.toJSBoolean(l_lastWrite_0);
    if v82 then
        v82 = false;
        if l_lastWrite_0.dmCount == v26:get(v78.cache) then
            v82 = v12(v80, l_lastWrite_0.variables) and v12(v79.data, l_lastWrite_0.result.data);
        end;
    end;
    return not v82;
end;
local v83 = nil;
v33.markResult = function(v84, v85, v86, v87)
    if not l_isNonEmptyArray_0(v85.errors) then
        v84.graphQLErrors = {};
    else
        v84.graphQLErrors = v85.errors;
    end;
    v84:reset();
    if v86.fetchPolicy == "no-cache" then
        v84:updateLastDiff({
            result = v85.data,
            complete = true
        }, v84:getDiffOptions(v86.variables));
        return ;
    else
        if v87 ~= v25.FORBID then
            if not v83(v85, v86.errorPolicy) then
                v84.lastWrite = nil;
            else
                v84.cache:performTransaction(function(v88)
                    if not v84:shouldWrite(v85, v86.variables) then
                        if not (not l_Boolean_0.toJSBoolean(v84.lastDiff) or not l_Boolean_0.toJSBoolean(v84.lastDiff.diff.complete)) then
                            v85.data = v84.lastDiff.diff.result;
                            return ;
                        end;
                    else
                        v88:writeQuery({
                            query = v84.document,
                            data = v85.data,
                            variables = v86.variables,
                            overwrite = v87 == v25.OVERWRITE
                        });
                        v84.lastWrite = {
                            result = v85,
                            variables = v86.variables,
                            dmCount = v26:get(v84.cache)
                        };
                    end;
                    local v89 = v84:getDiffOptions(v86.variables);
                    local v90 = v88:diff(v89);
                    if not v84.stopped then
                        v84:updateWatch(v86.variables);
                    end;
                    v84:updateLastDiff(v90, v89);
                    if l_Boolean_0.toJSBoolean(v90.complete) then
                        v85.data = v90.result;
                    end;
                end);
                return ;
            end;
        end;
        return ;
    end;
end;
v33.markReady = function(v91)
    v91.networkError = nil;
    v91.networkStatus = l_NetworkStatus_0.ready;
    return v91.networkStatus;
end;
v33.markError = function(v92, v93)
    v92.networkStatus = l_NetworkStatus_0.error;
    v92.lastWrite = nil;
    v92:reset();
    if l_Boolean_0.toJSBoolean(v93.graphQLErrors) then
        v92.graphQLErrors = v93.graphQLErrors;
    end;
    if l_Boolean_0.toJSBoolean(v93.networkError) then
        v92.networkError = v93.networkError;
    end;
    return v93;
end;
v0.QueryInfo = v33;
v83 = function(v94, v95)
    if v95 == nil then
        v95 = "none";
    end;
    local v96 = true;
    if v95 ~= "ignore" then
        v96 = v95 == "all";
    end;
    return not l_graphQLResultHasError_0(v94) or (v96 and l_Boolean_0.toJSBoolean(v94.data)) and true;
end;
v0.shouldWriteResult = v83;
return v0;


local v0 = {};
local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_Object_0 = require(l_Parent_1.LuauPolyfill).Object;
local l_DEV_0 = require(l_Parent_0.utilities).DEV;
local v5 = require(script.ApolloClient);
v0.ApolloClient = v5.ApolloClient;
v0.mergeOptions = v5.mergeOptions;
local v6 = require(script.ObservableQuery);
v0.applyNextFetchPolicy = v6.applyNextFetchPolicy;
v0.ObservableQuery = v6.ObservableQuery;
local _ = require(script.watchQueryOptions);
v0.NetworkStatus = require(script.networkStatus).NetworkStatus;
l_Object_0.assign(v0, (require(script.types)));
local _ = require(script.LocalState);
local v9 = require(script.Parent.errors);
v0.isApolloError = v9.isApolloError;
v0.ApolloError = v9.ApolloError;
local v10 = require(script.Parent.cache);
v0.ApolloCache = v10.ApolloCache;
v0.defaultDataIdFromObject = v10.defaultDataIdFromObject;
v0.InMemoryCache = v10.InMemoryCache;
v0.MissingFieldError = v10.MissingFieldError;
v0.makeVar = v10.makeVar;
v0.None = v10.None;
l_Object_0.assign(v0, (require(script.Parent.cache.inmemory.types)));
l_Object_0.assign(v0, (require(script.Parent.link.core)));
l_Object_0.assign(v0, (require(script.Parent.link.http)));
local v11 = require(script.Parent.link.utils);
v0.fromError = v11.fromError;
v0.toPromise = v11.toPromise;
v0.fromPromise = v11.fromPromise;
v0.throwServerError = v11.throwServerError;
local v12 = require(script.Parent.utilities);
v0.Observable = v12.Observable;
v0.isReference = v12.isReference;
v0.makeReference = v12.makeReference;
v0.NULL = v12.NULL;
local l_setVerbosity_0 = require(l_Parent_0.jsutils.invariant).setVerbosity;
v0.setLogVerbosity = l_setVerbosity_0;
l_setVerbosity_0(not l_DEV_0 and "silent" or "log");
local v14 = require(l_Parent_1.GraphQLTag);
v0.gql = v14.default;
v0.resetCaches = v14.resetCaches;
v0.disableFragmentWarnings = v14.disableFragmentWarnings;
v0.enableExperimentalFragmentVariables = v14.enableExperimentalFragmentVariables;
v0.disableExperimentalFragmentVariables = v14.disableExperimentalFragmentVariables;
return v0;


return {
    NetworkStatus = {
        loading = 1,
        setVariables = 2,
        fetchMore = 3,
        refetch = 4,
        poll = 6,
        ready = 7,
        error = 8
    },
    isNetworkRequestInFlight = function(v0)
        if not v0 then
            return false;
        else
            return v0 < 7;
        end;
    end
};


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local _ = require(l_Parent_1.LuauPolyfill);
local _ = require(l_Parent_1.GraphQL);
local _ = require(script.Parent.Parent.cache);
local _ = require(script.Parent.QueryInfo);
local _ = require(script.Parent.networkStatus);
local _ = require(script.Parent.ObservableQuery_types);
local _ = require(script.Parent.watchQueryOptions_types);
local _ = require(script.Parent.Parent.cache);
local _ = require(l_Parent_0.jsutils.typedDocumentNode);
return {};


local v0 = {};
local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local _ = require(l_Parent_1.LuauPolyfill);
local _ = require(l_Parent_1.GraphQL);
local _ = require(script.Parent.watchQueryOptions_types);
local _ = require(l_Parent_0.jsutils.typedDocumentNode);
local _ = require(script.Parent.types);
return v0;


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local _ = require(l_Parent_1.LuauPolyfill);
local _ = require(l_Parent_1.GraphQL);
local _ = require(script.Parent.Parent.cache);
local _ = require(script.Parent.Parent.link.core);
local _ = require(l_Parent_0.jsutils.typedDocumentNode);
return {};


local v0 = {};
local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v3 = require(l_Parent_1.LuauPolyfill);
local l_Boolean_0 = v3.Boolean;
local l_Array_0 = v3.Array;
local l_Error_0 = v3.Error;
local l_toJSBoolean_0 = require(script.Parent.utilities.globals.null).toJSBoolean;
local l_invariant_0 = require(l_Parent_0.jsutils.invariant).invariant;
local l_DEV_0 = require(l_Parent_0.utilities).DEV;
l_invariant_0(typeof(l_DEV_0) == "boolean", (tostring(l_DEV_0)));
local _ = require(l_Parent_1.GraphQL);
local l_isNonEmptyArray_0 = require(l_Parent_0.utilities).isNonEmptyArray;
local v12 = require(l_Parent_0.luaUtils.hasOwnProperty);
local v13 = setmetatable({}, {
    __index = l_Error_0
});
v13.__index = v13;
v0.isApolloError = function(v14)
    return v12(v14, "graphQLErrors");
end;
local function v23(v15)
    local v16 = "";
    if not (not (l_isNonEmptyArray_0(v15.graphQLErrors) and l_isNonEmptyArray_0(v15.graphQLErrors)) and not l_isNonEmptyArray_0(v15.clientErrors)) then
        local l_concat_0 = l_Array_0.concat;
        local v18 = not not l_Boolean_0.toJSBoolean(v15.graphQLErrors) and v15.graphQLErrors or {};
        local v19 = not not l_Boolean_0.toJSBoolean(v15.clientErrors) and v15.clientErrors or {};
        for _, v21 in pairs((l_concat_0(v18, v19))) do
            v16 = v16 .. ("%s\n"):format(not l_toJSBoolean_0(v21) and "Error message not found." or v21.message);
        end;
    end;
    if v15.networkError ~= nil then
        local l_networkError_0 = v15.networkError;
        v16 = v16 .. ("%s\n"):format(if typeof(l_networkError_0) == "string" then l_networkError_0 else if l_networkError_0.message then l_networkError_0.message else l_networkError_0.error);
    end;
    return (string.gsub(v16, "\n$", ""));
end;
v13.new = function(v24)
    local l_graphQLErrors_0 = v24.graphQLErrors;
    local l_clientErrors_0 = v24.clientErrors;
    local l_networkError_1 = v24.networkError;
    local l_errorMessage_0 = v24.errorMessage;
    local l_extraInfo_0 = v24.extraInfo;
    local v30 = l_Error_0.new(l_errorMessage_0);
    v30.graphQLErrors = not not l_Boolean_0.toJSBoolean(l_graphQLErrors_0) and l_graphQLErrors_0 or {};
    v30.clientErrors = not not l_Boolean_0.toJSBoolean(l_clientErrors_0) and l_clientErrors_0 or {};
    v30.networkError = not not l_Boolean_0.toJSBoolean(l_networkError_1) and l_networkError_1 or nil;
    v30.message = not not l_Boolean_0.toJSBoolean(l_errorMessage_0) and l_errorMessage_0 or v23(v30);
    v30.extraInfo = l_extraInfo_0;
    return (setmetatable(v30, v13));
end;
v0.ApolloError = v13;
return v0;


local v0 = {};
local l_Object_0 = require(script.Parent.LuauPolyfill).Object;
local v2 = require(script.core);
l_Object_0.assign(v0, v2);
v0.None = v2.None;
l_Object_0.assign(v0, (require(script.react)));
return v0;


return {
    displayName = "ApolloClientLua",
    testMatch = {
        "**/*.spec"
    },
    setupFiles = {
        script.Parent.config.jest.setup
    }
};


local v0 = require(script.Parent.Parent.Parent.LuauPolyfill);
local l_Array_0 = v0.Array;
local l_Object_0 = v0.Object;
local function v3(v4, v5)
    if typeof(v4) ~= typeof(v5) then
        return false;
    elseif v4 == v5 then
        return true;
    elseif typeof(v4) == "table" then
        if not l_Array_0.isArray(v4) or l_Array_0.isArray(v5) then
            if not (#v4 == #v5) or #l_Object_0.keys(v4) ~= #l_Object_0.keys(v5) then
                return false;
            else
                if not l_Array_0.isArray(v4) then
                    for v6 in pairs(v4) do
                        if not v3(v4[tostring(v6)], v5[tostring(v6)]) then
                            return false;
                        end;
                    end;
                else
                    for v7, _ in ipairs(v4) do
                        if not v3(v4[v7], v5[v7]) then
                            return false;
                        end;
                    end;
                end;
                return true;
            end;
        else
            return false;
        end;
    elseif not (typeof(v4) ~= "string" and typeof(v4) ~= "number") or typeof(v4) == "boolean" then
        return v4 == v5;
    elseif typeof(v4) == "function" then
        local v9 = false;
        if debug.info(v4, "n") == debug.info(v5, "n") then
            v9 = false;
            if debug.info(v4, "s") == debug.info(v5, "s") then
                v9 = false;
                if debug.info(v4, "l") == debug.info(v5, "l") then
                    v9 = debug.info(v4, "a") == debug.info(v5, "a");
                end;
            end;
        end;
        return v9;
    else
        if typeof(v4) == "thread" then
            error("unhandled equality check for type 'thread'");
        elseif typeof(v4) == "userdata" then
            error("unhandled equality check for type 'userdata'");
        end;
        error("unhandled equality check for type " .. typeof(v4));
        return ;
    end;
end;
return v3;


local v0 = {};
local l_Parent_0 = script.Parent.Parent.Parent;
local v2 = require(l_Parent_0.Parent.LuauPolyfill);
local l_Array_0 = v2.Array;
local l_Boolean_0 = v2.Boolean;
local l_Error_0 = v2.Error;
local v6 = require(l_Parent_0.jsutils.invariant);
local l_InvariantError_0 = v6.InvariantError;
local l_invariant_0 = v6.invariant;
local l_Observable_0 = require(l_Parent_0.utilities).Observable;
local _ = require(script.Parent.types);
local v11 = require(script.Parent.Parent.utils);
local l_validateOperation_0 = v11.validateOperation;
local l_createOperation_0 = v11.createOperation;
local l_transformOperation_0 = v11.transformOperation;
local v15 = {};
v15.__index = v15;
local function v19(_, v17, v18)
    if not l_Boolean_0.toJSBoolean(v18) then
        return l_Observable_0.of();
    else
        return (v18(v17));
    end;
end;
local function v21(v20)
    if typeof(v20) == "function" then
        return v15.new(v20);
    else
        return v20;
    end;
end;
local _ = function(v22)
    local v23, _ = debug.info(v22.request, "a");
    return v23 <= 2;
end;
local v26 = setmetatable({}, {
    __index = l_Error_0
});
v26.__index = v26;
v26.new = function(v27, v28)
    local v29 = l_Error_0.new(v27);
    v29.link = v28;
    return (setmetatable(v29, v26));
end;
v15.empty = function()
    return v15.new(function(_)
        return l_Observable_0.of();
    end);
end;
v15.from = function(v31)
    if #v31 == 0 then
        return v15.empty();
    else
        return (l_Array_0.reduce(l_Array_0.map(v31, v21, nil), function(v32, v33)
            return v32:concat(v33);
        end));
    end;
end;
v15.split_ = function(v34, v35, v36)
    local v37 = if typeof(v35) == "function" then v15.new(v35) else v35;
    local v38 = nil;
    if l_Boolean_0.toJSBoolean(v36) and v36 ~= nil then
        v38 = if typeof(v36) == "function" then v15.new(v36) else v36;
    else
        local v39 = v15.new(v19);
        v38 = if typeof(v39) == "function" then v15.new(v39) else v39;
    end;
    local v40, v41 = debug.info(v37.request, "a");
    if v40 <= 2 then
        local v42;
        v41, v42 = debug.info(v38.request, "a");
        if v41 <= 2 then
            return v15.new(function(_, v44)
                if not v34(v44) then
                    local v45 = v38:request(v44);
                    return not not l_Boolean_0.toJSBoolean(v45) and v45 or l_Observable_0.of();
                else
                    local v46 = v37:request(v44);
                    return not not l_Boolean_0.toJSBoolean(v46) and v46 or l_Observable_0.of();
                end;
            end);
        end;
    end;
    return v15.new(function(_, v48, v49)
        if not v34(v48) then
            local v50 = v38:request(v48, v49);
            return not not l_Boolean_0.toJSBoolean(v50) and v50 or l_Observable_0.of();
        else
            local v51 = v37:request(v48, v49);
            return not not l_Boolean_0.toJSBoolean(v51) and v51 or l_Observable_0.of();
        end;
    end);
end;
v15.execute = function(v52, v53)
    local v54 = v52:request(l_createOperation_0(v53.context, l_transformOperation_0(l_validateOperation_0(v53))));
    return not not l_Boolean_0.toJSBoolean(v54) and v54 or l_Observable_0.of();
end;
v15.concat_ = function(v55, v56)
    local v57 = if typeof(v55) == "function" then v15.new(v55) else v55;
    local v58, v59 = debug.info(v57.request, "a");
    if not (v58 <= 2) then
        local v60 = if typeof(v56) == "function" then v15.new(v56) else v56;
        local v61;
        v59, v61 = debug.info(v60.request, "a");
        if not (v59 <= 2) then
            return v15.new(function(_, v63, v64)
                local v67 = v57:request(v63, function(v65)
                    local v66 = v60:request(v65, v64);
                    return not not l_Boolean_0.toJSBoolean(v66) and v66 or l_Observable_0.of();
                end);
                return not not l_Boolean_0.toJSBoolean(v67) and v67 or l_Observable_0.of();
            end);
        else
            return v15.new(function(_, v69)
                local v72 = v57:request(v69, function(v70)
                    local v71 = v60:request(v70);
                    return not not l_Boolean_0.toJSBoolean(v71) and v71 or l_Observable_0.of();
                end);
                return not not l_Boolean_0.toJSBoolean(v72) and v72 or l_Observable_0.of();
            end);
        end;
    else
        l_invariant_0.warn(v26.new("You are calling concat on a terminating link, which will have no effect", v57));
        return v57;
    end;
end;
v15.new = function(v73)
    local v74 = {};
    if l_Boolean_0.toJSBoolean(v73) then
        v74.request = v73;
    end;
    return (setmetatable(v74, v15));
end;
v15.split = function(v75, v76, v77, v78)
    return v75:concat(v15.split_(v76, v77, not not l_Boolean_0.toJSBoolean(v78) and v78 or v15.new(v19)));
end;
v15.concat = function(v79, v80)
    return v15.concat_(v79, v80);
end;
v15.request = function(_, _, _)
    error(l_InvariantError_0.new("request is not implemented"));
end;
v15.onError = function(_, v85, v86)
    if not (l_Boolean_0.toJSBoolean(v86) and v86 ~= nil) or not l_Boolean_0.toJSBoolean(v86.error) then
        error(v85);
        return ;
    else
        v86:error(v85);
        return false;
    end;
end;
v15.setOnError = function(v87, v88)
    v87.onError = v88;
    return v87;
end;
v0.ApolloLink = v15;
return v0;


return {
    concat = require(script.Parent.ApolloLink).ApolloLink.concat_
};


return {
    execute = require(script.Parent.ApolloLink).ApolloLink.execute
};


local v0 = {};
local l_Parent_0 = script.Parent.Parent;
local l_Object_0 = require(l_Parent_0.Parent.LuauPolyfill).Object;
local l_invariant_0 = require(l_Parent_0.jsutils.invariant).invariant;
local l_DEV_0 = require(l_Parent_0.utilities).DEV;
l_invariant_0(typeof(l_DEV_0) == "boolean", (tostring(l_DEV_0)));
v0.empty = require(script.empty).empty;
v0.from = require(script.from).from;
v0.split = require(script.split).split;
v0.concat = require(script.concat).concat;
v0.execute = require(script.execute).execute;
v0.ApolloLink = require(script.ApolloLink).ApolloLink;
l_Object_0.assign(v0, (require(script.types)));
return v0;


return {
    split = require(script.Parent.ApolloLink).ApolloLink.split_
};


local v0 = {};
local _ = require(script.Parent.Parent.Parent.Parent.GraphQL);
local _ = require(script.Parent.Parent.Parent.utilities);
return v0;


local v0 = {};
local l_ApolloLink_0 = require(script.Parent.Parent.core).ApolloLink;
local _ = require(script.Parent.selectHttpOptionsAndBody);
local l_createHttpLink_0 = require(script.Parent.createHttpLink).createHttpLink;
local v4 = setmetatable({}, {
    __index = l_ApolloLink_0
});
v4.__index = v4;
v4.new = function(v5)
    if v5 == nil then
        v5 = {};
    end;
    local v6 = setmetatable(l_ApolloLink_0.new(l_createHttpLink_0(v5).request), v4);
    v6.options = v5;
    return v6;
end;
v0.HttpLink = v4;
return v0;


local l_Parent_0 = script.Parent.Parent.Parent;
local l_Boolean_0 = require(l_Parent_0.Parent.LuauPolyfill).Boolean;
local v2 = {};
local l_InvariantError_0 = require(l_Parent_0.jsutils.invariant).InvariantError;
v2.checkFetcher = function(v4)
    if not l_Boolean_0.toJSBoolean(v4) and typeof(_G.fetch) == "nil" then
        error(l_InvariantError_0.new("\n\"fetch\" has not been found globally and no fetcher has been configured. To fix this, install a fetch package (like https://www.npmjs.com/package/cross-fetch), instantiate the fetcher, and pass it into your HttpLink constructor. For example:\n\nimport fetch from 'cross-fetch';\nimport { ApolloClient, HttpLink } from '@apollo/client';\nconst client = new ApolloClient({\n  link: new HttpLink({ uri: '/graphql', fetch })\n});\n    "));
    end;
end;
return v2;


return {
    createSignalIfSupported = function()
        local l_AbortController_0 = _G.AbortController;
        if typeof(l_AbortController_0) == "nil" then
            return {
                controller = false,
                signal = false
            };
        else
            local v1 = l_AbortController_0.new();
            return {
                controller = v1,
                signal = v1.signal
            };
        end;
    end
};


local l_Parent_0 = script.Parent.Parent.Parent;
local v1 = require(l_Parent_0.Parent.LuauPolyfill);
local l_Array_0 = v1.Array;
local l_Boolean_0 = v1.Boolean;
local l_Object_0 = v1.Object;
local v5 = require(l_Parent_0.luaUtils.encodeURIComponent);
local v6 = {};
local l_serializeFetchParameter_0 = require(script.Parent.serializeFetchParameter).serializeFetchParameter;
local _ = require(script.Parent.selectHttpOptionsAndBody);
v6.rewriteURIForGET = function(v9, v10)
    local v11 = {};
    local function _(v12, v13)
        table.insert(v11, ("%s=%s"):format(v12, v5(v13)));
    end;
    if l_Array_0.indexOf(l_Object_0.keys(v10), "query") ~= -1 then
        table.insert(v11, ("%s=%s"):format("query", v5(v10.query)));
    end;
    if l_Boolean_0.toJSBoolean(v10.operationName) then
        table.insert(v11, ("%s=%s"):format("operationName", v5(v10.operationName)));
    end;
    if l_Boolean_0.toJSBoolean(v10.variables) then
        local v15 = nil;
        local l_status_0, l_result_0 = pcall(function()
            v15 = l_serializeFetchParameter_0(v10.variables, "Variables map", true);
        end);
        if l_status_0 then
            table.insert(v11, ("%s=%s"):format("variables", v5(v15)));
            --[[ close >= 4 ]]
        else
            return {
                parseError = l_result_0
            };
        end;
    end;
    if l_Boolean_0.toJSBoolean(v10.extensions) then
        local v18 = nil;
        local l_status_1, l_result_1 = pcall(function()
            v18 = l_serializeFetchParameter_0(v10.extensions, "Extensions map");
        end);
        if l_status_1 then
            table.insert(v11, ("%s=%s"):format("extensions", v5(v18)));
            --[[ close >= 4 ]]
        else
            return {
                parseError = l_result_1
            };
        end;
    end;
    local v21 = "";
    local l_v9_0 = v9;
    local v23 = string.find(v9, "#");
    if v23 ~= nil then
        v21 = string.sub(v9, v23);
        l_v9_0 = string.sub(v9, 1, v23 - 1);
    end;
    return {
        newURI = l_v9_0 .. (string.find(l_v9_0, "?") == nil and "?" or "&") .. l_Array_0.join(v11, "&") .. v21
    };
end;
return v6;


local l_Parent_0 = script.Parent.Parent.Parent.Parent;
local v1 = require(l_Parent_0.LuauPolyfill);
local l_Array_0 = v1.Array;
local l_Boolean_0 = v1.Boolean;
local l_Object_0 = v1.Object;
local v5 = {};
local l_print_0 = require(l_Parent_0.GraphQL).print;
local _ = require(script.Parent.Parent.core.types);
local v8 = nil;
v5.fallbackHttpConfig = {
    http = {
        includeQuery = true,
        includeExtensions = false
    },
    headers = {
        accept = "*/*",
        ["content-type"] = "application/json"
    },
    options = {
        method = "POST"
    }
};
v5.selectHttpOptionsAndBody = function(v9, v10, ...)
    local v11 = {
        ...
    };
    local v12 = l_Object_0.assign({}, v10.options, {
        headers = v10.headers,
        credentials = v10.credentials
    });
    local v13 = nil;
    v13 = if v10.http ~= nil then v10.http else {};
    l_Array_0.forEach(v11, function(v14)
        v12 = l_Object_0.assign({}, v12, v14.options, {
            headers = l_Object_0.assign({}, v12.headers, v8(v14.headers))
        });
        if l_Boolean_0.toJSBoolean(v14.credentials) then
            v12.credentials = v14.credentials;
        end;
        v13 = l_Object_0.assign({}, v13, v14.http);
    end);
    local l_operationName_0 = v9.operationName;
    local l_extensions_0 = v9.extensions;
    local l_variables_0 = v9.variables;
    local l_query_0 = v9.query;
    local v19 = {
        operationName = l_operationName_0,
        variables = l_variables_0
    };
    if v13.includeExtensions then
        v19.extensions = l_extensions_0;
    end;
    if v13.includeQuery then
        v19.query = l_print_0(l_query_0);
    end;
    return {
        options = v12,
        body = v19
    };
end;
v8 = function(v20)
    if v20 ~= nil then
        local v21 = {};
        l_Array_0.forEach(l_Object_0.keys(v20), function(v22)
            v21[string.lower(v22)] = v20[v22];
        end);
        return v21;
    else
        return v20;
    end;
end;
return v5;


local l_Boolean_0 = require(script.Parent.Parent.Parent.Parent.LuauPolyfill).Boolean;
local v1 = {};
local _ = require(script.Parent.Parent.core.types);
v1.selectURI = function(v3, v4)
    local l_uri_0 = v3:getContext().uri;
    if not l_Boolean_0.toJSBoolean(l_uri_0) then
        if typeof(v4) == "function" then
            return v4(v3);
        else
            return not not l_Boolean_0.toJSBoolean(v4) and v4 or "/graphql";
        end;
    else
        return l_uri_0;
    end;
end;
return v1;


local l_Parent_0 = script.Parent.Parent.Parent;
local v1 = require(l_Parent_0.Parent.LuauPolyfill);
local l_Error_0 = v1.Error;
local l_Array_0 = v1.Array;
local l_HttpService_0 = game:GetService("HttpService");
local v5 = {};
local l_InvariantError_0 = require(l_Parent_0.jsutils.invariant).InvariantError;
v5.serializeFetchParameter = function(v7, v8, v9)
    local v10 = nil;
    local l_status_0, l_result_0 = pcall(function()
        if not (l_Array_0.isArray(v7) and #v7 == 0) or not v9 then
            v10 = l_HttpService_0:JSONEncode(v7);
            return ;
        else
            v10 = "{}";
            return ;
        end;
    end);
    if not l_status_0 then
        local v13 = l_InvariantError_0.new(("Network request failed. %s is not serializable: %s"):format(v8, l_result_0));
        v13.parseError = l_Error_0.new(l_result_0);
        error(v13);
    end;
    return v10;
end;
return v5;


local v0 = {};
local l_Object_0 = require(script.Parent.Parent.Parent.Parent.LuauPolyfill).Object;
local _ = require(script.Parent.Parent.core.types);
v0.createOperation = function(v3, v4)
    local l_v4_0 = v4;
    local v6 = l_Object_0.assign({}, v3);
    return (setmetatable(l_v4_0, {
        __index = {
            setContext = function(_, v8)
                if typeof(v8) == "function" then
                    v6 = l_Object_0.assign({}, v6, v8(v6));
                    return ;
                else
                    v6 = l_Object_0.assign({}, v6, v8);
                    return ;
                end;
            end,
            getContext = function(_)
                return l_Object_0.assign({}, v6);
            end
        }
    }));
end;
return v0;


local v0 = {};
local l_Observable_0 = require(script.Parent.Parent.Parent.utilities).Observable;
v0.fromError = function(v2)
    return l_Observable_0.new(function(v3)
        v3:error(v2);
    end);
end;
return v0;


local v0 = {};
local _ = require(script.Parent.Parent.Parent.Parent.LuauPolyfill);
local l_Observable_0 = require(script.Parent.Parent.Parent.utilities).Observable;
v0.fromPromise = function(v3)
    return l_Observable_0.new(function(v4)
        v3:andThen(function(v5)
            v4:next(v5);
            v4:complete();
        end):catch(function(v6)
            v4.error(v4, v6);
        end);
    end);
end;
return v0;


return {
    fromError = require(script.fromError).fromError,
    toPromise = require(script.toPromise).toPromise,
    fromPromise = require(script.fromPromise).fromPromise,
    throwServerError = require(script.throwServerError).throwServerError,
    validateOperation = require(script.validateOperation).validateOperation,
    createOperation = require(script.createOperation).createOperation,
    transformOperation = require(script.transformOperation).transformOperation
};


local v0 = {};
local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v3 = require(l_Parent_1.Promise);
local _ = require(l_Parent_1.LuauPolyfill);
local l_invariant_0 = require(l_Parent_0.jsutils.invariant).invariant;
local _ = require(script.Parent.Parent.Parent.utilities);
v0.toPromise = function(v7)
    local v8 = false;
    return v3.new(function(v9, v10)
        v7:subscribe({
            next = function(_, v12)
                if not v8 then
                    v8 = true;
                    v9(v12);
                    return ;
                else
                    l_invariant_0.warn("Promise Wrapper does not support multiple results from Observable");
                    return ;
                end;
            end,
            error = function(_, v14)
                v10(v14);
            end
        });
    end):andThen(function(v15)
        return v3.delay(0):andThenReturn(v15);
    end);
end;
return v0;


local v0 = {};
local l_Boolean_0 = require(script.Parent.Parent.Parent.Parent.LuauPolyfill).Boolean;
local _ = require(script.Parent.Parent.core.types);
local l_getOperationName_0 = require(script.Parent.Parent.Parent.utilities).getOperationName;
v0.transformOperation = function(v4)
    local v5 = {
        variables = not not l_Boolean_0.toJSBoolean(v4.variables) and v4.variables or {},
        extensions = not not l_Boolean_0.toJSBoolean(v4.extensions) and v4.extensions or {},
        operationName = v4.operationName,
        query = v4.query
    };
    if not l_Boolean_0.toJSBoolean(v5.operationName) then
        if typeof(v5.query) ~= "string" then
            v5.operationName = not not l_Boolean_0.toJSBoolean(l_getOperationName_0(v5.query)) and l_getOperationName_0(v5.query) or nil;
            return v5;
        else
            v5.operationName = "";
        end;
    end;
    return v5;
end;
return v0;


local v0 = {};
local l_Parent_0 = script.Parent.Parent.Parent;
local v2 = require(l_Parent_0.Parent.LuauPolyfill);
local l_Array_0 = v2.Array;
local l_Object_0 = v2.Object;
local l_InvariantError_0 = require(l_Parent_0.jsutils.invariant).InvariantError;
local _ = require(script.Parent.Parent.core.types);
v0.validateOperation = function(v7)
    local v8 = {
        "query",
        "operationName",
        "variables",
        "extensions",
        "context"
    };
    for _, v10 in ipairs(l_Object_0.keys(v7)) do
        if l_Array_0.indexOf(v8, v10) < 0 then
            error(l_InvariantError_0.new(("illegal argument: %s"):format(v10)));
        end;
    end;
    return v7;
end;
return v0;


local v0 = require(script.Parent.Parent.Parent.LuauPolyfill);
return (v0.Object.assign({}, v0.Object, {
    getPrototypeOf = function(v1)
        local v2 = getmetatable(v1);
        return v2 ~= false and v2 or nil;
    end,
    create = function(v3, v4)
        if v4 == nil then
            v4 = {};
        end;
        return (setmetatable(v4, v3));
    end
}));


return require(script.Parent.Parent.LuauPolyfill).Object.assign({
    Object = require(script.Object)
}, require(script.makeIntervalImpl)(delay));


return function(v0)
    if typeof(v0) == "function" then
        return true;
    else
        if typeof(v0) == "table" then
            local v1 = getmetatable(v0);
            if not v1 or not rawget(v1, "__call") then
                if v0._isMockFunction then
                    return true;
                end;
            else
                return true;
            end;
        end;
        return false;
    end;
end;


local v0 = newproxy(false);
return function(v1)
    return {
        setInterval = function(v2, v3, ...)
            local v4 = {
                ...
            };
            local v5 = {
                [v0] = 1
            };
            if v3 == nil then
                v3 = 0;
            end;
            local v6 = v3 / 1000;
            local v7 = nil;
            v7 = function()
                v1(v6, function()
                    if v5[v0] == 1 then
                        v2(unpack(v4));
                        v7();
                    end;
                end);
            end;
            v7();
            return v5;
        end,
        clearInterval = function(v8)
            if v8[v0] == 1 then
                v8[v0] = 3;
            end;
        end
    };
end;


return function(v0, v1)
    for v2, _ in v0, nil, nil do
        v1(v2);
    end;
end;


local v0 = require(script.Parent.Parent.Parent.LuauPolyfill);
local l_Array_0 = v0.Array;
local l_Object_0 = v0.Object;
local l_HttpService_0 = game:GetService("HttpService");
sortedEncode = function(v4)
    if not l_Array_0.isArray(v4) and typeof(v4) == "table" then
        return "{" .. l_Array_0.join(l_Array_0.map(l_Array_0.sort(l_Object_0.keys(v4)), function(v5)
            return l_HttpService_0:JSONEncode(v5) .. ":" .. sortedEncode(v4[v5]);
        end), ",") .. "}";
    else
        return l_HttpService_0:JSONEncode(v4);
    end;
end;
return {
    sortedEncode = sortedEncode
};


return {
    stringIndexOf = function(v0, v1)
        local v2, _ = string.find(v0, v1);
        if v2 == nil then
            return -1;
        else
            return v2;
        end;
    end
};


local l_Map_0 = require(script.Parent.Parent.Parent.LuauPolyfill).Map;
local v1 = {};
local function v2()
end;
local v3 = {};
v3.__index = v3;
v3.new = function(v4, v5)
    local l_v4_0 = v4;
    local l_v5_0 = v5;
    if l_v4_0 == nil then
        l_v4_0 = math.huge;
    end;
    if l_v5_0 == nil then
        l_v5_0 = v2;
    end;
    local v8 = setmetatable({}, v3);
    v8.map = l_Map_0.new(nil);
    v8.newest = nil;
    v8.oldest = nil;
    v8.max = l_v4_0;
    v8.dispose = l_v5_0;
    return v8;
end;
v3.has = function(v9, v10)
    return v9.map:has(v10);
end;
v3.get = function(v11, v12)
    local v13 = v11:getNode(v12);
    if not v13 then
        return v13;
    else
        return v13.value;
    end;
end;
v3.getNode = function(v14, v15)
    local v16 = v14.map:get(v15);
    if v16 and v16 ~= v14.newest then
        local l_older_0 = v16.older;
        local l_newer_0 = v16.newer;
        if l_newer_0 then
            l_newer_0.older = l_older_0;
        end;
        if l_older_0 then
            l_older_0.newer = l_newer_0;
        end;
        v16.older = v14.newest;
        v16.older.newer = v16;
        v16.newer = nil;
        v14.newest = v16;
        if v16 == v14.oldest then
            v14.oldest = l_newer_0;
        end;
    end;
    return v16;
end;
v3.set = function(v19, v20, v21)
    local v22 = v19:getNode(v20);
    if not v22 then
        v22 = {
            key = v20,
            value = v21,
            newer = nil,
            older = v19.newest
        };
        if v19.newest then
            v19.newest.newer = v22;
        end;
        v19.newest = v22;
        v19.oldest = v19.oldest or v22;
        v19.map:set(v20, v22);
        return v22.value;
    else
        v22.value = v21;
        return v22.value;
    end;
end;
v3.clean = function(v23)
    while v23.oldest and v23.max < v23.map.size do
        v23:delete(v23.oldest.key);
    end;
end;
v3.delete = function(v24, v25)
    local v26 = v24.map:get(v25);
    if not v26 then
        return false;
    else
        if v26 == v24.newest then
            v24.newest = v26.older;
        end;
        if v26 == v24.oldest then
            v24.oldest = v26.newer;
        end;
        if v26.newer then
            v26.newer.older = v26.older;
        end;
        if v26.older then
            v26.older.newer = v26.newer;
        end;
        v24.map:delete(v25);
        v24.dispose(v26.value, v25);
        return true;
    end;
end;
v1.Cache = v3;
return v1;


local l_Parent_0 = script.Parent.Parent;
local v1 = {};
local _ = require(script.Parent.anyEntryTypes);
v1.parentEntrySlot = require(l_Parent_0.wry.context).Slot.new();
local v3 = require(l_Parent_0.wry.context);
v1.bindContext = v3.bind;
v1.noContext = v3.noContext;
v1.setTimeout = v3.setTimeout;
return v1;


local v0 = require(script.Parent.Parent.Parent.LuauPolyfill);
local l_Set_0 = v0.Set;
local l_Array_0 = v0.Array;
local v3 = {};
local _ = require(script.Parent.anyEntryTypes);
local _ = require(script.Parent.initTypes);
local l_parentEntrySlot_0 = require(script.Parent.context).parentEntrySlot;
local v7 = require(script.Parent.helpers);
local l_hasOwnProperty_0 = v7.hasOwnProperty;
local l_maybeUnsubscribe_0 = v7.maybeUnsubscribe;
local l_toArray_0 = v7.toArray;
local v11 = {
    setDirty = true,
    dispose = true,
    forget = true
};
local _ = require(script.Parent.depTypes);
v3.dep = function(v13)
    local v14 = {};
    local v15 = if v13 ~= nil then v13.subscribe else v13;
    local v20 = setmetatable({}, {
        __call = function(_, v17)
            local v18 = l_parentEntrySlot_0:getValue();
            if v18 ~= nil then
                local v19 = v14[v17];
                if not v19 then
                    v19 = l_Set_0.new();
                    v14[v17] = v19;
                end;
                v18:dependOn(v19);
                if type(v15) == "function" then
                    l_maybeUnsubscribe_0(v19);
                    v19.unsubscribe = v15(v17);
                end;
            end;
        end
    });
    v20.dirty = function(_, v22, v23)
        local v24 = v14[v22];
        if v24 then
            local v25 = if not not v23 and l_hasOwnProperty_0(v11, v23) then v23 else "setDirty";
            l_Array_0.forEach(l_toArray_0(v24), function(v26)
                v26[v25](v26);
            end);
            v14[v22] = nil;
            l_maybeUnsubscribe_0(v24);
        end;
    end;
    return v20;
end;
return v3;


local _ = require(script.Parent.Parent.Parent.LuauPolyfill);
local _ = require(script.Parent.helpers_types);
local _ = require(script.Parent.anyEntryTypes);
return {};


local v0 = require(script.Parent.Parent.Parent.LuauPolyfill);
local l_Array_0 = v0.Array;
local l_Set_0 = v0.Set;
local l_Map_0 = v0.Map;
local l_Error_0 = v0.Error;
local v5 = {};
local v6 = newproxy(true);
getmetatable(v6).__tostring = function()
    return "Value.None";
end;
local v7 = nil;
local v8 = nil;
local v9 = nil;
local v10 = nil;
local v11 = nil;
local v12 = nil;
local v13 = nil;
local v14 = nil;
local v15 = nil;
local v16 = nil;
local v17 = nil;
local v18 = nil;
local v19 = nil;
local v20 = nil;
local l_parentEntrySlot_0 = require(script.Parent.context).parentEntrySlot;
local _ = require(script.Parent.initTypes);
local _ = require(script.Parent.depTypes);
local v24 = require(script.Parent.helpers);
local l_maybeUnsubscribe_0 = v24.maybeUnsubscribe;
local l_toArray_0 = v24.toArray;
local v27 = {};
local function _(v28, v29)
    if not v28 then
        error(l_Error_0.new(v29 or "assertion failure"));
    end;
end;
local _ = require(script.Parent.entryTypes);
local _ = require(script.Parent.anyEntryTypes);
local function _(v33, v34)
    local v35 = #v33;
    local v36 = false;
    if v35 > 0 then
        v36 = false;
        if v35 == #v34 then
            v36 = v33[v35] == v34[v35];
        end;
    end;
    return v36;
end;
local function v39(v38)
    if v38[2] ~= nil then
        error(v38[2]);
        return ;
    elseif v38[1] ~= nil then
        if v38[1] == v6 then
            return nil;
        else
            return v38[1];
        end;
    else
        error(l_Error_0.new("unknown value"));
        return ;
    end;
end;
local function _(v40)
    return (table.clone(v40));
end;
local v42 = {};
v42.__index = v42;
v42.count = 0;
v42.new = function(v43)
    local v44 = setmetatable({}, v42);
    v44.parents = l_Set_0.new();
    v44.childValues = l_Map_0.new(nil);
    v44.dirtyChildren = nil;
    v44.dirty = true;
    v44.recomputing = false;
    v44.value = {};
    v44.deps = nil;
    v44.fn = v43;
    local l_v42_0 = v42;
    l_v42_0.count = l_v42_0.count + 1;
    return v44;
end;
v42.peek = function(v46)
    if not (#v46.value == 1) or v10(v46) then
        return nil;
    else
        v7(v46);
        return v46.value[1];
    end;
end;
v42.recompute = function(v47, v48)
    if v47.recomputing then
        error(l_Error_0.new("already recomputing"));
    end;
    v7(v47);
    if not v10(v47) then
        return v39(v47.value);
    else
        return v8(v47, v48);
    end;
end;
v42.setDirty = function(v49)
    if not v49.dirty then
        v49.dirty = true;
        v49.value = {};
        v12(v49);
        l_maybeUnsubscribe_0(v49);
        return ;
    else
        return ;
    end;
end;
v42.dispose = function(v50)
    v50:setDirty();
    v18(v50);
    v14(v50, function(v51, _)
        v51:setDirty();
        v19(v51, v50);
        return nil;
    end);
end;
v42.forget = function(v53)
    v53:dispose();
end;
v42.dependOn = function(v54, v55)
    v55:add(v54);
    if not v54.deps then
        v54.deps = table.remove(v27) or l_Set_0.new();
    end;
    v54.deps:add(v55);
end;
v42.forgetDeps = function(v56)
    if v56.deps then
        l_Array_0.forEach(l_toArray_0(v56.deps), function(v57)
            v57:delete(v56);
        end);
        v56.deps:clear();
        table.insert(v27, v56.deps);
        v56.deps = nil;
    end;
end;
v5.Entry = v42;
v7 = function(v58)
    local v59 = l_parentEntrySlot_0:getValue();
    if not v59 then
        return nil;
    else
        v58.parents:add(v59);
        if not v59.childValues:has(v58) then
            v59.childValues:set(v58, {});
        end;
        if not v10(v58) then
            v16(v59, v58);
            return v59;
        else
            v15(v59, v58);
            return v59;
        end;
    end;
end;
v8 = function(v60, v61)
    v18(v60);
    l_parentEntrySlot_0:withValue(v60, v9, {
        v60,
        v61
    });
    if v20(v60, v61) then
        v11(v60);
    end;
    return v39(v60.value);
end;
v9 = function(_, v63, v64)
    v63.recomputing = true;
    table.clear(v63.value);
    local l_status_0, l_result_0 = pcall(v63.fn, table.unpack(v64));
    if l_status_0 then
        v63.value[1] = l_result_0;
        if v63.value[1] == nil then
            v63.value[1] = v6;
        end;
    end;
    if not l_status_0 then
        v63.value[2] = l_result_0;
    end;
    v63.recomputing = false;
end;
v10 = function(v67)
    local l_dirty_0 = v67.dirty;
    if not l_dirty_0 then
        l_dirty_0 = false;
        if v67.dirtyChildren ~= nil then
            l_dirty_0 = v67.dirtyChildren.size > 0;
        end;
    end;
    return l_dirty_0;
end;
v11 = function(v69)
    v69.dirty = false;
    if not v10(v69) then
        v13(v69);
        return ;
    else
        return ;
    end;
end;
v12 = function(v70)
    v14(v70, v15);
end;
v13 = function(v71)
    v14(v71, v16);
end;
v14 = function(v72, v73)
    local l_size_0 = v72.parents.size;
    if l_size_0 then
        local v75 = l_toArray_0(v72.parents);
        for v76 = 1, l_size_0 do
            v73(v75[v76], v72);
        end;
    end;
end;
v15 = function(v77, v78)
    if _G.__DEV__ then
        local v79, v80 = v77.childValues:has(v78);
        if not v79 then
            error(l_Error_0.new(v80 or "assertion failure"));
        end;
        v79, v80 = v10(v78);
        if not v79 then
            error(l_Error_0.new(v80 or "assertion failure"));
        end;
    end;
    local v81 = not v10(v77);
    if v77.dirtyChildren then
        if v77.dirtyChildren:has(v78) then
            return ;
        end;
    else
        v77.dirtyChildren = table.remove(v27) or l_Set_0.new();
    end;
    v77.dirtyChildren:add(v78);
    if v81 then
        v12(v77);
    end;
end;
v16 = function(v82, v83)
    if _G.__DEV__ then
        local v84, v85 = v82.childValues:has(v83);
        if not v84 then
            error(l_Error_0.new(v85 or "assertion failure"));
        end;
        if v10(v83) then
            error(l_Error_0.new("assertion failure"));
        end;
    end;
    local v86 = v82.childValues:get(v83);
    if #v86 == 0 then
        v82.childValues:set(v83, (table.clone(v83.value)));
    else
        local l_value_0 = v83.value;
        local v88 = #v86;
        local v89 = false;
        if v88 > 0 then
            v89 = false;
            if v88 == #l_value_0 then
                v89 = v86[v88] == l_value_0[v88];
            end;
        end;
        if not v89 then
            v82:setDirty();
        end;
    end;
    v17(v82, v83);
    if not v10(v82) then
        v13(v82);
        return ;
    else
        return ;
    end;
end;
v17 = function(v90, v91)
    local l_dirtyChildren_0 = v90.dirtyChildren;
    if l_dirtyChildren_0 ~= nil then
        l_dirtyChildren_0:delete(v91);
        if l_dirtyChildren_0.size == 0 then
            if #v27 < 100 then
                table.insert(v27, l_dirtyChildren_0);
            end;
            v90.dirtyChildren = nil;
        end;
    end;
end;
v18 = function(v93)
    if v93.childValues.size > 0 then
        l_Array_0.forEach(table.clone(v93.childValues:keys()), function(v94)
            v19(v93, v94);
        end);
    end;
    v93:forgetDeps();
    if not (v93.dirtyChildren == nil) then
        error(l_Error_0.new("assertion failure"));
    end;
end;
v19 = function(v95, v96)
    v96.parents:delete(v95);
    v95.childValues:delete(v96);
    v17(v95, v96);
end;
v20 = function(v97, v98)
    if not (typeof(v97.subscribe) == "function") or pcall(function()
        l_maybeUnsubscribe_0(v97);
        v97.unsubscribe = v97.subscribe(table.unpack(v98));
        return nil, false;
    end) then
        return true;
    else
        v97:setDirty();
        return false;
    end;
end;
return v5;


local l_Parent_0 = script.Parent.Parent.Parent;
local _ = require(script.Parent.depTypes);
local _ = require(l_Parent_0.LuauPolyfill);
local _ = require(script.Parent.anyEntryTypes);
return {};


local l_Parent_0 = script.Parent.Parent;
local _ = require(l_Parent_0.Parent.LuauPolyfill);
local _ = require(script.Parent.helpers_types);
return {
    hasOwnProperty = require(l_Parent_0.luaUtils.hasOwnProperty),
    toArray = function(v3)
        if not v3._array then
            local v4 = {};
            v3:forEach(function(v5)
                table.insert(v4, v5);
            end);
            return v4;
        else
            return table.clone(v3._array);
        end;
    end,
    maybeUnsubscribe = function(v6)
        local l_unsubscribe_0 = v6.unsubscribe;
        if type(l_unsubscribe_0) == "function" then
            v6.unsubscribe = nil;
            l_unsubscribe_0();
        end;
    end
};


local l_Parent_0 = script.Parent;
local v1 = require(l_Parent_0.Parent.LuauPolyfill);
local l_Array_0 = v1.Array;
local l_Set_0 = v1.Set;
local l_Boolean_0 = v1.Boolean;
local l_Object_0 = v1.Object;
local v6 = {};
local l_Trie_0 = require(l_Parent_0.wry.trie).Trie;
local l_Cache_0 = require(script.cache).Cache;
local l_Entry_0 = require(script.entry).Entry;
local l_parentEntrySlot_0 = require(script.context).parentEntrySlot;
local v11 = require(script.context);
v6.bindContext = v11.bindContext;
v6.noContext = v11.noContext;
v6.setTimeout = v11.setTimeout;
v6.dep = require(script.dep).dep;
local _ = function()
    local v12 = l_Trie_0.new(true);
    return function(_, ...)
        return v12:lookupArray({
            ...
        });
    end;
end;
local v15 = l_Trie_0.new(true);
local l_v15_0 = v15 --[[ copy: 17 -> 19 ]];
v6.defaultMakeCacheKey = function(_, ...)
    return l_v15_0:lookupArray({
        ...
    });
end;
v6.KeyTrie = l_Trie_0;
v15 = require(script.initTypes);
local v18 = l_Set_0.new();
v6.wrap = function(v19, v20, v21)
    local l_v20_0 = v20;
    if l_v20_0 == nil then
        l_v20_0 = {};
    end;
    local v24 = l_Cache_0.new(not not l_Boolean_0.toJSBoolean(l_v20_0.max) and l_v20_0.max or 65536, function(v23)
        return v23:dispose();
    end);
    local l_keyArgs_0 = l_v20_0.keyArgs;
    local v26, v27, v28;
    if l_Boolean_0.toJSBoolean(l_v20_0.makeCacheKey) then
        v28 = l_v20_0.makeCacheKey;
        if v28 then
            goto label0;
        end;
    end;
    v26 = l_Trie_0.new(true);
    v27 = v26 --[[ copy: 7 -> 14 ]];
    v28 = function(_, ...)
        return v27:lookupArray({
            ...
        });
    end;
    ::label0::;
    if v21 ~= nil then
        v26 = v19;
        local l_v26_0 = v26 --[[ copy: 7 -> 17 ]];
        v19 = function(...)
            return l_v26_0(v21, ...);
        end;
    end;
    v26 = setmetatable({}, {
        __call = function(_, v32, ...)
            local v33 = nil;
            v33 = if v21 ~= nil then {
                ...
            } else {
                v32,
                ...
            };
            local v34 = v28(nil, table.unpack((function()
                if not l_keyArgs_0 then
                    return v33;
                else
                    return l_keyArgs_0(nil, table.unpack(v33));
                end;
            end)()));
            if v34 == nil then
                return v19(table.unpack(v33));
            else
                local v35 = v24:get(v34);
                if v35 == nil then
                    v35 = l_Entry_0.new(v19);
                    v24:set(v34, v35);
                    v35.subscribe = l_v20_0.subscribe;
                    v35.forget = function()
                        return v24:delete(v34);
                    end;
                end;
                local v36 = v35:recompute((l_Array_0.slice(v33)));
                v24:set(v34, v35);
                v18:add(v24);
                if not l_parentEntrySlot_0:hasValue() then
                    v18:forEach(function(v37)
                        return v37:clean();
                    end);
                    v18:clear();
                end;
                return v36;
            end;
        end,
        __index = function(v38, v39)
            if v39 == "size" then
                return v24.map.size;
            else
                return (rawget(v38, v39));
            end;
        end,
        __newindex = function(v40, v41, v42)
            if v41 == "size" then
                error("attempt to update a read-only table", 2);
            end;
            rawset(v40, v41, v42);
        end
    });
    local _ = function(v43)
        return function(_, ...)
            return v43(...);
        end;
    end;
    local function v48(v46)
        local v47 = v24:get(v46);
        if l_Boolean_0.toJSBoolean(v47) then
            v47:setDirty();
        end;
    end;
    v26.dirtyKey = function(_, ...)
        return v48(...);
    end;
    local function v51(...)
        local v50 = v24:get((v28(nil, ...)));
        if l_Boolean_0.toJSBoolean(v50) then
            v50:setDirty();
        end;
    end;
    local l_v51_0 = v51 --[[ copy: 11 -> 15 ]];
    v26.dirty = function(_, ...)
        return l_v51_0(...);
    end;
    local function v56(v54)
        local v55 = v24:get(v54);
        if not l_Boolean_0.toJSBoolean(v55) then
            return ;
        else
            return v55:peek();
        end;
    end;
    v26.peekKey = function(_, ...)
        return v56(...);
    end;
    local function v58(...)
        return v56(v28(nil, ...));
    end;
    v26.peek = function(_, ...)
        return v58(...);
    end;
    v51 = function(v60)
        return v24:delete(v60);
    end;
    v26.forgetKey = function(_, ...)
        return v51(...);
    end;
    local function v62(...)
        return v51(v28(nil, ...));
    end;
    local l_v62_0 = v62 --[[ copy: 13 -> 16 ]];
    v26.forget = function(_, ...)
        return l_v62_0(...);
    end;
    v26.makeCacheKey = v28;
    if not l_Boolean_0.toJSBoolean(l_keyArgs_0) then
        v26.getKey = v28;
    else
        v62 = function(...)
            return v28(nil, table.unpack(l_keyArgs_0(...)));
        end;
        v26.getKey = function(_, ...)
            return v62(...);
        end;
    end;
    return l_Object_0.freeze(v26);
end;
return v6;


local v0 = {};
local l_Parent_0 = script.Parent.Parent.Parent;
local l_Boolean_0 = require(l_Parent_0.Parent.LuauPolyfill).Boolean;
local _ = require(l_Parent_0.core);
local _ = require(script.Parent.types);
local l_useMutation_0 = require(script.Parent.Parent.hooks).useMutation;
v0.Mutation = function(v6)
    local v7, v8 = table.unpack(l_useMutation_0(v6.mutation, v6), 1, 2);
    if not l_Boolean_0.toJSBoolean(v6.children) then
        return nil;
    else
        return v6.children(v7, v8);
    end;
end;
return v0;


local v0 = {};
local l_Parent_0 = script.Parent.Parent.Parent;
local v2 = require(l_Parent_0.Parent.LuauPolyfill);
local l_Boolean_0 = v2.Boolean;
local l_Object_0 = v2.Object;
local _ = require(l_Parent_0.core);
local _ = require(script.Parent.types);
local l_useQuery_0 = require(script.Parent.Parent.hooks).useQuery;
v0.Query = function(v8)
    local l_children_0 = v8.children;
    local v10 = l_useQuery_0(v8.query, (l_Object_0.assign({}, v8, {
        children = l_Object_0.None,
        query = l_Object_0.None
    })));
    if not l_Boolean_0.toJSBoolean(v10) then
        return nil;
    else
        return l_children_0(v10);
    end;
end;
return v0;


local v0 = {
    Query = require(script.Query).Query,
    Mutation = require(script.Mutation).Mutation
};
local _ = require(script.types);
return v0;


local v0 = {};
local l_Parent_0 = script.Parent.Parent.Parent;
local _ = require(l_Parent_0.Parent.GraphQL);
local _ = require(l_Parent_0.jsutils.typedDocumentNode);
local _ = require(script.Parent.Parent.Parent.core);
local _ = require(script.Parent.Parent.Parent.cache);
local _ = require(script.Parent.Parent.types.types);
return v0;


local l_Parent_0 = script.Parent.Parent.Parent;
local v1 = require(l_Parent_0.Parent.React);
local l_getApolloContext_0 = require(script.Parent.ApolloContext).getApolloContext;
local l_invariant_0 = require(l_Parent_0.jsutils.invariant).invariant;
local _ = require(l_Parent_0.core.ApolloClient);
ApolloConsumer = function(v5)
    return v1.createElement(l_getApolloContext_0().Consumer, nil, function(v6)
        l_invariant_0(v6 and v6.client, "Could not find \"client\" in the context of ApolloConsumer. " .. "Wrap the root component in an <ApolloProvider>.");
        return v5.children(v6.client);
    end);
end;
return {
    ApolloConsumer = ApolloConsumer
};


local l_Parent_0 = script.Parent.Parent.Parent.Parent;
local l_WeakMap_0 = require(l_Parent_0.LuauPolyfill).WeakMap;
local v2 = require(l_Parent_0.React);
local _ = require(script.Parent.Parent.Parent.core);
local v4 = l_WeakMap_0.new();
return {
    getApolloContext = function()
        local v5 = v4:get(v2.createContext);
        if v5 == nil then
            v5 = v2.createContext({});
            v5.displayName = "ApolloContext";
            v4:set(v2.createContext, v5);
        end;
        return v5;
    end,
    resetApolloContext = function()
        v4 = l_WeakMap_0.new();
    end
};


local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local _ = require(l_Parent_1.LuauPolyfill);
local v3 = require(l_Parent_1.React);
local l_getApolloContext_0 = require(script.Parent.ApolloContext).getApolloContext;
local l_invariant_0 = require(l_Parent_0.jsutils.invariant).invariant;
local _ = require(l_Parent_0.core.ApolloClient);
ApolloProvider = function(v7)
    local v8 = l_getApolloContext_0();
    return v3.createElement(v8.Consumer, nil, function(v9)
        if v9 == nil then
            v9 = {};
        end;
        if v7.client and v9.client ~= v7.client then
            v9.client = v7.client;
        end;
        l_invariant_0(v9.client, "ApolloProvider was not passed a client instance. Make " .. "sure you pass in your client via the \"client\" prop.");
        return v3.createElement(v8.Provider, {
            value = v9
        }, v7.children);
    end);
end;
return {
    ApolloProvider = ApolloProvider
};


local v0 = {};
local l_Parent_0 = script.Parent.Parent.Parent;
local v2 = require(l_Parent_0.Parent.LuauPolyfill);
local l_Boolean_0 = v2.Boolean;
local l_Object_0 = v2.Object;
local v5 = require(l_Parent_0.jsutils.equal);
local l_DocumentType_0 = require(script.Parent.Parent.parser).DocumentType;
local l_ApolloError_0 = require(l_Parent_0.errors).ApolloError;
local _ = require(script.Parent.Parent.types.types);
local l_OperationData_0 = require(script.Parent.OperationData).OperationData;
local l_mergeOptions_0 = require(l_Parent_0.core).mergeOptions;
local _ = require(l_Parent_0.link.core);
local v12 = setmetatable({}, {
    __index = l_OperationData_0
});
v12.__index = v12;
v12.new = function(v13)
    local v14 = l_OperationData_0.new(v13.options, v13.context);
    v14.runMutation = function(v15)
        if v15 == nil then
            v15 = {};
        end;
        v14:onMutationStart();
        local v16 = v14:generateNewMutationId();
        return v14:mutate(v15):andThen(function(v17)
            v14:onMutationCompleted(v17, v16);
            return v17;
        end):catch(function(v18)
            local v19 = v14:getOptions();
            local l_onError_0 = v19.onError;
            v14:onMutationError(v18, v16);
            if not l_Boolean_0.toJSBoolean(l_onError_0) then
                error(v18);
                return ;
            else
                l_onError_0(v19, v18);
                return {
                    data = nil,
                    errors = v18
                };
            end;
        end);
    end;
    v14:verifyDocumentType(v13.options.mutation, l_DocumentType_0.Mutation);
    v14.result = v13.result;
    v14.setResult = v13.setResult;
    v14.mostRecentMutationId = 0;
    return (setmetatable(v14, v12));
end;
v12.execute = function(v21, v22)
    v21.isMounted = true;
    v21:verifyDocumentType(v21:getOptions().mutation, l_DocumentType_0.Mutation);
    return {
        v21.runMutation,
        l_Object_0.assign({}, v22, {
            client = v21:refreshClient().client
        })
    };
end;
v12.afterExecute = function(v23)
    v23.isMounted = true;
    return function(...)
        return v23:unmount(...);
    end;
end;
v12.cleanup = function(_)
end;
v12.mutate = function(v25, v26)
    return v25:refreshClient().client:mutate(l_mergeOptions_0(v25:getOptions(), v26));
end;
v12.onMutationStart = function(v27)
    if not (v27.result.loading or v27:getOptions().ignoreResults) then
        v27:updateResult({
            loading = true,
            error = nil,
            data = nil,
            called = true
        });
    end;
end;
v12.onMutationCompleted = function(v28, v29, v30)
    local v31 = v28:getOptions();
    local l_onCompleted_0 = v31.onCompleted;
    local l_ignoreResults_0 = v31.ignoreResults;
    local l_data_0 = v29.data;
    local l_errors_0 = v29.errors;
    local v36 = if not not l_errors_0 and #l_errors_0 > 0 then l_ApolloError_0.new({
        graphQLErrors = l_errors_0
    }) else nil;
    local function _()
        if not l_Boolean_0.toJSBoolean(l_onCompleted_0) then
            return nil;
        else
            return l_onCompleted_0(l_data_0);
        end;
    end;
    if not (not v28:isMostRecentMutation(v30) or l_ignoreResults_0) then
        v28:updateResult({
            called = true,
            loading = false,
            data = l_data_0,
            error = v36
        });
    end;
    if not l_Boolean_0.toJSBoolean(l_onCompleted_0) then
        return ;
    else
        local _ = l_onCompleted_0(l_data_0);
        return ;
    end;
end;
v12.onMutationError = function(v39, v40, v41)
    if v39:isMostRecentMutation(v41) then
        v39:updateResult({
            loading = false,
            error = v40,
            data = nil,
            called = true
        });
    end;
end;
v12.generateNewMutationId = function(v42)
    v42.mostRecentMutationId = v42.mostRecentMutationId + 1;
    return v42.mostRecentMutationId;
end;
v12.isMostRecentMutation = function(v43, v44)
    return v43.mostRecentMutationId == v44;
end;
v12.updateResult = function(v45, v46)
    if not v45.isMounted or v45.previousResult and v5(v45.previousResult, v46) then
        return nil;
    else
        v45:setResult(v46);
        v45.previousResult = v46;
        return v46;
    end;
end;
v0.MutationData = v12;
return v0;


local v0 = {};
local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_Boolean_0 = require(l_Parent_1.LuauPolyfill).Boolean;
local _ = require(l_Parent_1.GraphQL);
local v5 = require(l_Parent_0.jsutils.equal);
local l_invariant_0 = require(l_Parent_0.jsutils.invariant).invariant;
local _ = require(script.Parent.Parent.Parent.core);
local v8 = require(script.Parent.Parent.parser);
local l_parser_0 = v8.parser;
local l_operationName_0 = v8.operationName;
local _ = require(script.Parent.Parent.types.types);
local v12 = {};
v12.__index = v12;
v12.new = function(v13, v14)
    return (setmetatable({
        options = not not l_Boolean_0.toJSBoolean(v13) and v13 or {},
        context = not not l_Boolean_0.toJSBoolean(v14) and v14 or {}
    }, v12));
end;
v12.getOptions = function(v15)
    return v15.options;
end;
v12.setOptions = function(v16, v17, v18)
    if v18 == nil then
        v18 = false;
    end;
    if not (not v18 or v5(v16.options, v17)) then
        v16.previousOptions = v16.options;
    end;
    v16.options = v17;
end;
v12.unmount = function(v19)
    v19.isMounted = false;
end;
v12.refreshClient = function(v20)
    local v21 = not not l_Boolean_0.toJSBoolean(if not l_Boolean_0.toJSBoolean(v20.options) then v20.options else v20.options.client) and if not l_Boolean_0.toJSBoolean(v20.options) then v20.options else v20.options.client or if l_Boolean_0.toJSBoolean(v20.context) then v20.context.client else v20.context;
    l_invariant_0(l_Boolean_0.toJSBoolean(v21), "Could not find \"client\" in the context or passed in as an option. " .. "Wrap the root component in an <ApolloProvider>, or pass an " .. "ApolloClient instance in via options.");
    local v22 = false;
    if v21 ~= v20.client then
        v22 = true;
        v20.client = v21;
        v20:cleanup();
    end;
    return {
        client = v20.client,
        isNew = v22
    };
end;
v12.verifyDocumentType = function(_, v24, v25)
    local v26 = l_parser_0(v24);
    local v27 = l_operationName_0(v25);
    l_invariant_0(v26.type == v25, ("Running a %s requires a graphql "):format(v27) .. ("%s, but a %s was used instead."):format(v27, (l_operationName_0(v26.type))));
end;
v0.OperationData = v12;
return v0;