local v0 = require(script.Parent.debugPrint);
local v1 = require(script.Parent.InputBindingKind);
local v2 = require(script.Parent.Config);
local v3 = {
    [Enum.UserInputType.Keyboard] = true,
    [Enum.UserInputType.Gamepad1] = true,
    [Enum.UserInputType.Gamepad2] = true,
    [Enum.UserInputType.Gamepad3] = true,
    [Enum.UserInputType.Gamepad4] = true,
    [Enum.UserInputType.Gamepad5] = true,
    [Enum.UserInputType.Gamepad6] = true,
    [Enum.UserInputType.Gamepad7] = true,
    [Enum.UserInputType.Gamepad8] = true
};
local v4 = {};
local function _()
    return {
        gamepadConnectedConnection = nil,
        gamepadDisconnectedConnection = nil,
        onStepConnections = 0,
        primaryGamepadState = {}
    };
end;
local function _(v6)
    if v4[v6] == nil then
        v4[v6] = {
            gamepadConnectedConnection = nil,
            gamepadDisconnectedConnection = nil,
            onStepConnections = 0,
            primaryGamepadState = {}
        };
    end;
    return v4[v6];
end;
local function v16(v8)
    if v4[v8] == nil then
        v4[v8] = {
            gamepadConnectedConnection = nil,
            gamepadDisconnectedConnection = nil,
            onStepConnections = 0,
            primaryGamepadState = {}
        };
    end;
    local v9 = v4[v8];
    local l_Gamepad1_0 = Enum.UserInputType.Gamepad1;
    for _, v12 in ipairs(v8.getNavigationGamepads()) do
        if v8.getGamepadConnected(v12) then
            l_Gamepad1_0 = v12;
            break;
        end;
    end;
    local v13 = v8.getGamepadState(l_Gamepad1_0);
    v9.primaryGamepadState = {};
    for _, v15 in ipairs(v13) do
        v9.primaryGamepadState[v15.KeyCode] = v15;
    end;
end;
local function _(v17, v18)
    return function(v19)
        if v18(v19) then
            v0("[EVENT] Process input: ", v19.KeyCode, "-", v19.UserInputState);
            v17(v19);
        end;
    end;
end;
local function v24(v21, v22)
    if v4[v21] == nil then
        v4[v21] = {
            gamepadConnectedConnection = nil,
            gamepadDisconnectedConnection = nil,
            onStepConnections = 0,
            primaryGamepadState = {}
        };
    end;
    local v23 = v4[v21];
    if v23.onStepConnections == 0 then
        v16(v21);
        v23.gamepadConnectedConnection = v21.subscribeToGamepadConnected(function()
            v16(v21);
        end);
        v23.gamepadDisconnectedConnection = v21.subscribeToGamepadDisconnected(function()
            v16(v21);
        end);
    end;
    v23.onStepConnections = v23.onStepConnections + 1;
    return function()
        v22:Disconnect();
        v23.onStepConnections = v23.onStepConnections - 1;
        if v23.onStepConnections == 0 then
            v23.gamepadConnectedConnection:Disconnect();
            v23.gamepadConnectedConnection = nil;
            v23.gamepadDisconnectedConnection:Disconnect();
            v23.gamepadDisconnectedConnection = nil;
        end;
    end;
end;
local function v45(v25, v26)
    local function _(v27)
        if not v2.DebugKeyboardBindings or not table.find(v2.DebugKeyboardBindings[v25.keyCode] or {}, v27.KeyCode) then
            return v27.KeyCode == v25.keyCode;
        else
            return true;
        end;
    end;
    if v25.kind == v1.Begin then
        local function v31(v29)
            local v30 = v3[v29.UserInputType];
            if v30 then
                v30 = false;
                if v29.UserInputState == Enum.UserInputState.Begin then
                    if not v2.DebugKeyboardBindings or not table.find(v2.DebugKeyboardBindings[v25.keyCode] or {}, v29.KeyCode) then
                        v30 = v29.KeyCode == v25.keyCode;
                    else
                        return true;
                    end;
                end;
            end;
            return v30;
        end;
        local l_subscribeToInputBegan_0 = v26.subscribeToInputBegan;
        local l_action_0 = v25.action;
        l_subscribeToInputBegan_0 = l_subscribeToInputBegan_0(function(v34)
            if v31(v34) then
                v0("[EVENT] Process input: ", v34.KeyCode, "-", v34.UserInputState);
                l_action_0(v34);
            end;
        end);
        return function()
            l_subscribeToInputBegan_0:Disconnect();
        end;
    elseif v25.kind == v1.End then
        local function v37(v35)
            local v36 = v3[v35.UserInputType];
            if v36 then
                v36 = false;
                if v35.UserInputState == Enum.UserInputState.End then
                    if not v2.DebugKeyboardBindings or not table.find(v2.DebugKeyboardBindings[v25.keyCode] or {}, v35.KeyCode) then
                        v36 = v35.KeyCode == v25.keyCode;
                    else
                        return true;
                    end;
                end;
            end;
            return v36;
        end;
        local l_subscribeToInputEnded_0 = v26.subscribeToInputEnded;
        local l_action_1 = v25.action;
        l_subscribeToInputEnded_0 = l_subscribeToInputEnded_0(function(v40)
            if v37(v40) then
                v0("[EVENT] Process input: ", v40.KeyCode, "-", v40.UserInputState);
                l_action_1(v40);
            end;
        end);
        return function()
            l_subscribeToInputEnded_0:Disconnect();
        end;
    elseif v25.kind == v1.Step then
        if v4[v26] == nil then
            v4[v26] = {
                gamepadConnectedConnection = nil,
                gamepadDisconnectedConnection = nil,
                onStepConnections = 0,
                primaryGamepadState = {}
            };
        end;
        local v41 = v4[v26];
        return (v24(v26, (v26.subscribeToRenderStepped(function(v42)
            v25.action(v41.primaryGamepadState[v25.keyCode], v42);
        end))));
    elseif v25.kind == v1.MoveStep then
        if v4[v26] == nil then
            v4[v26] = {
                gamepadConnectedConnection = nil,
                gamepadDisconnectedConnection = nil,
                onStepConnections = 0,
                primaryGamepadState = {}
            };
        end;
        local v43 = v4[v26];
        return (v24(v26, (v26.subscribeToRenderStepped(function(v44)
            v25.action({
                [Enum.KeyCode.Thumbstick1] = v43.primaryGamepadState[Enum.KeyCode.Thumbstick1],
                [Enum.KeyCode.DPadUp] = v43.primaryGamepadState[Enum.KeyCode.DPadUp],
                [Enum.KeyCode.DPadDown] = v43.primaryGamepadState[Enum.KeyCode.DPadDown],
                [Enum.KeyCode.DPadLeft] = v43.primaryGamepadState[Enum.KeyCode.DPadLeft],
                [Enum.KeyCode.DPadRight] = v43.primaryGamepadState[Enum.KeyCode.DPadRight]
            }, v44);
        end))));
    else
        return nil;
    end;
end;
local function _(v46)
    return function(v47, v48, v49)
        local v50 = false;
        if typeof(v47) == "EnumItem" then
            v50 = v47.EnumType == Enum.KeyCode;
        end;
        assert(v50, "Invalid argument #1: expected a member of Enum.KeyCode");
        assert(typeof(v48) == "function", "Invalid argument #2: expected a function");
        return {
            kind = v46,
            keyCode = v47,
            action = v48,
            meta = v49
        };
    end;
end;
local function v53(v52)
    return {
        kind = v1.MoveStep,
        action = v52
    };
end;
local v55 = {
    getUniqueKey = function(v54)
        if not v54.keyCode then
            return (tostring(v54.kind));
        else
            return tostring(v54.kind) .. "-" .. tostring(v54.keyCode);
        end;
    end,
    connectToEvent = v45
};
local v56 = {};
local l_Begin_0 = v1.Begin;
local l_l_Begin_0_0 = l_Begin_0 --[[ copy: 17 -> 18 ]];
v56.onBegin = function(v59, v60, v61)
    local v62 = false;
    if typeof(v59) == "EnumItem" then
        v62 = v59.EnumType == Enum.KeyCode;
    end;
    assert(v62, "Invalid argument #1: expected a member of Enum.KeyCode");
    assert(typeof(v60) == "function", "Invalid argument #2: expected a function");
    return {
        kind = l_l_Begin_0_0,
        keyCode = v59,
        action = v60,
        meta = v61
    };
end;
l_Begin_0 = v1.End;
local l_l_Begin_0_1 = l_Begin_0 --[[ copy: 17 -> 19 ]];
v56.onEnd = function(v64, v65, v66)
    local v67 = false;
    if typeof(v64) == "EnumItem" then
        v67 = v64.EnumType == Enum.KeyCode;
    end;
    assert(v67, "Invalid argument #1: expected a member of Enum.KeyCode");
    assert(typeof(v65) == "function", "Invalid argument #2: expected a function");
    return {
        kind = l_l_Begin_0_1,
        keyCode = v64,
        action = v65,
        meta = v66
    };
end;
l_Begin_0 = v1.Step;
v56.onStep = function(v68, v69, v70)
    local v71 = false;
    if typeof(v68) == "EnumItem" then
        v71 = v68.EnumType == Enum.KeyCode;
    end;
    assert(v71, "Invalid argument #1: expected a member of Enum.KeyCode");
    assert(typeof(v69) == "function", "Invalid argument #2: expected a function");
    return {
        kind = l_Begin_0,
        keyCode = v68,
        action = v69,
        meta = v70
    };
end;
v56.onMoveStep = v53;
v55.PublicInterface = v56;
return v55;


