local l_waitForEvents_0 = require(game:GetService("CorePackages").Workspace.Packages.TestUtils).DeferredLuaHelpers.waitForEvents;
local function v1()
end;
local function _(v2)
    return function()
        return v2;
    end;
end;
local l_BindableEvent_0 = Instance.new("BindableEvent");
local l_BindableEvent_1 = Instance.new("BindableEvent");
local l_BindableEvent_2 = Instance.new("BindableEvent");
local v7 = {
    ParticipantsStateChanged = l_BindableEvent_0.Event,
    StateChanged = l_BindableEvent_2.Event,
    LocalPlayerModerated = l_BindableEvent_1.Event
};
local v8 = 0;
v7.GetVoiceChatApiVersionCB = function()
    return v8;
end;
v7.GetVoiceChatAvailableCB = v1;
v7.IsSubscribePausedCB = v1;
v7.SubscribePauseCB = v1;
v7.SubscribeBlockCB = v1;
v7.SubscribeUnblockCB = v1;
v7.SubscribePauseAllCB = v1;
v7.groupId = 10000;
v7.publishPaused = false;
v7.available = true;
v7.joinCalled = false;
v7.policyMapper = nil;
local function v11(v9, v10)
    return {
        userId = tostring(v9),
        UserId = tostring(v9),
        isMuted = false,
        isMutedLocally = not not v10
    };
end;
v7.Disconnect = function(_)
end;
v7.Leave = function(_)
end;
v7.GetGroupId = function(v14)
    return v14.groupId;
end;
v7.IsPublishPaused = function(v15)
    return v15.publishPaused;
end;
v7.JoinByGroupIdToken = function(v16)
    v16.joinCalled = true;
    return true;
end;
v7.IsSubscribePaused = function(v17)
    return v17.IsSubscribePausedCB();
end;
v7.SubscribePause = function(v18, v19)
    return v18.SubscribePauseCB(v19);
end;
v7.GetVoiceChatApiVersion = function(v20)
    return v20.GetVoiceChatApiVersionCB();
end;
v7.GetVoiceChatAvailable = function(v21)
    return v21.GetVoiceChatAvailableCB();
end;
v7.SubscribeBlock = function(v22)
    return v22.SubscribeBlockCB();
end;
v7.SubscribePauseAll = function(v23)
    return v23.SubscribePauseAllCB();
end;
v7.SubscribeUnblock = function(v24)
    return v24.SubscribeUnblockCB();
end;
v7.kickUsers = function(_, v26)
    l_BindableEvent_0:Fire(v26, {}, {});
    l_waitForEvents_0();
end;
v7.ModerateLocalPlayer = function(_)
    l_BindableEvent_1:Fire();
    l_waitForEvents_0();
end;
v7.addUsers = function(_, v29)
    l_BindableEvent_0:Fire({}, {}, v29);
    l_waitForEvents_0();
end;
v7.setUserStates = function(_, v31)
    l_BindableEvent_0:Fire({}, {}, v31);
    l_waitForEvents_0();
end;
v7.resetMocks = function(v32)
    l_BindableEvent_0 = Instance.new("BindableEvent");
    l_BindableEvent_2 = Instance.new("BindableEvent");
    l_BindableEvent_1 = Instance.new("BindableEvent");
    v32.LocalPlayerModerated = l_BindableEvent_1.Event;
    v32.ParticipantsStateChanged = l_BindableEvent_0.Event;
    v32.StateChanged = l_BindableEvent_2.Event;
    v32.joinCalled = false;
end;
return {
    ParticipantsStateChangedMock = l_BindableEvent_0,
    StateChangedMock = l_BindableEvent_2,
    VoiceChatServiceStub = v7,
    makeMockUser = v11
};


local v0 = not not game:GetEngineFeature("VoiceChatSupported") and Enum.VoiceChatState.Ended or nil;
local v1 = {
    voiceEnabled = false,
    voiceState = v0
};
local l_CorePackages_0 = game:GetService("CorePackages");
local l_CoreGui_0 = game:GetService("CoreGui");
local v4 = require(l_CorePackages_0.Packages.React);
local l_default_0 = require(l_CoreGui_0:WaitForChild("RobloxGui").Modules.VoiceChat.VoiceChatServiceManager).default;
local v6 = v4.createContext(v1);
return {
    Provider = function(v7)
        local v8, v9 = v4.useState(v1);
        local function v12(_, v11)
            if v11 ~= v8.voiceState then
                v9({
                    voiceEnabled = v11 ~= Enum.VoiceChatState.Ended,
                    voiceState = v11
                });
            end;
        end;
        v4.useEffect(function()
            local v13 = true;
            local v14 = nil;
            if game:GetEngineFeature("VoiceChatSupported") then
                l_default_0:asyncInit():andThen(function()
                    if v13 then
                        l_default_0:SetupParticipantListeners();
                        local v15 = l_default_0:getService();
                        if v15 then
                            local l_VoiceChatState_0 = v15.VoiceChatState;
                            if l_VoiceChatState_0 ~= v8.voiceState then
                                v9({
                                    voiceEnabled = l_VoiceChatState_0 ~= Enum.VoiceChatState.Ended,
                                    voiceState = l_VoiceChatState_0
                                });
                            end;
                            v14 = v15.StateChanged:Connect(v12);
                        end;
                    end;
                end):catch(function()
                    local l_v0_0 = v0;
                    if l_v0_0 ~= v8.voiceState then
                        v9({
                            voiceEnabled = l_v0_0 ~= Enum.VoiceChatState.Ended,
                            voiceState = l_v0_0
                        });
                    end;
                end);
            end;
            return function()
                v13 = false;
                if v14 then
                    v14:Disconnect();
                    v14 = nil;
                end;
            end;
        end, {});
        return v4.createElement(v6.Provider, {
            value = v8
        }, v7.children);
    end,
    Consumer = v6.Consumer,
    Context = v6,
    withVoiceState = function(v18)
        return v4.createElement(v6.Consumer, {
            render = v18
        });
    end
};


local _ = require(script.Parent.VoiceChatServiceManager);
local function _(v1)
    return (v1 and v1.Character) and v1.Character.PrimaryPart;
end;
local function _(v3, v4)
    local v5 = (v3 and v3.Character) and v3.Character.PrimaryPart;
    local v6 = nil;
    if v5 then
        v6 = (v5.Position - v4).Magnitude;
    end;
    return v6;
end;
return {
    getComparator = function(v8)
        return function(v9, v10)
            local v11 = (v9 and v9.Character) and v9.Character.PrimaryPart;
            local v12 = (v10 and v10.Character) and v10.Character.PrimaryPart;
            if v11 or v12 then
                if not v11 or v12 then
                    if v11 or not v12 then
                        local l_v8_0 = v8;
                        local v14 = (v9 and v9.Character) and v9.Character.PrimaryPart;
                        local v15 = nil;
                        if v14 then
                            v15 = (v14.Position - l_v8_0).Magnitude;
                        end;
                        local l_v15_0 = v15;
                        v14 = v8;
                        v15 = (v10 and v10.Character) and v10.Character.PrimaryPart;
                        local v17 = nil;
                        if v15 then
                            v17 = (v15.Position - v14).Magnitude;
                        end;
                        return l_v15_0 < v17;
                    else
                        return false;
                    end;
                else
                    return true;
                end;
            else
                return v9.Name:lower() < v10.Name:lower();
            end;
        end;
    end,
    getSortedPlayers = function(v18, v19, v20, v21, v22, v23, v24)
        local v25 = {};
        local function v35(v26, v27)
            local v28 = (v26 and v26.Character) and v26.Character.PrimaryPart;
            local v29 = (v27 and v27.Character) and v27.Character.PrimaryPart;
            if v28 or v29 then
                if not v28 or v29 then
                    if v28 or not v29 then
                        local l_v20_0 = v20;
                        local v31 = (v26 and v26.Character) and v26.Character.PrimaryPart;
                        local v32 = nil;
                        if v31 then
                            v32 = (v31.Position - l_v20_0).Magnitude;
                        end;
                        local l_v32_0 = v32;
                        v31 = v20;
                        v32 = (v27 and v27.Character) and v27.Character.PrimaryPart;
                        local v34 = nil;
                        if v32 then
                            v34 = (v32.Position - v31).Magnitude;
                        end;
                        return l_v32_0 < v34;
                    else
                        return false;
                    end;
                else
                    return true;
                end;
            else
                return v26.Name:lower() < v27.Name:lower();
            end;
        end;
        for v36, _ in pairs(v19.participants) do
            local l_v18_PlayerByUserId_0 = v18:GetPlayerByUserId(v36);
            if not (not (l_v18_PlayerByUserId_0 and v23 ~= l_v18_PlayerByUserId_0) or not v24 and not ((l_v18_PlayerByUserId_0 and l_v18_PlayerByUserId_0.Character) and l_v18_PlayerByUserId_0.Character.PrimaryPart)) then
                if not (not v21 or not l_v18_PlayerByUserId_0) then
                    local v39 = (l_v18_PlayerByUserId_0 and l_v18_PlayerByUserId_0.Character) and l_v18_PlayerByUserId_0.Character.PrimaryPart;
                    local v40 = nil;
                    if v39 then
                        v40 = (v39.Position - v20).Magnitude;
                    end;
                    if not (v21 >= v40) then
                        continue;
                    end;
                end;
                if not (v22 and not v19:getRecentUsersInteractionData()[tostring(l_v18_PlayerByUserId_0.UserId)]) then
                    table.insert(v25, l_v18_PlayerByUserId_0);
                end;
            end;
        end;
        table.sort(v25, v35);
        return v25;
    end
};


local l_HttpService_0 = game:GetService("HttpService");
local v1 = require(game:GetService("CorePackages").Cryo);
local _ = require(script.Parent.VoiceChatServiceManager);
local l_getSortedPlayers_0 = require(script.Parent.VoiceUsersByProximity).getSortedPlayers;
return function(v4, v5, v6)
    local l_v4_PlayerByUserId_0 = v4:GetPlayerByUserId(v6.abuserUserId);
    local v8 = nil;
    if not ((not l_v4_PlayerByUserId_0 or not l_v4_PlayerByUserId_0.Character) or not l_v4_PlayerByUserId_0.Character.PrimaryPart) then
        v8 = l_v4_PlayerByUserId_0.Character.PrimaryPart.Position;
    end;
    local v9 = #v1.Dictionary.values(v5.participants);
    local v10 = 0;
    if v8 then
        v10 = #l_getSortedPlayers_0(v4, v5, v8, 160, nil, l_v4_PlayerByUserId_0);
    end;
    return l_HttpService_0:JSONEncode({
        tags = {
            ENTRY_POINT = {
                valueList = {
                    {
                        data = "in-experience"
                    }
                }
            },
            SUBMITTER_USER_ID = {
                valueList = {
                    {
                        data = tostring(v6.localUserId)
                    }
                }
            },
            REPORT_TARGET_USER_ID = {
                valueList = {
                    {
                        data = tostring(v6.abuserUserId)
                    }
                }
            },
            REPORTED_ABUSE_CATEGORY = {
                valueList = {
                    {
                        data = v6.abuseReason
                    }
                }
            },
            REPORTER_COMMENT = {
                valueList = {
                    {
                        data = v6.abuseComment
                    }
                }
            },
            IS_PLACE_VOICE_ENABLED = {
                valueList = {
                    {
                        data = "true"
                    }
                }
            },
            VOICE_USER_IDS_FROM_CLIENT = {
                valueList = v1.List.map(v6.sortedPlayerListUserIds, function(v11)
                    return {
                        data = tostring(v11)
                    };
                end)
            },
            IN_EXP_MENU_OPENED_UNIX_MILLI = {
                valueList = {
                    {
                        data = tostring(v6.inExpMenuOpenedUnixMilli)
                    }
                }
            },
            VOICE_CHANNEL_ID = {
                valueList = {
                    {
                        data = tostring(if not game:GetEngineFeature("VoiceChatServiceExposesChannelId") then v5.service:GetGroupId() else v5.service:GetChannelId())
                    }
                }
            },
            VOICE_USER_COUNT = {
                valueList = {
                    {
                        data = tostring(v9)
                    }
                }
            },
            VOICE_IMPACTED_USER_COUNT = {
                valueList = {
                    {
                        data = tostring(v10)
                    }
                }
            },
            REPORTED_ABUSE_VECTOR = {
                valueList = {
                    {
                        data = v6.abuseVector
                    }
                }
            }
        }
    });
