local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_Players_0 = game:GetService("Players");
local l_IXPServiceWrapper_0 = require(l_Parent_1.IXPServiceWrapper).IXPServiceWrapper;
local v4 = require(l_Parent_0.Utils.getLocalUserId);
local l_FFlagEnableCapturesDesktopExperiment_0 = require(l_Parent_1.SharedFlags).FFlagEnableCapturesDesktopExperiment;
local v6 = require(l_Parent_0.Flags.FStringCapturesForDesktopEnabledIXPTreatmentKey);
local l_FStringCapturesIXPLayer_0 = require(l_Parent_1.SharedFlags).FStringCapturesIXPLayer;
return function(v8)
    if l_FFlagEnableCapturesDesktopExperiment_0 then
        if v8 then
            l_IXPServiceWrapper_0 = v8;
        end;
        local v9 = v4(l_Players_0);
        if v9 then
            assert(v9 ~= nil, "localUserIdStr must not be nil");
            local v10 = tonumber(v9);
            if v10 then
                assert(v10 ~= nil, "localUserId must not be nil");
                local _ = false;
                local l_l_IXPServiceWrapper_0_LayerData_0 = l_IXPServiceWrapper_0:GetLayerData(l_FStringCapturesIXPLayer_0);
                if l_l_IXPServiceWrapper_0_LayerData_0 then
                    assert(l_l_IXPServiceWrapper_0_LayerData_0 ~= nil, "layerData must not be nil");
                    return l_l_IXPServiceWrapper_0_LayerData_0[v6] or false;
                else
                    return false;
                end;
            else
                return false;
            end;
        else
            return false;
        end;
    else
        return false;
    end;
end;


return game:GetEngineFeature("CaptureServiceProvidesTriggerSource") and game:DefineFastFlag("CapturesFixPromptShareDuplicateToast", false);


return game:DefineFastFlag("EnableCapturesHotkeyExperiment_v2", false) and game:GetEngineFeature("SocialCaptureLayerRegistered");


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_ContextActionService_0 = game:GetService("ContextActionService");
local l_UserInputService_0 = game:GetService("UserInputService");
local v4 = require(l_Parent_1.React);
local v5 = require(l_Parent_1.RoactAppExperiment);
local v6 = require(l_Parent_1.RoactUtils);
local v7 = require(l_Parent_0.Utils.createShutterSound);
local v8 = require(l_Parent_0.Analytics.EventNames);
local v9 = require(l_Parent_0.Utils.getCaptureShortcutSetupKeys);
local v10 = require(l_Parent_0.Thunks.TakeCapture);
local v11 = require(l_Parent_0.Analytics.useAnalytics);
local l_useDispatch_0 = v6.Hooks.RoactRodux.useDispatch;
local l_useEffect_0 = v4.useEffect;
local l_useRef_0 = v4.useRef;
local l_useSelector_0 = v6.Hooks.RoactRodux.useSelector;
local l_useUserExperiment_0 = v5.useUserExperiment;
local l_FStringCapturesIXPLayer_0 = require(l_Parent_1.SharedFlags).FStringCapturesIXPLayer;
local v18 = require(l_Parent_0.Flags.FFlagEnableCapturesHotkeyExperiment);
local v19 = if not v18 then game:DefineFastString("CapturesIXPLayer", "Experience.Menu") else l_FStringCapturesIXPLayer_0;
local _ = function()
    for _, v21 in (v9()), nil, nil do
        if l_UserInputService_0:IsKeyDown(v21) then
            return true;
        end;
    end;
    return false;
end;
return function()
    if v18 then
        local v23 = v11();
        local v24 = l_useDispatch_0();
        local v26 = l_useSelector_0(function(v25)
            return v25.Screenshots.IsCapturesCoreGuiEnabled;
        end);
        local v27 = l_useRef_0(v7());
        local v29 = l_useUserExperiment_0({
            v19
        }, function(v28)
            return (v28[v19] or {}).CapturesDesktopHotkeyEnabled;
        end);
        l_useEffect_0(function()
            if v29 then
                if v26 then
                    if not v27.current then
                        v27.current = v7();
                    end;
                    local function _()
                        if v27.current then
                            v27.current:Play();
                        end;
                        v23.fireEvent(v8.CapturesEntrypointActivated);
                        v23.fireEvent(v8.CapturesDesktopHotkeyCaptureTriggered);
                        v24(v10());
                    end;
                    l_ContextActionService_0:BindCoreAction("CaptureShortcutAction", function(_, v32)
                        if v32 == Enum.UserInputState.Begin then
                            local v33;
                            for _, v35 in (v9()), nil, nil do
                                if l_UserInputService_0:IsKeyDown(v35) then
                                    v33 = true;
                                    goto label0 --[[  true, false  ]];
                                end;
                            end;
                            v33 = false;
                            ::label0::;
                            if v33 then
                                if v27.current then
                                    v27.current:Play();
                                end;
                                v23.fireEvent(v8.CapturesEntrypointActivated);
                                v23.fireEvent(v8.CapturesDesktopHotkeyCaptureTriggered);
                                v24(v10());
                                return Enum.ContextActionResult.Sink;
                            end;
                        end;
                        return Enum.ContextActionResult.Pass;
                    end, false, Enum.KeyCode.One);
                    return function()
                        if v27.current then
                            v27.current:Stop();
                            v27.current:Destroy();
                            v27.current = nil;
                        end;
                        l_ContextActionService_0:UnbindCoreAction("CaptureShortcutAction");
                    end;
                else
                    return ;
                end;
            else
                return ;
            end;
        end, {
            v24,
            v26,
            v29
        });
        return ;
    else
        return ;
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_ContextActionService_0 = game:GetService("ContextActionService");
local l_RunService_0 = game:GetService("RunService");
local l_UserGameSettings_0 = UserSettings():GetService("UserGameSettings");
local l_UserInputService_0 = game:GetService("UserInputService");
local v6 = require(l_Parent_1.Otter);
local v7 = require(l_Parent_1.React);
local v8 = require(l_Parent_1.RoactUtils);
local v9 = require(l_Parent_1.SocialCommon);
local v10 = require(l_Parent_1.UIBlox);
local v11 = require(l_Parent_0.Analytics.useAnalytics);
local l_useBinding_0 = v7.useBinding;
local l_useEffectOnce_0 = v8.Hooks.useEffectOnce;
local l_useExternalEvent_0 = v10.Core.Hooks.useExternalEvent;
local l_useIsHovered_0 = v9.Hooks.useIsHovered;
local l_useIsTouchDown_0 = v9.Hooks.useIsTouchDown;
local v17 = require(l_Parent_0.Analytics.EventNames);
local v18 = require(l_Parent_0.Utils.getClosestItemToCenter);
local v19 = require(l_Parent_0.Experimentation.getIsFeatureVisibleToDesktopUser);
local v20 = require(l_Parent_0.Flags.FFlagDecomposeDesktopCapturesEligibilityCheck);
local v21 = {
    dampingRatio = 1,
    frequency = 4
};
local function _(v22, v23, v24)
    return math.abs(v22 - v23) < v24;
end;
local function v87(v26, v27, v28)
    local v29 = nil;
    local v30 = false;
    local v31 = nil;
    local v32 = false;
    local v33 = 0;
    local v34 = false;
    local function v35()
        return v34;
    end;
    local function v36()
        v30 = false;
        v34 = false;
    end;
    local function v37()
        return v32;
    end;
    local function _(v38)
        if v38 == true then
            v30 = false;
            v34 = false;
        end;
        v32 = v38;
    end;
    local function v46(v40, v41, v42)
        if v31 then
            v31:destroy();
            v31 = nil;
        end;
        local v43 = v6.createSingleMotor(v40);
        v31 = v43;
        v43:onStep(function(v44)
            if v31 ~= v43 then
                v43:destroy();
                return ;
            elseif not v30 then
                local v45 = if not (math.abs(v44 - v33) < 0.5) then v44 else v33;
                if not v41 or not v41(v40, v45) then
                    if v26.current then
                        v26.current.CanvasPosition = Vector2.new(v45, 0);
                    end;
                    return ;
                else
                    return ;
                end;
            else
                v43:destroy();
                v31 = nil;
                return ;
            end;
        end);
        if v42 then
            v43:onComplete(v42);
        end;
        v43:start();
    end;
    local function v50(v47, v48, v49)
        if v31 then
            assert(v31 ~= nil, "setGoal called before resetMotor");
            v33 = v47.X * (v48 - 1);
            if not v49 then
                v31:setGoal(v6.spring(v33, v21));
                return ;
            else
                v31:setGoal(v6.instant(v33));
                return ;
            end;
        else
            return ;
        end;
    end;
    local v86 = {
        carouselRef = v26,
        getWasTouched = v35,
        getIsNavigationLocked = v37,
        handleDeleteTransition = function(v51, v52, v53, v54, v55, v56)
            local l_current_0 = v26.current;
            local l_current_1 = v27.current;
            if l_current_0 and l_current_1 then
                assert(l_current_0 ~= nil, "carousel should exist");
                assert(l_current_1 ~= nil, "selectedItem should exist");
                local l_ScrollingEnabled_0 = l_current_0.ScrollingEnabled;
                l_current_0.ScrollingEnabled = false;
                v30 = false;
                v34 = false;
                v32 = true;
                local function v62()
                    v46(l_current_0.CanvasPosition.X, function(v60, v61)
                        l_current_1.Size = UDim2.fromOffset(math.round(v53.X - math.abs(v60 - v61)), v53.Y);
                        return v54 == 1;
                    end, function()
                        v56();
                        l_current_1.Visible = false;
                        v51(1);
                        v32 = false;
                        l_current_0.ScrollingEnabled = l_ScrollingEnabled_0;
                    end);
                    v50(v53, v54 - 1, v55 or l_UserGameSettings_0.ReducedMotion);
                end;
                local function v67()
                    if v52 then
                        assert(v52 ~= nil, "setPostDeletionItemBinding should exist");
                        v46(l_current_0.CanvasPosition.X, function(_, _)
                            return v54 == 1;
                        end, function()
                            v56();
                            l_current_1.Visible = false;
                            local v65 = v6.createSingleMotor(0);
                            v65:onStep(function(v66)
                                v51(v66);
                                v52(1);
                            end);
                            v65:onComplete(function()
                                v32 = false;
                                l_current_0.ScrollingEnabled = l_ScrollingEnabled_0;
                            end);
                            v65:setGoal(v6.spring(1, {
                                frequency = 2
                            }));
                        end);
                        v50(v53, v54 - 1, true);
                        return ;
                    else
                        return ;
                    end;
                end;
                local function v69()
                    if v52 then
                        assert(v52 ~= nil, "setPostDeletionItemBinding should exist");
                        local v68 = v6.createSingleMotor(1);
                        v68:onStep(v52);
                        v68:onComplete(v67);
                        v68:setGoal(v6.spring(0, {
                            frequency = 6
                        }));
                        return ;
                    else
                        return ;
                    end;
                end;
                local v70 = v6.createSingleMotor(1);
                v70:onStep(v51);
                local v71 = nil;
                if not l_UserGameSettings_0.ReducedMotion then
                    v71 = 4;
                    v70:onComplete(v62);
                else
                    v71 = 6;
                    v70:onComplete(v69);
                end;
                v70:setGoal(v6.spring(0, {
                    frequency = v71
                }));
                return ;
            else
                return ;
            end;
        end,
        handleInertialMove = function(v72, v73)
            local v74 = nil;
            local l_current_2 = v26.current;
            if not v30 and l_current_2 then
                assert(l_current_2 ~= nil, "carousel should not be nil");
                v74 = -l_current_2:GetSampledInertialVelocity().X;
                l_current_2:ClearInertialScrolling();
                local v76, v77 = v18(v72, l_current_2);
                if math.abs(v74) < 60 and v76 == v73 then
                    if v77 > 0.5 then
                        v46(l_current_2.CanvasPosition.X);
                        v50(v72, v73, false);
                    end;
                    return ;
                else
                    if v29 then
                        v29:Disconnect();
                        v29 = nil;
                    end;
                    v29 = l_RunService_0.RenderStepped:Connect(function(v78)
                        local l_current_3 = v26.current;
                        if l_current_3 and not v30 then
                            assert(l_current_3 ~= nil, "carousel should not be nil");
                            local v80, v81 = v18(v72, l_current_3);
                            if math.abs(v74) < 60 then
                                assert(v29 ~= nil, "handleInertialMoveConn should exist");
                                v29:Disconnect();
                                v29 = nil;
                                if v80 == v73 then
                                    v46(l_current_3.CanvasPosition.X);
                                    v50(v72, v73, false);
                                    return ;
                                else
                                    v28(v80);
                                    return ;
                                end;
                            else
                                l_current_3.CanvasPosition = l_current_3.CanvasPosition + Vector2.new(v74 * v78, 0);
                                local v82 = math.max((v81 / (v72.X / 2)) * 1.25, 0.85);
                                local _ = nil;
                                v74 = v74 * (math.abs(v74) < 120 and 0.7 or 0.95 * v82) ^ (v78 / 0.016666666666666666);
                                return ;
                            end;
                        else
                            assert(v29 ~= nil, "handleInertialMoveConn should exist");
                            v29:Disconnect();
                            v29 = nil;
                            return ;
                        end;
                    end);
                    return ;
                end;
            else
                return ;
            end;
        end,
        onInputBegan = function(_, v85)
            if not v32 then
                if v85.UserInputType == Enum.UserInputType.Touch then
                    v30 = true;
                    v34 = true;
                end;
                return ;
            else
                return ;
            end;
        end,
        resetMotor = v46,
        resetTouchState = v36,
        setGoal = v50
    };
    v86.resetMotor(0);
    return v86;