return require(script.Parent.Parent.enumerate)("InputBindingKind", {
    "Begin",
    "End",
    "Step",
    "MoveStep"
});


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Roact);
local v2 = require(l_Parent_0.Cryo);
local v3 = require(l_Parent_0.t);
local v4 = require(script.Parent.FocusContext);
local v5 = require(script.Parent.FocusNode);
local v6 = require(script.Parent.getEngineInterface);
local v7 = require(script.Parent.FocusControllerInternalApi);
local v8 = {
    parentFocusNode = v2.None,
    parentNeighbors = v2.None,
    focusController = v2.None,
    onFocusGained = v2.None,
    onFocusLost = v2.None,
    onFocusChanged = v2.None,
    inputBindings = v2.None,
    innerRef = v2.None,
    restorePreviousChildFocus = v2.None,
    defaultChild = v2.None
};
local v9 = {};
local v11 = v3.intersection(v3.interface({
    parentFocusNode = v3.optional(v3.table),
    focusController = v3.optional(v3.table),
    innerRef = v3.optional(v3.table),
    restorePreviousChildFocus = v3.boolean,
    inputBindings = v3.table,
    defaultChild = v3.optional(v3.table),
    onFocusGained = v3.optional(v3.callback),
    onFocusLost = v3.optional(v3.callback),
    onFocusChanged = v3.optional(v3.callback)
}), function(v10)
    if v10.focusController ~= nil and v10.parentFocusNode ~= nil then
        return false, "Cannot attach a new focusController beneath an existing one";
    else
        return true;
    end;
end);
local v12 = {
    restorePreviousChildFocus = false,
    inputBindings = {}
};
return function(v13)
    local v14 = v1.Component:extend((("Focusable(%s)"):format((tostring(v13)))));
    v14.validateProps = v11;
    v14.defaultProps = v12;
    v14.init = function(v15)
        v15.focused = false;
        v15.defaultRef = v1.createRef();
        local v16 = v15.props.parentNeighbors or v9;
        v15:setState({
            focusNode = v5.new(v15.props, v15:getRef()),
            parentNeighbors = v16,
            neighbors = {
                NextSelectionLeft = v15.props.NextSelectionLeft or v16.NextSelectionLeft,
                NextSelectionRight = v15.props.NextSelectionRight or v16.NextSelectionRight,
                NextSelectionUp = v15.props.NextSelectionUp or v16.NextSelectionUp,
                NextSelectionDown = v15.props.NextSelectionDown or v16.NextSelectionDown
            },
            needsDescendantAddedRefocusCounter = 0,
            needsDescendantRemovedRefocusCounter = 0
        });
        v15.updateFocusedState = function(v17)
            if v15.focused or not v17 then
                if not (not v15.focused or v17) then
                    v15:loseFocus();
                end;
                return ;
            else
                v15:gainFocus();
                return ;
            end;
        end;
        if v15:isRoot() then
            local v18 = false;
            do
                local l_v18_0 = v18;
                v15.ancestryChanged = function(v20)
                    if not (l_v18_0 or not v20:IsDescendantOf(game)) then
                        l_v18_0 = true;
                        v15:getFocusControllerInternal():initialize(v6(v20));
                    end;
                end;
                v15.ancestryChangedListener = function(v21)
                    v15.ancestryChanged(v21);
                    local v22 = v15.props[v1.Event.AncestryChanged];
                    if v22 ~= nil then
                        v22(v21);
                    end;
                end;
                v15.refreshFocusOnDescendantAdded = function(v23)
                    if v15:getFocusControllerInternal():needsDescendantAddedRefocus() then
                        v15:setState(function(v24)
                            return {
                                needsDescendantAddedRefocusCounter = v24.needsDescendantAddedRefocusCounter + 1
                            };
                        end);
                    end;
                    local v25 = v15.props[v1.Event.DescendantAdded];
                    if v25 ~= nil then
                        v25(v23);
                    end;
                end;
                v15.refreshFocusOnDescendantRemoved = function(v26)
                    if v15:getFocusControllerInternal():needsDescendantRemovedRefocus() then
                        v15:setState(function(v27)
                            return {
                                needsDescendantRemovedRefocusCounter = v27.needsDescendantRemovedRefocusCounter + 1
                            };
                        end);
                    end;
                    local v28 = v15.props[v1.Event.DescendantRemoving];
                    if v28 ~= nil then
                        v28(v26);
                    end;
                end;
            end;
        end;
    end;
    v14.getDerivedStateFromProps = function(v29, v30)
        local v31 = v30.neighbors or v9;
        local v32 = v29.parentNeighbors or v9;
        local v33 = v29.NextSelectionLeft or v32.NextSelectionLeft;
        local v34 = v29.NextSelectionRight or v32.NextSelectionRight;
        local v35 = v29.NextSelectionUp or v32.NextSelectionUp;
        local v36 = v29.NextSelectionDown or v32.NextSelectionDown;
        if not ((v33 == v31.NextSelectionLeft and v34 == v31.NextSelectionRight) and v36 == v31.NextSelectionDown) or v35 ~= v31.NextSelectionUp then
            return {
                parentNeighbors = v32,
                neighbors = {
                    NextSelectionLeft = v33,
                    NextSelectionRight = v34,
                    NextSelectionUp = v35,
                    NextSelectionDown = v36
                }
            };
        else
            return nil;
        end;
    end;
    v14.gainFocus = function(v37)
        v37.focused = true;
        if v37.props.onFocusGained ~= nil then
            v37.props.onFocusGained();
        end;
        if v37.props.onFocusChanged ~= nil then
            v37.props.onFocusChanged(true);
        end;
    end;
    v14.loseFocus = function(v38)
        v38.focused = false;
        if v38.props.onFocusLost ~= nil then
            v38.props.onFocusLost();
        end;
        if v38.props.onFocusChanged ~= nil then
            v38.props.onFocusChanged(false);
        end;
    end;
    v14.isRoot = function(v39)
        local v40 = false;
        if v39.props.focusController ~= nil then
            v40 = v39.props.parentFocusNode == nil;
        end;
        return v40;
    end;
    v14.getFocusControllerInternal = function(v41)
        return v41.state.focusNode.focusController[v7];
    end;
    v14.getRef = function(v42)
        return v42.props.innerRef or v42.defaultRef;
    end;
    v14.render = function(v43)
        local v44 = v43:getRef();
        local v45 = {
            NextSelectionLeft = v44,
            NextSelectionRight = v44,
            NextSelectionDown = v44,
            NextSelectionUp = v44,
            [v1.Ref] = v44
        };
        local _ = nil;
        return v1.createElement(v4.Provider, {
            value = v43.state
        }, v1.createElement(v13, if not v43:isRoot() then v2.Dictionary.join(v45, v43.props.parentNeighbors or v9, v43.props, v8) else v2.Dictionary.join(v45, v43.props, {
            [v1.Event.AncestryChanged] = v43.ancestryChangedListener,
            [v1.Event.DescendantAdded] = v43.refreshFocusOnDescendantAdded,
            [v1.Event.DescendantRemoving] = v43.refreshFocusOnDescendantRemoved
        }, v8)));
    end;
    v14.didMount = function(v47)
        v47.state.focusNode:attachToTree(v47.props.parentFocusNode, v47.updateFocusedState);
        if v47:isRoot() then
            v47.ancestryChanged(v47:getRef():getValue());
        end;
    end;
    v14.didUpdate = function(v48, _, v50)
        v48.state.focusNode:updateNavProps(v48.props);
        if v48.state.focusNode.ref ~= (v48.props.innerRef or v48.defaultRef) then
            error("Cannot change the ref passed to a Focusable component", 0);
        end;
        if v48.state.needsDescendantAddedRefocusCounter ~= v50.needsDescendantAddedRefocusCounter then
            v48:getFocusControllerInternal():descendantAddedRefocus();
        end;
        if v48.state.needsDescendantRemovedRefocusCounter ~= v50.needsDescendantRemovedRefocusCounter then
            v48:getFocusControllerInternal():descendantRemovedRefocus();
        end;
    end;
    v14.willUnmount = function(v51)
        v51.state.focusNode:detachFromTree();
        if v51:isRoot() then
            v51:getFocusControllerInternal():teardown();
        end;
    end;
    return v1.forwardRef(function(v52, v53)
        return v1.createElement(v4.Consumer, {
            render = function(v54)
                if v54 == nil and v52.focusController == nil then
                    return v1.createElement(v13, (v2.Dictionary.join(v52, v8, {
                        [v1.Ref] = v53
                    })));
                else
                    return v1.createElement(v14, (v2.Dictionary.join(v52, {
                        parentFocusNode = not not v54 and v54.focusNode or nil,
                        parentNeighbors = not not v54 and v54.neighbors or nil,
                        innerRef = v53
                    })));
                end;
            end
        });
    end);
end;


local v0 = require(script.Parent.asFocusable);
local function v2(v1)
    assert(Instance.new(v1):IsA("GuiObject"));
end;
local _ = function(v3)
    local v4 = typeof(v3);
    if v4 == "string" then
        local l_status_0, _ = pcall(v2, v3);
        return l_status_0;
    elseif not (v4 ~= "function") or v4 == "table" then
        return true;
    else
        return false;
    end;
end;
return function()
    local v8 = {};
    setmetatable(v8, {
        __index = function(_, v10)
            local v11 = typeof(v10);
            local v12;
            if v11 == "string" then
                local l_status_1, _ = pcall(v2, v10);
                v12 = l_status_1;
            else
                v12 = v11 == "function" or v11 == "table";
            end;
            if not v12 then
                error("Component " .. tostring(v10) .. " (" .. typeof(v10) .. ") is not a valid focusable component", 2);
            end;
            v12 = v0(v10);
            v8[v10] = v12;
            return v12;
        end,
        __tostring = function(v15)
            local v16 = "{";
            for v17, v18 in pairs(v15) do
                v16 = ("%s\n\t%s -> %s"):format(v16, tostring(v17), (tostring(v18)));
            end;
            return v16 .. "\n}";
        end
    });
    return v8;