end;


local l_CorePackages_0 = game:GetService("CorePackages");
local l_RobloxGui_0 = game:GetService("CoreGui"):WaitForChild("RobloxGui");
local l_Players_0 = game:GetService("Players");
local v3 = require(l_RobloxGui_0.Modules.Flags.FFlagEnableVoiceChatStorybookFix);
local v4 = require(l_RobloxGui_0.Modules.Flags.GetFFlagSubscriptionFailureUX);
local v5 = require(l_RobloxGui_0.Modules.Flags.GetFFlagLocalMutedNilFix);
local v6 = require(l_RobloxGui_0.Modules.Flags.GetFFlagRemoveInGameChatBubbleChatReferences);
local v7 = require(script.Parent.Actions.VoiceEnabledChanged);
local v8 = require(script.Parent.Actions.VoiceStateChanged);
local v9 = require(script.Parent.Actions.ParticipantAdded);
local v10 = require(script.Parent.Actions.ParticipantRemoved);
local v11 = require(script.Parent.Actions.PlayerRemoved);
local l_default_0 = require(script.Parent.VoiceChatServiceManager).default;
local l_Constants_0 = require(l_CorePackages_0.Workspace.Packages.VoiceChat).Constants;
local v14 = require(l_RobloxGui_0.Modules.BlockingUtility);
local v15 = require(l_RobloxGui_0.Modules.InGameChat.BubbleChat.Logger)(script.Name);
if v6() then
    v15 = require(l_RobloxGui_0.Modules.VoiceChat.Logger)(script.Name);
end;
local v16 = nil;
v16 = if not v3() then l_default_0.VOICE_STATE else l_Constants_0.VOICE_STATE;
local function _(v17)
    return "..." .. string.sub(tostring(v17), -4);
end;
local v19 = nil;
local function v26(v20, v21)
    local v22 = tostring(l_Players_0.LocalPlayer.UserId);
    v21:dispatch(v7(v20 ~= Enum.VoiceChatState.Ended));
    if v19[v20] then
        v21:dispatch(v8(v22, v19[v20]));
    else
        v15:warning("LOCAL_STATE_MAP does not exist for {} state", v20);
        v21:dispatch(v8(v22, v16.MUTED));
    end;
    if v20 == Enum.VoiceChatState.Failed then
        for _, v24 in pairs(l_Players_0:GetPlayers()) do
            local v25 = tostring(v24.UserId);
            if v24 ~= l_Players_0.LocalPlayer then
                v21:dispatch(v8(v25, v16.HIDDEN));
            end;
        end;
        return ;
    else
        if not (not (v20 == Enum.VoiceChatState.Joined) or not if not v5 then not l_default_0.localMuted else l_default_0.localMuted == false) then
            v21:dispatch(v8(v22, v16.INACTIVE));
        end;
        return ;
    end;
end;
local function v44(v27)
    v19 = {
        [Enum.VoiceChatState.Idle] = v16.HIDDEN,
        [Enum.VoiceChatState.Joining] = v16.CONNECTING,
        [Enum.VoiceChatState.JoiningRetry] = v16.CONNECTING,
        [Enum.VoiceChatState.Joined] = v16.MUTED,
        [Enum.VoiceChatState.Leaving] = v16.MUTED,
        [Enum.VoiceChatState.Ended] = v16.HIDDEN,
        [Enum.VoiceChatState.Failed] = v16.ERROR
    };
    local v28 = l_default_0:getService();
    if v28 then
        local l_UserId_0 = l_Players_0.LocalPlayer.UserId;
        for _, v31 in pairs(l_Players_0:GetPlayers()) do
            v15:trace("Adding existing player {}", "..." .. string.sub(tostring(v31.UserId), -4));
            v27:dispatch(v9((tostring(v31.UserId))));
        end;
        l_Players_0.PlayerAdded:Connect(function(v32)
            v15:trace("Adding joining player {}", "..." .. string.sub(tostring(v32.UserId), -4));
            v27:dispatch(v9((tostring(v32.userId))));
        end);
        l_Players_0.PlayerRemoving:Connect(function(v33)
            v15:trace("Removing player {}", "..." .. string.sub(tostring(v33.UserId), -4));
            v27:dispatch(v11((tostring(v33.userId))));
            v27:dispatch(v10((tostring(v33.userId))));
        end);
        v27:dispatch(v8(l_UserId_0, v16.HIDDEN));
        l_default_0.muteChanged.Event:Connect(function(v34)
            v15:debug("Mute changed to {}", v34);
            v27:dispatch(v8(l_UserId_0, not not v34 and v16.MUTED or v16.INACTIVE));
        end);
        l_default_0.participantsUpdate.Event:Connect(function(v35)
            for v36, v37 in pairs(v35) do
                local l_INACTIVE_0 = v16.INACTIVE;
                if not v37.subscriptionFailed or not v4() then
                    if v37.subscriptionCompleted then
                        if not v37.isMutedLocally then
                            if not v37.isMuted then
                                if v37.isSignalActive then
                                    l_INACTIVE_0 = v16.TALKING;
                                end;
                            else
                                l_INACTIVE_0 = v16.MUTED;
                            end;
                        else
                            l_INACTIVE_0 = v16.LOCAL_MUTED;
                        end;
                    else
                        l_INACTIVE_0 = v16.CONNECTING;
                    end;
                else
                    l_INACTIVE_0 = v16.ERROR;
                end;
                v15:trace("Participant update for {}, voice state {}", v36, l_INACTIVE_0);
                v27:dispatch(v8(v36, l_INACTIVE_0));
            end;
        end);
        l_default_0.talkingChanged.Event:Connect(function(v39)
            if not v39 then
                v27:dispatch(v8(l_UserId_0, v16.INACTIVE));
                return ;
            else
                v27:dispatch(v8(l_UserId_0, v16.TALKING));
                return ;
            end;
        end);
        v14:GetBlockedStatusChangedEvent():Connect(function(v40, v41)
            if not v41 then
                v27:dispatch(v9((tostring(v40))));
                return ;
            else
                v27:dispatch(v10((tostring(v40))));
                return ;
            end;
        end);
        v15:debug("Initial voice state is {}", v28.VoiceChatState);
        v26(v28.VoiceChatState, v27);
        v28.StateChanged:Connect(function(_, v43)
            v15:debug("Voice state changed to {}", v43);
            v26(v43, v27);
        end);
        return ;
    else
        v15:debug("VoiceChatService is not available");
        return ;
    end;
end;
return function(v45)
    if game:GetEngineFeature("VoiceChatSupported") then
        l_default_0:asyncInit():andThen(function()
            l_default_0:SetupParticipantListeners();
            v44(v45);
        end):catch(function()
            v15:warning("Failed to init VoiceChatServiceManager");
        end);
    end;
end;


local l_CorePackages_0 = game:GetService("CorePackages");
local v1 = require(l_CorePackages_0.Roact);
local v2 = require(l_CorePackages_0.Packages.t);
local v3 = require(script.Parent.Parent.Parent.InGameMenu.InGameMenuPolicy);
local v4 = require(script.Parent.VoiceChatPromptFrame);
local v5 = v1.PureComponent:extend("VoiceChatPrompt");
v5.validateProps = v2.strictInterface({
    promptSignal = v2.optional(v2.RBXScriptSignal),
    errorText = v2.optional(v2.string),
    bannedUntil = v2.optional(v2.string),
    onContinueFunc = v2.optional(v2.callback),
    onPrimaryActivated = v2.optional(v2.callback),
    onSecondaryActivated = v2.optional(v2.callback),
    onReadyForSignal = v2.optional(v2.callback),
    Analytics = v2.optional(v2.table),
    VoiceChatServiceManager = v2.optional(v2.table),
    policyMapper = v2.optional(v2.callback)
});
v5.render = function(v6)
    return v1.createElement("ScreenGui", {
        AutoLocalize = false,
        DisplayOrder = 9,
        IgnoreGuiInset = true,
        OnTopOfCoreBlur = true,
        ZIndexBehavior = Enum.ZIndexBehavior.Sibling
    }, {
        PolicyProvider = v1.createElement(v3.Provider, {
            policy = {
                v6.props.policyMapper or v3.Mapper
            }
        }, {
            Content = v1.createElement(v4, v6.props)
        })
    });
end;
return v5;


return {
    None = "None",
    User = "User",
    Place = "Place",
    NotAudible = "NotAudible",
    Permission = "Permission",
    Retry = "Retry",
    VoiceChatSuspendedTemporary = "VoiceChatSuspendedTemporary",
    VoiceChatSuspendedTemporaryAvatarChat = "VoiceChatSuspendedTemporaryAvatarChat",
    VoiceChatSuspendedTemporaryB = "VoiceChatSuspendedTemporaryB",
    VoiceChatSuspendedPermanent = "VoiceChatSuspendedPermanent",
    VoiceLoading = "VoiceLoading",
    VoiceToxicityModal = "VoiceToxicityModal",
    VoiceToxicityToast = "VoiceToxicityToast",
    VoiceToxicityFeedbackToast = "VoiceToxicityFeedbackToast",
    VoiceChatSuspendedTemporaryToast = "VoiceChatSuspendedTemporaryToast",
    VoiceConsentDeclinedToast = "VoiceConsentDeclinedToast",
    VoiceConsentAcceptedToast = "VoiceConsentAcceptedToast",
    VoiceConsentModalV1 = "VoiceConsentModalV1",
    VoiceConsentModalV2 = "VoiceConsentModalV2",
    VoiceConsentModalV3 = "VoiceConsentModalV3"
};


local l_CorePackages_0 = game:GetService("CorePackages");
local v1 = require(l_CorePackages_0.Packages.Roact);
require(l_CorePackages_0.UIBlox).init(require(l_CorePackages_0.Workspace.Packages.RobloxAppUIBloxConfig));
v1.setGlobalConfig({
    elementTracing = true,
    propValidation = true
});
return {
    roact = v1,
    mapStory = function(v2)
        return function(v3)
            return v1.createElement(v2, v3);
        end;
    end
};


local l_CorePackages_0 = game:GetService("CorePackages");
local _ = game:GetService("CoreGui");
local l_RunService_0 = game:GetService("RunService");
local v3 = require(l_CorePackages_0.Roact);
local _ = require(l_CorePackages_0.RoactRodux);
local _ = require(l_CorePackages_0.UIBlox).App.ImageSet.Images;
local v6 = v3.PureComponent:extend("WatermarkComponent");
local l_PolicyService_0 = game:GetService("PolicyService");
v6.init = function(v8)
    local function v12()
        local l_v8_0 = v8;
        local v10 = {};
        local v11 = not l_RunService_0:IsStudio();
        if v11 then
            v11 = false;
            if l_PolicyService_0.IsLuobuServer == Enum.TriStateBoolean.True then
                v11 = l_PolicyService_0.LuobuWhitelisted == Enum.TriStateBoolean.False;
            end;
        end;
        v10.watermarkVisible = v11;
        l_v8_0:setState(v10);
    end;
    l_PolicyService_0:GetPropertyChangedSignal("IsLuobuServer"):connect(function()
        v12();
    end);
    l_PolicyService_0:GetPropertyChangedSignal("LuobuWhitelisted"):connect(function()
        v12();
    end);
    v8:setState({
        absoluteSize = Vector2.new(0, 0),
        watermarkVisible = false
    });
    v8.onAbsoluteSizeChange = function(v13)
        v8:setState({
            absoluteSize = v13.AbsoluteSize
        });
    end;
    v12();