end;
return function(v88, v89, v90)
    local v91 = v11();
    local v92, v93 = l_useBinding_0(1);
    local v94, v95 = l_useBinding_0(1);
    local v96 = v7.useRef(nil);
    local v97, v98, v99 = l_useIsHovered_0();
    local v100 = l_useIsTouchDown_0();
    local v101 = v7.useRef(nil);
    local v102 = v7.useRef(nil);
    if v102.current == nil then
        v102.current = v87(v96, v101, v90);
    end;
    local l_current_4 = v102.current;
    assert(l_current_4 ~= nil, "carouselController should exist");
    v7.useEffect(function()
        local l_current_5 = v96.current;
        if l_current_5 then
            assert(l_current_5 ~= nil, "carousel should exist");
            local v105 = false;
            if l_UserGameSettings_0.ReducedMotion then
                v105 = true;
            end;
            l_current_4.resetMotor(l_current_5.CanvasPosition.X);
            l_current_4.setGoal(v88, v89, v105);
            return ;
        else
            return ;
        end;
    end, {
        v89
    });
    l_useEffectOnce_0(function()
        l_current_4.setGoal(v88, v89, true);
    end, v89 ~= nil);
    v7.useEffect(function()
        l_current_4.setGoal(v88, v89, true);
    end, {
        v88
    });
    v7.useEffect(function()
        if not (v100 or not l_current_4.getWasTouched()) then
            l_current_4.resetTouchState();
            l_current_4.handleInertialMove(v88, v89);
        end;
    end, {
        v100
    });
    l_useExternalEvent_0(l_UserInputService_0.PointerAction, (v7.useCallback(function(v106)
        local l_current_6 = v96.current;
        if l_current_6 then
            assert(l_current_6 ~= nil, "carousel should exist");
            if not l_current_4.getIsNavigationLocked() then
                local v108 = v18(v88, l_current_6);
                if v97 and v106 > 0 then
                    v90(v108 - 1);
                    return ;
                else
                    if v97 and v106 < 0 then
                        v90(v108 + 1);
                    end;
                    return ;
                end;
            else
                return ;
            end;
        else
            return ;
        end;
    end, {
        v97,
        v88
    })));
    l_useExternalEvent_0(l_UserInputService_0.TouchSwipe, (v7.useCallback(function(v109)
        if l_UserGameSettings_0.ReducedMotion then
            local l_current_7 = v96.current;
            if l_current_7 then
                assert(l_current_7 ~= nil, "carousel should exist");
                if not l_current_4.getIsNavigationLocked() then
                    local v111 = v18(v88, l_current_7);
                    if v109 == Enum.SwipeDirection.Left then
                        v90(v111 + 1);
                        return ;
                    else
                        if v109 == Enum.SwipeDirection.Right then
                            v90(v111 - 1);
                        end;
                        return ;
                    end;
                else
                    return ;
                end;
            else
                return ;
            end;
        else
            return ;
        end;
    end, {})));
    v7.useEffect(function()
        if v19() or v20 then
            l_ContextActionService_0:BindCoreAction("CapturesCarouselNavigateShortcutAction", function(_, v113, v114)
                local l_current_8 = v96.current;
                if l_current_8 then
                    assert(l_current_8 ~= nil, "carousel should exist");
                    if not l_current_4.getIsNavigationLocked() then
                        if v113 == Enum.UserInputState.End then
                            v91.fireEvent(v17.CapturesCarouselNavigatedByKeyboard);
                            local v116 = v18(v88, l_current_8);
                            if v114.KeyCode == Enum.KeyCode.Left then
                                v90(v116 - 1);
                                return ;
                            elseif v114.KeyCode == Enum.KeyCode.Right then
                                v90(v116 + 1);
                            end;
                        end;
                        return ;
                    else
                        return ;
                    end;
                else
                    return ;
                end;
            end, false, Enum.KeyCode.Left, Enum.KeyCode.Right);
            return function()
                l_ContextActionService_0:UnbindCoreAction("CapturesCarouselNavigateShortcutAction");
            end;
        else
            return ;
        end;
    end, {});
    return {
        carouselInputBegan = v7.useCallback(function(v117, v118)
            if not l_current_4.getIsNavigationLocked() then
                if not l_UserGameSettings_0.ReducedMotion then
                    l_current_4.onInputBegan(v117, v118);
                    v98(v117, v118);
                    return ;
                else
                    v98(v117, v118);
                    return ;
                end;
            else
                return ;
            end;
        end, {
            l_current_4.onInputBegan,
            v98
        }),
        carouselInputEnded = v7.useCallback(function(v119, v120)
            v99(v119, v120);
        end, {
            v99
        }),
        carouselRef = v96,
        deleteSelectedItem = v7.useCallback(function(v121)
            l_current_4.handleDeleteTransition(v93, v95, v88, v89, false, v121);
        end, {
            v88,
            v89,
            v93
        }),
        postDeletionItemBinding = v94,
        selectedItemFadeOutBinding = v92,
        selectedItemRef = v101
    };
end;


local l_AppStorageService_0 = game:GetService("AppStorageService");
local l_Parent_0 = script.Parent.Parent;
local v2 = require(l_Parent_0.Parent.RoactUtils);
local v3 = require(l_Parent_0.Constants);
local l_useSelector_0 = v2.Hooks.RoactRodux.useSelector;
local function v5()
    pcall(function()
        l_AppStorageService_0:SetItem(v3.LastFlashOccurrenceTsLocalStorageKey, (tostring(DateTime.now().UnixTimestampMillis)));
        l_AppStorageService_0:Flush();
    end);
end;
return function(v6)
    local v7 = v6 or l_AppStorageService_0;
    if l_useSelector_0(function(v8)
        return v8.Screenshots.IsOverlayFlashActive;
    end) then
        local l_status_0, l_result_0 = pcall(function()
            return v7:GetItem(v3.LastFlashOccurrenceTsLocalStorageKey);
        end);
        if l_status_0 then
            local v11 = tonumber(l_result_0);
            if v11 == nil then
                return false, v5;
            else
                assert(v11 ~= nil, "lastFlashOccurrenceTs cannot be nil");
                if DateTime.now().UnixTimestampMillis - v11 < 500 then
                    return false, v5;
                else
                    return true, v5;
                end;
            end;
        else
            return false, v5;
        end;
    else
        return false, v5;
    end;
end;


local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.Dash);
local v3 = require(l_Parent_1.Roact);
local v4 = require(l_Parent_1.Dev.SocialTestHelpers);
local v5 = require(l_Parent_1.UIBlox);
local v6 = require(l_Parent_1.Dev.RobloxAppUIBloxConfig);
local v7 = require(l_Parent_0.Context.ShotsContext);
local l_mockLocale_0 = v4.StoryHelpers.mockLocale;
v5.init(v6);
local l_AppStyleProvider_0 = v5.App.Style.AppStyleProvider;
v3.setGlobalConfig({
    elementTracing = true
});
local v10 = {
    Default = {
        themeName = "Light",
        fontName = "Gotham"
    },
    Light = {
        themeName = "Light",
        fontName = "Gotham"
    },
    Dark = {
        themeName = "Dark",
        fontName = "Gotham"
    }
};
local v11 = {
    language = "en-us"
};
return {
    name = "Screenshots",
    storyRoot = l_Parent_0,
    roact = v3,
    mapDefinition = function(v12)
        return v2.join(v12, {
            controls = v2.join(v11, v12.controls)
        });
    end,
    mapStory = function(v13)
        return function(v14)
            return v3.createElement(v7.Provider, {
                value = {
                    fireAnalyticsEvent = v2.noop
                }
            }, {
                Element = v3.createElement(l_AppStyleProvider_0, {
                    style = not not v14 and v10[v14.theme] or v10.Default
                }, {
                    Child = l_mockLocale_0(v13, v14)
                })
            });
        end;
    end
};


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.Dash);
local v3 = require(l_Parent_1.Rodux);
local v4 = require(l_Parent_0.installReducer);
local v5 = require(l_Parent_0.App.Networking);
local v6 = require(l_Parent_0.installReducer.ScreenSize);
local v7 = require(l_Parent_0.installReducer.ServerType);
local v8 = {};
return function(v9)
    return v3.Store.new(v3.combineReducers({
        Games = v5.RoduxGames.installReducer(),
        NetworkStatus = v5.RoduxNetworking.installReducer(),
        Screenshots = v4(),
        ScreenSize = v6,
        ServerType = v7
    }), v2.joinDeep(v8, v9 or {}), {
        v3.thunkMiddleware
    });
end;