end;


local v0 = require(script.Parent.Parent.Roact);
return function()
    local v1 = {};
    setmetatable(v1, {
        __index = function(_, v3)
            local v4 = v0.createRef();
            v1[v3] = v4;
            return v4;
        end,
        __tostring = function(v5)
            local v6 = "{";
            for v7, v8 in pairs(v5) do
                v6 = ("%s\n\t%s -> %s"):format(v6, tostring(v7), (tostring(v8)));
            end;
            return v6 .. "\n}";
        end
    });
    return v1;
end;


return (setmetatable({
    isEnabled = false
}, {
    __call = function(_, ...)
    end
}));


local l_GuiService_0 = game:GetService("GuiService");
local l_RunService_0 = game:GetService("RunService");
local l_UserInputService_0 = game:GetService("UserInputService");
local l_CoreGui_0 = game:GetService("CoreGui");
local v13 = {
    getGamepadConnected = function(v4)
        return l_UserInputService_0:GetGamepadConnected(v4);
    end,
    getGamepadState = function(v5)
        return l_UserInputService_0:GetGamepadState(v5);
    end,
    getNavigationGamepads = function()
        return l_UserInputService_0:GetNavigationGamepads();
    end,
    getSelection = function()
        return l_GuiService_0.SelectedCoreObject;
    end,
    setSelection = function(v6)
        l_GuiService_0.SelectedCoreObject = v6;
    end,
    subscribeToSelectionChanged = function(v7)
        return l_GuiService_0:GetPropertyChangedSignal("SelectedCoreObject"):Connect(v7);
    end,
    subscribeToRenderStepped = function(v8)
        return l_RunService_0.RenderStepped:Connect(v8);
    end,
    subscribeToGamepadConnected = function(v9)
        return l_UserInputService_0.GamepadConnected:Connect(v9);
    end,
    subscribeToGamepadDisconnected = function(v10)
        return l_UserInputService_0.GamepadDisconnected:Connect(v10);
    end,
    subscribeToInputBegan = function(v11)
        return l_UserInputService_0.InputBegan:Connect(v11);
    end,
    subscribeToInputEnded = function(v12)
        return l_UserInputService_0.InputEnded:Connect(v12);
    end
};
local v16 = {
    getSelection = function()
        return l_GuiService_0.SelectedObject;
    end,
    setSelection = function(v14)
        l_GuiService_0.SelectedObject = v14;
    end,
    subscribeToSelectionChanged = function(v15)
        return l_GuiService_0:GetPropertyChangedSignal("SelectedObject"):Connect(v15);
    end,
    getGamepadConnected = v13.getGamepadConnected,
    getGamepadState = v13.getGamepadState,
    getNavigationGamepads = v13.getNavigationGamepads,
    subscribeToRenderStepped = v13.subscribeToRenderStepped,
    subscribeToGamepadConnected = v13.subscribeToGamepadConnected,
    subscribeToGamepadDisconnected = v13.subscribeToGamepadDisconnected,
    subscribeToInputBegan = v13.subscribeToInputBegan,
    subscribeToInputEnded = v13.subscribeToInputEnded
};
return function(v17)
    if not v17:IsDescendantOf(l_CoreGui_0) then
        if v17:FindFirstAncestorWhichIsA("PlayerGui") == nil then
            error("Gamepad navigation not supported. Must be a child of CoreGui or a PlayerGui");
        end;
        return v16;
    else
        return v13;
    end;
end;


return {
    createRefCache = require(script.createRefCache),
    Focusable = require(script.createFocusableCache)(),
    Input = require(script.Input).PublicInterface,
    withFocusController = require(script.withFocusController),
    createFocusController = require(script.FocusController).createPublicApiWrapper,
    useRootFocusController = require(script.useRootFocusController),
    useFocusController = require(script.useFocusController),
    useRefCache = require(script.useRefCache),
    FocusContext = require(script.FocusContext),
    Config = require(script.Config)
};


return function(v0, v1)
    if v0 == v1 then
        return true;
    else
        for v2, v3 in pairs(v0) do
            local v4 = v1[v2];
            if v4 == nil then
                return false;
            elseif not (v3.kind == v4.kind and v3.keyCode == v4.keyCode) or v3.action ~= v4.action then
                return false;
            else
                local l_meta_0 = v3.meta;
                local l_meta_1 = v4.meta;
                if l_meta_0 ~= l_meta_1 then
                    if typeof(l_meta_0) == "table" and typeof(l_meta_1) == "table" then
                        for v7, v8 in pairs(l_meta_0) do
                            if v8 ~= l_meta_1[v7] then
                                return false;
                            end;
                        end;
                        for v9 in pairs(l_meta_1) do
                            if l_meta_0[v9] == nil then
                                return false;
                            end;
                        end;
                    else
                        return false;
                    end;
                end;
            end;
        end;
        for v10 in pairs(v1) do
            if v0[v10] == nil then
                return false;
            end;
        end;
        return true;
    end;
end;


local v0 = require(script.Parent.Parent.React);
local v1 = require(script.Parent.FocusContext);
return function()
    local v2 = v0.useContext(v1);
    if not v2 then
        return nil;
    else
        return v2.focusNode.focusController;
    end;
end;


local v0 = require(script.Parent.Parent.React);
local v1 = require(script.Parent.createRefCache);
return function()
    local v2 = v0.useRef(nil);
    if v2.current == nil then
        v2.current = v1();
    end;
    return v2.current;
end;


local v0 = require(script.Parent.Parent.React);
local v1 = require(script.Parent.FocusController);
return function()
    local v2 = v0.useRef(nil);
    if v2.current == nil then
        v2.current = v1.createPublicApiWrapper();
    end;
    return v2.current;
end;


local v0 = require(script.Parent.Parent.Roact);
local v1 = require(script.Parent.FocusContext);
local function v5(v2)
    return v0.createElement(v1.Consumer, {
        render = function(v3)
            local _ = nil;
            return v2.render(if not v3 then nil else v3.focusNode.focusController);
        end
    });
end;
return function(v6)
    return v0.createElement(v5, {
        render = v6
    });
end;


local v0 = require(script.Parent.NavigationSymbol);
local v1 = {
    None = v0("NONE"),
    InitialRoute = v0("INITIAL_ROUTE"),
    Order = v0("ORDER"),
    History = v0("HISTORY")
};
setmetatable(v1, {
    __index = function(_, v3)
        error(("%q is not a valid member of BackBehavior"):format((tostring(v3))), 2);
    end
});
return v1;


local v0 = require(script.Parent.NavigationSymbol);
return {
    WillFocus = v0("WILL_FOCUS"),
    DidFocus = v0("DID_FOCUS"),
    WillBlur = v0("WILL_BLUR"),
    DidBlur = v0("DID_BLUR"),
    Action = v0("ACTION"),
    Refocus = v0("REFOCUS")
};


local v0 = require(script.Parent.NavigationSymbol);
local v1 = v0("BACK");
local v2 = v0("INIT");
local v3 = v0("NAVIGATE");
local v4 = v0("SET_PARAMS");
local v5 = {
    Back = v1,
    Init = v2,
    Navigate = v3,
    SetParams = v4
};
setmetatable(v5, {
    __index = function(_, v7)
        error(("%q is not a valid member of NavigationActions"):format((tostring(v7))), 2);
    end
});
v5.back = function(v8)
    local v9 = v8 or {};
    return {
        type = v1,
        key = v9.key,
        immediate = v9.immediate
    };
end;
v5.init = function(v10)
    return {
        type = v2,
        params = (v10 or {}).params
    };
end;
v5.navigate = function(v11)
    local v12 = v11 or {};
    return {
        type = v3,
        routeName = v12.routeName,
        params = v12.params,
        action = v12.action,
        key = v12.key
    };
end;
v5.setParams = function(v13)
    local v14 = v13 or {};
    return {
        type = v4,
        preserveFocus = true,
        key = v14.key,
        params = v14.params
    };
end;
return v5;


return function(v0)
    assert(type(v0) == "string", "Symbols must be created using a string name");
    local v1 = newproxy(true);
    getmetatable(v1).__tostring = function()
        return v0;
    end;
    return v1;
end;


local v0 = require(script.Parent.Parent.LuauPolyfill);
local l_Array_0 = v0.Array;
local l_Object_0 = v0.Object;
local v15 = {
    get = function(v3, v4)
        for _, v6 in v3.routes, nil, nil do
            if v6.key == v4 then
                return v6;
            end;
        end;
        return nil;
    end,
    indexOf = function(v7, v8)
        for v9, v10 in v7.routes, nil, nil do
            if v10.key == v8 then
                return v9;
            end;
        end;
        return nil;
    end,
    has = function(v11, v12)
        for _, v14 in v11.routes, nil, nil do
            if v14.key == v12 then
                return true;
            end;
        end;
        return false;
    end
};
v15.push = function(v16, v17)
    assert(v15.indexOf(v16, v17.key) == nil, ("should not push route with duplicated key %s"):format(v17.key));
    local v18 = l_Array_0.concat(v16.routes, {
        v17
    });
    return l_Object_0.assign(table.clone(v16), {
        index = #v18,
        routes = v18
    });