end;
v6.render = function(v14)
    local function _()
        return v14.state.absoluteSize.X * 0.9681476403781077 + v14.state.absoluteSize.Y * 0.25038000405444144;
    end;
    local function _()
        return v14.state.absoluteSize.Y * 0.9681476403781077 + v14.state.absoluteSize.X * 0.25038000405444144;
    end;
    return not not v14.state.watermarkVisible and v3.createElement("ScreenGui", {
        IgnoreGuiInset = true,
        ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
        AutoLocalize = false,
        DisplayOrder = 10,
        [v3.Change.AbsoluteSize] = v14.onAbsoluteSizeChange
    }, {
        FullScreenFrame = v3.createElement("Frame", {
            BackgroundTransparency = 1,
            Size = UDim2.new(0, v14.state.absoluteSize.X * 0.9681476403781077 + v14.state.absoluteSize.Y * 0.25038000405444144, 0, v14.state.absoluteSize.Y * 0.9681476403781077 + v14.state.absoluteSize.X * 0.25038000405444144),
            Position = UDim2.new(0, (v14.state.absoluteSize.X - (v14.state.absoluteSize.X * 0.9681476403781077 + v14.state.absoluteSize.Y * 0.25038000405444144)) * 0.5, 0, (v14.state.absoluteSize.Y - (v14.state.absoluteSize.Y * 0.9681476403781077 + v14.state.absoluteSize.X * 0.25038000405444144)) * 0.5),
            Rotation = 14.5
        }, ((function()
            local v17 = math.ceil((v14.state.absoluteSize.X * 0.9681476403781077 + v14.state.absoluteSize.Y * 0.25038000405444144) / 450);
            local v18 = math.ceil((v14.state.absoluteSize.Y * 0.9681476403781077 + v14.state.absoluteSize.X * 0.25038000405444144) / 450);
            local v19 = {};
            for v20 = 0, v18 - 1 do
                for v21 = 0, v17 - 1 do
                    table.insert(v19, v3.createElement("TextLabel", {
                        BackgroundTransparency = 1,
                        TextTransparency = 0.75,
                        Text = "\228\187\133\231\148\168\228\186\142\230\181\139\232\175\149\239\188\140\n\233\157\158\230\173\163\229\188\143\229\143\145\232\161\168\227\128\130",
                        TextSize = 30,
                        TextColor3 = Color3.new(1, 1, 1),
                        Size = UDim2.new(0, 225, 0, 225),
                        Position = UDim2.new(0, v21 * 450, 0, v20 * 450)
                    }));
                    table.insert(v19, v3.createElement("TextLabel", {
                        BackgroundTransparency = 1,
                        TextTransparency = 0.91,
                        Text = "\228\187\133\231\148\168\228\186\142\230\181\139\232\175\149\239\188\140\n\233\157\158\230\173\163\229\188\143\229\143\145\232\161\168\227\128\130",
                        TextSize = 30,
                        TextColor3 = Color3.new(0, 0, 0),
                        Size = UDim2.new(0, 225, 0, 225),
                        Position = UDim2.new(0, v21 * 450 + 1, 0, v20 * 450 + 1)
                    }));
                    table.insert(v19, v3.createElement("TextLabel", {
                        BackgroundTransparency = 1,
                        TextTransparency = 0.75,
                        Text = "\228\187\133\231\148\168\228\186\142\230\181\139\232\175\149\239\188\140\n\233\157\158\230\173\163\229\188\143\229\143\145\232\161\168\227\128\130",
                        TextSize = 30,
                        TextColor3 = Color3.new(1, 1, 1),
                        Size = UDim2.new(0, 225, 0, 225),
                        Position = UDim2.new(0, v21 * 450 + 225, 0, v20 * 450 + 225)
                    }));
                    table.insert(v19, v3.createElement("TextLabel", {
                        BackgroundTransparency = 1,
                        TextTransparency = 0.91,
                        Text = "\228\187\133\231\148\168\228\186\142\230\181\139\232\175\149\239\188\140\n\233\157\158\230\173\163\229\188\143\229\143\145\232\161\168\227\128\130",
                        TextSize = 30,
                        TextColor3 = Color3.new(0, 0, 0),
                        Size = UDim2.new(0, 225, 0, 225),
                        Position = UDim2.new(0, v21 * 450 + 226, 0, v20 * 450 + 226)
                    }));
                end;
            end;
            return v19;
        end)()))
    }) or nil;
end;
return v6;


local l_CorePackages_0 = game:GetService("CorePackages");
local l_CoreGui_0 = game:GetService("CoreGui");
local v2 = require(l_CorePackages_0.Roact);
local v3 = require(script.WatermarkComponent);
local v4 = {};
v4.__index = v4;
v4.new = function()
    local v5 = setmetatable({}, v4);
    v5.root = v2.createElement(v3);
    v5.element = v2.mount(v5.root, l_CoreGui_0, "Watermark");
    return v5;
end;
return v4.new();


local l_Players_0 = game:GetService("Players");
local l_VRService_0 = game:GetService("VRService");
local l_CorePackages_0 = game:GetService("CorePackages");
local v3 = require(script.Parent.IsExperienceMenuABTestEnabled);
local v4 = require(script.Parent.ExperienceMenuABTestManager);
game:DefineFastInt("NewInGameMenuPercentRollout3", 0);
game:DefineFastString("NewInGameMenuForcedUserIds", "");
game:DefineFastFlag("NewInGameMenuDisabledInVR", false);
local _ = game:GetService("CoreGui"):WaitForChild("RobloxGui");
local v6 = game:DefineFastFlag("DisableNewIGMinDUA", false);
local l_isSubjectToDesktopPolicies_0 = require(l_CorePackages_0.Workspace.Packages.SharedFlags).isSubjectToDesktopPolicies;
return function()
    if not l_VRService_0.VREnabled then
        if v6 or not l_isSubjectToDesktopPolicies_0() then
            local l_LocalPlayer_0 = l_Players_0.LocalPlayer;
            while not l_LocalPlayer_0 do
                l_Players_0:GetPropertyChangedSignal("LocalPlayer"):Wait();
                l_LocalPlayer_0 = l_Players_0.LocalPlayer;
            end;
            for v9 in game:GetFastString("NewInGameMenuForcedUserIds"):gmatch("%d+") do
                if tonumber(v9) == l_LocalPlayer_0.UserId then
                    return true;
                end;
            end;
            if not v3() or not v4.default:isV3MenuEnabled() then
                if not (l_LocalPlayer_0.UserId % 100 < game:GetFastInt("NewInGameMenuPercentRollout3")) then
                    return false;
                else
                    return true;
                end;
            else
                return true;
            end;
        else
            return true;
        end;
    else
        return true;
    end;
end;


local l_RobloxGui_0 = game:GetService("CoreGui"):WaitForChild("RobloxGui");
local v1 = require(l_RobloxGui_0.Modules.isNewInGameMenuEnabled);
local v2 = require(l_RobloxGui_0.Modules.Chrome.Enabled);
return function()
    return v2() and not v1();
end;


local l_CoreGui_0 = game:GetService("CoreGui");
local l_UserInputService_0 = game:GetService("UserInputService");
local l_RobloxGui_0 = l_CoreGui_0:WaitForChild("RobloxGui");
local v3 = require(l_RobloxGui_0.Modules.Common.PolicyService);
local v4 = require(l_RobloxGui_0.Modules.Flags.GetFFlagScreenshotHudApi);
return function()
    local l_l_UserInputService_0_Platform_0 = l_UserInputService_0:GetPlatform();
    local v6 = true;
    if l_l_UserInputService_0_Platform_0 ~= Enum.Platform.IOS then
        v6 = l_l_UserInputService_0_Platform_0 == Enum.Platform.Android;
    end;
    local v7 = false;
    if not ((not v4() or not v6) or v3:IsSubjectToChinaPolicies()) then
        v7 = true;
    end;
    return v7;
end;


return require(game:GetService("CorePackages").Rodux).makeActionCreator(script.Name, function(v0)
    return {
        deviceOrientation = v0
    };
end);


return require(game:GetService("CorePackages").Rodux).makeActionCreator(script.Name, function(v0, v1)
    return {
        userId = v0,
        universeId = v1
    };
end);