local l_Parent_0 = script.Parent.Parent;
local l_mockAnalytics_0 = require(l_Parent_0.Parent.SocialLuaAnalytics).TestingAnalytics.mockAnalytics;
local v2 = require(l_Parent_0.Analytics.setupFireEvent);
return function(v3, v4)
    local v5 = l_mockAnalytics_0(v4);
    local v6 = if not not v3 and v3.pid then v3.pid else "1818";
    local v7 = if not not v3 and v3.source then v3.source else "mock";
    local v8 = if not not v3 and v3.uid then v3.uid else "101";
    return {
        analyticsMock = v5,
        fireAnalyticsEvent = v2({
            analytics = v5,
            infoForAllEvents = {
                isUnder13 = false,
                pid = v6,
                source = v7,
                uid = v8
            }
        }),
        uid = v8
    };
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Parent.Dash);
local v2 = require(l_Parent_0.Enums.CaptureType);
local _ = require(l_Parent_0.Types);
local v4 = {
    {
        contentId = "rbxasset://textures/AvatarEditorImages/AvatarEditor.png",
        filePath = "c://some/path/to/2231221_1818_1234598400000.png",
        type = v2.Screenshot
    },
    {
        contentId = "rbxasset://textures/AvatarEditorImages/AvatarEditor_LightTheme.png",
        filePath = "c://some/path/to/2231221_14375697_1653030000000.png",
        type = v2.Screenshot
    }
};
return function(v5)
    local v6 = {};
    for v7 = 1, v5 do
        local v8 = v1.joinDeep(v4[v7 % #v4 + 1], {});
        v8.contentId = "rbxasset://textures/" .. ("/./"):rep((math.floor(v7 / #v4))) .. string.sub(v8.contentId, 21);
        table.insert(v6, v8);
    end;
    return v6;
end;


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.Dev.JestGlobals);
local v3 = require(l_Parent_1.Localization);
local v4 = require(l_Parent_1.LuaSocialLibrariesDeps);
local v5 = require(l_Parent_1.React);
local v6 = require(l_Parent_1.RoactRodux);
local v7 = require(l_Parent_1.Dev.UnitTestHelpers);
local l_LocalizationProvider_0 = v3.LocalizationProvider;
local l_Mock_0 = v4.Mock;
local l_jest_0 = v2.jest;
local v11 = require(l_Parent_0.Context.ShotsContext);
local v12 = require(l_Parent_0.TestUtils.createStore);
local v13 = require(l_Parent_0.TestUtils.mockAnalytics);
local v14 = require(l_Parent_0.App.ScreenshotsPolicy);
local v15 = {
    EligibleForCapturesFeature = true,
    EnableCapturesBulkManagement = true,
    EnableShareCaptureCTA = true
};
return function(v16, v17)
    local v18 = l_Mock_0.MagicMock.new({
        name = "Localization"
    });
    v18.Format = function(_, v20, _)
        return v20;
    end;
    local v22 = v13({}, l_jest_0);
    local v23 = v12();
    if v17 then
        if v17.analytics then
            v22 = v17.analytics;
        end;
        if v17.store then
            v23 = v17.store;
        end;
    end;
    return v5.createElement(v6.StoreProvider, {
        store = v23
    }, {
        PolicyProvider = v5.createElement(v14.Provider, {
            policy = {
                v14.Mapper
            },
            policyData = not not v17 and v17.policyData or v15
        }, {
            ContextProvider = v5.createElement(v11.Provider, {
                value = {
                    fireAnalyticsEvent = v22.fireAnalyticsEvent,
                    chromeEnabled = not not v17 and v17.chromeEnabled or nil
                }
            }, {
                StyleProvider = v7.createStyleProvider({
                    localizationProvider = v5.createElement(l_LocalizationProvider_0, {
                        localization = v18
                    }, {
                        child = v16
                    })
                })
            })
        })
    });
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Actions.CarouselIndexSelected);
local v2 = require(l_Parent_0.Constants);
return function(v3)
    return function(v4)
        v4:dispatch(v1((math.clamp(v4:getState().Screenshots.Carousel.SelectedCaptureIndex + (v3 == v2.CarouselDirection.Left and -1 or 1), 1, #v4:getState().Screenshots.Captures))));
    end;
end;


local v0 = require(script.Parent.Parent.Actions.CarouselIndexSelected);
return function(v1)
    return function(v2)
        v2:dispatch(v0((math.clamp(v1, 1, #v2:getState().Screenshots.Captures))));
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local l_CaptureService_0 = game:GetService("CaptureService");
local v2 = require(l_Parent_0.Thunks.RetrieveCaptures);
local _ = require(l_Parent_0.Types);
return function(v4)
    return function(v5)
        l_CaptureService_0:DeleteCapture(v4.filePath);
        v5:dispatch(v2());
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local l_CaptureService_0 = game:GetService("CaptureService");
local v2 = require(l_Parent_0.Thunks.RetrieveCaptures);
local _ = require(l_Parent_0.Types);
return function(v4)
    local v5 = {};
    for _, v7 in ipairs(v4) do
        table.insert(v5, v7.filePath);
    end;
    return function(v8)
        if not game:GetEngineFeature("CaptureServiceBulkManagementFeatureEnabled") then
            for _, v10 in ipairs(v5) do
                l_CaptureService_0:DeleteCapture(v10);
            end;
        else
            l_CaptureService_0:DeleteCapturesAsync(v5);
        end;
        v8:dispatch(v2());
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local l_CaptureService_0 = game:GetService("CaptureService");
local v2 = require(l_Parent_0.Actions.CapturesRetrieved);
local _ = require(l_Parent_0.Types);
local function _(v4)
    local l_SelectedCaptureIndex_0 = v4.Screenshots.Carousel.SelectedCaptureIndex;
    if l_SelectedCaptureIndex_0 ~= nil then
        return v4.Screenshots.Captures[l_SelectedCaptureIndex_0];
    else
        return nil;
    end;
end;
return function()
    return function(v7)
        local v8 = v7:getState();
        local l_SelectedCaptureIndex_1 = v8.Screenshots.Carousel.SelectedCaptureIndex;
        v7:dispatch(v2(l_CaptureService_0:RetrieveCaptures(), if l_SelectedCaptureIndex_1 ~= nil then v8.Screenshots.Captures[l_SelectedCaptureIndex_1] else nil));
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Services.CaptureService);
local v2 = require(l_Parent_0.Experimentation.getIsFeatureVisibleToDesktopUser);
local v3 = require(l_Parent_0.Enums.ShotsToastType);
local v4 = require(l_Parent_0.Actions.ToastTriggered);
local _ = require(l_Parent_0.Types);
local v6 = require(l_Parent_0.Flags.FFlagDecomposeDesktopCapturesEligibilityCheck);
return function(v7)
    return function(v8)
        v1:SaveCaptureToExternalStorage(v7.filePath);
        if not v2() or v6 then
            v8:dispatch(v4(v3.CaptureSavedToDevice));
            return ;
        else
            v8:dispatch(v4(v3.CaptureSavedToDeviceWithOpenCTA));
            return ;
        end;
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local l_CaptureService_0 = game:GetService("CaptureService");
local v2 = require(l_Parent_0.Actions.PromptDismissed);
return function(v3, v4)
    return function(v5)
        v5:dispatch(v2(v3));
        l_CaptureService_0:OnSavePromptFinished(v3, v4);
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local l_CaptureService_0 = game:GetService("CaptureService");
local v2 = require(l_Parent_0.Enums.ShotsToastType);
local v3 = require(l_Parent_0.Actions.ToastTriggered);
local _ = require(l_Parent_0.Types);
return function(v5)
    local v6 = {};
    for _, v8 in v5, nil, nil do
        table.insert(v6, v8.filePath);
    end;
    return function(v9)
        if not game:GetEngineFeature("CaptureServiceBulkManagementFeatureEnabled") then
            for _, v11 in v6, nil, nil do
                l_CaptureService_0:SaveCaptureToExternalStorage(v11);
            end;
        else
            l_CaptureService_0:SaveCapturesToExternalStorageAsync(v6);
        end;
        v9:dispatch(v3(v2.CaptureSavedToDevice));
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Actions.UpdateSelectedCaptures);
local v2 = require(l_Parent_0.Utils.getUpdatedSelectedCapturesArray);
local _ = require(l_Parent_0.Types);
return function(v4)
    return function(v5)
        v5:dispatch(v1(v2(v5:getState().Screenshots.CaptureManager.SelectedCaptures, v4)));
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local l_CaptureService_0 = game:GetService("CaptureService");
local v2 = require(l_Parent_0.Actions.PromptDismissed);
local v3 = require(l_Parent_0.Thunks.ShareCapture);
local v4 = require(l_Parent_0.Enums.CaptureType);
local _ = require(l_Parent_0.Types);
return function(v6, v7, v8)
    return function(v9)
        v9:dispatch(v2(v6));
        if v8 then
            task.spawn(function()
                v9:dispatch(v3({
                    contentId = v7.contentId,
                    filePath = l_CaptureService_0:GetCaptureFilePathAsync(v7.contentId),
                    type = v4.Screenshot
                }, v7.launchData));
            end);
        end;
        l_CaptureService_0:OnSharePromptFinished(v6, v8);
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local l_CaptureService_0 = game:GetService("CaptureService");
local l_GuiService_0 = game:GetService("GuiService");
local l_UserInputService_0 = game:GetService("UserInputService");
local v4 = require(l_Parent_0.Experimentation.getIsFeatureVisibleToDesktopUser);
local v5 = require(l_Parent_0.Utils.getScreenshotHud);
local v6 = require(l_Parent_0.Actions.OverlayActivated);
local v7 = require(l_Parent_0.Actions.OverlayDeactivated);
local v8 = require(l_Parent_0.Actions.OverlayFlashActivated);
local v9 = require(l_Parent_0.Actions.OverlayFlashDeactivated);
local v10 = require(l_Parent_0.Utils.removeCoreUI);
local v11 = require(l_Parent_0.Enums.ShotsToastType);
local v12 = require(l_Parent_0.Actions.ToastTriggered);
local v13 = require(l_Parent_0.Flags.FFlagDecomposeDesktopCapturesEligibilityCheck);
local function _(v14)
    if l_GuiService_0:GetGuiIsVisible(v14) then
        l_GuiService_0:ToggleGuiIsVisibleForCaptures(v14);
    end;
end;
local function _(v16)
    if not l_GuiService_0:GetGuiIsVisible(v16) then
        l_GuiService_0:ToggleGuiIsVisibleForCaptures(v16);
    end;
end;
local function _()
    if l_GuiService_0:GetGuiIsVisible(Enum.GuiType.Custom) then
        l_GuiService_0:ToggleGuiIsVisibleForCaptures(Enum.GuiType.Custom);
    end;
end;
local function _()
    if not l_GuiService_0:GetGuiIsVisible(Enum.GuiType.Custom) then
        l_GuiService_0:ToggleGuiIsVisibleForCaptures(Enum.GuiType.Custom);
    end;
end;
return function()
    return function(v20)
        local v21 = false;
        local v22 = false;
        v20:dispatch(v12(v11.None));
        local l_OverrideMouseIconBehavior_0 = l_UserInputService_0.OverrideMouseIconBehavior;
        if not (not v13 and not v4()) then
            l_UserInputService_0.OverrideMouseIconBehavior = Enum.OverrideMouseIconBehavior.ForceHide;
        end;
        local v24 = v5();
        if not (v24 and not v24.HidePlayerGuiForCaptures) then
            if l_GuiService_0:GetGuiIsVisible(Enum.GuiType.Custom) then
                l_GuiService_0:ToggleGuiIsVisibleForCaptures(Enum.GuiType.Custom);
            end;
            v22 = true;
        end;
        local v25 = nil;
        if not (v24 and not v24.HideCoreGuiForCaptures) then
            v25 = v10();
            v21 = true;
        end;
        local l_CustomBillboards_0 = Enum.GuiType.CustomBillboards;
        if l_GuiService_0:GetGuiIsVisible(l_CustomBillboards_0) then
            l_GuiService_0:ToggleGuiIsVisibleForCaptures(l_CustomBillboards_0);
        end;
        l_CustomBillboards_0 = Enum.GuiType.PlayerNameplates;
        if l_GuiService_0:GetGuiIsVisible(l_CustomBillboards_0) then
            l_GuiService_0:ToggleGuiIsVisibleForCaptures(l_CustomBillboards_0);
        end;
        v20:dispatch(v6());
        l_CaptureService_0:OnCaptureBegan();
        task.wait(0.1);
        l_CaptureService_0:SaveScreenshotCapture();
        task.wait();
        v20:dispatch(v8());
        task.wait(0.5);
        l_CaptureService_0:OnCaptureEnded();
        v20:dispatch(v9());
        v20:dispatch(v7());
        if not (not v13 and not v4()) then
            l_UserInputService_0.OverrideMouseIconBehavior = l_OverrideMouseIconBehavior_0;
        end;
        if not (not v22 or l_GuiService_0:GetGuiIsVisible(Enum.GuiType.Custom)) then
            l_GuiService_0:ToggleGuiIsVisibleForCaptures(Enum.GuiType.Custom);
        end;
        if v21 then
            v25();
        end;
        l_CustomBillboards_0 = Enum.GuiType.CustomBillboards;
        if not l_GuiService_0:GetGuiIsVisible(l_CustomBillboards_0) then
            l_GuiService_0:ToggleGuiIsVisibleForCaptures(l_CustomBillboards_0);
        end;
        l_CustomBillboards_0 = Enum.GuiType.PlayerNameplates;
        if not l_GuiService_0:GetGuiIsVisible(l_CustomBillboards_0) then
            l_GuiService_0:ToggleGuiIsVisibleForCaptures(l_CustomBillboards_0);
        end;
    end;
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Enums.CaptureType);
local _ = require(l_Parent_0.Enums.PromptType);
return {};


local l_RobloxGui_0 = game:GetService("CoreGui"):WaitForChild("RobloxGui");
return function()
    local l_Sound_0 = Instance.new("Sound");
    l_Sound_0.Name = "ShutterSound";
    l_Sound_0.Parent = l_RobloxGui_0;
    l_Sound_0.Volume = 1;
    l_Sound_0.SoundId = "rbxassetid://10066921516";
    return l_Sound_0;
end;


local _ = require(script.Parent.Parent.Types);
return function(v1)
    local v2, v3, v4 = string.match(v1.filePath, "(%d+)_(%d+)_(%d+)%.?%w*$");
    if not (v2 ~= nil and v3 ~= nil) or v4 == nil then
        return nil;
    else
        local v5 = tonumber(v2);
        local v6 = tonumber(v3);
        local v7 = tonumber(v4);
        assert(v5 ~= nil, "userId should not be nil");
        assert(v6 ~= nil, "placeId should not be nil");
        assert(v7 ~= nil, "unixTimestamp should not be nil");
        return {
            userId = v5,
            placeId = v6,
            unixTimestamp = v7
        };
    end;
end;


local l_UserInputService_0 = game:GetService("UserInputService");
return function()
    if l_UserInputService_0:GetPlatform() == Enum.Platform.OSX then
        return {
            Enum.KeyCode.LeftMeta,
            Enum.KeyCode.RightMeta
        };
    else
        return {
            Enum.KeyCode.LeftAlt,
            Enum.KeyCode.RightAlt
        };
    end;
end;


local l_CaptureService_0 = game:GetService("CaptureService");
return function(v1)
    local l_status_0, l_result_0 = pcall(function()
        return l_CaptureService_0:GetCaptureSizeAsync(v1);
    end);
    if not l_status_0 or l_result_0 == Vector2.new(0, 0) then
        return nil;
    else
        return l_result_0;
    end;
end;


local l_CaptureService_0 = game:GetService("CaptureService");
local _ = require(script.Parent.Parent.Types);
formatBytes = function(v2)
    local v3 = {
        "Bytes",
        "KB",
        "MB",
        "GB",
        "TB"
    };
    local v4 = math.floor(math.log(v2) / 6.931471805599453);
    return string.format("%.2f%s", v2 / math.pow(1024, v4), v3[v4 + 1]);
end;
return function(v5)
    if #v5 == 0 then
        return ;
    else
        local v6 = {};
        for _, v8 in ipairs(v5) do
            table.insert(v6, v8.filePath);
        end;
        local _, l_result_0 = pcall(function()
            return l_CaptureService_0:GetCaptureStorageSizeAsync(v6);
        end);
        return formatBytes(l_result_0);
    end;
end;


return function(v0, v1)
    local l_AbsoluteSize_0 = v1.AbsoluteSize;
    local l_CanvasPosition_0 = v1.CanvasPosition;
    local v4 = math.floor((l_CanvasPosition_0.X + l_AbsoluteSize_0.X / 2) / v0.X) + 1;
    return v4, (math.abs(l_CanvasPosition_0.X - (v4 - 1) * v0.X));
end;


local l_AppStorageService_0 = game:GetService("AppStorageService");
local l_Players_0 = game:GetService("Players");
local l_Parent_0 = script.Parent.Parent;
local v3 = require(l_Parent_0.Constants);
local v4 = require(l_Parent_0.Utils.getLocalUserId);
local v5 = require(l_Parent_0.Utils.getUserIdsFromString);
return function()
    local l_status_0, l_result_0 = pcall(function()
        return l_AppStorageService_0:GetItem(v3.DeleteWarningModalOptOutStorageKey);
    end);
    if not (l_status_0 and l_result_0 ~= "") or not v5(l_result_0)[v4(l_Players_0) or ""] then
        return false;
    else
        return true;
    end;
end;


local l_Players_0 = game:GetService("Players");
return function(v1)
    local l_LocalPlayer_0 = (v1 or l_Players_0).LocalPlayer;
    if not l_LocalPlayer_0 then
        return nil;
    else
        return (tostring(l_LocalPlayer_0.UserId));
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Utils.getCaptureMetadata);
local _ = require(l_Parent_0.Types);
return function(v3)
    local v4 = v1(v3);
    if not v4 then
        return nil;
    else
        return v4.placeId;
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_UserInputService_0 = game:GetService("UserInputService");
local l_default_0 = require(l_Parent_1.PermissionsProtocol).PermissionsProtocol.default;
local v4 = require(l_Parent_0.Thunks.SaveCaptureToExternalStorage);
local v5 = require(l_Parent_0.Thunks.SaveCapturesToExternalStorage);
local _ = require(l_Parent_0.Types);
local v7 = require(l_Parent_0.Flags.FFlagCaptureStorageBulkManagementM2Enabled);
local v8 = require(l_Parent_0.Flags.FFlagScreenshotsSaveToDeviceToast);
return function(v9, v10, v11)
    l_default_0:hasPermissions({
        l_default_0.Permissions.WRITE_MEDIA_STORAGE
    }):andThen(function(v12)
        local v13 = v12.status == l_default_0.Status.AUTHORIZED;
        if not (l_UserInputService_0:GetPlatform() == Enum.Platform.Android) or v13 then
            if not v8 or v13 then
                if v7 and #v9 > 0 then
                    v11(v5(v9));
                    return ;
                else
                    v11(v4(v9));
                    return ;
                end;
            else
                l_default_0:requestPermissions({
                    l_default_0.Permissions.WRITE_MEDIA_STORAGE
                }):andThen(function(v14)
                    if v14.status == l_default_0.Status.AUTHORIZED then
                        if v7 and #v9 > 0 then
                            v11(v5(v9));
                            return ;
                        else
                            v11(v4(v9));
                        end;
                    end;
                end):catch(function()
                end);
                return ;
            end;
        elseif v10 then
            assert(v10 ~= nil, "openPermissionModal is not nil");
            v10();
            return ;
        else
            return ;
        end;
    end):catch(function()
        if l_UserInputService_0:GetPlatform() ~= Enum.Platform.Android then
            return ;
        elseif v10 then
            assert(v10 ~= nil, "openPermissionModal is not nil");
            v10();
            return ;
        else
            return ;
        end;
    end);
    return nil;
end;


local l_GuiService_0 = game:GetService("GuiService");
return function()
    return l_GuiService_0:FindFirstChildWhichIsA("ScreenshotHud");
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Utils.getCaptureMetadata);
local _ = require(l_Parent_0.Types);
return function(v3)
    local v4 = v1(v3);
    if not v4 then
        return nil;
    else
        return v4.unixTimestamp;
    end;
end;


getUpdatedSelectedCapturesArray = function(v0, v1)
    local v2 = {};
    local v3 = false;
    for _, v5 in ipairs(v0) do
        if v5 == v1 then
            v3 = true;
        else
            table.insert(v2, v5);
        end;
    end;
    if not v3 then
        table.insert(v2, v1);
    end;
    return v2;
end;
return getUpdatedSelectedCapturesArray;


return function(v0)
    local v1 = string.split(v0, ",");
    local v2 = {};
    for _, v4 in v1, nil, nil do
        if tonumber(v4) then
            v2[v4] = true;
        end;
    end;
    return v2;
end;


return function(v0)
    local v1 = nil;
    local v2 = nil;
    local v3 = nil;
    local function _(v4)
        if v4 ~= v1 then
            v1 = v4;
            v0(v4);
        end;
    end;
    local function v8()
        local l_CurrentCamera_0 = workspace.CurrentCamera;
        if l_CurrentCamera_0 then
            local l_ViewportSize_0 = l_CurrentCamera_0.ViewportSize;
            if l_ViewportSize_0 ~= v1 then
                v1 = l_ViewportSize_0;
                v0(l_ViewportSize_0);
            end;
        end;
    end;
    v2 = workspace:GetPropertyChangedSignal("CurrentCamera"):Connect(function()
        if v3 then
            v3:Disconnect();
            v3 = nil;
        end;
        local l_CurrentCamera_1 = workspace.CurrentCamera;
        if l_CurrentCamera_1 then
            v3 = l_CurrentCamera_1:GetPropertyChangedSignal("ViewportSize"):Connect(v8);
            local l_CurrentCamera_2 = workspace.CurrentCamera;
            if l_CurrentCamera_2 then
                local l_ViewportSize_1 = l_CurrentCamera_2.ViewportSize;
                if l_ViewportSize_1 ~= v1 then
                    v1 = l_ViewportSize_1;
                    v0(l_ViewportSize_1);
                end;
            end;
        end;
    end);
    if v3 then
        v3:Disconnect();
        v3 = nil;
    end;
    local l_CurrentCamera_3 = workspace.CurrentCamera;
    if l_CurrentCamera_3 then
        v3 = l_CurrentCamera_3:GetPropertyChangedSignal("ViewportSize"):Connect(v8);
        local l_CurrentCamera_4 = workspace.CurrentCamera;
        if l_CurrentCamera_4 then
            local l_ViewportSize_2 = l_CurrentCamera_4.ViewportSize;
            if l_ViewportSize_2 ~= v1 then
                v1 = l_ViewportSize_2;
                v0(l_ViewportSize_2);
            end;
        end;
    end;
    return function()
        if v2 then
            v2:Disconnect();
            v2 = nil;
        end;
        if v3 then
            v3:Disconnect();
            v3 = nil;
        end;
    end;
end;


local l_AppStorageService_0 = game:GetService("AppStorageService");
local l_Players_0 = game:GetService("Players");
local l_Parent_0 = script.Parent.Parent;
local v3 = require(l_Parent_0.Parent.Dash);
local v4 = require(l_Parent_0.Constants);
local v5 = require(l_Parent_0.Analytics.EventNames);
local v6 = require(l_Parent_0.Utils.getLocalUserId);
local v7 = require(l_Parent_0.Utils.getUserIdsFromString);
return function(v8)
    local l_status_0, l_result_0 = pcall(function()
        return l_AppStorageService_0:GetItem(v4.DeleteWarningModalOptOutStorageKey);
    end);
    if l_status_0 then
        local v11 = v7(l_result_0);
        v11[v6(l_Players_0) or ""] = true;
        local v12 = table.concat(v3.keys(v11), ",");
        local l_status_1, _ = pcall(function()
            l_AppStorageService_0:SetItem(v4.DeleteWarningModalOptOutStorageKey, v12);
            l_AppStorageService_0:Flush();
        end);
        if l_status_1 then
            v8.fireEvent(v5.CapturesDeleteWarningModalOptedOut);
            return ;
        else
            return ;
        end;
    else
        return ;
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local l_CoreGui_0 = game:GetService("CoreGui");
local v2 = require(l_Parent_0.Constants);
return function()
    local v3 = {};
    for _, v5 in l_CoreGui_0:GetChildren() do
        if not (not v5:IsA("LayerCollector") or not v5.Enabled) and v5.Name ~= v2.OverlayName then
            v5.Enabled = false;
            table.insert(v3, v5);
        end;
    end;
    return function()
        for _, v7 in v3, nil, nil do
            v7.Enabled = true;
        end;
    end;
end;


local _ = require(script.App.App);
local v1 = require(script.Constants);
local _ = require(script.Types);
return {
    ["jest.config"] = script["jest.config"],
    Actions = require(script.Actions),
    Analytics = require(script.Analytics),
    App = require(script.App),
    Constants = v1,
    Context = require(script.Context),
    Flags = require(script.Flags),
    installReducer = require(script.installReducer),
    RoduxKey = v1.RoduxKey,
    ScreenshotsPolicy = require(script.App.ScreenshotsPolicy)
};


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.Rodux);
local v3 = require(l_Parent_1.Cryo);
local _ = require(l_Parent_0.Types);
return v2.createReducer({
    IsOpen = false,
    SelectedCaptures = {}
}, {
    [require(l_Parent_0.Actions.CaptureManagerClosed).name] = function(v5, _)
        return v3.Dictionary.join(v5, {
            IsOpen = false,
            SelectedCaptures = {}
        });
    end,
    [require(l_Parent_0.Actions.CaptureManagerOpened).name] = function(v7, _)
        return v3.Dictionary.join(v7, {
            IsOpen = true
        });
    end,
    [require(l_Parent_0.Actions.CapturesRetrieved).name] = function(v9, v10)
        return v3.Dictionary.join(v9, {
            IsOpen = v9.IsOpen and #v10.captures > 0,
            SelectedCaptures = {}
        });
    end,
    [require(l_Parent_0.Actions.UpdateSelectedCaptures).name] = function(v11, v12)
        return v3.Dictionary.join(v11, {
            SelectedCaptures = v12.selectedCaptures
        });
    end
});


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Parent.Rodux);
local v2 = require(l_Parent_0.Actions.CapturesRetrieved);
local _ = require(l_Parent_0.Types);
return v1.createReducer({}, {
    [v2.name] = function(_, v5)
        return v5.captures;
    end
});


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.Cryo);
local v3 = require(l_Parent_1.Rodux);
local v4 = require(l_Parent_0.Actions.CapturesRetrieved);
local v5 = require(l_Parent_0.Actions.CarouselClosed);
local v6 = require(l_Parent_0.Actions.CarouselIndexSelected);
local v7 = require(l_Parent_0.Actions.CarouselOpened);
local v8 = require(l_Parent_0.Actions.DeleteWarningModalClosed);
local v9 = require(l_Parent_0.Actions.DeleteWarningModalOpened);
local _ = require(l_Parent_0.Types);
local v11 = {
    IsOpen = false,
    IsDeleteWarningModalOpen = false,
    SelectedCaptureIndex = 0
};
local function _(v12, v13, v14)
    if v12[v13] ~= nil and v12[v13].filePath == v14.filePath then
        return v13;
    else
        return v2.List.findWhere(v12, function(v15)
            return v15.filePath == v14.filePath;
        end);
    end;
end;
return v3.createReducer(v11, {
    [v4.name] = function(v17, v18)
        if v17.IsOpen == false then
            return v17;
        elseif #v18.captures == 0 then
            return v2.Dictionary.join(v17, {
                IsOpen = false,
                SelectedCaptureIndex = 0
            });
        elseif v18.selectedCapture == nil then
            return v2.Dictionary.join(v17, {
                SelectedCaptureIndex = math.min(v17.SelectedCaptureIndex, #v18.captures)
            });
        else
            assert(v18.selectedCapture ~= nil, "CapturesRetrieved selectedCapture should not be nil");
            local l_selectedCapture_0 = v18.selectedCapture;
            local l_captures_0 = v18.captures;
            local l_SelectedCaptureIndex_0 = v17.SelectedCaptureIndex;
            local v23 = if l_captures_0[l_SelectedCaptureIndex_0] ~= nil and l_captures_0[l_SelectedCaptureIndex_0].filePath == l_selectedCapture_0.filePath then l_SelectedCaptureIndex_0 else v2.List.findWhere(l_captures_0, function(v22)
                return v22.filePath == l_selectedCapture_0.filePath;
            end);
            if v23 == v17.SelectedCaptureIndex then
                return v17;
            elseif v23 ~= nil then
                return v2.Dictionary.join(v17, {
                    SelectedCaptureIndex = v23
                });
            else
                return v2.Dictionary.join(v17, {
                    SelectedCaptureIndex = math.clamp(v17.SelectedCaptureIndex - 1, 1, #v18.captures)
                });
            end;
        end;
    end,
    [v5.name] = function(v24, _)
        return v2.Dictionary.join(v24, {
            IsOpen = false,
            SelectedCaptureIndex = 0
        });
    end,
    [v6.name] = function(v26, v27)
        return v2.Dictionary.join(v26, {
            SelectedCaptureIndex = v27.index
        });
    end,
    [v7.name] = function(v28, v29)
        return v2.Dictionary.join(v28, {
            IsOpen = true,
            SelectedCaptureIndex = v29.index
        });
    end,
    [v8.name] = function(v30, _)
        return v2.Dictionary.join(v30, {
            IsDeleteWarningModalOpen = false
        });
    end,
    [v9.name] = function(v32, _)
        return v2.Dictionary.join(v32, {
            IsDeleteWarningModalOpen = true
        });
    end
});


local l_Parent_0 = script.Parent.Parent;
return require(l_Parent_0.Parent.Rodux).createReducer(false, {
    [require(l_Parent_0.Actions.ShotsActivated).name] = function(_, _)
        return true;
    end,
    [require(l_Parent_0.Actions.ShotsDeactivated).name] = function(_, _)
        return false;
    end
});


local l_Parent_0 = script.Parent.Parent;
return require(l_Parent_0.Parent.Rodux).createReducer(true, {
    [require(l_Parent_0.Actions.CapturesCoreGuiDisabled).name] = function(_, _)
        return false;
    end,
    [require(l_Parent_0.Actions.CapturesCoreGuiEnabled).name] = function(_, _)
        return true;
    end
});


local l_Parent_0 = script.Parent.Parent;
return require(l_Parent_0.Parent.Rodux).createReducer(false, {
    [require(l_Parent_0.Actions.MenuClosed).name] = function(_, _)
        return false;
    end,
    [require(l_Parent_0.Actions.MenuOpened).name] = function(_, _)
        return true;
    end
});


local l_Parent_0 = script.Parent.Parent;
return require(l_Parent_0.Parent.Rodux).createReducer(false, {
    [require(l_Parent_0.Actions.OverlayActivated).name] = function(_, _)
        return true;
    end,
    [require(l_Parent_0.Actions.OverlayDeactivated).name] = function(_, _)
        return false;
    end
});


local l_Parent_0 = script.Parent.Parent;
return require(l_Parent_0.Parent.Rodux).createReducer(false, {
    [require(l_Parent_0.Actions.OverlayFlashActivated).name] = function(_, _)
        return true;
    end,
    [require(l_Parent_0.Actions.OverlayFlashDeactivated).name] = function(_, _)
        return false;
    end
});


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.Cryo);
local v3 = require(l_Parent_1.Rodux);
local v4 = require(l_Parent_0.Actions.PromptDismissed);
local v5 = require(l_Parent_0.Actions.PromptTriggered);
local _ = require(l_Parent_0.Types);
return v3.createReducer({}, {
    [v4.name] = function(v7, v8)
        return v2.List.filter(v7, function(v9)
            return v9.PromptId ~= v8.promptId;
        end);
    end,
    [v5.name] = function(v10, v11)
        return v2.List.join(v10, {
            {
                PromptData = v11.promptData,
                PromptType = v11.promptType,
                PromptId = v11.promptId
            }
        });
    end
});


local l_Parent_0 = script.Parent.Parent;
return require(l_Parent_0.Parent.Rodux).createReducer(Vector2.new(0, 0), {
    [require(l_Parent_0.Actions.ScreenSizeChanged).name] = function(_, v2)
        return v2.screenSize;
    end
});


local l_Parent_0 = script.Parent.Parent;
return require(l_Parent_0.Parent.Rodux).createReducer(require(l_Parent_0.Enums.ServerType).StandardServer, {
    [require(l_Parent_0.Actions.ServerTypeDetected).name] = function(_, v2)
        return v2.serverType;
    end
});


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.Dash);
local v3 = require(l_Parent_1.Rodux);
local v4 = require(l_Parent_0.Enums.ShotsToastType);
local v5 = require(l_Parent_0.Actions.ToastDismissed);
local v6 = require(l_Parent_0.Actions.ToastTriggered);
local v7 = require(l_Parent_0.Actions.ToastVanished);
local _ = require(l_Parent_0.Types);
return v3.createReducer({
    IsDismissed = false,
    ToastType = v4.None,
    ToastConfig = nil
}, {
    [v7.name] = function(v9, _)
        if v9.ToastType == v4.None then
            return v9;
        else
            return {
                IsDismissed = false,
                ToastType = v4.None
            };
        end;
    end,
    [v5.name] = function(v11, _)
        if not v11.IsDismissed then
            if v11.ToastType == v4.None then
                return v11;
            else
                return v2.join(v11, {
                    IsDismissed = true
                });
            end;
        else
            return v11;
        end;
    end,
    [v6.name] = function(v13, v14)
        local v15 = v2.shallowEqual(v13.ToastConfig, v14.toastConfig);
        if (not (v13.ToastType == v14.toastType) or v13.IsDismissed) or not v15 then
            return {
                IsDismissed = false,
                ToastType = v14.toastType,
                ToastConfig = v14.toastConfig
            };
        else
            return v13;
        end;
    end
});


local v0 = require(script.Parent.Parent.Parent.Rodux);
local v1 = require(script.Parent.CaptureManager);
local v2 = require(script.Parent.Captures);
local v3 = require(script.Parent.Carousel);
local v4 = require(script.Parent.IsActive);
local v5 = require(script.Parent.IsCapturesCoreGuiEnabled);
local v6 = require(script.Parent.IsMenuOpen);
local v7 = require(script.Parent.IsOverlayActive);
local v8 = require(script.Parent.IsOverlayFlashActive);
local v9 = require(script.Parent.Prompts);
local v10 = require(script.Parent.Toast);
return function()
    return v0.combineReducers({
        CaptureManager = v1,
        Captures = v2,
        Carousel = v3,
        IsActive = v4,
        IsCapturesCoreGuiEnabled = v5,
        IsMenuOpen = v6,
        IsOverlayActive = v7,
        IsOverlayFlashActive = v8,
        Prompts = v9,
        Toast = v10
    });
end;


local v0 = require(script.Parent.Parent.Dev.JestConfigs);
return {
    displayName = "Screenshots",
    setupFilesAfterEnv = {
        v0.setupFiles.LogHandler,
        v0.setupFiles.UIBloxInitializer,
        v0.setupFiles.createPromiseRejectionHandler()
    }
};


local l_Parent_0 = script:FindFirstAncestor("ServerUI").Parent;
local v1 = require(l_Parent_0.HttpRequest);
local v2 = require(l_Parent_0.Lumberyak).Logger.new(nil, "UIConfiguration");
local v3 = require(l_Parent_0.RoduxNetworking);
local l_Url_0 = require(l_Parent_0.Http).Url;
local v5 = {};
v5.__index = v5;
v5.new = function(v6)
    local v7 = if not not v6 and v6.enableLogging then v2:new("UIConfiguration Networking") else nil;
    local v13 = {
        networking = v3.config({
            keyPath = not not v6 and v6.roduxKeyPath or "UIConfiguration.NetworkStatus",
            networkImpl = v1.config({
                requestFunction = function(v8, v9, v10)
                    if v7 then
                        v7:info("Fetching: {}", string.format("[ requestMethod = %q, url = %q ]", v9, v8));
                    end;
                    return v1.requestFunctions.HttpRbxApi(v8, v9, v10);
                end,
                postRequestFunction = function(v11, v12)
                    if v7 then
                        v7:debug("Returned: {}", string.format("[ requestMethod = %q, url = %q, statusCode = %s, body = %s ]", v12.requestMethod, v12.url, v11.StatusCode, v11.Body));
                    end;
                end,
                maxRetryCount = not not v6 and v6.maxRetryCount or 0
            })
        })
    };
    setmetatable(v13, v5);
    return v13;
end;
v5.fetch = function(v14, v15, v16)
    return v14.networking.GET(script, function(v17)
        return v17(l_Url_0.APIS_URL):path(v15):queryArgs(v16);
    end).API();
end;
return v5;


return {
    DEFAULT_TEMPLATE_NAME = "default",
    CONFIGURATION_VIEW_ERROR = {
        NETWORK_FETCH_ERROR = "NETWORK_FETCH_ERROR",
        RENDER_TRANSFORM_ERROR = "RENDER_TRANSFORM_ERROR"
    }
};


local l_script_FirstAncestor_0 = script:FindFirstAncestor("ServerUI");
local l_Parent_0 = l_script_FirstAncestor_0.Parent;
local v2 = require(l_Parent_0.React);
local v3 = require(l_Parent_0.Cryo);
local v4 = require(l_script_FirstAncestor_0.Navigation.NavigationContext);
return function(v5)
    local v6, v7 = v2.useState({});
    local v8 = v2.useMemo(function()
        return not not v6 and v6[#v6] or nil;
    end);
    return v2.createElement(v4.Provider, {
        value = {
            stack = v6,
            setStack = v7,
            currentRoute = v8,
            reset = function(v9, v10, v11)
                v7({
                    {
                        componentRefs = v9,
                        params = v10,
                        templateName = v11
                    }
                });
            end,
            push = function(v12, v13, v14)
                if not (not v14 and (not v8 or not v8.templateName)) then
                    v7(v3.List.join(v6, {
                        {
                            componentRefs = v12,
                            params = v13,
                            templateName = v14 or v8.templateName
                        }
                    }));
                end;
            end,
            pushParams = function(v15)
                if v8 then
                    v7(v3.List.join(v6, {
                        {
                            componentRefs = v8.componentRefs,
                            params = v15,
                            templateName = v8.templateName
                        }
                    }));
                end;
            end
        }
    }, v5.children);
end;


local l_script_FirstAncestor_0 = script:FindFirstAncestor("ServerUI");
local v1 = require(l_script_FirstAncestor_0.Parent.React);
local v2 = require(l_script_FirstAncestor_0.Navigation.NavigationContext);
return function()
    return v1.useContext(v2);
end;


return (require(script:FindFirstAncestor("ServerUI").Parent.React).createContext({
    stack = {}
}));


local _ = require(script:FindFirstAncestor("ServerUI").Parent.React);
return {};


local _ = require(script.Types);
return {
    Constants = require(script.Constants),
    UIConfiguration = require(script.Components.UIConfiguration),
    ReactServerUIView = require(script.Views.ReactServerUIView),
    Navigation = require(script.Navigation.Components.Navigation),
    Hooks = {
        useNavigator = require(script.Navigation.Hooks.useNavigator)
    }
};


local v0 = require(script.Parent.Enums.EventNames);
return {
    [v0.CustomizeNameModalOpened] = {
        name = game:DefineFastString("CustomizeNameModalOpened", "CustomizeNameModalOpened")
    },
    [v0.CustomizeNameClearedInput] = {
        name = game:DefineFastString("CustomizeNameClearedInput", "CustomizeNameClearedInput")
    },
    [v0.CustomizeNameMaximumCharLimitTyped] = {
        name = game:DefineFastString("CustomizeNameMaximumCharLimitTyped", "CustomizeNameMaximumCharLimitTyped")
    },
    [v0.CustomizeNameModalClosed] = {
        name = game:DefineFastString("CustomizeNameModalClosed", "CustomizeNameModalClosed")
    },
    [v0.CustomizeNameSaved] = {
        name = game:DefineFastString("CustomizeNameSaved", "CustomizeNameSaved")
    },
    [v0.CustomizeNameSaveAttemptInvalidInput] = {
        name = game:DefineFastString("CustomizeNameSaveAttemptInvalidInput", "CustomizeNameSaveAttemptInvalidInput")
    }
};


return {
    CloseCustomizeName = "closeCustomizeName",
    SaveAlias = "saveAlias"
};


return {
    ProfileCardName = "profileCardName",
    ContextualMenu = "contextualMenu"
};


return {
    CustomizeNameModalOpened = "CustomizeNameModalOpened",
    CustomizeNameClearedInput = "CustomizeNameClearedInput",
    CustomizeNameMaximumCharLimitTyped = "CustomizeNameMaximumCharLimitTyped",
    CustomizeNameModalClosed = "CustomizeNameModalClosed",
    CustomizeNameSaved = "CustomizeNameSaved",
    CustomizeNameSaveAttemptInvalidInput = "CustomizeNameSaveAttemptInvalidInput"
};


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_Dash_0 = require(l_Parent_0.dependencies).Dash;
local l_Enums_0 = require(l_Parent_1.SocialLuaAnalytics).Analytics.Enums;
local l_Contexts_0 = l_Enums_0.Contexts;
local l_EventTypes_0 = l_Enums_0.EventTypes;
local v6 = require(script.Parent.Enums.EventNames);
local v7 = require(script.Parent.Enums.BtnValues);
return {
    [v6.CustomizeNameModalOpened] = {
        context = l_Contexts_0.CustomizeName,
        eventType = l_EventTypes_0.PageLoad,
        formatRulesForAdditionalInfo = {
            origin = l_Dash_0.identity
        }
    },
    [v6.CustomizeNameClearedInput] = {
        context = l_Contexts_0.CustomizeName,
        eventType = l_EventTypes_0.CustomizeNameClearedInput,
        formatRulesForAdditionalInfo = {
            origin = l_Dash_0.identity
        }
    },
    [v6.CustomizeNameMaximumCharLimitTyped] = {
        context = l_Contexts_0.CustomizeName,
        eventType = l_EventTypes_0.CustomizeNameMaximumCharLimitTyped,
        formatRulesForAdditionalInfo = {
            alias = l_Dash_0.identity,
            origin = l_Dash_0.identity
        }
    },
    [v6.CustomizeNameModalClosed] = {
        context = l_Contexts_0.CustomizeName,
        eventType = l_EventTypes_0.ButtonClick,
        additionalInfo = {
            btn = v7.CloseCustomizeName
        },
        formatRulesForAdditionalInfo = {
            origin = l_Dash_0.identity
        }
    },
    [v6.CustomizeNameSaved] = {
        context = l_Contexts_0.CustomizeName,
        eventType = l_EventTypes_0.ButtonClick,
        additionalInfo = {
            btn = v7.SaveAlias
        },
        formatRulesForAdditionalInfo = {
            alias = l_Dash_0.identity,
            origin = l_Dash_0.identity
        }
    },
    [v6.CustomizeNameSaveAttemptInvalidInput] = {
        context = l_Contexts_0.CustomizeName,
        eventType = l_EventTypes_0.CustomizeNameSaveAttemptInvalidInput,
        formatRulesForAdditionalInfo = {
            alias = l_Dash_0.identity,
            origin = l_Dash_0.identity
        }
    }
};


local v0 = require(script.Parent.Parent.dependencies);
return v0.React.createContext({
    fireAnalyticsEvent = v0.Dash.noop
});


local l_Parent_0 = script.Parent;
local v1 = require(script.SetAliasAnalyticsContext);
return {
    AnalyticsService = require(script.AnalyticsService),
    Context = v1,
    connect = require(l_Parent_0.dependencies).SocialLibraries.Context.getConnect(v1),
    EventNames = require(script.Enums.EventNames),
    EntryPoints = require(script.Enums.EntryPoints),
    setupFireAnalyticsEvents = require(script.setupFireAnalyticsEvents),
    useAnalytics = require(script.useAnalytics)
};


local l_SocialLuaAnalytics_0 = require(script.Parent.Parent.dependencies).SocialLuaAnalytics;
local l_fireDiagCounter_0 = l_SocialLuaAnalytics_0.Analytics.FireEvent.fireDiagCounter;
local l_fireEventStream_0 = l_SocialLuaAnalytics_0.Analytics.FireEvent.fireEventStream;
local v3 = require(script.Parent.DiagActionList);
local v4 = require(script.Parent.EventStreamActionList);
local _ = require(script.Parent.Enums.EventNames);
return function(v6)
    local v7 = l_fireEventStream_0({
        eventStreamImpl = v6.analytics.EventStream,
        eventList = v4,
        infoForAllEvents = v6.infoForAllEvents
    });
    local v8 = l_fireDiagCounter_0({
        diagImpl = v6.analytics.Diag,
        eventList = v3
    });
    return function(v9, v10)
        if v3[v9] then
            v8(v9);
        end;
        return v7(v9, v10);
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(script.Parent.SetAliasAnalyticsContext);
local l_React_0 = require(l_Parent_0.dependencies).React;
return function()
    return l_React_0.useContext(v1);
end;


return {
    RODUX_KEY = "SetAlias",
    PROFILE_USER_ID = "profileUserId",
    ORIGIN = "origin"
};


return {
    MODAL_TITLE = "Feature.Profile.Label.ChangeAlias",
    CANCEL_BUTTON = "Feature.Profile.Label.Cancel",
    SAVE_BUTTON = "Feature.Profile.Action.Save",
    MODAL_DESCRIPTION = "Feature.Profile.Description.SetAlias",
    CUSTOMIZE_NAME_MODAL_TITLE = "Feature.Profile.Label.CustomizeName",
    SET_CUSTOM_NAME_DESCRIPTION = "Feature.Profile.Description.SetCustomName",
    SET_CUSTOM_NAME_NO_DISPLAY_NAME_DESCRIPTION = "Feature.Profile.Description.SetCustomNameNoDisplayName",
    RECOGNIZE_FRIENDS_BY_CUSTOM_NAME_DESCRIPTION = "Feature.Profile.Description.RecognizeFriendsByCustomName",
    CUSTOM_NAME_PLACEHOLDER = "Feature.Profile.Label.CustomizeNamePlaceholder",
    INVALID_ALIAS_ERROR = "Feature.Profile.Message.InvalidAliasError"
};


local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_0.dependencies);
local v3 = require(l_Parent_0.Common.TextKeys);
local v4 = require(l_Parent_0.Analytics);
local l_EventNames_0 = v4.EventNames;
local l_useAnalytics_0 = v4.useAnalytics;
local l_React_0 = v2.React;
local l_Dash_0 = v2.Dash;
local l_UIBlox_0 = v2.UIBlox;
local l_RoactFitComponents_0 = v2.RoactFitComponents;
local l_useLocalization_0 = v2.Hooks.useLocalization;
local l_SocialLibraries_0 = v2.SocialLibraries;
local l_FitFrameVertical_0 = l_RoactFitComponents_0.FitFrameVertical;
local l_FitTextLabel_0 = l_RoactFitComponents_0.FitTextLabel;
local l_InteractiveAlert_0 = l_UIBlox_0.App.Dialog.Alert.InteractiveAlert;
local l_ButtonType_0 = l_UIBlox_0.App.Button.Enum.ButtonType;
local l_useStyle_0 = l_UIBlox_0.Core.Style.useStyle;
local l_ImageSetLabel_0 = l_UIBlox_0.Core.ImageSet.ImageSetLabel;
local l_Images_0 = l_UIBlox_0.App.ImageSet.Images;
local l_IconSize_0 = l_UIBlox_0.App.Constant.IconSize;
local l_CallbackInputBox_0 = l_SocialLibraries_0.Components.CallbackInputBox;
local l_UplevelAliasIXP_0 = v2.UserProfiles.Flags.UplevelAliasIXP;
local v23 = game:DefineFastFlag("LuaAppAllowClearAlias", false);
local l_FFlagCountUTF8CharactersInAliasAndDisplayName_0 = require(l_Parent_1.SharedFlags).FFlagCountUTF8CharactersInAliasAndDisplayName;
return function(v25)
    local v26 = l_React_0.useRef(nil);
    local v27, v28 = l_React_0.useState(Vector2.new(0, 0));
    local v29, v30 = l_React_0.useState(v25.alias);
    local v31, v32 = l_React_0.useState(not v25.alias and 0 or if l_FFlagCountUTF8CharactersInAliasAndDisplayName_0 then utf8.len(v25.alias) or 0 else string.len(v25.alias));
    local v33 = l_useStyle_0();
    local l_Font_0 = v33.Font;
    local l_Theme_0 = v33.Theme;
    local v36 = l_Font_0.BaseSize * l_Font_0.Body.RelativeSize;
    local v37 = not not l_UplevelAliasIXP_0.isSetupEnabled() and v25.uplevelAliasEnabled;
    local v38 = l_useLocalization_0({
        titleText = if not v37 then v3.MODAL_TITLE else v3.CUSTOMIZE_NAME_MODAL_TITLE,
        cancelButtonText = v3.CANCEL_BUTTON,
        saveButtonText = v3.SAVE_BUTTON,
        descriptionText = if not not v37 and v25.displayName then {
            v3.SET_CUSTOM_NAME_DESCRIPTION;
            displayName = v25.displayName
        } else if v37 then v3.SET_CUSTOM_NAME_NO_DISPLAY_NAME_DESCRIPTION else v3.MODAL_DESCRIPTION,
        recognizeFriendsByCustomNameText = if not v37 then nil else v3.RECOGNIZE_FRIENDS_BY_CUSTOM_NAME_DESCRIPTION,
        customNamePlaceholderText = if not v37 then nil else v3.CUSTOM_NAME_PLACEHOLDER,
        invalidAliasErrorText = if not v37 then nil else v3.INVALID_ALIAS_ERROR
    });
    local v39 = if not v37 then nil else l_useAnalytics_0();
    local v40 = l_React_0.useRef(false);
    local v41 = nil;
    if not v23 then
        if not v37 then
            v41 = nil;
        else
            local v42 = false;
            if string.len((l_Dash_0.trim(v29 or ""))) > 0 then
                v42 = not v25.hasSaveAliasError;
            end;
            v41 = v42;
        end;
    else
        v41 = if not v37 then nil else not v25.hasSaveAliasError;
    end;
    local v44 = l_React_0.useCallback(function(v43)
        if v27.X ~= v43.AbsoluteSize.X then
            v28(v43.AbsoluteSize);
        end;
    end, {
        v27
    });
    local function v45()
        v25.saveOnActivated(v29);
    end;
    local function v46()
        if not (not v37 or not v39) then
            v39.fireAnalyticsEvent(l_EventNames_0.CustomizeNameModalClosed);
        end;
        v25.cancelOnActivated();
    end;
    local function v50(v47)
        local v48 = if not l_FFlagCountUTF8CharactersInAliasAndDisplayName_0 then string.len(v47) else utf8.len(v47);
        if l_FFlagCountUTF8CharactersInAliasAndDisplayName_0 and v48 == nil then
            return ;
        else
            local l_v48_0 = v48;
            if l_v48_0 > 20 then
                v47 = if not l_FFlagCountUTF8CharactersInAliasAndDisplayName_0 then string.sub(v47, 1, 20) else if v31 == 20 then v29 else string.sub(v47, 1, utf8.offset(v47, 21) - 1);
                l_v48_0 = 20;
                if not (not v26 or not v26.current) then
                    v26.current.Text = v47;
                end;
            end;
            v32(l_v48_0);
            v30(v47);
            if v37 then
                if v25.onTextChanged then
                    v25.onTextChanged();
                end;
                if not (not (if not l_FFlagCountUTF8CharactersInAliasAndDisplayName_0 then string.len(v47) else l_v48_0 == 0) or not v39) then
                    v39.fireAnalyticsEvent(l_EventNames_0.CustomizeNameClearedInput);
                end;
                if not ((not (if not l_FFlagCountUTF8CharactersInAliasAndDisplayName_0 then string.len(v47) else l_v48_0 == 20) or not v39) or v40.current) then
                    v40.current = true;
                    v39.fireAnalyticsEvent(l_EventNames_0.CustomizeNameMaximumCharLimitTyped, {
                        alias = v47
                    });
                end;
            end;
            return ;
        end;
    end;
    return l_React_0.createElement(l_InteractiveAlert_0, {
        title = v38.titleText,
        screenSize = v25.screenSize,
        anchorPoint = Vector2.new(0.5, 0),
        position = UDim2.new(0.5, 0, 0, v27.Y),
        middleContent = function()
            return l_React_0.createElement(l_FitFrameVertical_0, {
                BackgroundTransparency = 1,
                width = UDim.new(1, 0),
                FillDirection = Enum.FillDirection.Vertical,
                VerticalAlignment = Enum.VerticalAlignment.Center,
                contentPadding = UDim.new(0, 16),
                [l_React_0.Change.AbsoluteSize] = v44
            }, {
                InputGroup = l_React_0.createElement("Frame", {
                    BackgroundTransparency = 1,
                    Size = UDim2.fromScale(1, 0),
                    AutomaticSize = Enum.AutomaticSize.Y,
                    LayoutOrder = 1
                }, {
                    UIListLayout = l_React_0.createElement("UIListLayout", {
                        Padding = if not v37 then UDim.new(0, 24) else nil,
                        FillDirection = Enum.FillDirection.Vertical,
                        VerticalAlignment = Enum.VerticalAlignment.Center,
                        HorizontalAlignment = if not v37 then nil else Enum.HorizontalAlignment.Center,
                        SortOrder = if not v37 then nil else Enum.SortOrder.LayoutOrder
                    }),
                    Description = l_React_0.createElement(l_FitTextLabel_0, {
                        LayoutOrder = 1,
                        BackgroundTransparency = 1,
                        TextWrapped = true,
                        width = l_FitTextLabel_0.Width.FitToText,
                        maximumWidth = v27.X,
                        Font = l_Font_0.Body.Font,
                        Text = v38.descriptionText,
                        TextSize = l_Font_0.BaseSize * l_Font_0.Body.RelativeSize,
                        TextColor3 = l_Theme_0.TextDefault.Color,
                        RichText = not not v37 or nil
                    }),
                    RecognizeFriendsByCustomNameContainer = if not v37 then nil else l_React_0.createElement("Frame", {
                        BackgroundTransparency = 1,
                        Size = UDim2.fromScale(1, 0),
                        AutomaticSize = Enum.AutomaticSize.Y,
                        LayoutOrder = 2
                    }, {
                        UIPadding = l_React_0.createElement("UIPadding", {
                            PaddingTop = UDim.new(0, 2),
                            PaddingBottom = UDim.new(0, 24)
                        }),
                        RecognizeFriendsByCustomName = l_React_0.createElement(l_FitTextLabel_0, {
                            LayoutOrder = 1,
                            BackgroundTransparency = 1,
                            TextWrapped = true,
                            width = l_FitTextLabel_0.Width.FitToText,
                            maximumWidth = v27.X,
                            Font = l_Font_0.CaptionBody.Font,
                            Text = v38.recognizeFriendsByCustomNameText,
                            TextSize = l_Font_0.BaseSize * l_Font_0.CaptionBody.RelativeSize,
                            TextColor3 = l_Theme_0.TextDefault.Color
                        })
                    }),
                    InputBackground = l_React_0.createElement(l_ImageSetLabel_0, {
                        Size = UDim2.new(1, 0, 0, v36 + 20),
                        BackgroundTransparency = 1,
                        LayoutOrder = not v37 and 2 or 3,
                        Image = l_Images_0["component_assets/circle_21"],
                        ImageColor3 = l_Theme_0.UIMuted.Color,
                        ImageTransparency = l_Theme_0.UIMuted.Transparency,
                        ScaleType = Enum.ScaleType.Slice,
                        SliceCenter = Rect.new(8, 8, 9, 9)
                    }, {
                        InputBorder = l_React_0.createElement(l_ImageSetLabel_0, {
                            Size = UDim2.new(1, 0, 0, v36 + 20),
                            BackgroundTransparency = 1,
                            LayoutOrder = 1,
                            Image = l_Images_0["component_assets/circle_21_stroke_1"],
                            ImageColor3 = if not not v37 and v25.hasSaveAliasError then l_Theme_0.Alert.Color else l_Theme_0.Divider.Color,
                            ScaleType = Enum.ScaleType.Slice,
                            SliceCenter = Rect.new(8, 8, 9, 9)
                        }, {
                            Padding = l_React_0.createElement("UIPadding", {
                                PaddingLeft = UDim.new(0, 12),
                                PaddingRight = UDim.new(0, 12)
                            }),
                            Textbox = l_React_0.createElement(l_CallbackInputBox_0, {
                                inputTextXAlignment = Enum.TextXAlignment.Left,
                                inputTextColor3 = l_Theme_0.TextDefault.Color,
                                inputTextTransparency = l_Theme_0.TextDefault.Transparency,
                                inputTextSize = v36,
                                initialInputText = v29,
                                placeholderText = not v37 and "" or v38.customNamePlaceholderText,
                                placeholderTextColor3 = l_Theme_0.TextDefault.Color,
                                captureFocusOnMount = true,
                                clearIcon = if not v37 then nil else l_Images_0["icons/actions/edit/clear_small"],
                                clearIconColor3 = if not v37 then nil else l_Theme_0.IconEmphasis.Color,
                                clearIconTransparency = if not v37 then nil else l_Theme_0.IconEmphasis.Transparency,
                                clearButtonSize = if not v37 then nil else l_IconSize_0.Small,
                                clearButtonDisabled = not v37 and true or false,
                                textChangedCallback = v50,
                                inputBoxRef = v26
                            })
                        })
                    })
                }),
                Counter = l_React_0.createElement("Frame", {
                    BackgroundTransparency = 1,
                    Size = UDim2.fromScale(1, 0),
                    AutomaticSize = Enum.AutomaticSize.Y,
                    LayoutOrder = 2
                }, {
                    l_React_0.createElement(l_FitTextLabel_0, {
                        BackgroundTransparency = 1,
                        width = l_FitTextLabel_0.Width.FitToText,
                        maximumWidth = v27.X,
                        Font = l_Font_0.CaptionBody.Font,
                        Text = if not not v37 and v25.hasSaveAliasError then v38.invalidAliasErrorText else string.format("%d/%d", v31, 20),
                        TextSize = l_Font_0.BaseSize * l_Font_0.CaptionBody.RelativeSize,
                        TextColor3 = if not not v37 and (not (v31 ~= 20) or v25.hasSaveAliasError) then l_Theme_0.Alert.Color else l_Theme_0.TextMuted.Color,
                        TextTransparency = if not not v37 and (not (v31 ~= 20) or v25.hasSaveAliasError) then l_Theme_0.Alert.Transparency else l_Theme_0.TextMuted.Transparency,
                        AnchorPoint = if not not v37 and v25.hasSaveAliasError then Vector2.new(0, 0.5) else Vector2.new(1, 0.5),
                        Position = if not not v37 and v25.hasSaveAliasError then nil else UDim2.fromScale(1, 0)
                    }, {
                        UISizeConstraint = if not v37 then nil else l_React_0.createElement("UISizeConstraint", {
                            MaxSize = Vector2.new(math.huge, (l_Font_0.BaseSize * l_Font_0.CaptionBody.RelativeSize) * 2)
                        })
                    })
                })
            });
        end,
        buttonStackInfo = {
            buttons = {
                {
                    buttonType = l_ButtonType_0.Secondary,
                    props = {
                        onActivated = if not v37 then v25.cancelOnActivated else v46,
                        text = v38.cancelButtonText
                    }
                },
                {
                    buttonType = l_ButtonType_0.PrimarySystem,
                    props = {
                        onActivated = v45,
                        text = v38.saveButtonText,
                        isDisabled = if not v37 then nil else not v41
                    }
                }
            },
            buttonHeight = 48,
            marginBetween = 6,
            forcedFillDirection = Enum.FillDirection.Horizontal
        }
    });
end;


local l_Parent_0 = script.Parent.Parent.Parent;
local v1 = require(l_Parent_0.dependencies);
local l_React_0 = v1.React;
local l_useLocalUserId_0 = v1.Hooks.useLocalUserId;
local l_UplevelAliasIXP_0 = v1.UserProfiles.Flags.UplevelAliasIXP;
local v5 = require(l_Parent_0.Analytics);
local v6 = require(l_Parent_0.Common.Constants);
local v7 = require(script.Parent.SetAliasModalContainer);
return function(v8)
    local v9 = l_useLocalUserId_0();
    if not (not not l_UplevelAliasIXP_0.isSetupEnabled() and l_UplevelAliasIXP_0.useIsExperimentEnabled()) then
        return l_React_0.createElement(v7, v8);
    else
        return l_React_0.createElement(v5.Context.Provider, {
            value = {
                fireAnalyticsEvent = v5.setupFireAnalyticsEvents({
                    analytics = v5.AnalyticsService,
                    infoForAllEvents = {
                        uid = v9,
                        origin = v8.navigation.getParam(v6.ORIGIN)
                    }
                })
            }
        }, {
            l_React_0.createElement(v7, v8)
        });
    end;
end;


local l_script_FirstAncestor_0 = script:FindFirstAncestor("SetAlias");
local l_Parent_0 = l_script_FirstAncestor_0.Parent;
local v2 = require(l_script_FirstAncestor_0.dependencies);
local l_Roact_0 = v2.Roact;
local l_Dash_0 = v2.Dash;
local l_UIBlox_0 = v2.UIBlox;
local v6 = require(l_Parent_0.Dev.RobloxAppUIBloxConfig);
local l_mockLocale_0 = require(l_Parent_0.Dev.SocialTestHelpers).StoryHelpers.mockLocale;
l_UIBlox_0.init(v6);
local l_AppStyleProvider_0 = l_UIBlox_0.App.Style.AppStyleProvider;
local v9 = {
    Default = {
        themeName = "Light",
        fontName = "Gotham"
    },
    Light = {
        themeName = "Light",
        fontName = "Gotham"
    },
    Dark = {
        themeName = "Dark",
        fontName = "Gotham"
    }
};
local v10 = {
    language = "en-us"
};
return {
    name = "SetAlias",
    storyRoot = l_script_FirstAncestor_0,
    roact = l_Roact_0,
    mapDefinition = function(v11)
        return l_Dash_0.join(v11, {
            controls = l_Dash_0.join(v10, v11.controls or {})
        });
    end,
    mapStory = function(v12)
        return function(v13)
            return l_Roact_0.createElement(l_AppStyleProvider_0, {
                style = not not v13 and v9[v13.theme] or v9.Default
            }, {
                Child = l_mockLocale_0(v12, v13)
            });
        end;
    end
};


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.dependencies);
local v2 = require(l_Parent_0.devDependencies);
local v3 = require(l_Parent_0.Analytics);
local l_Roact_0 = v1.Roact;
local l_RoactRodux_0 = v1.RoactRodux;
local l_Rodux_0 = v1.Rodux;
local l_UIBlox_0 = v1.UIBlox;
local l_LocalizationProvider_0 = v1.LocalizationProvider;
local v9 = v2.Mock.MagicMock.new({
    name = "Localization"
});
v9.Format = function(_, v11, _)
    return v11;
end;
local v13 = l_Rodux_0.Store.new(function()
    return {};
end, {}, {
    l_Rodux_0.thunkMiddleware
});
return function(v14, v15)
    return (l_Roact_0.createFragment({
        storeProvider = l_Roact_0.createElement(l_RoactRodux_0.StoreProvider, {
            store = v15.store or v13
        }, {
            styleProvider = l_Roact_0.createElement(l_UIBlox_0.App.Style.AppStyleProvider, {
                style = {
                    themeName = "Dark",
                    fontName = "Gotham"
                }
            }, {
                localizationProvider = l_Roact_0.createElement(l_LocalizationProvider_0, {
                    localization = v9
                }, {
                    analyticsProvider = l_Roact_0.createElement(v3.Context.Provider, {
                        value = v15.mockAnalytics or {}
                    }, {
                        myElement = l_Roact_0.createElement(v14, v15.props)
                    })
                })
            })
        })
    }));
end;


local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.LuaSocialLibrariesDeps);
local l_RODUX_KEY_0 = require(l_Parent_0.Common.Constants).RODUX_KEY;
local l_RoduxNetworking_0 = v2.RoduxNetworking;
local v5 = require(l_Parent_1.Lumberyak);
local l_httpRequest_0 = v2.httpRequest;
local v7 = v5.Logger.new(nil, l_RODUX_KEY_0):new(l_RODUX_KEY_0 .. " Networking");
local v13 = l_RoduxNetworking_0.config({
    keyPath = l_RODUX_KEY_0 .. ".NetworkStatus",
    networkImpl = l_httpRequest_0.config({
        requestFunction = function(v8, v9, v10)
            v7:info("Fetching: {}", string.format("[ requestMethod = %q, url = %q ]", v9, v8));
            return l_httpRequest_0.requestFunctions.HttpRbxApi(v8, v9, v10);
        end,
        postRequestFunction = function(v11, v12)
            v7:debug("Returned: {}", string.format("[ requestMethod = %q, url = %q, statusCode = %s, body = %s ]", v12.requestMethod, v12.url, v11.StatusCode, v11.Body));
        end,
        maxRetryCount = game:DefineFastInt("SetAliasHttpRetryCount", 3)
    })
});
return {
    AppStorageService = game:GetService("AppStorageService"),
    Analytics = require(l_Parent_1.Analytics),
    SocialLuaAnalytics = require(l_Parent_1.SocialLuaAnalytics),
    Dash = require(l_Parent_1.Dash),
    UIBlox = require(l_Parent_1.UIBlox),
    Roact = require(l_Parent_1.Roact),
    RoactRodux = require(l_Parent_1.RoactRodux),
    RoactNavigation = require(l_Parent_1.RoactNavigation),
    Rodux = require(l_Parent_1.Rodux),
    React = require(l_Parent_1.React),
    ContactsProtocol = require(l_Parent_1.ContactsProtocol).ContactsProtocol,
    Promise = require(l_Parent_1.Promise),
    enumerate = require(l_Parent_1.enumerate),
    UserProfiles = require(l_Parent_1.UserProfiles),
    RoactFitComponents = v2.RoactFitComponents,
    RoduxNetworking = v13,
    NetworkingAliases = v2.NetworkingAliases.config({
        roduxNetworking = v13
    }),
    RoduxAliases = v2.RoduxAliases.config({
        keyPath = l_RODUX_KEY_0 .. ".Aliases"
    }),
    SocialLibraries = v2.SocialLibraries.config({}),
    LocalizationProvider = require(l_Parent_1.Localization).LocalizationProvider,
    Hooks = {
        useEffectOnMount = require(l_Parent_1.RoactUtils).Hooks.useEffectOnMount,
        useLocalization = require(l_Parent_1.Localization).Hooks.useLocalization,
        useSelector = require(l_Parent_1.RoactUtils).Hooks.RoactRodux.useSelector,
        useDispatch = require(l_Parent_1.RoactUtils).Hooks.RoactRodux.useDispatch,
        useLocalUserId = require(l_Parent_1.RobloxAppHooks).useLocalUserId
    }
};


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.LuaSocialLibrariesDeps);
local v2 = require(l_Parent_0.Dev.JestGlobals);
return {
    ReactRoblox = require(l_Parent_0.Dev.ReactRoblox),
    Rhodium = require(l_Parent_0.Dev.Rhodium),
    Mock = v1.Mock,
    UnitTestHelpers = require(l_Parent_0.Dev.SocialTestHelpers).TestHelpers,
    jestExpect = v2.expect,
    jest = v2.jest,
    describe = v2.describe,
    it = v2.it,
    beforeAll = v2.beforeAll,
    afterAll = v2.afterAll,
    expect = v2.expect,
    RhodiumHelpers = function()
        return require(l_Parent_0.Dev.RhodiumHelpers);
    end
};