end;
v15.pop = function(v19)
    if v19.index <= 1 then
        return v19;
    else
        local v20 = table.clone(v19.routes);
        table.remove(v20, #v20);
        return l_Object_0.assign(table.clone(v19), {
            index = #v20,
            routes = v20
        });
    end;
end;
v15.jumpToIndex = function(v21, v22)
    if v22 == v21.index then
        return v21;
    else
        assert(v21.routes[v22] ~= nil, ("invalid index %d to jump to"):format(v22));
        return l_Object_0.assign(table.clone(v21), {
            index = v22
        });
    end;
end;
v15.jumpTo = function(v23, v24)
    local v25 = v15.indexOf(v23, v24);
    assert(v25 ~= nil, ("attempt to jump to unknown key \"%s\""):format(v24));
    return v15.jumpToIndex(v23, v25);
end;
v15.back = function(v26)
    local v27 = v26.index - 1;
    if v26.routes[v27] then
        return v15.jumpToIndex(v26, v27);
    else
        return v26;
    end;
end;
v15.forward = function(v28)
    local v29 = v28.index + 1;
    if v28.routes[v29] then
        return v15.jumpToIndex(v28, v29);
    else
        return v28;
    end;
end;
v15.replaceAndPrune = function(v30, v31, v32)
    local v33 = v15.indexOf(v30, v31);
    local v34 = v15.replaceAtIndex(v30, v33, v32);
    return l_Object_0.assign(table.clone(v34), {
        routes = {
            unpack(v34.routes, 1, v33)
        }
    });
end;
v15.replaceAt = function(v35, v36, v37, v38)
    local v39 = v15.indexOf(v35, v36);
    local v40 = if not v38 then v39 else v35.index;
    local v41 = v15.replaceAtIndex(v35, v39, v37);
    v41.index = v40;
    return v41;
end;
v15.replaceAtIndex = function(v42, v43, v44)
    assert(v42.routes[v43] ~= nil, ("invalid index %d for replacing route %s"):format(v43, v44.key));
    if v42.routes[v43] == v44 and v43 == v42.index then
        return v42;
    else
        local v45 = table.clone(v42.routes);
        v45[v43] = v44;
        return l_Object_0.assign(table.clone(v42), {
            index = v43,
            routes = v45
        });
    end;
end;
v15.reset = function(v46, v47, v48)
    local v49 = false;
    if type(v47) == "table" then
        v49 = #v47 > 0;
    end;
    assert(v49, "invalid routes to replace");
    local v50 = v48 or #v47;
    if #v46.routes == #v47 and v46.index == v50 then
        v49 = true;
        for v51 = 1, #v47 do
            if v46.routes[v51] ~= v47[v51] then
                v49 = false;
                break;
            end;
        end;
        if v49 then
            return v46;
        end;
    end;
    assert(v47[v50] ~= nil, ("invalid index %d to reset"):format(v50));
    return l_Object_0.assign(table.clone(v46), {
        index = v50,
        routes = v47
    });
end;
return v15;


local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.React);
local v3 = require(l_Parent_1.LuauPolyfill);
local l_console_0 = v3.console;
local l_Object_0 = v3.Object;
local v6 = require(l_Parent_0.NavigationActions);
local v7 = require(l_Parent_0.Events);
local v8 = require(l_Parent_0.views.NavigationContext);
local v9 = require(l_Parent_0.getNavigation);
local l_assert_0 = assert;
local l_urlToPathAndParams_0 = require(l_Parent_0.routers.pathUtils).urlToPathAndParams;
local function _(v12)
    return not v12.navigation;
end;
local function v19(v14)
    if v14.persistenceKey then
        warn("You passed persistenceKey prop to a navigator. " .. "The persistenceKey prop was replaced by a more flexible persistence mechanism, " .. "please see the navigation state persistence docs for more information. " .. "Passing the persistenceKey prop is a no-op.");
    end;
    if v14.navigation then
        local v15 = l_Object_0.assign(table.clone(v14), {
            navigation = l_Object_0.None,
            screenProps = l_Object_0.None,
            persistNavigationState = l_Object_0.None,
            loadNavigationState = l_Object_0.None,
            externalDispatchConnector = l_Object_0.None
        });
        if next(v15) ~= nil then
            error("This navigator has both navigation and container props, so it is " .. ("unclear if it should own its own state. Remove props: %q "):format(table.concat(l_Object_0.keys(v15), ", ")) .. "if the navigator should get its state from the navigation prop. If the " .. "navigator should maintain its own state, do not pass a navigation prop.");
        end;
        local l_persistNavigationState_0 = v14.persistNavigationState;
        local l_loadNavigationState_0 = v14.loadNavigationState;
        local v18;
        if l_persistNavigationState_0 == nil then
            v18 = true;
            if not (l_loadNavigationState_0 ~= nil) then
                goto label0;
            end;
        end;
        v18 = false;
        if type(l_persistNavigationState_0) == "function" then
            v18 = type(l_loadNavigationState_0) == "function";
        end;
        ::label0::;
        l_assert_0(v18, "both persistNavigationState and loadNavigationState must either be undefined, or be functions");
        return ;
    else
        return ;
    end;
end;
local v20 = 0;
return {
    createAppContainer = function(v21, v22)
        local v23 = false;
        if type(v21) == "table" then
            v23 = v21.router ~= nil;
        end;
        l_assert_0(v23, "AppComponent must be a navigator or a stateful Roact component with a 'router' field");
        v23 = v2.Component:extend((string.format("NavigationContainer(%s)", (tostring(v21)))));
        v23.router = v21.router;
        v23.getDerivedStateFromProps = function(v24)
            v19(v24);
            return nil;
        end;
        v23.init = function(v25)
            v19(v25.props);
            v25._actionEventSubscribers = {};
            v25._initialAction = v6.init();
            local v26 = nil;
            if not (not v25:_isStateful() or v25.props.loadNavigationState) then
                v26 = v21.router.getStateForAction(v25._initialAction);
            end;
            v25.state = {
                nav = v26
            };
        end;
        v23._updateExternalDispatchConnector = function(v27)
            if v27._disconnectExternalDispatch then
                v27._disconnectExternalDispatch();
                v27._disconnectExternalDispatch = nil;
            end;
            local l_externalDispatchConnector_0 = v27.props.externalDispatchConnector;
            if l_externalDispatchConnector_0 ~= nil then
                v27._disconnectExternalDispatch = l_externalDispatchConnector_0(function(...)
                    if not v27._isMounted then
                        return false;
                    else
                        return v27:dispatch(...);
                    end;
                end);
            end;
        end;
        v23._renderLoading = function(v29)
            return v29.props.renderLoading and v29.props.renderLoading();
        end;
        v23._isStateful = function(v30)
            return not v30.props.navigation;
        end;
        v23._handleOpenURL = function(v31, v32)
            local l_url_0 = v32.url;
            local l_enableURLHandling_0 = v31.props.enableURLHandling;
            local l_uriPrefix_0 = v31.props.uriPrefix;
            if l_enableURLHandling_0 == false then
                return ;
            else
                local v36 = l_urlToPathAndParams_0(l_url_0, l_uriPrefix_0);
                if v36 then
                    local v37 = v21.router.getActionForPathAndParams(v36.path, v36.params);
                    if v37 then
                        v31:dispatch(v37);
                    end;
                end;
                return ;
            end;
        end;
        v23._onNavigationStateChange = function(v38, v39, v40, v41)
            local l_onNavigationStateChange_0 = v38.props.onNavigationStateChange;
            if (not (l_onNavigationStateChange_0 == nil) or not v38:_isStateful()) or not _G.REACT_NAV_LOGGING then
                if type(l_onNavigationStateChange_0) == "function" then
                    l_onNavigationStateChange_0(v39, v40, v41);
                end;
                return ;
            else
                l_console_0.group("Navigation Dispatch: ");
                l_console_0.log("Action: ", v41);
                l_console_0.log("New State: ", v40);
                l_console_0.log("Last State: ", v39);
                l_console_0.groupEnd();
                return ;
            end;
        end;
        v23.didUpdate = function(v43, v44)
            if v43._navState == v43.state.nav then
                v43._navState = nil;
            end;
            if v43.props.externalDispatchConnector ~= v44.externalDispatchConnector then
                v43:_updateExternalDispatchConnector();
            end;
        end;
        v23.didMount = function(v45)
            v45._isMounted = true;
            v45:_updateExternalDispatchConnector();
            if v45:_isStateful() then
                if not (not _G.__DEV__ or v45.props.detached) and v20 > 0 then
                    l_console_0.warn("You should only render one navigator explicitly in your app, and other" .. " navigators should be rendered by including them in that navigator." .. " Full details at: " .. "https://reactnavigation.org/docs/4.x/common-mistakes#explicitly-rendering-more-than-one-navigator");
                end;
                v20 = v20 + 1;
                if v22 then
                    v22:listenForLuaURLs(function(v46)
                        v45:_handleOpenURL({
                            url = v46
                        });
                    end, false);
                end;
                local v47 = nil;
                local v48 = nil;
                if v45.props.enableURLHandling ~= false then
                    local v49 = v45:getStartupParams();
                    v47 = v49.parsedUrl;
                    v48 = v49.userProvidedStartupState;
                end;
                local l__initialAction_0 = v45._initialAction;
                local v51 = v45.state.nav or v21.router.getStateForAction(l__initialAction_0);
                if v48 then
                    v51 = v48;
                end;
                if v47 then
                    local v52 = v21.router.getActionForPathAndParams(v47.path, v47.params);
                    if v52 then
                        l__initialAction_0 = v52;
                        v51 = v21.router.getStateForAction(v52, v51);
                    end;
                end;
                local function v54()
                    for v53 in v45._actionEventSubscribers, nil, nil do
                        v53({
                            type = v7.Action,
                            action = l__initialAction_0,
                            state = v45.state.nav,
                            lastState = nil
                        });
                    end;
                end;
                if v51 == v45.state.nav then
                    spawn(v54);
                    return ;
                else
                    v45:setState({
                        nav = v51
                    }, v54);
                    return ;
                end;
            else
                return ;
            end;
        end;
        v23.getStartupParams = function(v55)
            local l_props_0 = v55.props;
            local l_uriPrefix_1 = l_props_0.uriPrefix;
            local l_loadNavigationState_1 = l_props_0.loadNavigationState;
            local v59 = nil;
            local v60 = nil;
            if v22 then
                pcall(function()
                    v59 = v22:getLastLuaURL();
                end);
            end;
            if l_loadNavigationState_1 then
                pcall(function()
                    v60 = l_loadNavigationState_1();
                end);
            end;
            return {
                parsedUrl = v59 and l_urlToPathAndParams_0(v59, l_uriPrefix_1),
                userProvidedStartupState = v60
            };
        end;
        v23._persistNavigationState = function(v61, v62)
            local l_persistNavigationState_1 = v61.props.persistNavigationState;
            if l_persistNavigationState_1 then
                local l_status_0, l_result_0 = pcall(l_persistNavigationState_1, v62);
                if not l_status_0 then
                    warn("Uncaught error while calling persistNavigationState() " .. "You should handle exceptions thrown from persistNavigationState(), " .. "ignoring them may result in undefined behavior.\n" .. l_result_0);
                end;
            end;
        end;
        v23.willUnmount = function(v66)
            v66._isMounted = false;
            if v22 then
                v22:stopListeningForLuaURLs();
            end;
            if v66._disconnectExternalDispatch then
                v66._disconnectExternalDispatch();
                v66._disconnectExternalDispatch = nil;
            end;
            if v66:_isStateful() then
                v20 = v20 - 1;
            end;
        end;
        v23.dispatch = function(v67, v68)
            if not v67.props.navigation then
                v67._navState = v67._navState or v67.state.nav;
                local l__navState_0 = v67._navState;
                l_assert_0(l__navState_0 ~= nil, "should be set in constructor if stateful");
                local v70 = v21.router.getStateForAction(v68, l__navState_0);
                local l_v70_0 = v70;
                if v70 == nil then
                    l_v70_0 = l__navState_0;
                end;
                local function v73()
                    for v72 in v67._actionEventSubscribers, nil, nil do
                        v72({
                            type = v7.Action,
                            action = v68,
                            state = l_v70_0,
                            lastState = l__navState_0
                        });
                    end;
                end;
                if v70 == nil then
                    v73();
                    return true;
                elseif l_v70_0 ~= l__navState_0 then
                    v67._navState = l_v70_0;
                    v67:setState({
                        nav = l_v70_0
                    }, function()
                        v67:_onNavigationStateChange(l__navState_0, l_v70_0, v68);
                        task.defer(v73);
                        v67:_persistNavigationState(l_v70_0);
                    end);
                    return true;
                else
                    v73();
                    return false;
                end;
            else
                return v67.props.navigation.dispatch(v68);
            end;
        end;
        v23._getScreenProps = function(v74, v75, v76)
            if v75 == nil then
                return v74.props.screenProps;
            else
                local l_screenProps_0 = v74.props.screenProps;
                if not (l_screenProps_0 ~= nil) or l_screenProps_0[v75] == nil then
                    return v76;
                else
                    return l_screenProps_0[v75];
                end;
            end;
        end;
        v23.render = function(v78)
            local l_navigation_0 = v78.props.navigation;
            if v78:_isStateful() then
                local l_nav_0 = v78.state.nav;
                if l_nav_0 then
                    if not v78._navigation or v78._navigation.state ~= l_nav_0 then
                        v78._navigation = v9(v21.router, l_nav_0, function(...)
                            return v78:dispatch(...);
                        end, v78._actionEventSubscribers, function(...)
                            return v78:_getScreenProps(...);
                        end, function()
                            return v78._navigation;
                        end);
                    end;
                    l_navigation_0 = v78._navigation;
                else
                    return v78:_renderLoading();
                end;
            end;
            l_assert_0(l_navigation_0 ~= nil, "failed to get navigation");
            return v2.createElement(v8.Provider, {
                value = l_navigation_0
            }, {
                AppComponent = v2.createElement(v21, l_Object_0.assign(table.clone(v78.props), {
                    navigation = l_navigation_0
                }))
            });
        end;
        return v23;
    end,
    _TESTING_ONLY_reset_container_count = function()
        v20 = 0;
    end
};