local l_UserInputService_0 = game:GetService("UserInputService");
local v1 = {};
local function _()
    local v2 = v1[#v1];
    if not v2 then
        l_UserInputService_0.OverrideMouseIconBehavior = Enum.OverrideMouseIconBehavior.None;
        return ;
    else
        l_UserInputService_0.OverrideMouseIconBehavior = v2[2];
        return ;
    end;
end;
return {
    push = function(v4, v5)
        local v6 = true;
        if type(v4) ~= "userdata" then
            v6 = type(v4) == "string";
        end;
        assert(v6, "key");
        assert(typeof(v5) == "EnumItem", "behavior");
        assert(v5.EnumType == Enum.OverrideMouseIconBehavior, "behavior.EnumType");
        for v7, v8 in ipairs(v1) do
            if v8[1] == v4 then
                table.remove(v1, v7);
                break;
            end;
        end;
        table.insert(v1, {
            v4,
            v5
        });
        local v9 = v1[#v1];
        if not v9 then
            l_UserInputService_0.OverrideMouseIconBehavior = Enum.OverrideMouseIconBehavior.None;
            return ;
        else
            l_UserInputService_0.OverrideMouseIconBehavior = v9[2];
            return ;
        end;
    end,
    pop = function(v10)
        local v11 = true;
        if type(v10) ~= "userdata" then
            v11 = type(v10) == "string";
        end;
        assert(v11, "key");
        local v12 = nil;
        for v13, v14 in ipairs(v1) do
            if v14[1] == v10 then
                v12 = v13;
                break;
            end;
        end;
        if v12 then
            table.remove(v1, v12);
        end;
        v11 = v1[#v1];
        if not v11 then
            l_UserInputService_0.OverrideMouseIconBehavior = Enum.OverrideMouseIconBehavior.None;
            return ;
        else
            l_UserInputService_0.OverrideMouseIconBehavior = v11[2];
            return ;
        end;
    end
};


local _ = game:DefineFastFlag("LoggingRethrowUsingError", false);
local function _()
    return game:GetFastFlag("LoggingRethrowUsingError");
end;
local v2 = true;
local v3 = {};
local function v6()
    local v4 = {
        warnings = {}
    };
    setmetatable(v4, {
        __tostring = function(v5)
            return ("LogInfo\n\tWarnings (%d):\n\t\t%s"):format(#v5.warnings, table.concat(v5.warnings, "\n\t\t"));
        end
    });
    return v4;
end;
return {
    capture = function(v7)
        local v8 = v6();
        local l_v2_0 = v2;
        v2 = false;
        v3[v8] = true;
        local l_status_0, l_result_0 = pcall(v7);
        v3[v8] = nil;
        v2 = l_v2_0;
        if not game:GetFastFlag("LoggingRethrowUsingError") then
            assert(l_status_0, l_result_0);
        elseif not l_status_0 then
            error(l_result_0);
            return v8;
        end;
        return v8;
    end,
    warn = function(v12)
        for v13 in pairs(v3) do
            table.insert(v13.warnings, v12);
        end;
        if v2 then
            warn(v12);
        end;
    end
};


local _ = function(v0)
    return function(_, ...)
        local v2 = v0(...);
        return {
            pass = v2.pass,
            message = function()
                return v2.message;
            end
        };
    end;
end;
local v4 = {};
local v5 = require(script.Parent.above);
local l_v5_0 = v5 --[[ copy: 3 -> 4 ]];
v4.toBeAbove = function(_, ...)
    local v8 = l_v5_0(...);
    return {
        pass = v8.pass,
        message = function()
            return v8.message;
        end
    };
end;
v5 = require(script.Parent.alignedHorizontally);
local l_v5_1 = v5 --[[ copy: 3 -> 5 ]];
v4.toBeAlignedHorizontally = function(_, ...)
    local v11 = l_v5_1(...);
    return {
        pass = v11.pass,
        message = function()
            return v11.message;
        end
    };
end;
v5 = require(script.Parent.alignedVertically);
local l_v5_2 = v5 --[[ copy: 3 -> 6 ]];
v4.toBeAlignedVertically = function(_, ...)
    local v14 = l_v5_2(...);
    return {
        pass = v14.pass,
        message = function()
            return v14.message;
        end
    };
end;
v5 = require(script.Parent.below);
local l_v5_3 = v5 --[[ copy: 3 -> 7 ]];
v4.toBeBelow = function(_, ...)
    local v17 = l_v5_3(...);
    return {
        pass = v17.pass,
        message = function()
            return v17.message;
        end
    };
end;
v5 = require(script.Parent.inside);
local l_v5_4 = v5 --[[ copy: 3 -> 8 ]];
v4.toBeInside = function(_, ...)
    local v20 = l_v5_4(...);
    return {
        pass = v20.pass,
        message = function()
            return v20.message;
        end
    };
end;
v5 = require(script.Parent.insideAbove);
local l_v5_5 = v5 --[[ copy: 3 -> 9 ]];
v4.toBeInsideAbove = function(_, ...)
    local v23 = l_v5_5(...);
    return {
        pass = v23.pass,
        message = function()
            return v23.message;
        end
    };
end;
v5 = require(script.Parent.insideBelow);
local l_v5_6 = v5 --[[ copy: 3 -> 10 ]];
v4.toBeInsideBelow = function(_, ...)
    local v26 = l_v5_6(...);
    return {
        pass = v26.pass,
        message = function()
            return v26.message;
        end
    };
end;
v5 = require(script.Parent.insideLeftOf);
local l_v5_7 = v5 --[[ copy: 3 -> 11 ]];
v4.toBeInsideLeftOf = function(_, ...)
    local v29 = l_v5_7(...);
    return {
        pass = v29.pass,
        message = function()
            return v29.message;
        end
    };
end;
v5 = require(script.Parent.insideRightOf);
local l_v5_8 = v5 --[[ copy: 3 -> 12 ]];
v4.toBeInsideRightOf = function(_, ...)
    local v32 = l_v5_8(...);
    return {
        pass = v32.pass,
        message = function()
            return v32.message;
        end
    };
end;
v5 = require(script.Parent.leftOf);
local l_v5_9 = v5 --[[ copy: 3 -> 13 ]];
v4.toBeLeftOf = function(_, ...)
    local v35 = l_v5_9(...);
    return {
        pass = v35.pass,
        message = function()
            return v35.message;
        end
    };
end;
v5 = require(script.Parent.rightOf);
local l_v5_10 = v5 --[[ copy: 3 -> 14 ]];
v4.toBeRightOf = function(_, ...)
    local v38 = l_v5_10(...);
    return {
        pass = v38.pass,
        message = function()
            return v38.message;
        end
    };
end;
v5 = require(script.Parent.intersect);
v4.toIntersect = function(_, ...)
    local v40 = v5(...);
    return {
        pass = v40.pass,
        message = function()
            return v40.message;
        end
    };
end;
return v4;


return {
    above = require(script.Parent.above),
    alignedHorizontally = require(script.Parent.alignedHorizontally),
    alignedVertically = require(script.Parent.alignedVertically),
    below = require(script.Parent.below),
    inside = require(script.Parent.inside),
    insideAbove = require(script.Parent.insideAbove),
    insideBelow = require(script.Parent.insideBelow),
    insideLeftOf = require(script.Parent.insideLeftOf),
    insideRightOf = require(script.Parent.insideRightOf),
    intersect = require(script.Parent.intersect),
    leftOf = require(script.Parent.leftOf),
    rightOf = require(script.Parent.rightOf)
};


local v0 = require(script.Parent.toRect);
local v1 = require(script.Parent.returnValue);
return function(v2, v3, v4)
    local v5 = -(v0(v2).Max - v0(v3).Min);
    if not v4 then
        return v1(v5.Y >= 0, "Was above the element", "Was below the element");
    else
        if typeof(v4) == "number" then
            v4 = NumberRange.new(v4);
        end;
        local l_v1_0 = v1;
        local v7 = false;
        if v4.Min <= v5.Y then
            v7 = v5.Y <= v4.Max;
        end;
        return l_v1_0(v7, "Was within range", "Was not within range ( " .. tostring(v4) .. ")");
    end;
end;


local v0 = require(script.Parent.toRect);
local v1 = require(script.Parent.returnValue);
return function(v2, v3, v4)
    local v5 = v0(v2);
    local v6 = v0(v3);
    if v4 == Enum.HorizontalAlignment.Left then
        return v1(v5.Min.X == v6.Min.X, "", "");
    elseif v4 == Enum.HorizontalAlignment.Center then
        return v1(((v5.Min + v5.Max) / 2).X == ((v6.Min + v6.Max) / 2).X, "", "");
    elseif v4 == Enum.HorizontalAlignment.Right then
        return v1(v5.Max.X == v6.Max.X, "", "");
    else
        return v1(false, "Invalid horizontal alignment");
    end;
end;


local v0 = require(script.Parent.toRect);
local v1 = require(script.Parent.returnValue);
return function(v2, v3, v4)
    local v5 = v0(v2);
    local v6 = v0(v3);
    if v4 == Enum.VerticalAlignment.Top then
        return v1(v5.Min.Y == v6.Min.Y, "", "");
    elseif v4 == Enum.VerticalAlignment.Center then
        return v1(((v5.Min + v5.Max) / 2).Y == ((v6.Min + v6.Max) / 2).Y, "", "");
    elseif v4 == Enum.VerticalAlignment.Bottom then
        return v1(v5.Max.Y == v6.Max.Y, "", "");
    else
        return v1(false, "Invalid VerticalAlignment");
    end;
end;


local v0 = require(script.Parent.toRect);
local v1 = require(script.Parent.returnValue);
return function(v2, v3, v4)
    local v5 = v0(v2).Min - v0(v3).Max;
    if not v4 then
        return v1(v5.Y >= 0, "Was below the element", "Was above the element");
    else
        if typeof(v4) == "number" then
            v4 = NumberRange.new(v4);
        end;
        local l_v1_0 = v1;
        local v7 = false;
        if v4.Min <= v5.Y then
            v7 = v5.Y <= v4.Max;
        end;
        return l_v1_0(v7, "Was within range", "Was not within range ( " .. tostring(v4) .. ")");
    end;
end;


return {
    TestEZ = require(script.TestEZ),
    Jest = require(script.Jest)
};


local v0 = require(script.Parent.toRect);
local v1 = require(script.Parent.returnValue);
local function _(v2, v3)
    local v4 = false;
    if v3.Min.X <= v2.X then
        v4 = false;
        if v2.X <= v3.Max.X then
            v4 = false;
            if v3.Min.Y <= v2.Y then
                v4 = v2.Y <= v3.Max.Y;
            end;
        end;
    end;
    return v4;
end;
return function(v6, v7)
    local v8 = v0(v6);
    local v9 = v0(v7);
    local l_v1_0 = v1;
    local l_Min_0 = v8.Min;
    local v12 = false;
    if v9.Min.X <= l_Min_0.X then
        v12 = false;
        if l_Min_0.X <= v9.Max.X then
            v12 = false;
            if v9.Min.Y <= l_Min_0.Y then
                v12 = l_Min_0.Y <= v9.Max.Y;
            end;
        end;
    end;
    if v12 then
        l_Min_0 = v8.Max;
        v12 = false;
        if v9.Min.X <= l_Min_0.X then
            v12 = false;
            if l_Min_0.X <= v9.Max.X then
                v12 = false;
                if v9.Min.Y <= l_Min_0.Y then
                    v12 = l_Min_0.Y <= v9.Max.Y;
                end;
            end;
        end;
    end;
    return l_v1_0(v12, "Is inside the element", "Is not inside the element");
end;


local v0 = require(script.Parent.toRect);
local v1 = require(script.Parent.returnValue);
return function(v2, v3, v4)
    local v5 = -(v0(v2).Max - v0(v3).Max);
    if not v4 then
        return v1(v5.Y >= 0, "Was not below the element", "Was too far below the element");
    else
        if typeof(v4) == "number" then
            v4 = NumberRange.new(v4);
        end;
        local l_v1_0 = v1;
        local v7 = false;
        if v4.Min <= v5.Y then
            v7 = v5.Y <= v4.Max;
        end;
        return l_v1_0(v7, "Was within range", "Was not within range ( " .. tostring(v4) .. ")");
    end;
end;


local v0 = require(script.Parent.toRect);
local v1 = require(script.Parent.returnValue);
return function(v2, v3, v4)
    local v5 = v0(v2).Min - v0(v3).Min;
    if not v4 then
        return v1(v5.Y >= 0, "Was not above the element", "Was too far above the element");
    else
        if typeof(v4) == "number" then
            v4 = NumberRange.new(v4);
        end;
        local l_v1_0 = v1;
        local v7 = false;
        if v4.Min <= v5.Y then
            v7 = v5.Y <= v4.Max;
        end;
        return l_v1_0(v7, "Was within range", "Was not within range ( " .. tostring(v4) .. ")");
    end;
end;


local v0 = require(script.Parent.toRect);
local v1 = require(script.Parent.returnValue);
return function(v2, v3, v4)
    local v5 = -(v0(v2).Max - v0(v3).Max);
    if not v4 then
        return v1(v5.X >= 0, "Was not right of the element", "Was too far right of the element");
    else
        if typeof(v4) == "number" then
            v4 = NumberRange.new(v4);
        end;
        local l_v1_0 = v1;
        local v7 = false;
        if v4.Min <= v5.X then
            v7 = v5.X <= v4.Max;
        end;
        return l_v1_0(v7, "Was within range", "Was not within range ( " .. tostring(v4) .. ")");
    end;
end;


local v0 = require(script.Parent.toRect);
local v1 = require(script.Parent.returnValue);
return function(v2, v3, v4)
    local v5 = v0(v2).Min - v0(v3).Min;
    if not v4 then
        return v1(v5.X >= 0, "Was not left of the element", "Was too far left of the element");
    else
        if typeof(v4) == "number" then
            v4 = NumberRange.new(v4);
        end;
        local l_v1_0 = v1;
        local v7 = false;
        if v4.Min <= v5.X then
            v7 = v5.X <= v4.Max;
        end;
        return l_v1_0(v7, "Was within range", "Was not within range ( " .. tostring(v4) .. ")");
    end;
end;


local v0 = require(script.Parent.toRect);
local v1 = require(script.Parent.returnValue);
return function(v2, v3)
    local v4 = v0(v2);
    local v5 = v0(v3);
    local l_v1_0 = v1;
    local v7 = false;
    if math.abs(v4.Min.X - v5.Min.X) * 2 < v4.Width + v5.Width then
        v7 = math.abs(v4.Min.Y - v5.Min.Y) * 2 < v4.Height + v5.Height;
    end;
    return l_v1_0(v7, "Intersects the element", "Does not intersect the element");
end;


local v0 = require(script.Parent.toRect);
local v1 = require(script.Parent.returnValue);
return function(v2, v3, v4)
    local v5 = -(v0(v2).Max - v0(v3).Min);
    if not v4 then
        return v1(v5.X >= 0, "Was not right of the element", "Was to the right of the element");
    else
        if typeof(v4) == "number" then
            v4 = NumberRange.new(v4);
        end;
        local l_v1_0 = v1;
        local v7 = false;
        if v4.Min <= v5.X then
            v7 = v5.X <= v4.Max;
        end;
        return l_v1_0(v7, "Was within range", "Was not within range ( " .. tostring(v4) .. ")");
    end;
end;


return function(v0, v1, v2)
    return {
        pass = v0,
        message = (not not v0 and v1 or v2) or v1
    };
end;


local v0 = require(script.Parent.toRect);
local v1 = require(script.Parent.returnValue);
return function(v2, v3, v4)
    local v5 = v0(v2).Min - v0(v3).Max;
    if not v4 then
        return v1(v5.X >= 0, "Was not left of the element", "Was to the left of the element");
    else
        if typeof(v4) == "number" then
            v4 = NumberRange.new(v4);
        end;
        local l_v1_0 = v1;
        local v7 = false;
        if v4.Min <= v5.X then
            v7 = v5.X <= v4.Max;
        end;
        return l_v1_0(v7, "Was within range", "Was not within range ( " .. tostring(v4) .. ")");
    end;
end;


return function(v0)
    local v1 = typeof(v0);
    if v1 == "Rect" then
        return v0;
    elseif v1 == "Instance" then
        return Rect.new(v0.AbsolutePosition, v0.AbsolutePosition + v0.AbsoluteSize);
    else
        return ;
    end;
end;


local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.LuauPolyfill);
local l_Object_0 = v2.Object;
local l_Boolean_0 = v2.Boolean;
local v5 = {};
local _ = require(l_Parent_1.GraphQL);
local l_wrap_0 = require(l_Parent_0.optimism).wrap;
local l_getFragmentQueryDocument_0 = require(script.Parent.Parent.Parent.utilities).getFragmentQueryDocument;
local _ = require(script.Parent.types.DataProxy);
local _ = require(script.Parent.types.Cache);
local v11 = {};
v11.__index = v11;
v11.new = function()
    local v12 = setmetatable({}, v11);
    v12.getFragmentDoc = l_wrap_0(l_getFragmentQueryDocument_0);
    return v12;
end;
v11.read = function(_, _)
    error("not implemented abstract method");
end;
v11.write = function(_, _)
    error("not implemented abstract method");
end;
v11.diff = function(_, _)
    error("not implemented abstract method");
end;
v11.watch = function(_, _)
    error("not implemented abstract method");
end;
v11.reset = function(_)
    error("not implemented abstract method");
end;
v11.evict = function(_, _)
    error("not implemented abstract method");
end;
v11.restore = function(_, _)
    error("not implemented abstract method");
end;
v11.extract = function(_, _)
    error("not implemented abstract method");
end;
v11.removeOptimistic = function(_, _)
    error("not implemented abstract method");
end;
v11.batch = function(v30, v31)
    local _ = nil;
    v30:performTransaction(v31.update, if typeof(v31.optimistic) == "string" then v31.optimistic else if v31.optimistic == false then nil else nil);
end;
v11.performTransaction = function(_, _, _)
    error("not implemented abstract method");
end;
v11.recordOptimisticTransaction = function(v36, v37, v38)
    v36:performTransaction(v37, v38);
end;
v11.transformDocument = function(_, v40)
    return v40;
end;
v11.identify = function(_, _)
end;
v11.gc = function(_)
    return {};
end;
v11.modify = function(_, _)
    return false;
end;
v11.transformForLink = function(_, v47)
    return v47;
end;
v11.readQuery = function(v48, v49, v50)
    if v50 == nil then
        v50 = not not v49.optimistic;
    end;
    return v48:read(l_Object_0.assign(table.clone(v49), {
        rootId = not not l_Boolean_0.toJSBoolean(v49.id) and v49.id or "ROOT_QUERY",
        optimistic = v50
    }));
end;
v11.readFragment = function(v51, v52, v53)
    if v53 == nil then
        v53 = not not v52.optimistic;
    end;
    return v51:read(l_Object_0.assign({}, v52, {
        query = v51.getFragmentDoc(v52.fragment, v52.fragmentName),
        rootId = v52.id,
        optimistic = v53
    }));
end;
v11.writeQuery = function(v54, v55)
    return v54:write(l_Object_0.assign(l_Object_0.assign(table.clone(v55), {
        id = l_Object_0.None,
        data = l_Object_0.None
    }), {
        dataId = v55.id or "ROOT_QUERY",
        result = v55.data
    }));
end;
v11.writeFragment = function(v56, v57)
    return v56:write(l_Object_0.assign(l_Object_0.assign(table.clone(v57), {
        id = l_Object_0.None,
        data = l_Object_0.None,
        fragment = l_Object_0.None,
        fragmentName = l_Object_0.None
    }), {
        query = v56.getFragmentDoc(v57.fragment, v57.fragmentName),
        dataId = v57.id,
        result = v57.data
    }));
end;
v5.ApolloCache = v11;
return v5;


local l_Parent_0 = script.Parent.Parent.Parent.Parent;
local _ = require(l_Parent_0.Parent.GraphQL);
local _ = require(l_Parent_0.jsutils.typedDocumentNode);
local _ = require(script.Parent.DataProxy);
local _ = require(script.Parent.common);
return {};


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


local v0 = {};
local l_Parent_0 = script.Parent.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_Error_0 = require(l_Parent_1.LuauPolyfill).Error;
local _ = require(l_Parent_1.GraphQL);
local _ = require(l_Parent_0.utilities.graphql.types);
local v6 = setmetatable({}, {
    __index = l_Error_0
});
v6.__index = v6;
v6.new = function(v7, v8, v9, v10)
    local v11 = l_Error_0.new(v7);
    v11.message = v7;
    v11.path = v8;
    v11.query = v9;
    v11.variables = v10;
    return (setmetatable(v11, v6));
end;
v0.MissingFieldError = v6;
return v0;


local v0 = {};
local l_Parent_0 = script.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(script.Parent.utilities).DEV;
l_invariant_0(typeof(l_DEV_0) == "boolean", l_DEV_0);
v0.ApolloCache = require(script.core.cache).ApolloCache;
local _ = require(script.core.types.Cache);
local _ = require(script.core.types.DataProxy);
v0.MissingFieldError = require(script.core.types.common).MissingFieldError;
local v7 = require(script.Parent.utilities.graphql.storeUtils);
v0.isReference = v7.isReference;
v0.makeReference = v7.makeReference;
v0.EntityStore = require(script.inmemory.entityStore).EntityStore;
v0.fieldNameFromStoreName = require(script.inmemory.helpers).fieldNameFromStoreName;
v0.InMemoryCache = require(script.inmemory.inMemoryCache).InMemoryCache;
local v8 = require(script.inmemory.reactiveVars);
v0.makeVar = v8.makeVar;
v0.cacheSlot = v8.cacheSlot;
local v9 = require(script.inmemory.policies);
v0.defaultDataIdFromObject = v9.defaultDataIdFromObject;
v0.Policies = v9.Policies;
v0.None = v9.None;
v0.canonicalStringify = require(script.inmemory["object-canon"]).canonicalStringify;
l_Object_0.assign(v0, (require(script.inmemory.types)));
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_Boolean_0 = v2.Boolean;
local l_instanceof_0 = v2.instanceof;
local l_Object_0 = v2.Object;
local l_Set_0 = v2.Set;
local v8 = require(l_Parent_0.luaUtils.isCallable);
local v9 = require(l_Parent_0.luaUtils.objectKeysForEach);
local l_dep_0 = require(l_Parent_0.optimism).dep;
local l_invariant_0 = require(l_Parent_0.jsutils.invariant).invariant;
local v12 = require(l_Parent_0.jsutils.equal);
local l_Trie_0 = require(l_Parent_0.wry.trie).Trie;
local v14 = require(script.Parent.Parent.Parent.utilities);
local l_isReference_0 = v14.isReference;
local l_makeReference_0 = v14.makeReference;
local l_DeepMerger_0 = v14.DeepMerger;
local l_maybeDeepFreeze_0 = v14.maybeDeepFreeze;
local l_canUseWeakMap_0 = v14.canUseWeakMap;
local l_isNonNullObject_0 = v14.isNonNullObject;
local _ = require(script.Parent.types);
local v22 = require(script.Parent.helpers);
local l_hasOwn_0 = v22.hasOwn;
local l_fieldNameFromStoreName_0 = v22.fieldNameFromStoreName;
local _ = require(script.Parent.policies);
local _ = require(script.Parent.Parent.core.types.Cache);
local _ = require(script.Parent.Parent.core.types.common);
local v28 = {};
local v29 = nil;
v29 = function()
    return v28;
end;
local v30 = {};
local v31 = nil;
local v32 = nil;
local v33 = nil;
local v34 = nil;
local v35 = nil;
local v36 = {};
v36.__index = v36;
v36.new = function(v37, v38)
    local v39 = setmetatable({}, v36);
    v39.policies = v37;
    v39.group = v38;
    v39.data = {};
    v39.rootIds = {};
    v39.refs = {};
    v39.getFieldValue = function(_, v41, v42)
        return (l_maybeDeepFreeze_0(if not l_isReference_0(v41) then v41 and v41[v42] else v39:get(v41.__ref, v42)));
    end;
    v39.canRead = function(_, v44)
        if not l_isReference_0(v44) then
            return typeof(v44) == "table";
        else
            return v39:has(v44.__ref);
        end;
    end;
    v39.toReference = function(_, v46, v47)
        if type(v46) == "string" then
            return l_makeReference_0(v46);
        elseif not l_isReference_0(v46) then
            local v48 = table.unpack(v39.policies:identify(v46), 1, 1);
            if not v48 then
                return ;
            else
                local v49 = l_makeReference_0(v48);
                if v47 then
                    v39:merge(v48, v46);
                end;
                return v49;
            end;
        else
            return v46;
        end;
    end;
    return v39;
end;
v36.addLayer = function(_, _, _)
    error("not implemented abstract method");
end;
v36.removeLayer = function(_, _)
    error("not implemented abstract method");
end;
v36.toObject = function(v55)
    return table.clone(v55.data);
end;
v36.has = function(v56, v57)
    return v56:lookup(v57, true) ~= nil;
end;
v36.get = function(v58, v59, v60)
    v58.group:depend(v59, v60);
    if l_hasOwn_0(v58.data, v59) then
        local v61 = v58.data[v59];
        if not (not l_Boolean_0.toJSBoolean(v61) or not l_hasOwn_0(v61, v60)) then
            return v61[v60];
        end;
    end;
    if not (v60 == "__typename") or not l_hasOwn_0(v58.policies.rootTypenamesById, v59) then
        if not l_instanceof_0(v58, v31) then
            return nil;
        else
            return v58.parent:get(v59, v60);
        end;
    else
        return v58.policies.rootTypenamesById[v59];
    end;
end;
v36.lookup = function(v62, v63, v64)
    if v64 then
        v62.group:depend(v63, "__exists");
    end;
    if not l_hasOwn_0(v62.data, v63) then
        if not l_instanceof_0(v62, v31) then
            if not v62.policies.rootTypenamesById[v63] then
                return nil;
            else
                return {};
            end;
        else
            return v62.parent:lookup(v63, v64);
        end;
    else
        return v62.data[v63];
    end;
end;
v36.merge = function(v65, v66, v67)
    local v68 = nil;
    if l_isReference_0(v66) then
        v66 = v66.__ref;
    end;
    if l_isReference_0(v67) then
        v67 = v67.__ref;
    end;
    local v69 = nil;
    if type(v66) == "string" then
        v68 = v66;
        v69 = v65:lookup(v68);
    else
        v69 = v66;
    end;
    local v70 = nil;
    if type(v67) == "string" then
        v68 = v67;
        v70 = v65:lookup(v68);
    else
        v70 = v67;
    end;
    if v70 then
        l_invariant_0(typeof(v68) == "string", "store.merge expects a string ID");
        local v71 = l_DeepMerger_0.new(v34):merge(v69, v70);
        v65.data[v68] = v71;
        if v71 ~= v69 then
            v65.refs[v68] = nil;
            if v65.group.caching then
                local v72 = {};
                if not v69 then
                    v72.__exists = 1;
                end;
                v9(v70, function(v73)
                    if not v69 or v69[v73] ~= v71[v73] then
                        v72[v73] = 1;
                        local v74 = l_fieldNameFromStoreName_0(v73);
                        if not (not (v74 ~= v73) or v65.policies:hasKeyArgs(v71.__typename, v74)) then
                            v72[v74] = 1;
                        end;
                        if not (not (v71[v73] == nil) or l_instanceof_0(v65, v31)) then
                            v71[v73] = nil;
                        end;
                    end;
                end);
                if not (not v72.__typename or v69 and v69.__typename) and v65.policies.rootTypenamesById[v68] == v71.__typename then
                    v72.__typename = nil;
                end;
                v9(v72, function(v75)
                    return v65.group:dirty(v68, v75);
                end);
            end;
        end;
        return ;
    else
        return ;
    end;
end;
v36.modify = function(v76, v77, v78)
    local v79 = v76:lookup(v77);
    if v79 then
        local v80 = {};
        local v81 = false;
        local v82 = true;
        local v87 = {
            DELETE = v28,
            INVALIDATE = v30,
            isReference = function(_, ...)
                return l_isReference_0(...);
            end,
            toReference = v76.toReference,
            canRead = v76.canRead,
            readField = function(_, v85, v86)
                return v76.policies:readField(typeof(v85) == "string" and {
                    fieldName = v85,
                    from = v86 or l_makeReference_0(v77)
                } or v85, {
                    store = v76
                });
            end
        };
        v9(v79, function(v88)
            local v89 = l_fieldNameFromStoreName_0(v88);
            local v90 = v79[v88];
            if v90 == nil then
                return ;
            else
                local v91 = nil;
                if not v8(v78) then
                    local l_v78_0 = v78;
                    v91 = l_v78_0[v88] or l_v78_0[v89];
                else
                    v91 = v78;
                end;
                if v91 then
                    local v93 = nil;
                    v93 = if v91 == v29 then v28 else v91(not v8(v78) and v78 or nil, l_maybeDeepFreeze_0(v90), l_Object_0.assign(table.clone(v87), {
                        fieldName = v89,
                        storeFieldName = v88,
                        storage = v76:getStorage(v77, v88)
                    }));
                    if v93 == v30 then
                        v76.group:dirty(v77, v88);
                    else
                        if v93 == v28 then
                            v93 = l_DeepMerger_0.None;
                        end;
                        if v93 ~= v90 then
                            v80[v88] = v93;
                            v81 = true;
                            v90 = v93;
                        end;
                    end;
                end;
                if v90 ~= nil and v90 ~= l_DeepMerger_0.None then
                    v82 = false;
                end;
                return ;
            end;
        end);
        if not v81 then
            --[[ close >= 5 ]]
        else
            v76:merge(v77, v80);
            if v82 then
                if not l_instanceof_0(v76, v31) then
                    v76.data[v77] = nil;
                else
                    v76.data[v77] = nil;
                end;
                v76.group:dirty(v77, "__exists");
            end;
            return true;
        end;
    end;
    return false;
end;
v36.delete = function(v94, v95, v96, v97)
    local v98 = v94:lookup(v95);
    if not v98 then
        return false;
    else
        local v99 = v94:getFieldValue(v98, "__typename");
        local v100 = nil;
        v100 = if not not v96 and v97 then v94.policies:getStoreFieldName({
            typename = v99,
            fieldName = v96,
            args = v97
        }) else v96;
        return v94:modify(v95, if not v100 then v29 else {
            [v100] = v29
        });
    end;
end;
v36.evict = function(v101, v102)
    local v103 = false;
    if v102.id then
        if l_hasOwn_0(v101.data, v102.id) then
            v103 = v101:delete(v102.id, v102.fieldName, v102.args);
        end;
        if l_instanceof_0(v101, v31) then
            v103 = v101.parent:evict(v102) or v103;
        end;
        if not (not v102.fieldName and not v103) then
            v101.group:dirty(v102.id, v102.fieldName or "__exists");
        end;
    end;
    return v103;
end;
v36.clear = function(v104)
    v104:replace(nil);
end;
v36.extract = function(v105)
    local v106 = v105:toObject();
    local v107 = {};
    v105:getRootIdSet():forEach(function(v108)
        if not l_hasOwn_0(v105.policies.rootTypenamesById, v108) then
            table.insert(v107, v108);
        end;
    end);
    if #v107 > 0 then
        v106.__META = {
            extraRootIds = l_Array_0.sort(v107)
        };
    end;
    return v106;
end;
v36.replace = function(v109, v110)
    v9(v109.data, function(v111)
        if not (v110 and l_hasOwn_0(v110, v111)) then
            v109:delete(v111);
        end;
    end);
    if v110 ~= nil then
        local l___META_0 = v110.__META;
        local v113 = l_Object_0.assign(table.clone(v110), {
            __META = l_Object_0.None
        });
        v9(v113, function(v114)
            v109:merge(v114, v113[v114]);
        end);
        if l___META_0 ~= nil then
            l_Array_0.forEach(l___META_0.extraRootIds, v109.retain, v109);
        end;
    end;
end;
v36.getStorage = function(_, _, ...)
    error("not implemented abstract method");
end;
v36.retain = function(v117, v118)
    v117.rootIds[v118] = (not l_Boolean_0.toJSBoolean(v117.rootIds[v118]) and 0 or v117.rootIds[v118]) + 1;
    return v117.rootIds[v118];
end;
v36.release = function(v119, v120)
    if v119.rootIds[v120] > 0 then
        local l_rootIds_0 = v119.rootIds;
        l_rootIds_0[v120] = l_rootIds_0[v120] - 1;
        l_rootIds_0 = v119.rootIds[v120];
        if not l_Boolean_0.toJSBoolean(l_rootIds_0) then
            v119.rootIds[v120] = nil;
        end;
        return l_rootIds_0;
    else
        return 0;
    end;
end;
v36.getRootIdSet = function(v122, v123)
    local l_v123_0 = v123;
    if v123 == nil then
        l_v123_0 = l_Set_0.new();
    end;
    l_Array_0.forEach(l_Object_0.keys(v122.rootIds), l_v123_0.add, l_v123_0);
    if not l_instanceof_0(v122, v31) then
        l_Array_0.forEach(l_Object_0.keys(v122.policies.rootTypenamesById), l_v123_0.add, l_v123_0);
        return l_v123_0;
    else
        v122.parent:getRootIdSet(l_v123_0);
        return l_v123_0;
    end;
end;
v36.gc = function(v125)
    local v126 = v125:getRootIdSet();
    local v127 = v125:toObject();
    for _, v129 in v126, nil, nil do
        if l_hasOwn_0(v127, v129) then
            l_Array_0.forEach(l_Object_0.keys(v125:findChildRefIds(v129)), v126.add, v126);
            v127[v129] = nil;
        end;
    end;
    local v130 = l_Object_0.keys(v127);
    if l_Boolean_0.toJSBoolean(#v130) then
        local l_v125_0 = v125;
        while l_instanceof_0(l_v125_0, v31) do
            l_v125_0 = l_v125_0.parent;
        end;
        do
            local l_l_v125_0_0 = l_v125_0;
            l_Array_0.forEach(v130, function(v133)
                return l_l_v125_0_0:delete(v133);
            end);
        end;
    end;
    return v130;
end;
v36.findChildRefIds = function(v134, v135)
    if not l_hasOwn_0(v134.refs, v135) then
        v134.refs[v135] = {};
        local v136 = v134.refs[v135];
        local v137 = v134.data[v135];
        if v137 then
            local v138 = l_Set_0.new({
                v137
            });
            for _, v140 in v138, nil, nil do
                if l_isReference_0(v140) then
                    v136[v140.__ref] = true;
                end;
                if l_isNonNullObject_0(v140) then
                    v9(v140, function(v141)
                        local v142 = v140[v141];
                        if l_isNonNullObject_0(v142) then
                            v138:add(v142);
                        end;
                    end);
                end;
            end;
        else
            return v136;
        end;
    end;
    return v134.refs[v135];
end;
v36.makeCacheKey = function(v143, ...)
    return v143.group.keyMaker:lookupArray({
        ...
    });
end;
v0.EntityStore = v36;
local v144 = {};
v144.__index = v144;
v144.new = function(v145, v146)
    local v147 = setmetatable({}, v144);
    v147.caching = v145;
    v147.parent = v146;
    v147.d = nil;
    v147:resetCaching();
    return v147;
end;
v144.resetCaching = function(v148)
    v148.d = if not v148.caching then nil else l_dep_0();
    v148.keyMaker = l_Trie_0.new(l_canUseWeakMap_0);
end;
v144.depend = function(v149, v150, v151)
    if v149.d then
        v149.d(v33(v150, v151));
        local v152 = l_fieldNameFromStoreName_0(v151);
        if v152 ~= v151 then
            v149.d(v33(v150, v152));
        end;
        if v149.parent then
            v149.parent:depend(v150, v151);
        end;
    end;
end;
v144.dirty = function(v153, v154, v155)
    if v153.d then
        v153.d:dirty(v33(v154, v155), v155 == "__exists" and "forget" or "setDirty");
    end;
end;
v33 = function(v156, v157)
    return v157 .. "#" .. v156;
end;
v0.maybeDependOnExistenceOfEntity = function(v158, v159)
    if v35(v158) then
        v158.group:depend(v159, "__exists");
    end;
end;
local v160 = setmetatable({}, {
    __index = v36
});
v160.__index = v160;
v160.new = function(v161)
    local l_policies_0 = v161.policies;
    local l_resultCaching_0 = v161.resultCaching;
    local l_seed_0 = v161.seed;
    if v161.resultCaching == nil then
        l_resultCaching_0 = true;
    end;
    local v165 = setmetatable(v36.new(l_policies_0, v144.new(l_resultCaching_0)), v160);
    v165.stump = v32.new(v165);
    v165.storageTrie = l_Trie_0.new(l_canUseWeakMap_0);
    if l_seed_0 then
        v165:replace(l_seed_0);
    end;
    return v165;
end;
v160.addLayer = function(v166, v167, v168)
    return v166.stump:addLayer(v167, v168);
end;
v160.removeLayer = function(v169)
    return v169;
end;
v160.getStorage = function(v170, ...)
    return v170.storageTrie:lookupArray({
        ...
    });
end;
v0.EntityStore_Root = v160;
v31 = setmetatable({}, {
    __index = v36
});
v31.__index = v31;
v31.new = function(v171, v172, v173, v174)
    local v175 = setmetatable(v36.new(v172.policies, v174), v31);
    v175.id = v171;
    v175.parent = v172;
    v175.replay = v173;
    v175.group = v174;
    v173(v175, v175);
    return v175;
end;
v31.addLayer = function(v176, v177, v178)
    return v31.new(v177, v176, v178, v176.group);
end;
v31.removeLayer = function(v179, v180)
    local v181 = v179.parent:removeLayer(v180);
    if v180 == v179.id then
        if v179.group.caching then
            v9(v179.data, function(v182)
                local v183 = v179.data[v182];
                local v184 = v181.lookup(v181, v182);
                if v184 then
                    if v183 then
                        if v183 ~= v184 then
                            v9(v183, function(v185)
                                if not v12(v183[v185], v184[v185]) then
                                    v179.group:dirty(v182, v185);
                                end;
                            end);
                        end;
                        return ;
                    else
                        v179.group:dirty(v182, "__exists");
                        v9(v184, function(v186)
                            v179.group:dirty(v182, v186);
                        end);
                        return ;
                    end;
                else
                    v179:delete(v182);
                    return ;
                end;
            end);
        end;
        return v181;
    elseif v181 == v179.parent then
        return v179;
    else
        return v181:addLayer(v179.id, v179.replay);
    end;
end;
v31.toObject = function(v187)
    return l_Object_0.assign({}, v187.parent:toObject(), v187.data);
end;
v31.findChildRefIds = function(v188, v189)
    local v190 = v188.parent:findChildRefIds(v189);
    return not not l_hasOwn_0(v188.data, v189) and l_Object_0.assign({}, v190, getmetatable((getmetatable(v188))).__index.findChildRefIds(v188, v189)) or v190;
end;
v31.getStorage = function(v191, ...)
    local l_parent_0 = v191.parent;
    while l_parent_0.parent do
        l_parent_0 = l_parent_0.parent;
    end;
    return l_parent_0:getStorage(...);
end;
v32 = setmetatable({}, {
    __index = v31
});
v32.__index = v32;
v32.new = function(v193)
    return (setmetatable(v31.new("EntityStore.Stump", v193, function()
    end, v144.new(v193.group.caching, v193.group)), v32));
end;
v32.removeLayer = function(v194)
    return v194;
end;
v32.merge = function(v195, ...)
    return v195.parent:merge(...);
end;
v34 = function(_, v197, v198, v199)
    local v200 = v197[v199];
    local v201 = v198[v199];
    if not v12(v200, v201) then
        return v201;
    else
        return v200;
    end;
end;
v35 = function(v202)
    local v203 = false;
    if type(v202) == "table" then
        v203 = false;
        if type(v202.group) == "table" then
            v203 = v202.group.caching == true;
        end;
    end;
    return v203;
end;
v0.supportsResultCaching = v35;
return v0;


local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_Array_0 = require(l_Parent_1.LuauPolyfill).Array;
local v3 = require(l_Parent_1.LuauRegExp);
local _ = require(l_Parent_1.GraphQL);
local _ = require(script.Parent.types);
local v6 = require(l_Parent_0.utilities);
local l_isReference_0 = v6.isReference;
local l_isField_0 = v6.isField;
local l_DeepMerger_0 = v6.DeepMerger;
local l_resultKeyNameFromFieldf_0 = v6.resultKeyNameFromFieldf;
local l_shouldInclude_0 = v6.shouldInclude;
local l_isNonNullObject_0 = v6.isNonNullObject;
local v13 = {};
local v14 = require(l_Parent_0.luaUtils.hasOwnProperty);
v13.hasOwn = v14;
v13.getTypenameFromStoreObject = function(v15, v16)
    if not l_isReference_0(v16) then
        if not v16 then
            return nil;
        else
            return v16.__typename;
        end;
    else
        return (v15:get(v16.__ref, "__typename"));
    end;
end;
v13.TypeOrFieldNameRegExp = v3("^[_a-zA-Z][_0-9a-zA-Z]*", "i");
local v17 = {};
v13.fieldNameFromStoreName = function(v18)
    if not v17[v18] then
        local v19 = string.match(v18, "^[_a-zA-Z][_0-9a-zA-Z]*") or v18;
        v17[v18] = v19;
        return v19;
    else
        return v17[v18];
    end;
end;
local function v20(v21, v22, v23)
    if not l_isNonNullObject_0(v22) then
        return false;
    elseif not l_Array_0.isArray(v22) then
        return l_Array_0.every(v21.selections, function(v24)
            if not l_isField_0(v24) or not l_shouldInclude_0(v24, v23) then
                return true;
            else
                local v25 = l_resultKeyNameFromFieldf_0(v24);
                return v14(v22, v25) and (not v24.selectionSet or v20(v24.selectionSet, v22[v25], v23));
            end;
        end);
    else
        return l_Array_0.every(v22, function(v26)
            return v20(v21, v26, v23);
        end);
    end;
end;
v13.selectionSetMatchesResult = v20;
v13.storeValueIsStoreObject = function(v27)
    return (l_isNonNullObject_0(v27) and not l_isReference_0(v27)) and not l_Array_0.isArray(v27);
end;
v13.makeProcessedFieldsMerger = function()
    return l_DeepMerger_0.new();
end;
return v13;


local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.LuauPolyfill);
local l_Map_0 = v2.Map;
local l_Object_0 = v2.Object;
local l_Set_0 = v2.Set;
local l_instanceof_0 = v2.instanceof;
local l_NULL_0 = require(l_Parent_0.utilities).NULL;
local v8 = require(l_Parent_1.Promise);
local v9 = {};
local _ = require(l_Parent_1.GraphQL);
local l_wrap_0 = require(l_Parent_0.optimism).wrap;
local v12 = require(l_Parent_0.jsutils.equal);
local l_ApolloCache_0 = require(script.Parent.Parent.core.cache).ApolloCache;
local _ = require(script.Parent.Parent.core.types.Cache);
local l_MissingFieldError_0 = require(script.Parent.Parent.core.types.common).MissingFieldError;
local v16 = require(script.Parent.Parent.Parent.utilities);
local l_addTypenameToDocument_0 = v16.addTypenameToDocument;
local l_isReference_0 = v16.isReference;
local _ = require(script.Parent.types);
local l_StoreReader_0 = require(script.Parent.readFromStore).StoreReader;
local l_StoreWriter_0 = require(script.Parent.writeToStore).StoreWriter;
local v22 = require(script.Parent.entityStore);
local l_EntityStore_Root_0 = v22.EntityStore_Root;
local l_supportsResultCaching_0 = v22.supportsResultCaching;
local v25 = require(script.Parent.reactiveVars);
local l_makeVar_0 = v25.makeVar;
local l_forgetCache_0 = v25.forgetCache;
local l_recallCache_0 = v25.recallCache;
local v29 = require(script.Parent.policies);
local l_defaultDataIdFromObject_0 = v29.defaultDataIdFromObject;
local l_Policies_0 = v29.Policies;
local l_hasOwn_0 = require(script.Parent.helpers).hasOwn;
local l_canonicalStringify_0 = require(script.Parent["object-canon"]).canonicalStringify;
local v34 = {
    dataIdFromObject = l_defaultDataIdFromObject_0,
    addTypename = true,
    resultCaching = true,
    typePolicies = {}
};
local v35 = setmetatable({}, {
    __index = l_ApolloCache_0
});
v35.__index = v35;
v35.new = function(v36)
    local v37 = setmetatable(l_ApolloCache_0.new(), v35);
    if v36 == nil then
        v36 = {};
    end;
    v37.watches = l_Set_0.new();
    v37.typenameDocumentCache = l_Map_0.new(nil);
    v37.makeVar = l_makeVar_0;
    v37.txCount = 0;
    v37.config = l_Object_0.assign({}, v34, v36);
    v37.addTypename = v37.config.addTypename;
    v37.policies = l_Policies_0.new({
        cache = v37,
        dataIdFromObject = v37.config.dataIdFromObject,
        possibleTypes = v37.config.possibleTypes,
        typePolicies = v37.config.typePolicies
    });
    v37:init();
    return v37;
end;
v35.init = function(v38)
    v38.data = l_EntityStore_Root_0.new({
        policies = v38.policies,
        resultCaching = v38.config.resultCaching
    });
    v38.optimisticData = v38.data.stump;
    v38:resetResultCache();
end;
v35.resetResultCache = function(v39, v40)
    local l_storeReader_0 = v39.storeReader;
    v39.storeReader = l_StoreReader_0.new({
        cache = v39,
        addTypename = v39.addTypename,
        resultCacheMaxSize = v39.config.resultCacheMaxSize,
        canon = if not v40 then if l_storeReader_0 then l_storeReader_0.canon else nil else nil
    });
    v39.storeWriter = l_StoreWriter_0.new(v39, v39.storeReader);
    v39.maybeBroadcastWatch = l_wrap_0(function(_, v43, v44)
        return v39:broadcastWatch(v43, v44);
    end, {
        max = v39.config.resultCacheMaxSize,
        makeCacheKey = function(_, v46)
            local v47 = nil;
            v47 = if not v46.optimistic then v39.data else v39.optimisticData;
            if not l_supportsResultCaching_0(v47) then
                return ;
            else
                return v47:makeCacheKey(v46.query, v46.callback, l_canonicalStringify_0({
                    optimistic = v46.optimistic,
                    rootId = v46.rootId,
                    variables = v46.variables
                }));
            end;
        end
    }, v39);
    l_Set_0.new({
        v39.data.group,
        v39.optimisticData.group
    }):forEach(function(v48)
        return v48:resetCaching();
    end);
end;
v35.restore = function(v49, v50)
    v49:init();
    if v50 then
        v49.data:replace(v50);
    end;
    return v49;
end;
v35.extract = function(v51, v52)
    if v52 == nil then
        v52 = false;
    end;
    if not v52 then
        return v51.data:extract();
    else
        return v51.optimisticData:extract();
    end;
end;
v35.read = function(v53, v54)
    local v55 = nil;
    v55 = not (v54.returnPartialData == nil) and v54.returnPartialData;
    local l_status_0, l_result_0 = pcall(function()
        return v53.storeReader:diffQueryAgainstStore(l_Object_0.assign({}, v54, {
            store = not not v54.optimistic and v53.optimisticData or v53.data,
            config = v53.config,
            returnPartialData = v55
        })).result or l_NULL_0;
    end);
    if not l_status_0 then
        if not l_instanceof_0(l_result_0, l_MissingFieldError_0) then
            error(l_result_0);
        else
            return l_NULL_0;
        end;
    end;
    return l_result_0;
end;
v35.write = function(v58, v59)
    local l_status_1, l_result_1 = pcall(function()
        local l_v58_0 = v58;
        l_v58_0.txCount = l_v58_0.txCount + 1;
        return v58.storeWriter:writeToStore(v58.data, v59);
    end);
    v58.txCount = v58.txCount - 1;
    if v58.txCount == 0 and v59.broadcast ~= false then
        v58:broadcastWatches();
    end;
    if not l_status_1 then
        error(l_result_1);
    end;
    return l_result_1;
end;
v35.modify = function(v63, v64)
    if not l_hasOwn_0(v64, "id") or v64.id then
        local v65 = nil;
        v65 = if not v64.optimistic then v63.data else v63.optimisticData;
        local l_status_2, l_result_2 = pcall(function()
            local l_v63_0 = v63;
            l_v63_0.txCount = l_v63_0.txCount + 1;
            return v65:modify(v64.id or "ROOT_QUERY", v64.fields);
        end);
        v63.txCount = v63.txCount - 1;
        if v63.txCount == 0 and v64.broadcast ~= false then
            v63:broadcastWatches();
        end;
        if not l_status_2 then
            error(l_result_2);
        end;
        return l_result_2;
    else
        return false;
    end;
end;
v35.diff = function(v69, v70)
    return v69.storeReader:diffQueryAgainstStore(l_Object_0.assign({}, v70, {
        store = not not v70.optimistic and v69.optimisticData or v69.data,
        rootId = v70.id or "ROOT_QUERY",
        config = v69.config
    }));
end;
v35.watch = function(v71, v72)
    if v71.watches.size == 0 then
        l_recallCache_0(v71);
    end;
    v71.watches:add(v72);
    if v72.immediate then
        v71:maybeBroadcastWatch(v72);
    end;
    return function()
        if v71.watches:delete(v72) and v71.watches.size == 0 then
            l_forgetCache_0(v71);
        end;
        v71.maybeBroadcastWatch:forget(v72);
    end;
end;
v35.gc = function(v73, v74)
    l_canonicalStringify_0:reset();
    local v75 = v73.optimisticData:gc();
    if v74 and v73.txCount == 0 then
        if not v74.resetResultCache then
            if v74.resetResultIdentities then
                v73.storeReader:resetCanon();
            end;
        else
            v73:resetResultCache(v74.resetResultIdentities);
            return v75;
        end;
    end;
    return v75;
end;
v35.retain = function(v76, v77, v78)
    if not v78 then
        return v76.data:retain(v77);
    else
        return v76.optimisticData:retain(v77);
    end;
end;
v35.release = function(v79, v80, v81)
    if not v81 then
        return v79.data:release(v80);
    else
        return v79.optimisticData:release(v80);
    end;
end;
v35.identify = function(v82, v83)
    if not l_isReference_0(v83) then
        return v82.policies:identify(v83)[1];
    else
        return v83.__ref;
    end;
end;
v35.evict = function(v84, v85)
    if not v85.id then
        if not l_hasOwn_0(v85, "id") then
            v85 = l_Object_0.assign(table.clone(v85), {
                id = "ROOT_QUERY"
            });
        else
            return false;
        end;
    end;
    local l_status_3, l_result_3 = pcall(function()
        local l_v84_0 = v84;
        l_v84_0.txCount = l_v84_0.txCount + 1;
        return v84.optimisticData:evict(v85);
    end);
    v84.txCount = v84.txCount - 1;
    if v84.txCount == 0 and v85.broadcast ~= false then
        v84:broadcastWatches();
    end;
    if not l_status_3 then
        error(l_result_3);
    end;
    return l_result_3;
end;
v35.reset = function(v89)
    v89:init();
    v89:broadcastWatches();
    l_canonicalStringify_0:reset();
    return v8.delay(0);
end;
v35.removeOptimistic = function(v90, v91)
    local v92 = v90.optimisticData:removeLayer(v91);
    if v92 ~= v90.optimisticData then
        v90.optimisticData = v92;
        v90:broadcastWatches();
    end;
end;
v35.batch = function(v93, v94)
    local v95 = v94.optimistic == nil and true or v94.optimistic;
    local l_removeOptimistic_0 = v94.removeOptimistic;
    local l_onWatchUpdated_0 = v94.onWatchUpdated;
    local function v104(v98)
        local l_data_0 = v93.data;
        local l_optimisticData_0 = v93.optimisticData;
        local l_v93_0 = v93;
        l_v93_0.txCount = l_v93_0.txCount + 1;
        if v98 then
            v93.optimisticData = v98;
            v93.data = v93.optimisticData;
        end;
        local v102;
        l_v93_0, v102 = pcall(v94.update, v94, v93);
        local l_v93_1 = v93;
        l_v93_1.txCount = l_v93_1.txCount - 1;
        v93.data = l_data_0;
        v93.optimisticData = l_optimisticData_0;
        if not l_v93_0 then
            error(v102);
        end;
    end;
    local v105 = l_Set_0.new();
    if l_onWatchUpdated_0 and v93.txCount == 0 then
        v93:broadcastWatches(l_Object_0.assign(table.clone(v94), {
            onWatchUpdated = function(_, v107)
                v105:add(v107);
                return false;
            end
        }));
    end;
    if typeof(v95) == "string" then
        v93.optimisticData = v93.optimisticData:addLayer(v95, v104);
    elseif v95 == false then
        v104(v93.data);
    else
        v104();
    end;
    if typeof(l_removeOptimistic_0) == "string" then
        v93.optimisticData = v93.optimisticData:removeLayer(l_removeOptimistic_0);
    end;
    if l_onWatchUpdated_0 and v105.size > 0 then
        v93:broadcastWatches(l_Object_0.assign(table.clone(v94), {
            onWatchUpdated = function(v108, v109, v110)
                local v111 = l_onWatchUpdated_0(v108, v109, v110);
                if v111 ~= false then
                    v105:delete(v109);
                end;
                return v111;
            end
        }));
        if v105.size > 0 then
            v105:forEach(function(v112)
                return v93.maybeBroadcastWatch:dirty(v112);
            end);
        end;
    else
        v93:broadcastWatches(v94);
    end;
end;
v35.performTransaction = function(v113, v114, v115)
    return v113:batch({
        update = function(_, ...)
            return v114(...);
        end,
        optimistic = v115 or v115 ~= l_NULL_0
    });
end;
v35.transformDocument = function(v117, v118)
    if not v117.addTypename then
        return v118;
    else
        local v119 = v117.typenameDocumentCache:get(v118);
        if not v119 then
            v119 = l_addTypenameToDocument_0(v118);
            v117.typenameDocumentCache:set(v118, v119);
            v117.typenameDocumentCache:set(v119, v119);
        end;
        return v119;
    end;
end;
v35.broadcastWatches = function(v120, v121)
    if v120.txCount == 0 then
        v120.watches:forEach(function(v122)
            return v120:maybeBroadcastWatch(v122, v121);
        end);
    end;
end;
v35.broadcastWatch = function(v123, v124, v125)
    local l_lastDiff_0 = v124.lastDiff;
    local v127 = v123:diff({
        query = v124.query,
        variables = v124.variables,
        optimistic = v124.optimistic
    });
    if v125 then
        if v124.optimistic and typeof(v125.optimistic) == "string" then
            v127.fromOptimisticTransaction = true;
        end;
        local l_onWatchUpdated_1 = v125.onWatchUpdated;
        if l_onWatchUpdated_1 and l_onWatchUpdated_1(v123, v124, v127, l_lastDiff_0) == false then
            return ;
        end;
    end;
    if not (l_lastDiff_0 and v12(l_lastDiff_0.result, v127.result)) then
        v124.lastDiff = v127;
        v124:callback(v124.lastDiff, l_lastDiff_0);
    end;
end;
v9.InMemoryCache = v35;
return v9;


local l_Parent_0 = script.Parent.Parent.Parent;
local v1 = require(l_Parent_0.Parent.LuauPolyfill);
local l_Array_0 = v1.Array;
local l_Set_0 = v1.Set;
local l_WeakMap_0 = v1.WeakMap;
local l_Map_0 = v1.Map;
local v6 = require(l_Parent_0.luaUtils.Object);
local l_HttpService_0 = game:GetService("HttpService");
local v8 = {};
local l_Trie_0 = require(l_Parent_0.wry.trie).Trie;
local v10 = require(script.Parent.Parent.Parent.utilities);
local l_canUseWeakMap_0 = v10.canUseWeakMap;
local l_isNonNullObject_0 = v10.isNonNullObject;
local l_sortedEncode_0 = require(l_Parent_0.luaUtils.sortedEncode).sortedEncode;
local v14 = nil;
local v15 = nil;
local v16 = nil;
local function _(v17)
    return (table.clone(v17));
end;
local function _(v19)
    if not (#v19 == 0) or next(v19) then
        if #v19 > 1 then
            return true;
        else
            return false;
        end;
    else
        return true;
    end;
end;
local v21 = {};
v21.__index = v21;
v21.new = function()
    local v22 = setmetatable({}, v21);
    v22.known = l_Set_0.new();
    v22.pool = l_Trie_0.new(l_canUseWeakMap_0);
    v22.passes = l_WeakMap_0.new();
    v22.keysByJSON = l_Map_0.new(nil);
    v22.empty = v22:admit({});
    return v22;
end;
v21.isKnown = function(v23, v24)
    return l_isNonNullObject_0(v24) and v23.known:has(v24);
end;
v21.pass = function(v25, v26)
    if not l_isNonNullObject_0(v26) then
        return v26;
    else
        local v27 = table.clone(v26);
        v25.passes:set(v27, v26);
        return v27;
    end;
end;
v21.admit = function(v28, v29)
    if l_isNonNullObject_0(v29) then
        local v30 = v28.passes:get(v29);
        if not v30 then
            if v6.getPrototypeOf(v29) == nil then
                if not (#v29 == 0 and not next(v29) or #v29 > 1) then
                    if not v28.known:has(v29) then
                        local v31 = v6.getPrototypeOf(v29);
                        local v32 = {
                            v31
                        };
                        local v33 = v28:sortedKeys(v29);
                        table.insert(v32, v33.json);
                        local v34 = #v32;
                        l_Array_0.forEach(v33.sorted, function(v35)
                            table.insert(v32, v28:admit(v29[v35]));
                        end);
                        local v36 = v28.pool:lookupArray(v32);
                        if not v36.object then
                            v36.object = v6.create(v31);
                            local l_object_0 = v36.object;
                            v28.known:add(l_object_0);
                            l_Array_0.forEach(v33.sorted, function(v38, v39)
                                l_object_0[v38] = v32[v34 + v39];
                            end);
                            if _G.__DEV__ then
                                v6.freeze(l_object_0);
                            end;
                        end;
                        return v36.object;
                    else
                        return v29;
                    end;
                elseif not v28.known:has(v29) then
                    local v40 = l_Array_0.map(v29, v28.admit, v28);
                    local v41 = v28.pool:lookupArray(v40);
                    if not v41.array then
                        v41.array = v40;
                        v28.known:add(v41.array);
                        if _G.__DEV__ then
                            v6.freeze(v40);
                        end;
                    end;
                    return v41.array;
                else
                    return v29;
                end;
            end;
        else
            return v30;
        end;
    end;
    return v29;
end;
v21.sortedKeys = function(v42, v43)
    local v44 = v6.keys(v43);
    local v45 = v42.pool:lookupArray(v44);
    if not v45.keys then
        l_Array_0.sort(v44);
        local v46 = l_HttpService_0:JSONEncode(v44);
        v45.keys = v42.keysByJSON:get(v46);
        if not v45.keys then
            v45.keys = {
                sorted = v44,
                json = v46
            };
            v42.keysByJSON:set(v46, v45.keys);
        end;
    end;
    return v45.keys;
end;
v8.ObjectCanon = v21;
v8.canonicalStringify = v6.assign(setmetatable({}, {
    __call = function(_, v48)
        if not l_isNonNullObject_0(v48) then
            return l_HttpService_0:JSONEncode(v48);
        else
            if v15 == nil then
                v14();
            end;
            local v49 = v15:admit(v48);
            local v50 = v16:get(v49);
            if v50 == nil then
                local l_v16_0 = v16;
                local l_v49_0 = v49;
                v50 = l_sortedEncode_0(v49);
                l_v16_0:set(l_v49_0, v50);
            end;
            return v50;
        end;
    end
}), {
    reset = function(_)
        return v14();
    end
});
v14 = function()
    v15 = v21.new();
    v16 = l_WeakMap_0.new();
end;
return v8;