return {
    SetAliasModal = require(script.Components.SetAliasModal),
    Analytics = require(script.Analytics),
    RoduxKey = require(script.Common.Constants).RODUX_KEY,
    installReducer = require(script.installReducer),
    ["jest.config"] = script["jest.config"]
};


local v0 = require(script.Parent.Parent.dependencies);
local l_Rodux_0 = v0.Rodux;
local l_RoduxNetworking_0 = v0.RoduxNetworking;
local l_RoduxAliases_0 = v0.RoduxAliases;
return function()
    return l_Rodux_0.combineReducers({
        Aliases = l_RoduxAliases_0.installReducer(),
        NetworkStatus = l_RoduxNetworking_0.installReducer()
    });
end;


local v0 = require(script.Parent.Parent.Dev.JestConfigs);
return {
    displayName = "SetAlias",
    testMatch = {
        "**/*.test"
    },
    setupFilesAfterEnv = {
        v0.setupFiles.LogHandler,
        v0.setupFiles.UIBloxInitializer,
        v0.setupFiles.createPromiseRejectionHandler()
    }
};


local v0 = require(script.Parent.dependencies);
local l_Roact_0 = v0.Roact;
local l_UIBlox_0 = v0.UIBlox;
local l_t_0 = v0.t;
local l_withLocalization_0 = v0.withLocalization;
local l_ButtonType_0 = l_UIBlox_0.App.Button.Enum.ButtonType;
local l_InteractiveAlert_0 = l_UIBlox_0.App.Dialog.Alert.InteractiveAlert;
local v7 = l_Roact_0.Component:extend("ShareLinkInvalidModal");
v7.validateProps = l_t_0.interface({
    closeModal = l_t_0.callback,
    screenSize = l_t_0.Vector2
});
v7.render = function(v8)
    local l_props_0 = v8.props;
    return l_withLocalization_0({
        titleText = "Feature.SocialShare.Label.InvalidLinkError",
        bodyText = "Feature.SocialShare.Description.InvalidLinkError",
        buttonText = "Feature.Friends.Label.Cancel"
    })(function(v10)
        return l_Roact_0.createElement(l_InteractiveAlert_0, {
            screenSize = l_props_0.screenSize,
            title = v10.titleText,
            bodyText = v10.bodyText,
            buttonStackInfo = {
                buttons = {
                    {
                        buttonType = l_ButtonType_0.PrimarySystem,
                        props = {
                            text = v10.buttonText,
                            onActivated = l_props_0.closeModal
                        }
                    }
                }
            }
        });
    end);