local v0 = require(script.Parent.Parent.LuauPolyfill);
local l_Array_0 = v0.Array;
local l_Object_0 = v0.Object;
local v3 = require(script.Parent.getEventManager);
local v4 = require(script.Parent.getChildRouter);
local v5 = require(script.Parent.routers.getNavigationActionCreators);
local v6 = require(script.Parent.getChildrenNavigationCache);
local function _(v7)
    return function(v8, v9)
        local l_params_0 = v7.params;
        if l_params_0 and l_params_0[v8] ~= nil then
            return l_params_0[v8];
        else
            return v9;
        end;
    end;
end;
local function v12(v13, v14, v15)
    local v16 = v6(v13);
    local v18 = l_Array_0.findIndex(v13.state.routes, function(v17)
        return v17.key == v14;
    end);
    if v18 < 1 then
        return nil;
    else
        local v19 = v13.state.routes[v18];
        local v20 = v16[v14];
        if v20 and v20.state == v19 then
            return v20;
        else
            local v21 = v4(v13.router, v19.routeName);
            local v22 = nil;
            if v19.routes and type(v19.index) == "number" then
                v22 = v19.routes[v19.index];
            end;
            local v23 = l_Object_0.assign(if not v13.actions then {} else table.clone(v13.actions), v13.router.getActionCreators(v19, v13.state.key) or {}, (not not v21 and v21.getActionCreators(v22, v19.key) or {}) or {}, v5(v19) or {});
            local v24 = {};
            for v25, v26 in v23, nil, nil do
                v24[v25] = function(...)
                    return v13.dispatch((v26(...)));
                end;
            end;
            local v27 = true;
            local v28 = v15();
            if v28 then
                v27 = l_Array_0.indexOf(v28.state.routes, v19) == 1;
            end;
            if v20 and v20.isFirstRouteInParent() == v27 then
                local v29 = nil;
                v29 = l_Object_0.assign(table.clone(v20), v24, {
                    state = v19,
                    router = v21,
                    actions = v23,
                    getParam = function(v30, v31)
                        local l_params_1 = v19.params;
                        if l_params_1 and l_params_1[v30] ~= nil then
                            return l_params_1[v30];
                        else
                            return v31;
                        end;
                    end,
                    getChildNavigation = function(v33)
                        return v12(v29, v33, function()
                            local v34 = v15();
                            if not v34 then
                                return nil;
                            else
                                return (v34.getChildNavigation(v14));
                            end;
                        end);
                    end
                });
                v16[v14] = v29;
                return v29;
            else
                local v35 = v3(v14);
                local v36 = nil;
                v36 = l_Object_0.assign(table.clone(v24), {
                    state = v19,
                    router = v21,
                    actions = v23,
                    getParam = function(v37, v38)
                        local l_params_2 = v19.params;
                        if l_params_2 and l_params_2[v37] ~= nil then
                            return l_params_2[v37];
                        else
                            return v38;
                        end;
                    end,
                    getChildNavigation = function(v40)
                        return v12(v36, v40, function()
                            local v41 = v15();
                            if not v41 then
                                return nil;
                            else
                                return (v41.getChildNavigation(v14));
                            end;
                        end);
                    end,
                    isFocused = function()
                        local v42 = v15();
                        if v42 then
                            if v42.isFocused() then
                                local l_state_0 = v42.state;
                                if l_state_0.routes[l_state_0.index].key == v14 then
                                    return true;
                                else
                                    return false;
                                end;
                            else
                                return false;
                            end;
                        else
                            return false;
                        end;
                    end,
                    isFirstRouteInParent = function()
                        return v27;
                    end,
                    dispatch = v13.dispatch,
                    getScreenProps = v13.getScreenProps,
                    _dangerouslyGetParent = v15,
                    addListener = v35.addListener,
                    emit = v35.emit
                });
                v16[v14] = v36;
                return v36;
            end;
        end;
    end;
end;
return v12;


local v0 = require(script.Parent.utils.invariant);
return function(v1, v2)
    if not v1.childRouters or not v1.childRouters[v2] then
        v0(type(v1.getComponentForRouteName) == "function", "router.getComponentForRouteName must be a function if no child routers are specified");
        local v3 = v1.getComponentForRouteName(v2);
        if type(v3) == "table" then
            return v3.router;
        else
            return nil;
        end;
    else
        return v1.childRouters[v2];
    end;
end;


return function(v0)
    if v0 then
        if not v0._childrenNavigation then
            v0._childrenNavigation = {};
        end;
        local l__childrenNavigation_0 = v0._childrenNavigation;
        local v2 = {};
        local v3 = v0.state.routes or {};
        for _, v5 in v3, nil, nil do
            v2[v5.key] = true;
        end;
        if not v0.state.isTransitioning then
            for v6, _ in l__childrenNavigation_0, nil, nil do
                if not v2[v6] then
                    l__childrenNavigation_0[v6] = nil;
                end;
            end;
        end;
        return v0._childrenNavigation;
    else
        return {};
    end;
end;


return function(v0)
    local v1 = {};
    local function _(v2, v3)
        local v4 = v1[v2];
        local v5 = if not v4 then nil else v4[v0];
        if v5 then
            table.remove(v5, (table.find(v5, v3)));
            return ;
        else
            return ;
        end;
    end;
    return {
        addListener = function(v7, v8)
            v1[v7] = v1[v7] or {};
            v1[v7][v0] = v1[v7][v0] or {};
            table.insert(v1[v7][v0], v8);
            return {
                remove = function()
                    local l_v7_0 = v7;
                    local l_v8_0 = v8;
                    local v11 = v1[l_v7_0];
                    local v12 = if not v11 then nil else v11[v0];
                    if v12 then
                        table.remove(v12, (table.find(v12, l_v8_0)));
                        return ;
                    else
                        return ;
                    end;
                end
            };
        end,
        emit = function(v13, v14)
            local v15 = v1[v13] or {};
            local v16 = if not v15[v0] then nil else table.clone(v15[v0]);
            if v16 then
                for _, v18 in v16, nil, nil do
                    v18(v14);
                end;
            end;
        end
    };
end;


local l_Parent_0 = script.Parent;
local l_Object_0 = require(l_Parent_0.Parent.LuauPolyfill).Object;
local v2 = require(l_Parent_0.Events);
local v3 = require(l_Parent_0.routers.getNavigationActionCreators);
local v4 = require(l_Parent_0.getChildNavigation);
local v5 = require(l_Parent_0.getChildrenNavigationCache);
return function(v6, v7, v8, v9, v10, v11)
    local v12 = v6.getActionCreators(v7, nil);
    local v13 = {
        actions = v12,
        router = v6,
        state = v7,
        dispatch = v8,
        getScreenProps = v10,
        _dangerouslyGetParent = function()
            return nil;
        end,
        isFirstRouteInParent = function()
            return true;
        end,
        _childrenNavigation = v5(v11())
    };
    v13.getChildNavigation = function(v14)
        return v4(v13, v14, v11);
    end;
    v13.isFocused = function(v15)
        local l_state_0 = v11().state;
        local l_routes_0 = l_state_0.routes;
        local l_index_0 = l_state_0.index;
        local v19 = true;
        if v15 ~= nil then
            v19 = l_routes_0[l_index_0].key == v15;
        end;
        return v19;
    end;
    v13.addListener = function(v20, v21)
        if v20 ~= v2.Action then
            return {
                remove = function()
                end
            };
        else
            v9[v21] = true;
            return {
                remove = function()
                    v9[v21] = nil;
                end
            };
        end;
    end;
    local v22 = l_Object_0.assign(v3(v13.state), v12);
    for v23, _ in v22, nil, nil do
        v13[v23] = function(...)
            v13.dispatch(v22[v23](...));
        end;
    end;
    return v13;
end;


local v0 = require(script.views.NavigationContext);
return {
    createAppContainer = require(script.createAppContainer).createAppContainer,
    getNavigation = require(script.getNavigation),
    Context = v0,
    Provider = v0.Provider,
    Consumer = v0.Consumer,
    withNavigation = require(script.views.withNavigation),
    withNavigationFocus = require(script.views.withNavigationFocus),
    createRobloxStackNavigator = require(script.navigators.createRobloxStackNavigator),
    createRobloxSwitchNavigator = require(script.navigators.createRobloxSwitchNavigator),
    createSwitchNavigator = require(script.navigators.createSwitchNavigator),
    createNavigator = require(script.navigators.createNavigator),
    StackRouter = require(script.routers.StackRouter),
    SwitchRouter = require(script.routers.SwitchRouter),
    TabRouter = require(script.routers.TabRouter),
    DontMatchEmptyPath = require(script.routers:FindFirstChild("NullPathSymbol.roblox")),
    Actions = require(script.NavigationActions),
    StackActions = require(script.routers.StackActions),
    SwitchActions = require(script.routers.SwitchActions),
    BackBehavior = require(script.BackBehavior),
    Events = require(script.Events),
    NavigationEvents = require(script.views.NavigationEvents),
    None = require(script.Parent.LuauPolyfill).Object.None,
    StackPresentationStyle = require(script.views.RobloxStackView.StackPresentationStyle),
    StackViewTransitionConfigs = require(script.views.RobloxStackView.StackViewTransitionConfigs),
    SceneView = require(script.views.SceneView),
    RobloxSwitchView = require(script.views.RobloxSwitchView),
    RobloxStackView = require(script.views.RobloxStackView.StackView),
    createConfigGetter = require(script.routers.createConfigGetter),
    getScreenForRouteName = require(script.routers.getScreenForRouteName),
    validateRouteConfigMap = require(script.routers.validateRouteConfigMap),
    getActiveChildNavigationOptions = require(script.utils.getActiveChildNavigationOptions)
};


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.React);
local v3 = require(l_Parent_1.LuauPolyfill);
local l_Object_0 = v3.Object;
local l_Array_0 = v3.Array;
local v6 = require(l_Parent_0.utils.invariant);
local v7 = require(l_Parent_0.views.NavigationFocusEvents);
return function(v8, v9, v10)
    local v11 = v2.Component:extend("Navigator");
    v11.router = v9;
    v11.navigationOptions = v10.navigationOptions;
    v11.init = function(v12)
        v12.state = {
            descriptors = {},
            transitioningDescriptors = {},
            screenProps = v12.props.screenProps
        };
    end;
    v11.getDerivedStateFromProps = function(v13, v14)
        local l_descriptors_0 = v14.descriptors;
        local l_transitioningDescriptors_0 = v14.transitioningDescriptors;
        local l_navigation_0 = v13.navigation;
        local l_screenProps_0 = v13.screenProps;
        v6(l_navigation_0 ~= nil, "The navigation prop is missing for this navigator. " .. "In react-navigation v3 and v4 you must set up your app container directly. " .. "More info: https://reactnavigation.org/docs/en/app-containers.html");
        local l_routes_0 = l_navigation_0.state.routes;
        v6(type(l_routes_0) == "table", "No \"routes\" found in navigation state. " .. "Did you try to pass the navigation prop of a React component to a Navigator child? " .. "See https://reactnavigation.org/docs/en/custom-navigators.html#navigator-navigation-prop");
        local v24 = l_Array_0.reduce(l_routes_0, function(v20, v21)
            if (not (not l_descriptors_0 or not l_descriptors_0[v21.key]) and v21 == l_descriptors_0[v21.key].state) and l_screenProps_0 == v14.screenProps then
                v20[v21.key] = l_descriptors_0[v21.key];
                return v20;
            else
                local function v22()
                    return v9.getComponentForRouteName(v21.routeName);
                end;
                local v23 = l_navigation_0.getChildNavigation(v21.key);
                v20[v21.key] = {
                    key = v21.key,
                    getComponent = v22,
                    options = v9.getScreenOptions(v23, l_screenProps_0),
                    state = v21,
                    navigation = v23
                };
                return v20;
            end;
        end, {});
        local v25 = {};
        if l_navigation_0.state.isTransitioning then
            v25 = l_Object_0.assign({}, l_transitioningDescriptors_0, l_descriptors_0, l_Array_0.reduce(l_routes_0, function(v26, v27)
                v26[v27.key] = l_Object_0.None;
                return v26;
            end, {}));
        end;
        return {
            descriptors = v24,
            transitioningDescriptors = v25,
            screenProps = l_screenProps_0
        };
    end;
    v11.render = function(v28)
        local l_navigation_1 = v28.props.navigation;
        local l_screenProps_1 = v28.state.screenProps;
        local l_descriptors_1 = v28.state.descriptors;
        local l_transitioningDescriptors_1 = v28.state.transitioningDescriptors;
        return v2.createElement(v2.Fragment, {}, {
            Events = v2.createElement(v7, {
                navigation = l_navigation_1,
                onEvent = function(v33, v34, v35)
                    if not l_descriptors_1[v33] then
                        if l_transitioningDescriptors_1[v33] then
                            l_transitioningDescriptors_1[v33].navigation.emit(v34, v35);
                        end;
                        return ;
                    else
                        l_descriptors_1[v33].navigation.emit(v34, v35);
                        return ;
                    end;
                end
            }),
            View = v2.createElement(v8, l_Object_0.assign(table.clone(v28.props), {
                screenProps = l_screenProps_1,
                navigation = l_navigation_1,
                navigationConfig = v10,
                descriptors = l_descriptors_1
            }))
        });
    end;
    return v11;
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(script.Parent.createNavigator);
local v2 = require(l_Parent_0.routers.StackRouter);
local v3 = require(l_Parent_0.views.RobloxStackView.StackView);
return function(v4, v5)
    return v1(v3, v2(v4, v5), v5 or {});
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(script.Parent.createNavigator);
local v2 = require(l_Parent_0.routers.SwitchRouter);
local v3 = require(l_Parent_0.views.RobloxSwitchView);
return function(v4, v5)
    return v1(v3, v2(v4, v5), v5 or {});
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(script.Parent.createNavigator);
local v2 = require(l_Parent_0.routers.SwitchRouter);
local v3 = require(l_Parent_0.views.SwitchView.SwitchView);
return function(v4, v5)
    if v5 == nil then
        v5 = {};
    end;
    return v1(v3, v2(v4, v5), v5);
end;


local l_Parent_0 = script.Parent.Parent;
local l_Object_0 = require(l_Parent_0.Parent.LuauPolyfill).Object;
local v2 = require(l_Parent_0.NavigationSymbol);
local v3 = v2("POP");
local v4 = v2("POP_TO_TOP");
local v5 = v2("PUSH");
local v6 = v2("RESET");
local v7 = v2("REPLACE");
local v8 = v2("COMPLETE_TRANSITION");
local v9 = {
    Pop = v3,
    PopToTop = v4,
    Push = v5,
    Reset = v6,
    Replace = v7,
    CompleteTransition = v8
};
setmetatable(v9, {
    __index = function(_, v11)
        error(("%q is not a valid member of StackActions"):format((tostring(v11))), 2);
    end
});
v9.pop = function(v12)
    local v13 = {
        type = v3
    };
    if not v12 then
        return v13;
    else
        return (l_Object_0.assign(v13, v12));
    end;
end;
v9.popToTop = function(v14)
    local v15 = {
        type = v4
    };
    if not v14 then
        return v15;
    else
        return (l_Object_0.assign(v15, v14));
    end;