end;
return v7;


local l_script_FirstAncestor_0 = script:FindFirstAncestor("ShareLinkInvalidModal");
local l_Parent_0 = l_script_FirstAncestor_0.Parent;
local v2 = require(l_Parent_0.UIBlox);
v2.init(require(l_Parent_0.Dev.RobloxAppUIBloxConfig));
local l_mockLocale_0 = require(l_Parent_0.Dev.SocialTestHelpers).StoryHelpers.mockLocale;
local v4 = require(l_script_FirstAncestor_0.dependencies);
local l_Roact_0 = v4.Roact;
local l_llama_0 = v4.llama;
local l_AppStyleProvider_0 = v2.App.Style.AppStyleProvider;
l_Roact_0.setGlobalConfig({
    propValidation = true,
    elementTracing = true
});
local v8 = {
    Default = {
        themeName = "Light",
        fontName = "Gotham"
    },
    Light = {
        themeName = "Light",
        fontName = "Gotham"
    },
    Dark = {
        themeName = "Dark",
        fontName = "Gotham"
    }
};
local v9 = {
    language = "en-us"
};
return {
    name = "ShareLinkInvalidModal",
    storyRoot = script,
    roact = l_Roact_0,
    mapDefinition = function(v10)
        return l_llama_0.Dictionary.join(v10, {
            controls = l_llama_0.Dictionary.join(v9, v10.controls or {})
        });
    end,
    mapStory = function(v11)
        return function(v12)
            return l_Roact_0.createElement(l_AppStyleProvider_0, {
                style = not not v12 and v8[v12.theme] or v8.Default
            }, {
                Child = l_mockLocale_0(v11, v12)
            });
        end;
    end
};