end;
v9.push = function(v16)
    local v17 = {
        type = v5
    };
    if not v16 then
        return v17;
    else
        return (l_Object_0.assign(v17, v16));
    end;
end;
v9.reset = function(v18)
    local v19 = {
        type = v6
    };
    if not v18 then
        return v19;
    else
        return (l_Object_0.assign(v19, v18));
    end;
end;
v9.replace = function(v20)
    local v21 = {
        type = v7,
        preserveFocus = true
    };
    if not v20 then
        return v21;
    else
        return (l_Object_0.assign(v21, v20));
    end;
end;
v9.completeTransition = function(v22)
    local v23 = {
        type = v8,
        preserveFocus = true
    };
    if not v22 then
        return v23;
    else
        return (l_Object_0.assign(v23, v22));
    end;
end;
return v9;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Parent.LuauPolyfill);
local l_Array_0 = v1.Array;
local l_Object_0 = v1.Object;
local v4 = require(l_Parent_0.NavigationActions);
local v5 = require(script.Parent.StackActions);
local v6 = require(l_Parent_0.utils.KeyGenerator);
local v7 = require(l_Parent_0.StateUtils);
local v8 = require(script.Parent.getScreenForRouteName);
local v9 = require(script.Parent.createConfigGetter);
local v10 = require(script.Parent.validateRouteConfigArray);
local v11 = require(script.Parent.validateRouteConfigMap);
local v12 = require(l_Parent_0.utils.invariant);
local l_createPathParser_0 = require(script.Parent.pathUtils).createPathParser;
local v14 = require(script.Parent["ChildIsScreenRouterSymbol.roblox"]);
local function v15()
    return {};
end;
local function _(v16)
    local v17 = true;
    if v16.type ~= v4.Navigate then
        v17 = v16.type == v5.Push;
    end;
    return v17;
end;
local function _(v19)
    local v20 = false;
    if v19.type == v5.Reset then
        v20 = v19.key == nil;
    end;
    return v20;
end;
local function v23(v22)
    return (next(v22));
end;
local function v29(v24, v25, _)
    local v27, v28 = next(v25);
    v24[v27] = v28;
    return v24;