local v0 = require(script:FindFirstAncestor("ShareLinkInvalidModal").dependencies);
local l_Roact_0 = v0.Roact;
local l_RoactNavigation_0 = v0.RoactNavigation;
local l_RoactRodux_0 = v0.RoactRodux;
local l_Dash_0 = v0.Dash;
local l_t_0 = v0.t;
local v6 = require(script.Parent.ShareLinkInvalidModal);
local v7 = l_Roact_0.Component:extend("ShareLinkInvalidModalContainer");
v7.validateProps = l_t_0.interface({
    navigation = l_t_0.table,
    closeModal = l_t_0.callback
});
v7.init = function(v8)
    v8.closeModal = function()
        local l_props_0 = v8.props;
        l_props_0.closeModal();
        l_props_0.navigation.pop();
    end;
end;
v7.render = function(v10)
    return l_Roact_0.createElement(v6, l_Dash_0.join(v10.props, {
        closeModal = v10.closeModal
    }));
end;
return l_RoactNavigation_0.withNavigation((l_RoactRodux_0.connect(function(v11)
    return {
        screenSize = v11.ScreenSize
    };
end)(v7)));


local l_Parent_0 = script.Parent.Parent;
return {
    Dash = require(l_Parent_0.Dash),
    Roact = require(l_Parent_0.Roact),
    RoactNavigation = require(l_Parent_0.RoactNavigation),
    RoactRodux = require(l_Parent_0.RoactRodux),
    Rodux = require(l_Parent_0.Rodux),
    t = require(l_Parent_0.t),
    UIBlox = require(l_Parent_0.UIBlox),
    LocalizationProvider = require(l_Parent_0.Localization).LocalizationProvider,
    withLocalization = require(l_Parent_0.Localization).withLocalization,
    llama = require(l_Parent_0.LuaSocialLibrariesDeps).llama
};


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.LuaSocialLibrariesDeps);
local v2 = require(l_Parent_0.Dev.JestGlobals);
v2.expect.extend(v1.CollisionMatchers.Jest);
return {
    JestGlobals = v2,
    ReactRoblox = require(l_Parent_0.Dev.ReactRoblox),
    Mock = v1.Mock,
    UnitTestHelpers = require(l_Parent_0.Dev.SocialTestHelpers).TestHelpers,
    Rhodium = require(l_Parent_0.Dev.Rhodium),
    RhodiumHelpers = function()
        return require(l_Parent_0.Dev.RhodiumHelpers);
    end,
    createTreeWithProviders = require(l_Parent_0.Dev.SocialTestHelpers).TestHelpers.createTreeWithProviders,
    DeferredLuaHelpers = require(l_Parent_0.Dev.TestUtils).DeferredLuaHelpers
};


return {
    ShareLinkInvalidModal = require(script.ShareLinkInvalidModalContainer),
    ["jest.config"] = script["jest.config"]
};


local v0 = require(script.Parent.Parent.Dev.JestConfigs);
return {
    displayName = "ShareLinkInvalidModal",
    testMatch = {
        "**/*.test"
    },
    setupFilesAfterEnv = {
        v0.setupFiles.LogHandler,
        v0.setupFiles.UIBloxInitializer,
        v0.setupFiles.createPromiseRejectionHandler()
    }
};


return {
    FFlagDebugUnmuteLuaErrors = require(script.FFlagDebugUnmuteLuaErrors)
};


game:DefineFastFlag("EnableOptionalPlaceIdForUserIdGameJoins", false);
game:DefineFastFlag("EnableOptionalPlaceIdForUserIdGameJoinsTesting", false);
return function()
    if not game:GetFastFlag("EnableOptionalPlaceIdForUserIdGameJoinsTesting") then
        return game:GetFastFlag("EnableOptionalPlaceIdForUserIdGameJoins") and game:GetEngineFeature("JoinByUserTakesOptionalPlaceId");
    else
        return true;
    end;
end;


return require(script.Parent.FFlagOmniSearchAutoTabIXP) and game:DefineFastFlag("AutoSearchLoadingTimeEvent", false);


return require(script.Parent.GetFFlagTenFootUiExperiencesOmniLogFix)() and game:DefineFastFlag("CleanPlayerSearchProp", false);


return game:DefineFastFlag("EnableCapturesDesktopExperiment_v10", false) and game:GetEngineFeature("FixMacSaveToExternalStorage");


game:DefineFastFlag("LuaAppEnableToastNotificationsForMobileCoreScript2", false);
return function()
    return game:GetFastFlag("LuaAppEnableToastNotificationsForMobileCoreScript2");
end;


return ((require(script.Parent.FFlagUserSearchUseNewEndpointIXP) and require(script.Parent.FFlagCleanPlayerSearchProp)) and require(script.Parent.FFlagRefactorOmniSearchFetch)) and game:DefineFastFlag("OmniSearchAutoTabIXP", false);


game:DefineFastFlag("PackagifyJoinExperience", false);
return function()
    return game:GetFastFlag("PackagifyJoinExperience");
end;


return game:DefineFastFlag("UnifyNavigationGraph5", false) and require(script.Parent.GetFFlagTenFootMoreSettingsAndAboutRefactor)();