end;
return function(v30, v31)
    v10(v30);
    v31 = v31 or {};
    local v32 = v11(l_Array_0.reduce(v30, v29, {}));
    local v33 = v31.order or l_Array_0.map(v30, v23);
    local v34 = {};
    for _, v36 in v33, nil, nil do
        local v37 = v32[v36];
        local v38 = if type(v37) == "table" and v37.screen then v37.screen else v37;
        if not (type(v38) == "table") or not v38.router then
            v34[v36] = v14;
        else
            v34[v36] = v38.router;
        end;
    end;
    local l_initialRouteParams_0 = v31.initialRouteParams;
    local v40 = v31.getCustomActionCreators or v15;
    local v41 = v31.initialRouteName or v33[1];
    local v42 = v34[v41];
    if l_Array_0.indexOf(v33, v41) < 1 then
        local v43 = "";
        for _, v45 in v33, nil, nil do
            v43 = v43 .. v45 .. ",";
        end;
        error(string.format("Invalid initialRouteName '%s'. Must be one of [%s]", v41, v43), 2);
    end;
    local function v51(v46)
        local v47 = {};
        local v48 = v34[v46.routeName];
        local v49 = true;
        if v46.type ~= v4.Navigate then
            v49 = v46.type == v5.Push;
        end;
        if v49 and v48 ~= nil then
            v49 = {};
            if v48 ~= v14 then
                v49 = v48.getStateForAction(v46.action or v4.init({
                    params = v46.params
                }));
            end;
            return {
                key = "StackRouterRoot",
                isTransitioning = false,
                index = 1,
                routes = {
                    l_Object_0.assign({
                        params = v46.params
                    }, v49, {
                        key = v46.key or v6.generateKey(),
                        routeName = v46.routeName
                    })
                }
            };
        else
            if v42 ~= nil and v42 ~= v14 then
                v47 = v42.getStateForAction(v4.navigate({
                    routeName = v41,
                    params = l_initialRouteParams_0
                }));
            end;
            v49 = v32[v41];
            local v50 = false;
            if type(v49) == "table" then
                v50 = v49.params;
            end;
            return {
                key = "StackRouterRoot",
                isTransitioning = false,
                index = 1,
                routes = {
                    (l_Object_0.assign(table.clone(v47), {
                        params = (((v50 or v47.params) or v46.params) or l_initialRouteParams_0) and l_Object_0.assign(if not v50 then {} else table.clone(v50), v47.params or {}, v46.params or {}, l_initialRouteParams_0 or {}),
                        routeName = v41,
                        key = (v46.key or v31.initialRouteKey) or v6.generateKey()
                    }))
                }
            };
        end;
    end;
    local function v55(v52, v53)
        if v53.params == l_Object_0.None then
            return nil;
        else
            local v54 = v32[v52];
            if not (type(v54) == "table") or not v54.params then
                if not v53.params then
                    return nil;
                else
                    return l_Object_0.assign({}, v53.params);
                end;
            else
                return l_Object_0.assign(table.clone(v54.params), v53.params);
            end;
        end;
    end;
    local v56 = l_createPathParser_0(v34, v32, v31);
    local l_getPathAndParamsForRoute_0 = v56.getPathAndParamsForRoute;
    local l_getActionForPathAndParams_0 = v56.getActionForPathAndParams;
    local v59 = {};
    for v60, v61 in v34, nil, nil do
        if v61 ~= v14 then
            v59[v60] = v61;
        end;
    end;
    return {
        childRouters = v59,
        _CHILD_IS_SCREEN = v14,
        getComponentForState = function(v62)
            local v63 = v62.routes[v62.index] or {};
            local l_routeName_0 = v63.routeName;
            v12(l_routeName_0, "There is no route defined for index '%d'. " .. "Make sure that you passed in a navigation state with a " .. "valid stack index.", v62.index);
            local v65 = v34[l_routeName_0];
            if v65 ~= nil and v65 ~= v14 then
                return v34[l_routeName_0].getComponentForState(v63);
            else
                return v8(v32, l_routeName_0);
            end;
        end,
        getComponentForRouteName = function(v66)
            return v8(v32, v66);
        end,
        getActionCreators = function(v67, v68)
            return l_Object_0.assign(table.clone(v40(v67, v68)), {
                pop = function(v69, v70)
                    return v5.pop(l_Object_0.assign({
                        n = v69
                    }, v70 or {}));
                end,
                popToTop = function(v71)
                    return v5.popToTop(v71);
                end,
                push = function(v72, v73, v74)
                    return v5.push({
                        routeName = v72,
                        params = v73,
                        action = v74
                    });
                end,
                replace = function(v75, v76, v77, v78)
                    if type(v75) == "string" then
                        return v5.replace({
                            routeName = v75,
                            params = v76,
                            action = v77,
                            key = v67.key,
                            newKey = v78
                        });
                    else
                        v12(type(v75) == "table", "replaceWith must be a table or string");
                        v12(v76 == nil, "params must not be provided to .replace() when specifying a table");
                        v12(v77 == nil, "Child action must not be provided to .replace() when specifying a table");
                        v12(v78 == nil, "newKey must not be provided to .replace() when specifying a table");
                        return v5.replace(v75);
                    end;
                end,
                reset = function(v79, v80)
                    local l_v80_0 = v80;
                    if v80 == nil then
                        l_v80_0 = #v79;
                    end;
                    return v5.reset({
                        actions = v79,
                        index = l_v80_0,
                        key = v68
                    });
                end,
                dismiss = function()
                    return v4.back({
                        key = v68
                    });
                end
            });
        end,
        getStateForAction = function(v82, v83)
            if v83 then
                local v84 = v83.routes[v83.index];
                local v85 = false;
                if v82.type == v5.Reset then
                    v85 = v82.key == nil;
                end;
                if not v85 and v82.type ~= v4.Navigate then
                    v85 = v34[v84.routeName];
                    if v85 ~= nil and v85 ~= v14 then
                        local v86 = v85.getStateForAction(v82, v84);
                        if v86 ~= nil and v86 ~= v84 then
                            return v7.replaceAt(v83, v84.key, v86, v82.type == v4.SetParams);
                        end;
                    end;
                elseif v82.type == v4.Navigate then
                    for v87 = #v83.routes, 1, -1 do
                        local v88 = v83.routes[v87];
                        local v89 = v34[v88.routeName];
                        local l_v82_0 = v82;
                        if not (not (v82.routeName == v88.routeName) or not v82.action) then
                            l_v82_0 = v82.action;
                        end;
                        if v89 ~= nil and v89 ~= v14 then
                            local v91 = v89.getStateForAction(l_v82_0, v88);
                            if not (v91 ~= nil) or v91 ~= v88 then
                                local v92 = v7.replaceAndPrune(v83, if not v91 then v88.key else v91.key, v91 or v88);
                                local l_isTransitioning_0 = v83.isTransitioning;
                                if v83.index ~= v92.index then
                                    l_isTransitioning_0 = v82.immediate ~= true;
                                end;
                                return l_Object_0.assign(table.clone(v92), {
                                    isTransitioning = l_isTransitioning_0
                                });
                            end;
                        end;
                    end;
                end;
                v85 = true;
                if v82.type ~= v4.Navigate then
                    v85 = v82.type == v5.Push;
                end;
                if v85 and v34[v82.routeName] ~= nil then
                    v85 = v34[v82.routeName];
                    local l_v12_0 = v12;
                    local v95 = true;
                    if v82.type == v5.Push then
                        v95 = v82.key == nil;
                    end;
                    l_v12_0(v95, "StackRouter does not support key on the push action");
                    l_v12_0 = function(v96)
                        return v96.routeName == v82.routeName;
                    end;
                    if v82.key then
                        l_v12_0 = function(v97)
                            return v97.key == v82.key;
                        end;
                    end;
                    v95 = l_Array_0.findIndex(v83.routes, l_v12_0);
                    if v82.type ~= v5.Push and v95 > 0 then
                        if not (v83.index == v95) or v82.params then
                            local v98 = l_Array_0.slice(v83.routes, 1, v95 + 1);
                            if v82.params then
                                local v99 = v83.routes[v95];
                                v98[v95] = l_Object_0.assign(table.clone(v99), {
                                    params = if v82.params == l_Object_0.None then l_Object_0.None else if v99.params then l_Object_0.assign(table.clone(v99.params), v82.params) else table.clone(v82.params)
                                });
                            end;
                            local l_isTransitioning_1 = v83.isTransitioning;
                            if v83.index ~= v95 then
                                l_isTransitioning_1 = v82.immediate ~= true;
                            end;
                            return l_Object_0.assign(table.clone(v83), {
                                isTransitioning = l_isTransitioning_1,
                                index = v95,
                                routes = v98
                            });
                        else
                            return nil;
                        end;
                    else
                        local _ = nil;
                        return l_Object_0.assign(v7.push(v83, if v85 ~= v14 then l_Object_0.assign({
                            params = v55(v82.routeName, v82)
                        }, v85.getStateForAction(v82.action or v4.init({
                            params = v55(v82.routeName, v82)
                        })), {
                            routeName = v82.routeName,
                            key = v82.key or v6.generateKey()
                        }) else {
                            params = v55(v82.routeName, v82),
                            routeName = v82.routeName,
                            key = v82.key or v6.generateKey()
                        }), {
                            isTransitioning = v82.immediate ~= true
                        });
                    end;
                elseif v82.type == v5.Push and v34[v82.routeName] == nil then
                    return v83;
                else
                    v85 = true;
                    if v82.type ~= v4.Navigate then
                        v85 = v82.type == v5.Push;
                    end;
                    if v85 then
                        for v102 in v34, nil, nil do
                            local v103 = v34[v102];
                            if v103 ~= nil and v103 ~= v14 then
                                local v104 = v103.getStateForAction(v4.init());
                                local v105 = v103.getStateForAction(v82, v104);
                                local v106 = nil;
                                if v105 == nil then
                                    v106 = v104;
                                elseif v105 ~= v104 then
                                    v106 = v105;
                                end;
                                if v106 then
                                    return l_Object_0.assign(v7.push(v83, (l_Object_0.assign(table.clone(v106), {
                                        routeName = v102,
                                        key = v82.key or v6.generateKey()
                                    }))), {
                                        isTransitioning = v82.immediate ~= true
                                    });
                                end;
                            end;
                        end;
                    end;
                    if v82.type == v5.PopToTop then
                        if v82.key and v83.key ~= v82.key then
                            return v83;
                        elseif v83.index > 1 then
                            return l_Object_0.assign(table.clone(v83), {
                                isTransitioning = v82.immediate ~= true,
                                index = 1,
                                routes = {
                                    v83.routes[1]
                                }
                            });
                        else
                            return v83;
                        end;
                    else
                        if v82.type == v5.Replace then
                            v85 = nil;
                            v85 = if v82.key == nil and #v83.routes > 0 then #v83.routes else l_Array_0.findIndex(v83.routes, function(v107)
                                return v107.key == v82.key;
                            end);
                            if v85 > 0 then
                                local v108 = v34[v82.routeName];
                                local v109 = {};
                                if v108 ~= nil and v108 ~= v14 then
                                    v109 = v108.getStateForAction(v82.action or v4.init({
                                        params = v55(v82.routeName, v82)
                                    }));
                                end;
                                local v110 = table.clone(v83.routes);
                                v110[v85] = l_Object_0.assign({
                                    params = v55(v82.routeName, v82)
                                }, v109, {
                                    routeName = v82.routeName,
                                    key = v82.newKey or v6.generateKey()
                                });
                                return l_Object_0.assign(table.clone(v83), {
                                    routes = v110
                                });
                            end;
                        end;
                        if not ((v82.type == v5.CompleteTransition and (not (v82.key ~= nil) or v82.key == v83.key)) and v82.toChildKey == v83.routes[v83.index].key) or not v83.isTransitioning then
                            if v82.type == v4.SetParams then
                                v85 = v82.key;
                                local l_v85_0 = v85 --[[ copy: 3 -> 14 ]];
                                local v113 = l_Array_0.findIndex(v83.routes, function(v112)
                                    return v112.key == l_v85_0;
                                end);
                                if v113 > 0 then
                                    local v114 = v83.routes[v113];
                                    local l_None_0 = l_Object_0.None;
                                    if v82.params ~= l_Object_0.None then
                                        l_None_0 = if not not v114.params and v82.params then l_Object_0.assign(table.clone(v114.params), v82.params) else if v114.params then table.clone(v114.params) else if v82.params then table.clone(v82.params) else {};
                                    end;
                                    local v116 = table.clone(v83.routes);
                                    v116[v113] = l_Object_0.assign(table.clone(v114), {
                                        params = l_None_0
                                    });
                                    return l_Object_0.assign(table.clone(v83), {
                                        routes = v116
                                    });
                                end;
                            end;
                            if v82.type == v5.Reset then
                                if v82.key ~= nil and v82.key ~= v83.key then
                                    return v83;
                                else
                                    return l_Object_0.assign(table.clone(v83), {
                                        routes = if not v82.actions then {} else l_Array_0.map(v82.actions, function(v117)
                                            local v118 = v34[v117.routeName];
                                            local v119 = {};
                                            if v118 ~= nil and v118 ~= v14 then
                                                v119 = v118.getStateForAction(v117.action or v4.init({
                                                    params = v55(v117.routeName, v117)
                                                }));
                                            end;
                                            return l_Object_0.assign({
                                                params = v55(v117.routeName, v117)
                                            }, v119, {
                                                routeName = v117.routeName,
                                                key = v117.key or v6.generateKey()
                                            });
                                        end),
                                        index = v82.index
                                    });
                                end;
                            else
                                if not (v82.type ~= v4.Back) or v82.type == v5.Pop then
                                    v85 = v82.key;
                                    local l_n_0 = v82.n;
                                    local l_immediate_0 = v82.immediate;
                                    local l_prune_0 = v82.prune;
                                    if not (v82.type == v5.Pop and l_prune_0 == false) or not v85 then
                                        local l_index_0 = v83.index;
                                        if v82.type == v5.Pop and l_n_0 ~= nil then
                                            l_index_0 = math.max(2, (v83.index - l_n_0) + 1);
                                        elseif v85 then
                                            local l_v85_1 = v85 --[[ copy: 3 -> 13 ]];
                                            l_index_0 = l_Array_0.findIndex(v83.routes, function(v125)
                                                return v125.key == l_v85_1;
                                            end);
                                        end;
                                        if l_index_0 > 1 then
                                            return l_Object_0.assign(table.clone(v83), {
                                                routes = l_Array_0.slice(v83.routes, 1, l_index_0),
                                                index = l_index_0 - 1,
                                                isTransitioning = l_immediate_0 ~= true
                                            });
                                        end;
                                    else
                                        local l_v85_2 = v85 --[[ copy: 3 -> 12 ]];
                                        local v128 = l_Array_0.findIndex(v83.routes, function(v127)
                                            return v127.key == l_v85_2;
                                        end);
                                        if v128 > 0 then
                                            local v129 = l_Array_0.concat(l_Array_0.slice(v83.routes, 1, math.max(v128 - (l_n_0 or 1), 1) + 1), l_Array_0.slice(v83.routes, v128 + 1));
                                            if #v129 > 0 then
                                                return l_Object_0.assign(table.clone(v83), {
                                                    routes = v129,
                                                    index = #v129,
                                                    isTransitioning = l_immediate_0 ~= true
                                                });
                                            end;
                                        end;
                                    end;
                                end;
                                v85 = if not v82.key then nil else v7.indexOf(v83, v82.key);
                                for v130 = #v83.routes, 1, -1 do
                                    local v131 = v83.routes[v130];
                                    if v131.key ~= v84.key and (not (v85 ~= 1) or v131.key == v82.key) then
                                        local v132 = v34[v131.routeName];
                                        if v132 ~= nil and v132 ~= v14 then
                                            local v133 = v132.getStateForAction(v82, v131);
                                            if v133 == nil then
                                                return v83;
                                            elseif v133 ~= v131 then
                                                return v7.replaceAt(v83, v131.key, v133, v82.preserveFocus);
                                            end;
                                        end;
                                    end;
                                end;
                                return v83;
                            end;
                        else
                            return l_Object_0.assign(table.clone(v83), {
                                isTransitioning = false
                            });
                        end;
                    end;
                end;
            else
                return (v51(v82));
            end;
        end,
        getPathAndParamsForState = function(v134)
            return l_getPathAndParamsForRoute_0(v134.routes[v134.index]);
        end,
        getActionForPathAndParams = function(v135, v136)
            return l_getActionForPathAndParams_0(v135, v136);
        end,
        getScreenOptions = v9(v32, v31.defaultNavigationOptions)
    };
end;


local l_Object_0 = require(script.Parent.Parent.Parent.LuauPolyfill).Object;
local v1 = require(script.Parent.Parent.NavigationSymbol)("JUMP_TO");
local v2 = {
    JumpTo = v1
};
setmetatable(v2, {
    __index = function(_, v4)
        error(("%q is not a valid member of SwitchActions"):format((tostring(v4))), 2);
    end
});
v2.jumpTo = function(v5)
    local v6 = {
        type = v1,
        preserveFocus = true
    };
    if not v5 then
        return v6;
    else
        return (l_Object_0.assign(v6, v5));
    end;
end;
return v2;