local l_Parent_0 = script.Parent.Parent.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(l_Parent_0.UIBlox.Core.Style.withStyle);
local v5 = require(l_Parent_0.UIBlox.App.ImageSet.Images);
local v6 = require(l_Parent_0.UIBlox.Core.InputButton.InputButton);
local v7 = require(l_Parent_0.UIBlox.App.SelectionImage.CursorKind);
local v8 = require(l_Parent_0.UIBlox.App.SelectionImage.withSelectionCursorProvider);
local v9 = require(l_Parent_0.UIBlox.App.SelectionCursor.withCursor);
local v10 = require(l_Parent_0.UIBlox.App.SelectionCursor.CursorType);
local v11 = require(l_Parent_0.UIBlox.UIBloxConfig);
local v12 = v1.PureComponent:extend("Checkbox");
v12.validateProps = v3.strictInterface({
    text = v3.string,
    isSelected = v3.optional(v3.boolean),
    isDisabled = v3.optional(v3.boolean),
    onActivated = v3.callback,
    size = v3.optional(v3.UDim2),
    layoutOrder = v3.optional(v3.number),
    frameRef = v3.optional(v3.table),
    NextSelectionDown = v3.optional(v3.table),
    NextSelectionUp = v3.optional(v3.table),
    NextSelectionLeft = v3.optional(v3.table),
    NextSelectionRight = v3.optional(v3.table)
});
v12.defaultProps = {
    text = "Checkbox Text",
    isSelected = false,
    isDisabled = false
};
v12.init = function(v13)
    v13.state = {
        value = v13.props.isSelected
    };
    v13.onFlip = function()
        if not v13.props.isDisabled then
            v13.props.onActivated(not v13.props.isSelected);
            return ;
        else
            return ;
        end;
    end;
end;
v12.render = function(v14)
    return v8(function(v15)
        return v4(function(v16)
            if not v11.migrateToNewSelectionCursor then
                return v14:renderWithProviders(v16, v15);
            else
                return v9(function(v17)
                    return v14:renderWithProviders(v16, v15, (v17.getCursorByType(v10.InputButton)));
                end);
            end;
        end);
    end);
end;
v12.renderWithProviders = function(v18, v19, v20, v21)
    local v22 = nil;
    local v23 = nil;
    local v24 = nil;
    local v25 = nil;
    local l_Theme_0 = v19.Theme;
    local l_Transparency_0 = l_Theme_0.TextDefault.Transparency;
    local l_Color_0 = l_Theme_0.TextDefault.Color;
    local l_Color_1 = l_Theme_0.SystemPrimaryContent.Color;
    if v18.props.isDisabled then
        l_Transparency_0 = 0.5;
    end;
    if not v18.props.isSelected then
        v22 = v5["squircles/hollow"];
        v23 = l_Theme_0.TextDefault.Color;
    else
        v22 = v5["squircles/fill"];
        v23 = l_Theme_0.SystemPrimaryDefault.Color;
        v24 = v5["icons/status/success_small"];
        v25 = UDim2.new(0, 14, 0, 14);
    end;
    return v1.createElement(v6, {
        text = v18.props.text,
        onActivated = v18.onFlip,
        size = v18.props.size,
        image = v22,
        imageColor = v23,
        fillImage = v24,
        fillImageSize = v25,
        fillImageColor = l_Color_1,
        selectedColor = l_Theme_0.SystemPrimaryDefault.Color,
        textColor = l_Color_0,
        transparency = l_Transparency_0,
        layoutOrder = v18.props.layoutOrder,
        isDisabled = v18.props.isDisabled,
        [v1.Ref] = v18.props.frameRef,
        SelectionImageObject = if not v11.migrateToNewSelectionCursor then v20(v7.InputButton) else v21
    });
end;
return v1.forwardRef(function(v30, v31)
    return v1.createElement(v12, v2.Dictionary.join(v30, {
        frameRef = v31
    }));
end);


local l_Parent_0 = script.Parent.Parent.Parent.Parent;
local v1 = require(l_Parent_0.Roact);
local v2 = require(l_Parent_0.t);
local v3 = require(l_Parent_0.Cryo);
local v4 = require(script.Parent.Checkbox);
local v5 = v1.PureComponent:extend("CheckboxList");
v5.validateProps = v2.strictInterface({
    checkboxes = v2.array(v2.union(v2.string, (v2.strictInterface({
        label = v2.string,
        isSelected = v2.optional(v2.boolean),
        isDisabled = v2.optional(v2.boolean)
    })))),
    onActivated = v2.callback,
    elementSize = v2.UDim2,
    atMost = v2.optional(v2.number),
    layoutOrder = v2.optional(v2.number)
});
local _ = function(v6)
    local v7 = 0;
    for _, v9 in pairs(v6) do
        if v9 then
            v7 = v7 + 1;
        end;
    end;
    return v7;
end;
v5.init = function(v11)
    local v12 = v11.props.atMost or #v11.props.checkboxes;
    local v13 = {};
    local v14 = {};
    for v15, v16 in ipairs(v11.props.checkboxes) do
        if type(v16) == "table" then
            v13[v15] = v16.isSelected or false;
            v14[v15] = v16.isDisabled or false;
        end;
    end;
    local v17 = 0;
    for _, v19 in pairs(v13) do
        if v19 then
            v17 = v17 + 1;
        end;
    end;
    assert(v17 < v12, "number of 'isSelected' must be less than atMost");
    v11.state = {
        selectedIndices = v13,
        disabledIndices = v14
    };
    v11.doLogic = function(v20)
        local l_v11_0 = v11;
        local v22 = {};
        local l_join_0 = v3.Dictionary.join;
        local l_selectedIndices_0 = v11.state.selectedIndices;
        local v25 = {};
        local v26 = not v11.state.selectedIndices[v20];
        if v26 then
            local l_selectedIndices_1 = v11.state.selectedIndices;
            local v28 = 0;
            for _, v30 in pairs(l_selectedIndices_1) do
                if v30 then
                    v28 = v28 + 1;
                end;
            end;
            v26 = v28 < v12;
        end;
        v25[v20] = v26;
        v22.selectedIndices = l_join_0(l_selectedIndices_0, v25);
        l_v11_0:setState(v22);
        v11.props.onActivated(v11.state.selectedIndices);
    end;
end;
v5.render = function(v31)
    local v32 = {
        layout = v1.createElement("UIListLayout", {
            SortOrder = Enum.SortOrder.LayoutOrder
        })
    };
    for v33, v34 in ipairs(v31.props.checkboxes) do
        v32["Checkbox" .. v33] = v1.createElement(v4, {
            text = type(v34) == "table" and v34.label or v34,
            isSelected = v31.state.selectedIndices[v33],
            isDisabled = v31.state.disabledIndices[v33],
            onActivated = function()
                v31.doLogic(v33);
            end,
            size = v31.props.elementSize,
            layoutOrder = v33
        });
    end;
    return v1.createElement("Frame", {
        Size = UDim2.new(1, 0, 1, 0),
        BackgroundTransparency = 1,
        LayoutOrder = v31.props.layoutOrder
    }, v32);
end;
return v5;


local l_Parent_0 = script.Parent.Parent.Parent.Parent;
local v1 = require(l_Parent_0.Roact);
local v2 = require(l_Parent_0.t);
local v3 = require(l_Parent_0.Cryo);
local v4 = require(l_Parent_0.UIBlox.Core.Style.withStyle);
local v5 = require(l_Parent_0.UIBlox.App.ImageSet.Images);
local v6 = require(l_Parent_0.UIBlox.Core.InputButton.InputButton);
local v7 = require(l_Parent_0.RoactGamepad);
local v8 = v1.PureComponent:extend("RadioButton");
v8.validateProps = v2.strictInterface({
    text = v2.string,
    isSelected = v2.optional(v2.boolean),
    isDisabled = v2.optional(v2.boolean),
    onActivated = v2.callback,
    size = v2.UDim2,
    layoutOrder = v2.optional(v2.number),
    id = v2.number,
    NextSelectionDown = v2.optional(v2.table),
    NextSelectionUp = v2.optional(v2.table),
    NextSelectionLeft = v2.optional(v2.table),
    NextSelectionRight = v2.optional(v2.table),
    SelectionImageObject = v2.optional(v2.table),
    forwardRef = v2.optional(v2.table)
});
v8.defaultProps = {
    text = "RadioButton Text",
    isSelected = false,
    isDisabled = false,
    layoutOrder = 0
};
v8.init = function(v9)
    v9.onSetValue = function()
        if not v9.props.isDisabled then
            v9.props.onActivated(v9.props.id);
        end;
    end;
end;
v8.render = function(v10)
    return v4(function(v11)
        local l_Theme_0 = v11.Theme;
        local v13 = v5["component_assets/circle_24_stroke_1"];
        local l_Color_0 = l_Theme_0.TextDefault.Color;
        local v15 = v5["component_assets/circle_16"];
        local l_Color_1 = l_Theme_0.TextDefault.Color;
        local v17 = nil;
        local l_isSelected_0 = v10.props.isSelected;
        local l_Color_2 = l_Theme_0.TextDefault.Color;
        local l_Transparency_0 = l_Theme_0.TextDefault.Transparency;
        if v10.props.isDisabled then
            l_Transparency_0 = 0.5;
        end;
        if not l_isSelected_0 then
            v17 = UDim2.new(0, 0, 0, 0);
        else
            v17 = UDim2.new(0, 18, 0, 18);
            l_Color_1 = l_Theme_0.SystemPrimaryDefault.Color;
            l_Color_0 = l_Theme_0.SystemPrimaryDefault.Color;
        end;
        return v1.createElement(v7.Focusable[v6], {
            text = v10.props.text,
            onActivated = v10.onSetValue,
            size = v10.props.size,
            image = v13,
            imageColor = l_Color_0,
            fillImage = v15,
            fillImageSize = v17,
            fillImageColor = l_Color_1,
            selectedColor = l_Theme_0.SystemPrimaryDefault.Color,
            textColor = l_Color_2,
            transparency = l_Transparency_0,
            layoutOrder = v10.props.layoutOrder,
            isDisabled = v10.props.isDisabled,
            [v1.Ref] = v10.props.forwardRef,
            NextSelectionUp = v10.props.NextSelectionUp,
            NextSelectionDown = v10.props.NextSelectionDown,
            NextSelectionLeft = v10.props.NextSelectionLeft,
            NextSelectionRight = v10.props.NextSelectionRight,
            SelectionImageObject = v10.props.SelectionImageObject
        });
    end);
end;
return v1.forwardRef(function(v21, v22)
    return v1.createElement(v8, v3.Dictionary.join(v21, {
        forwardRef = v22
    }));
end);


local l_Parent_0 = script.Parent.Parent.Parent.Parent;
local l_UIBlox_0 = l_Parent_0.UIBlox;
local v2 = require(l_Parent_0.Roact);
local v3 = require(l_Parent_0.RoactGamepad);
local v4 = require(l_Parent_0.t);
local v5 = require(script.Parent.RadioButton);
local v6 = require(l_Parent_0.Cryo);
local v7 = require(l_UIBlox_0.App.SelectionImage.withSelectionCursorProvider);
local v8 = require(l_UIBlox_0.App.SelectionImage.CursorKind);
local v9 = require(l_UIBlox_0.App.SelectionCursor.withCursor);
local v10 = require(l_UIBlox_0.App.SelectionCursor.CursorType);
local v11 = require(l_UIBlox_0.UIBloxConfig);
local v12 = v2.PureComponent:extend("RadioButtonList");
v12.validateProps = v4.strictInterface({
    radioButtons = v4.array(v4.union(v4.string, (v4.strictInterface({
        label = v4.string,
        isDisabled = v4.optional(v4.boolean)
    })))),
    onActivated = v4.callback,
    elementSize = v4.UDim2,
    initialValue = v4.optional(v4.number),
    currentValue = v4.optional(v4.number),
    layoutOrder = v4.optional(v4.number),
    padding = v4.optional(v4.UDim),
    automaticSize = v4.optional(v4.boolean),
    NextSelectionLeft = v4.optional(v4.table),
    NextSelectionRight = v4.optional(v4.table),
    NextSelectionUp = v4.optional(v4.table),
    NextSelectionDown = v4.optional(v4.table),
    forwardRef = v4.optional(v4.table)
});
v12.init = function(v13)
    v13.state = {
        currentValue = v13.props.initialValue or 0
    };
    local v14 = {};
    for v15, v16 in ipairs(v13.props.radioButtons) do
        v14[v15] = type(v16) == "table" and (v16.isDisabled or false);
    end;
    v13.state.disabledIndices = v14;
    v13.doLogic = function(v17)
        if not v13.state.disabledIndices[v17] then
            v13:setState({
                currentValue = v17
            });
            v13.props.onActivated(v17);
            return ;
        else
            return ;
        end;
    end;
    v13.gamepadRefs = v3.createRefCache();
end;
v12.renderWithProviders = function(v18, v19, v20)
    local v21 = {
        layout = v2.createElement("UIListLayout", {
            SortOrder = Enum.SortOrder.LayoutOrder,
            Padding = v18.props.padding
        })
    };
    for v22, v23 in ipairs(v18.props.radioButtons) do
        v21["RadioButton" .. v22] = v2.createElement(v3.Focusable[v5], {
            text = type(v23) == "table" and v23.label or v23,
            isSelected = if v18.props.currentValue ~= nil then v22 == v18.props.currentValue else v22 == v18.state.currentValue,
            isDisabled = v18.state.disabledIndices[v22],
            onActivated = v18.doLogic,
            size = v18.props.elementSize,
            layoutOrder = v22,
            id = v22,
            [v2.Ref] = v18.gamepadRefs[v22],
            NextSelectionUp = v22 > 1 and v18.gamepadRefs[v22 - 1] or nil,
            NextSelectionDown = v22 < #v18.props.radioButtons and v18.gamepadRefs[v22 + 1] or nil,
            SelectionImageObject = if not v11.migrateToNewSelectionCursor then v19(v8.RoundedRect) else v20,
            inputBindings = {
                OnActivatedButton = v3.Input.onBegin(Enum.KeyCode.ButtonA, function()
                    v18.doLogic(v22);
                end)
            }
        });
    end;
    return v2.createElement(v3.Focusable.Frame, {
        Size = if not v18.props.automaticSize then UDim2.fromScale(1, 1) else UDim2.fromScale(1, 0),
        AutomaticSize = if not v18.props.automaticSize then nil else Enum.AutomaticSize.Y,
        BackgroundTransparency = 1,
        LayoutOrder = v18.props.layoutOrder,
        NextSelectionLeft = v18.props.NextSelectionLeft,
        NextSelectionRight = v18.props.NextSelectionRight,
        NextSelectionDown = v18.props.NextSelectionDown,
        NextSelectionUp = v18.props.NextSelectionUp,
        [v2.Ref] = v18.props.forwardRef
    }, v21);
end;
v12.render = function(v24)
    return v7(function(v25)
        if not v11.migrateToNewSelectionCursor then
            return v24:renderWithProviders(v25);
        else
            return v9(function(v26)
                return v24:renderWithProviders(v25, (v26.getCursorByType(v10.RoundedRect)));
            end);
        end;
    end);
end;
return v2.forwardRef(function(v27, v28)
    return v2.createElement(v12, v6.Dictionary.join(v27, {
        forwardRef = v28
    }));
end);


local l_Parent_0 = script.Parent.Parent.Parent.Parent;
local v1 = require(l_Parent_0.Otter);
local v2 = require(l_Parent_0.Roact);
local v3 = require(l_Parent_0.t);
local v4 = require(l_Parent_0.UIBlox.Core.Style.withStyle);
local v5 = require(l_Parent_0.UIBlox.App.ImageSet.Images);
local v6 = require(l_Parent_0.UIBlox.Core.Control.Controllable);
local v7 = require(l_Parent_0.UIBlox.Core.Control.Enum.ControlState);
local v8 = require(l_Parent_0.UIBlox.Core.ImageSet.ImageSetComponent);
local v9 = require(l_Parent_0.UIBlox.Utility.divideTransparency);
local v10 = require(l_Parent_0.UIBlox.Utility.lerp);
local v11 = {
    frequency = 4
};
local v12 = UDim2.new(0, -4, 0.5, 0);
local v13 = UDim2.new(0, 20, 0.5, 0);
local v14 = Rect.new(18, 18, 18, 18);
local v15 = Rect.new(18, 18, 18, 18);
local v16 = v2.PureComponent:extend("Toggle");
v16.validateProps = v3.strictInterface({
    isSelected = v3.optional(v3.boolean),
    isDisabled = v3.optional(v3.boolean),
    onActivated = v3.callback,
    layoutOrder = v3.optional(v3.integer),
    anchorPoint = v3.optional(v3.Vector2),
    position = v3.optional(v3.UDim2)
});
v16.init = function(v17)
    local v18 = not v17.props.isSelected and 0 or 1;
    v17.state = {
        progress = v18
    };
    v17.progressMotor = v1.createSingleMotor(v18);
    v17.progressMotor:onStep(function(v19)
        v17:setState({
            progress = v19
        });
    end);
    v17.setControlState = function(_, v21)
        v17:setState({
            controlState = v21
        });
    end;
end;
v16.render = function(v22)
    return v4(function(v23)
        local l_Theme_0 = v23.Theme;
        local l_controlState_0 = v22.state.controlState;
        local l_progress_0 = v22.state.progress;
        local v27 = l_controlState_0 == v7.Disabled and 2 or 1;
        local v28 = if l_controlState_0 == v7.Hover then l_Theme_0.SecondaryOnHover else l_Theme_0.SecondaryDefault;
        local l_Color_0 = v28.Color;
        local v30 = v9(v28.Transparency, v27);
        local v31 = v9(l_Theme_0.ContextualPrimaryDefault.Transparency, v27);
        local v32 = v10(v30, 1, l_progress_0);
        local v33 = v10(1, v31, l_progress_0);
        local v34 = v12:lerp(v13, l_progress_0);
        return v2.createElement(v6, {
            controlComponent = {
                component = "ImageButton",
                props = {
                    BackgroundTransparency = 1,
                    Image = "",
                    Size = UDim2.fromOffset(60, 44),
                    Position = v22.props.position,
                    LayoutOrder = v22.props.layoutOrder,
                    AnchorPoint = v22.props.anchorPoint,
                    [v2.Event.Activated] = not v22.props.isDisabled and v22.props.onActivated
                },
                children = {
                    Track = v2.createElement(v8.Label, {
                        Size = UDim2.fromOffset(60, 36),
                        BackgroundTransparency = 1,
                        Image = v5["component_assets/circle_36_stroke_1"],
                        ScaleType = Enum.ScaleType.Slice,
                        SliceCenter = v14,
                        ImageTransparency = v32,
                        ImageColor3 = l_Color_0,
                        Position = UDim2.fromScale(0.5, 0.5),
                        AnchorPoint = Vector2.new(0.5, 0.5)
                    }),
                    Fill = v2.createElement(v8.Label, {
                        Size = UDim2.fromOffset(60, 36),
                        BackgroundTransparency = 1,
                        Image = v5["component_assets/circle_36"],
                        ScaleType = Enum.ScaleType.Slice,
                        SliceCenter = v15,
                        ImageColor3 = l_Theme_0.ContextualPrimaryDefault.Color,
                        ImageTransparency = v33,
                        Position = UDim2.fromScale(0.5, 0.5),
                        AnchorPoint = Vector2.new(0.5, 0.5),
                        ZIndex = 2
                    }),
                    Knob = v2.createElement(v8.Label, {
                        Size = UDim2.fromOffset(44, 44),
                        BackgroundTransparency = 1,
                        Image = v5["component_assets/circle_28_padding_10"],
                        ImageTransparency = v31,
                        Position = v34,
                        AnchorPoint = Vector2.new(0, 0.5),
                        ZIndex = 4
                    }),
                    KnobShadow = v2.createElement(v8.Label, {
                        Size = UDim2.fromOffset(44, 44),
                        BackgroundTransparency = 1,
                        Image = v5["component_assets/dropshadow_28"],
                        ImageTransparency = v31,
                        Position = v34,
                        AnchorPoint = Vector2.new(0, 0.5),
                        ZIndex = 3
                    })
                }
            },
            isDisabled = v22.props.isDisabled,
            onStateChanged = v22.setControlState
        });
    end);
end;
v16.didMount = function(v35)
    v35.progressMotor:start();
end;
v16.didUpdate = function(v36, v37, _)
    if v37.isSelected ~= v36.props.isSelected then
        v36.progressMotor:setGoal(v1.spring(not v36.props.isSelected and 0 or 1, v11));
    end;
end;
v16.willUnmount = function(v39)
    v39.progressMotor:destroy();
end;
return v16;


return require(script.Parent.Parent.Parent.Parent.Parent.enumerate)("debugProps", {
    "forceLoading",
    "forceFailed"
});


return require(script.Parent.Parent.Parent.Parent.Parent.enumerate)("LoadingStrategy", {
    "Eager",
    "Default"
});


return require(script.Parent.Parent.Parent.Parent.Parent.enumerate)("RenderOnFailedStyle", {
    "EmptyStatePage",
    "RetryButton"
});


return require(script.Parent.Parent.Parent.Parent.Parent.enumerate)("RetrievalStatus", {
    "NotStarted",
    "Fetching",
    "Done",
    "Failed"
});


local v0 = nil;
pcall(function()
    v0 = game:GetService("RbxAnalyticsService");
end);
local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent.Parent;
local l_Parent_2 = l_Parent_1.Parent;
local l_Core_0 = l_Parent_1.Core;
local v5 = require(l_Parent_2.Roact);
local v6 = require(l_Parent_2.t);
local v7 = require(l_Parent_2.Cryo);
local v8 = require(l_Parent_0.ShimmerPanel);
local v9 = require(l_Parent_0.Enum.DebugProps);
local v10 = require(l_Parent_0.Enum.LoadingStrategy);
local v11 = require(l_Parent_1.Core.Style.withStyle);
local v12 = require(l_Parent_1.App.ImageSet.Images);
local v13 = require(l_Parent_1.Core.ImageSet.ImageSetComponent);
local v14 = require(l_Core_0.ImageSet.Validator.validateImageSetData);
local v15 = require(l_Parent_1.App.Context.ContentProvider);
local v16 = v5.PureComponent:extend("LoadableImage");
v16.validateProps = v6.strictInterface({
    AnchorPoint = v6.optional(v6.Vector2),
    BackgroundColor3 = v6.optional(v6.Color3),
    BackgroundTransparency = v6.optional(v6.number),
    cornerRadius = v6.optional(v6.UDim),
    Image = v6.optional(v6.union(v6.string, v14)),
    ImageColor3 = v6.optional(v6.Color3),
    ImageTransparency = v6.optional(v6.number),
    ImageRectOffset = v6.optional(v6.union(v6.Vector2, v6.table)),
    ImageRectSize = v6.optional(v6.union(v6.Vector2, v6.table)),
    LayoutOrder = v6.optional(v6.integer),
    loadingImage = v6.optional(v6.union(v6.string, v6.table)),
    loadingStrategy = v6.optional(v10.isEnumValue),
    loadingTimeout = v6.optional(v6.numberPositive),
    renderOnLoading = v6.optional(v6.callback),
    renderOnFailed = v6.optional(v6.callback),
    MaxSize = v6.optional(v6.Vector2),
    MinSize = v6.optional(v6.Vector2),
    onLoaded = v6.optional(v6.callback),
    Position = v6.optional(v6.UDim2),
    ScaleType = v6.optional(v6.enum(Enum.ScaleType)),
    Size = v6.UDim2,
    useShimmerAnimationWhileLoading = v6.optional(v6.boolean),
    showFailedStateWhenLoadingFailed = v6.optional(v6.boolean),
    ZIndex = v6.optional(v6.integer),
    shouldHandleReloads = v6.optional(v6.boolean),
    contentProvider = v6.union(v6.instanceOf("ContentProvider"), v6.table),
    [v9.forceLoading] = v6.optional(v6.boolean),
    [v9.forceFailed] = v6.optional(v6.boolean)
});
v16.defaultProps = {
    BackgroundTransparency = 0,
    cornerRadius = UDim.new(0, 0),
    MaxSize = Vector2.new(math.huge, math.huge),
    MinSize = Vector2.new(0, 0),
    useShimmerAnimationWhileLoading = false,
    showFailedStateWhenLoadingFailed = false,
    loadingStrategy = v10.Default,
    loadingTimeout = 30,
    shouldHandleReloads = false
};
v16.init = function(v17)
    v17.currentImageLoadIndex = 0;
    v17:setState({
        eagerRetrying = false
    });
    v17.imageRef = v5.createRef();
    v17._isMounted = false;
end;
v16.renderShimmer = function(v18, v19, v20)
    return v5.createElement("Frame", {
        AnchorPoint = v18.props.AnchorPoint,
        BorderSizePixel = 0,
        BackgroundColor3 = v19.PlaceHolder.Color,
        BackgroundTransparency = v19.PlaceHolder.Transparency,
        LayoutOrder = v18.props.LayoutOrder,
        Position = v18.props.Position,
        Size = v18.props.Size,
        ZIndex = v18.props.ZIndex
    }, {
        Shimmer = v5.createElement(v8, {
            Size = UDim2.new(1, 0, 1, 0),
            cornerRadius = v18.props.cornerRadius
        }),
        UISizeConstraint = v20,
        UICorner = v5.createElement("UICorner", {
            CornerRadius = v18.props.cornerRadius
        }) or nil
    });
end;
v16.defaultRenderOnFail = function(v21, v22, v23)
    local l_cornerRadius_0 = v21.props.cornerRadius;
    local v25 = v12["icons/status/imageunavailable"];
    local v26 = v25.ImageRectSize / v12.ImagesResolutionScale;
    return v5.createElement("Frame", {
        AnchorPoint = v21.props.AnchorPoint,
        BorderSizePixel = 0,
        BackgroundColor3 = v22.PlaceHolder.Color,
        BackgroundTransparency = v22.PlaceHolder.Transparency,
        LayoutOrder = v21.props.LayoutOrder,
        Position = v21.props.Position,
        Size = v21.props.Size,
        ZIndex = v21.props.ZIndex
    }, {
        EmptyIcon = v5.createElement(v13.Label, {
            BackgroundTransparency = 1,
            AnchorPoint = Vector2.new(0.5, 0.5),
            Image = v25,
            ImageColor3 = v22.UIDefault.Color,
            ImageTransparency = v22.UIDefault.Transparency,
            Position = UDim2.new(0.5, 0, 0.5, 0),
            Size = UDim2.new(0, v26.X, 0, v26.Y)
        }, {
            UICorner = l_cornerRadius_0 ~= UDim.new(0, 0) and v5.createElement("UICorner", {
                CornerRadius = l_cornerRadius_0
            }) or nil
        }),
        UISizeConstraint = v23,
        UICorner = l_cornerRadius_0 ~= UDim.new(0, 0) and v5.createElement("UICorner", {
            CornerRadius = l_cornerRadius_0
        }) or nil
    });
end;
v16.isImageNonNil = function(v27)
    local v28 = false;
    if v27.props.Image ~= v5.None then
        v28 = v27.props.Image ~= nil;
    end;
    return v28;
end;
v16.getCurrentImageAssetFetchStatus = function(v29, v30)
    local v31 = v30[v29:getAssetFetchStatusStateKey(v29.currentImageLoadIndex)];
    if v31 == nil then
        v31 = Enum.AssetFetchStatus.None;
    end;
    return v31;
end;
v16.isLoadingComplete = function(v32, v33)
    local v34 = v32:getCurrentImageAssetFetchStatus(v33);
    if not (v34 ~= Enum.AssetFetchStatus.None) or v34 == Enum.AssetFetchStatus.Loading then
        return false;
    elseif not (not (v34 ~= Enum.AssetFetchStatus.Failure) or v34 == Enum.AssetFetchStatus.TimedOut) or not v33.eagerRetrying then
        return true;
    else
        return false;
    end;
end;
v16.render = function(v35)
    local l_AnchorPoint_0 = v35.props.AnchorPoint;
    local l_LayoutOrder_0 = v35.props.LayoutOrder;
    local l_Size_0 = v35.props.Size;
    local l_Position_0 = v35.props.Position;
    local l_BackgroundColor3_0 = v35.props.BackgroundColor3;
    local l_BackgroundTransparency_0 = v35.props.BackgroundTransparency;
    local l_cornerRadius_1 = v35.props.cornerRadius;
    local l_ScaleType_0 = v35.props.ScaleType;
    local l_ZIndex_0 = v35.props.ZIndex;
    local l_Image_0 = v35.props.Image;
    local l_ImageTransparency_0 = v35.props.ImageTransparency;
    local l_ImageRectOffset_0 = v35.props.ImageRectOffset;
    local l_ImageRectSize_0 = v35.props.ImageRectSize;
    local l_ImageColor3_0 = v35.props.ImageColor3;
    local l_MaxSize_0 = v35.props.MaxSize;
    local l_MinSize_0 = v35.props.MinSize;
    local l_renderOnLoading_0 = v35.props.renderOnLoading;
    local l_renderOnFailed_0 = v35.props.renderOnFailed;
    local l_loadingImage_0 = v35.props.loadingImage;
    local l_loadingStrategy_0 = v35.props.loadingStrategy;
    local l_useShimmerAnimationWhileLoading_0 = v35.props.useShimmerAnimationWhileLoading;
    local l_showFailedStateWhenLoadingFailed_0 = v35.props.showFailedStateWhenLoadingFailed;
    local v58 = v35:isImageNonNil() and v35:isLoadingComplete(v35.state);
    local v59 = v35:getCurrentImageAssetFetchStatus(v35.state);
    local v60 = v59 ~= Enum.AssetFetchStatus.None;
    local v61 = v59 == Enum.AssetFetchStatus.Failure;
    local v62 = false;
    if v35.props[v9.forceLoading] then
        v58 = false;
    end;
    if v35.props[v9.forceFailed] then
        v61 = true;
    end;
    if not ((l_MaxSize_0.X == math.huge and l_MaxSize_0.Y == math.huge) and l_MinSize_0.X == 0) or l_MinSize_0.Y ~= 0 then
        v62 = true;
    end;
    local v63 = v62 and v5.createElement("UISizeConstraint", {
        MaxSize = l_MaxSize_0,
        MinSize = l_MinSize_0
    });
    return v11(function(v64)
        local l_Theme_0 = v64.Theme;
        if not v61 or not l_renderOnFailed_0 then
            if not v61 or not l_showFailedStateWhenLoadingFailed_0 then
                if not (v58 or not l_renderOnLoading_0) and l_loadingStrategy_0 ~= v10.Default then
                    return l_renderOnLoading_0();
                elseif not (v58 or not l_useShimmerAnimationWhileLoading_0) and l_loadingStrategy_0 ~= v10.Default then
                    return v35:renderShimmer(l_Theme_0, v63);
                else
                    local v66 = v58 or l_loadingStrategy_0 == v10.Default;
                    local v67 = nil;
                    if not (v58 or not l_renderOnLoading_0) and l_loadingStrategy_0 == v10.Default then
                        v67 = l_renderOnLoading_0();
                    end;
                    local v68 = nil;
                    if not (not (not (v58 or not l_useShimmerAnimationWhileLoading_0) and l_loadingStrategy_0 == v10.Default) or not v60) then
                        v68 = v35:renderShimmer(l_Theme_0, v63);
                    end;
                    return v5.createElement(v13.Label, {
                        AnchorPoint = l_AnchorPoint_0,
                        BackgroundColor3 = l_BackgroundColor3_0 or l_Theme_0.PlaceHolder.Color,
                        BackgroundTransparency = l_BackgroundTransparency_0 or l_Theme_0.PlaceHolder.Transparency,
                        BorderSizePixel = 0,
                        Image = not not v66 and l_Image_0 or l_loadingImage_0,
                        ImageTransparency = l_ImageTransparency_0,
                        ImageRectOffset = l_ImageRectOffset_0,
                        ImageRectSize = l_ImageRectSize_0,
                        ImageColor3 = not not v66 and l_ImageColor3_0 or nil,
                        LayoutOrder = l_LayoutOrder_0,
                        Position = l_Position_0,
                        ScaleType = l_ScaleType_0,
                        Size = l_Size_0,
                        ZIndex = l_ZIndex_0,
                        [v5.Ref] = v35.imageRef
                    }, {
                        UISizeConstraint = v63,
                        UICorner = l_cornerRadius_1 ~= UDim.new(0, 0) and v5.createElement("UICorner", {
                            CornerRadius = l_cornerRadius_1
                        }) or nil,
                        OnLoading = v67,
                        Shimmer = v68
                    });
                end;
            else
                return v35:defaultRenderOnFail(l_Theme_0, v63);
            end;
        else
            return l_renderOnFailed_0();
        end;
    end);
end;
v16.maybeCallOnLoaded = function(v69, v70)
    if v69.props.onLoaded then
        local v71 = v69:isLoadingComplete(v70);
        local v72 = v69:isLoadingComplete(v69.state);
        if not (v71 or not v72) then
            v69.props.onLoaded();
        end;
    end;
end;
v16.didUpdate = function(v73, v74, v75)
    if v74.Image ~= v73.props.Image then
        v73:loadImage();
    end;
    v73:maybeCallOnLoaded(v75);
end;
v16.didMount = function(v76)
    v76._isMounted = true;
    v76:loadImage();
end;
v16.willUnmount = function(v77)
    v77._isMounted = false;
    v77:dropConnections();
end;
v16.isTerminalStatus = function(_, v79)
    local v80 = true;
    if v79 ~= Enum.AssetFetchStatus.Success then
        v80 = true;
        if v79 ~= Enum.AssetFetchStatus.Failure then
            v80 = v79 == Enum.AssetFetchStatus.TimedOut;
        end;
    end;
    return v80;
end;
v16.getImageUri = function(v81)
    if not v81.props.Image then
        return nil;
    elseif typeof(v81.props.Image) == "string" then
        return v81.props.Image;
    else
        return v81.props.Image.Image;
    end;
end;
v16.awaitImageLoaded = function(v82, v83, v84)
    if not v82:isTerminalStatus(v84) then
        local v85 = v82:getImageUri();
        local function v87(v86)
            v82:updateAssetFetchStatusForImageLoadIndex(v86, v83, v85);
            v82:maybeReportCounter("Await", v86);
            if not (not v82:isTerminalStatus(v86) or not v82.awaitImageLoadedConnection) then
                v82.awaitImageLoadedConnection:Disconnect();
                v82.awaitImageLoadedConnection = nil;
            end;
        end;
        if v85 == "" then
            local l_Success_0 = Enum.AssetFetchStatus.Success;
            v82:updateAssetFetchStatusForImageLoadIndex(l_Success_0, v83, v85);
            v82:maybeReportCounter("Await", l_Success_0);
            if not (not v82:isTerminalStatus(l_Success_0) or not v82.awaitImageLoadedConnection) then
                v82.awaitImageLoadedConnection:Disconnect();
                v82.awaitImageLoadedConnection = nil;
            end;
            return ;
        else
            v82.awaitImageLoadedConnection = v82.props.contentProvider:GetAssetFetchStatusChangedSignal(v85):Connect(v87);
            return ;
        end;
    else
        return ;
    end;
end;
v16.maybeReportCounter = function(_, v90, v91)
    pcall(function()
        v0:ReportCounter("UIBlox_LoadableImage_" .. v90 .. "_" .. tostring(v91));
    end);
end;
v16.preloadImageWithRetryLogic = function(v92, v93)
    local v94 = v92:getImageUri();
    local v95 = 0;
    local l_None_0 = Enum.AssetFetchStatus.None;
    while true do
        if v92._isMounted then
            if v95 > 0 then
                task.wait(1.5 * math.pow(2, v95 - 1));
            end;
            v92.props.contentProvider:PreloadAsync({
                v94
            }, function(_, v98)
                local v99 = v92:getImageUri();
                if v92._isMounted and v99 == v94 then
                    v92:maybeReportCounter("PreloadAsync", v98);
                    l_None_0 = v98;
                    v92:updateAssetFetchStatusForImageLoadIndex(v98, v93, v94);
                end;
            end);
            local v100 = v92:getImageUri();
            if not v92._isMounted or v100 ~= v94 then
                return ;
            else
                if l_None_0 ~= Enum.AssetFetchStatus.Success then
                    v95 = v95 + 1;
                    if not (l_None_0 == Enum.AssetFetchStatus.Failure and v95 > 3) and (not (l_None_0 == Enum.AssetFetchStatus.TimedOut) or v95 <= 5) then
                        v92:setState({
                            eagerRetrying = true
                        });
                        continue;
                    end;
                end;
                v92:setState({
                    eagerRetrying = false
                });
                return ;
            end;
        else
            return ;
        end;
    end;
end;
v16.getAssetFetchStatusStateKey = function(_, v102)
    return "assetFetchStatus_" .. tostring(v102);
end;
v16.updateAssetFetchStatusForImageLoadIndex = function(v103, v104, v105, _)
    v103:setState({
        [v103:getAssetFetchStatusStateKey(v105)] = v104
    });
end;
v16.dropConnections = function(v107)
    if v107.listenForReloadsConnection then
        v107.listenForReloadsConnection:Disconnect();
        v107.listenForReloadsConnection = nil;
    end;
    if v107.awaitImageLoadedConnection then
        v107.awaitImageLoadedConnection:Disconnect();
        v107.awaitImageLoadedConnection = nil;
    end;
end;
v16.loadImage = function(v108)
    local v109 = v108.currentImageLoadIndex + 1;
    v108.currentImageLoadIndex = v109;
    local v110 = v108:getImageUri();
    local l_loadingStrategy_1 = v108.props.loadingStrategy;
    v108:dropConnections();
    if v110 == nil then
        v108:updateAssetFetchStatusForImageLoadIndex(Enum.AssetFetchStatus.Success, v109, v110);
        v108:setState({
            eagerRetrying = false
        });
        return ;
    else
        local l_AssetFetchStatus_0 = v108.props.contentProvider:GetAssetFetchStatus(v110);
        v108:maybeReportCounter("InitialStatus", l_AssetFetchStatus_0);
        v108:updateAssetFetchStatusForImageLoadIndex(l_AssetFetchStatus_0, v109, v110);
        if v108.props.shouldHandleReloads then
            v108.listenForReloadsConnection = v108.props.contentProvider:GetAssetFetchStatusChangedSignal(v110):Connect(function(v113, _)
                v108:maybeReportCounter("Reloads", v113);
                v108:updateAssetFetchStatusForImageLoadIndex(v113, v109, v110);
            end);
        end;
        if l_loadingStrategy_1 == v10.Eager then
            task.spawn(function()
                v108:preloadImageWithRetryLogic(v109);
            end);
            return ;
        else
            if l_loadingStrategy_1 == v10.Default then
                v108:awaitImageLoaded(v109, l_AssetFetchStatus_0);
            end;
            return ;
        end;
    end;
end;
return function(v115)
    return v5.createElement(v15.Consumer, {
        render = function(v116)
            return v5.createElement(v16, (v7.Dictionary.join(v115, {
                contentProvider = v116
            })));
        end
    });
end;


local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.Roact);
local v3 = require(l_Parent_1.t);
local v4 = require(l_Parent_0.App.ImageSet.Images);
local v5 = require(l_Parent_0.Core.Animation.SpinningImage);
local v6 = v2.PureComponent:extend("LoadingSpinner");
v6.validateProps = v3.strictInterface({
    size = v3.optional(v3.UDim2),
    position = v3.optional(v3.union(v3.UDim2, v3.table)),
    anchorPoint = v3.optional(v3.Vector2),
    rotationRate = v3.optional(v3.number)
});
v6.render = function(v7)
    return v2.createElement(v5, {
        image = v4["icons/graphic/loadingspinner"],
        size = v7.props.size,
        position = v7.props.position,
        anchorPoint = v7.props.anchorPoint,
        rotationRate = v7.props.rotationRate
    });
end;
return v6;


local l_RunService_0 = game:GetService("RunService");
local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v3 = require(l_Parent_1.Roact);
local v4 = require(l_Parent_1.t);
local l_EventConnection_0 = require(l_Parent_1.ReactUtils).EventConnection;
local v6 = require(l_Parent_0.Core.Style.withStyle);
local v7 = require(script.Parent.TextureScroller);
local v8 = require(l_Parent_1.UIBlox.Utility.lerp);
local v9 = v3.PureComponent:extend("ShimmerPanel");
v9.validateProps = v4.strictInterface({
    AnchorPoint = v4.optional(v4.Vector2),
    LayoutOrder = v4.optional(v4.integer),
    Position = v4.optional(v4.UDim2),
    Size = v4.UDim2,
    cornerRadius = v4.optional(v4.UDim),
    Image = v4.optional(v4.string),
    imageDimensions = v4.optional(v4.Vector2),
    imageScale = v4.optional(v4.number),
    shimmerSpeed = v4.optional(v4.number)
});
v9.defaultProps = {
    cornerRadius = UDim.new(0, 0),
    Image = "rbxasset://textures/ui/LuaApp/graphic/shimmer.png",
    imageDimensions = Vector2.new(219, 250),
    imageScale = 2.5,
    shimmerSpeed = 4
};
local function _(v10)
    v10 = math.abs(v10 - 1);
    if v10 > 1 then
        return 1;
    elseif v10 < 0.5 then
        return 4 * math.pow(v10, 3);
    else
        return 1 - math.pow(-2 * v10 + 2, 3) / 2;
    end;
end;
v9.init = function(v12)
    v12.state = {
        lerpValue = 0
    };
    v12.frameRef = v3.createRef();
    v12.lerpValue = 0;
end;
v9.render = function(v13)
    local l_AnchorPoint_0 = v13.props.AnchorPoint;
    local l_LayoutOrder_0 = v13.props.LayoutOrder;
    local l_Position_0 = v13.props.Position;
    local l_cornerRadius_0 = v13.props.cornerRadius;
    local l_Image_0 = v13.props.Image;
    local l_imageDimensions_0 = v13.props.imageDimensions;
    local l_imageScale_0 = v13.props.imageScale;
    local l_shimmerSpeed_0 = v13.props.shimmerSpeed;
    local l_Size_0 = v13.props.Size;
    local v23 = l_imageDimensions_0 / l_imageScale_0;
    local v24 = 0;
    if l_shimmerSpeed_0 ~= 0 then
        v24 = (l_imageScale_0 + 1) / l_shimmerSpeed_0;
    end;
    return v6(function(v25)
        local l_Theme_0 = v25.Theme;
        local l_Settings_0 = v25.Settings;
        local function v33(v28)
            local l_BackgroundOnHover_0 = l_Theme_0.BackgroundOnHover;
            local v30 = v13.lerpValue + v28;
            if v30 > 2.5 then
                v30 = 0;
            end;
            v13.lerpValue = v30;
            if v13.frameRef.current then
                local v31 = math.abs(v13.lerpValue - 1);
                local v32 = v31 > 1 and 1 or if v31 < 0.5 then 4 * math.pow(v31, 3) else 1 - math.pow(-2 * v31 + 2, 3) / 2;
                v13.frameRef.current.BackgroundColor3 = l_BackgroundOnHover_0.Color:Lerp(l_BackgroundOnHover_0.Color, v32);
                v13.frameRef.current.BackgroundTransparency = v8(l_BackgroundOnHover_0.Transparency, l_BackgroundOnHover_0.Transparency - 0.1, v32);
            end;
        end;
        if not l_Settings_0.ReducedMotion then
            return v3.createElement(v7, {
                anchorPoint = l_AnchorPoint_0,
                layoutOrder = l_LayoutOrder_0,
                backgroundColor3 = l_Theme_0.PlaceHolder.Color,
                backgroundTransparency = l_Theme_0.PlaceHolder.Transparency,
                cornerRadius = l_cornerRadius_0,
                image = l_Image_0,
                imageRectSize = v23,
                imageAnchorPoint = Vector2.new(0, 0.5),
                imageTransparency = 0,
                imageRectOffsetStart = Vector2.new(l_imageDimensions_0.X, l_imageDimensions_0.Y / 2),
                imageRectOffsetEnd = Vector2.new(-v23.X, l_imageDimensions_0.Y / 2),
                imageScrollCycleTime = v24,
                position = l_Position_0,
                size = l_Size_0
            });
        else
            return v3.createElement("Frame", {
                AnchorPoint = l_AnchorPoint_0,
                LayoutOrder = l_LayoutOrder_0,
                BorderSizePixel = 0,
                Position = l_Position_0,
                Size = l_Size_0,
                [v3.Ref] = v13.frameRef
            }, {
                UICorner = l_cornerRadius_0 ~= UDim.new(0, 0) and v3.createElement("UICorner", {
                    CornerRadius = l_cornerRadius_0
                }) or nil,
                renderStepped = v3.createElement(l_EventConnection_0, {
                    callback = v33,
                    event = l_RunService_0.renderStepped
                })
            });
        end;
    end);
end;
return v9;


local l_RunService_0 = game:GetService("RunService");
local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v3 = require(l_Parent_1.Roact);
local v4 = require(l_Parent_1.t);
local l_EventConnection_0 = require(l_Parent_1.ReactUtils).EventConnection;
local v6 = require(l_Parent_0.Core.ImageSet.ImageSetComponent);
local function _(v7)
    return Vector2.new(math.floor(v7.X), (math.floor(v7.Y)));
end;
local v9 = v3.PureComponent:extend("TextureScroller");
v9.validateProps = v4.strictInterface({
    anchorPoint = v4.optional(v4.Vector2),
    layoutOrder = v4.optional(v4.integer),
    backgroundColor3 = v4.optional(v4.Color3),
    backgroundTransparency = v4.optional(v4.number),
    position = v4.optional(v4.UDim2),
    cornerRadius = v4.optional(v4.UDim),
    image = v4.string,
    imageTransparency = v4.optional(v4.number),
    imageAnchorPoint = v4.optional(v4.Vector2),
    imageRectOffsetStart = v4.Vector2,
    imageRectOffsetEnd = v4.Vector2,
    imageScrollCycleTime = v4.optional(v4.number),
    imageRectSize = v4.Vector2,
    size = v4.optional(v4.UDim2)
});
v9.defaultProps = {
    backgroundTransparency = 1,
    cornerRadius = UDim.new(0, 0),
    imageAnchorPoint = Vector2.new(0, 0),
    imageScrollCycleTime = 1
};
v9.init = function(v10)
    v10.lerpValue = 0;
    v10.imageRef = v3.createRef();
    v10.renderSteppedCallback = function(v11)
        local l_imageScrollCycleTime_0 = v10.props.imageScrollCycleTime;
        local l_imageRectOffsetStart_0 = v10.props.imageRectOffsetStart;
        local l_imageRectOffsetEnd_0 = v10.props.imageRectOffsetEnd;
        local l_imageRectSize_0 = v10.props.imageRectSize;
        local l_imageAnchorPoint_0 = v10.props.imageAnchorPoint;
        local v17 = Vector2.new(l_imageRectOffsetStart_0.X - l_imageAnchorPoint_0.X * l_imageRectSize_0.X, l_imageRectOffsetStart_0.Y - l_imageAnchorPoint_0.Y * l_imageRectSize_0.Y);
        local v18 = Vector2.new(l_imageRectOffsetEnd_0.X - l_imageAnchorPoint_0.X * l_imageRectSize_0.X, l_imageRectOffsetEnd_0.Y - l_imageAnchorPoint_0.Y * l_imageRectSize_0.Y);
        local v19 = 0;
        if l_imageScrollCycleTime_0 ~= 0 then
            v19 = v11 / l_imageScrollCycleTime_0;
        end;
        v10.lerpValue = (v10.lerpValue + v19) % 1;
        if v10.imageRef.current then
            local l_current_0 = v10.imageRef.current;
            local v21 = v17:lerp(v18, v10.lerpValue);
            l_current_0.ImageRectOffset = Vector2.new(math.floor(v21.X), (math.floor(v21.Y)));
        end;
    end;
end;
v9.render = function(v22)
    local l_anchorPoint_0 = v22.props.anchorPoint;
    local l_backgroundColor3_0 = v22.props.backgroundColor3;
    local l_backgroundTransparency_0 = v22.props.backgroundTransparency;
    local l_cornerRadius_0 = v22.props.cornerRadius;
    local l_image_0 = v22.props.image;
    local l_imageRectSize_1 = v22.props.imageRectSize;
    return v3.createElement("Frame", {
        AnchorPoint = l_anchorPoint_0,
        BackgroundColor3 = l_backgroundColor3_0,
        BackgroundTransparency = l_backgroundTransparency_0,
        BorderSizePixel = 0,
        LayoutOrder = v22.props.layoutOrder,
        Position = v22.props.position,
        Size = v22.props.size
    }, {
        TextureScrollerImage = v3.createElement(v6.Label, {
            BackgroundTransparency = 1,
            Image = l_image_0,
            ImageTransparency = v22.props.imageTransparency,
            Size = UDim2.new(1, 0, 1, 0),
            ScaleType = Enum.ScaleType.Slice,
            SliceCenter = Rect.new(0, 0, l_imageRectSize_1.X, l_imageRectSize_1.Y),
            [v3.Ref] = v22.imageRef,
            ImageRectSize = l_imageRectSize_1
        }, {
            UICorner = l_cornerRadius_0 ~= UDim.new(0, 0) and v3.createElement("UICorner", {
                CornerRadius = l_cornerRadius_0
            }) or nil
        }),
        renderStepped = v3.createElement(l_EventConnection_0, {
            callback = v22.renderSteppedCallback,
            event = l_RunService_0.renderStepped
        }),
        UICorner = l_cornerRadius_0 ~= UDim.new(0, 0) and v3.createElement("UICorner", {
            CornerRadius = l_cornerRadius_0
        }) or nil
    });
end;
return v9;


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_Parent_2 = l_Parent_1.Parent;
local v3 = require(l_Parent_2.RoactGamepad);
local v4 = require(l_Parent_2.Roact);
local v5 = require(l_Parent_2.React);
local v6 = require(l_Parent_2.Cryo);
local v7 = require(l_Parent_2.t);
local v8 = require(l_Parent_1.Core.Style.withStyle);
local v9 = require(l_Parent_1.Core.Style.useStyle);
local v10 = require(l_Parent_1.Core.Style.Validator.validateColorInfo);
local v11 = require(l_Parent_1.Core.ImageSet.ImageSetComponent);
local v12 = require(script.Parent.validateButtonProps);
local v13 = require(l_Parent_0.Container.VerticalScrollView);
local v14 = require(l_Parent_0.ImageSet.Images);
local v15 = require(l_Parent_0.SelectionImage.withSelectionCursorProvider);
local v16 = require(l_Parent_0.SelectionImage.CursorKind);
local v17 = require(l_Parent_0.SelectionCursor.withCursor);
local v18 = require(l_Parent_0.SelectionCursor.CursorType);
local v19 = require(l_Parent_1.Utility.setDefault);
local v20 = require(script.Parent.Cell);
local v21 = require(script.Parent.RoundedFrame);
local v22 = require(script.Parent.StyleDefaults);
local v23 = require(l_Parent_1.UIBloxConfig);
local v24 = v14["component_assets/dropshadow_17_8"];
local v25 = v14["component_assets/circle_17"];
local v26 = v4.PureComponent:extend("BaseMenu");
v26.validateProps = v7.strictInterface({
    buttonProps = v12,
    width = v7.optional(v7.UDim),
    position = v7.optional(v7.union(v7.UDim2, v7.table)),
    anchorPoint = v7.optional(v7.Vector2),
    layoutOrder = v7.optional(v7.number),
    topElementRounded = v7.optional(v7.boolean),
    bottomElementRounded = v7.optional(v7.boolean),
    setFirstItemRef = v7.optional(v7.union(v7.callback, v7.table)),
    setFrameRef = v7.optional(v7.union(v7.callback, v7.table)),
    stayOnActivated = v7.optional(v7.boolean),
    maxHeight = v7.optional(v7.number),
    showDropShadow = v7.optional(v7.boolean),
    fixedListHeight = v7.optional(v7.number),
    isElementBackgroundVisible = v7.optional(v7.boolean),
    isElementDividerVisible = v7.optional(v7.boolean),
    elementHeight = v7.optional(v7.number),
    borderCornerRadius = v7.optional(v7.integer),
    background = v7.optional(v10),
    enableTokenOverride = v7.optional(v7.boolean),
    renderHeader = v7.optional(v7.callback),
    headerHeight = v7.optional(v7.number),
    selectionOrder = v7.optional(v7.number)
});
v26.defaultProps = {
    width = UDim.new(1, 0),
    position = UDim2.new(0, 0, 0, 0),
    topElementRounded = true,
    bottomElementRounded = true,
    showDropShadow = false,
    fixedListHeight = nil,
    isElementBackgroundVisible = true,
    isElementDividerVisible = true,
    elementHeight = 56,
    borderCornerRadius = 4,
    enableTokenOverride = true,
    headerHeight = 0
};
v26.init = function(v27)
    v27.gamepadRefs = v3.createRefCache();
end;
v26.renderFixedHeightMenu = function(_, v29, v30, v31)
    local l_fixedListHeight_0 = v29.fixedListHeight;
    local v33 = v19(v29.borderCornerRadius, 8);
    local l_BackgroundUIDefault_0 = v30.Theme.BackgroundUIDefault;
    local v35 = v19(v29.background, {
        Color = l_BackgroundUIDefault_0.Color,
        Transparency = l_BackgroundUIDefault_0.Transparency
    });
    return v4.createElement("Frame", {
        AnchorPoint = v29.anchorPoint,
        BackgroundTransparency = 1,
        LayoutOrder = v29.layoutOrder,
        Size = UDim2.new(v29.width.Scale, v29.width.Offset, 0, l_fixedListHeight_0),
        Position = v29.position
    }, {
        DropShadow = not not v29.showDropShadow and v4.createElement(v11.Label, {
            ZIndex = 2,
            Position = UDim2.new(0.5, 0, 0.5, 0),
            AnchorPoint = Vector2.new(0.5, 0.5),
            BackgroundTransparency = 1,
            Size = UDim2.new(1, 16, 1, 16),
            Image = v24,
            ImageColor3 = v30.Theme.DropShadow.Color,
            ImageTransparency = v30.Theme.DropShadow.Transparency,
            ScaleType = Enum.ScaleType.Slice,
            SliceCenter = Rect.new(16, 16, 16, 16)
        }) or nil,
        ContentFrame = v4.createElement("Frame", {
            AnchorPoint = Vector2.new(0.5, 0.5),
            Size = UDim2.new(1, 0, 1, 0),
            Position = UDim2.new(0.5, 0, 0.5, 0),
            BackgroundColor3 = v35.Color,
            BackgroundTransparency = v35.Transparency,
            ZIndex = 3
        }, {
            UICorner = v4.createElement("UICorner", {
                CornerRadius = UDim.new(0, v33)
            }),
            ClippingFrame = v4.createElement("Frame", {
                ZIndex = 4,
                BackgroundTransparency = 1,
                Size = UDim2.new(1, 0, 1, -v33 * 2),
                Position = UDim2.new(0, 0, 0.5, 0),
                AnchorPoint = Vector2.new(0, 0.5),
                ClipsDescendants = true
            }, {
                ScrollingFrame = v4.createElement(v13, {
                    canvasSizeY = UDim.new(0, #v29.buttonProps * v29.elementHeight),
                    selectable = if not v23.fixFixedHeightMenuFrameSelectable then nil else false
                }, v31)
            })
        })
    });
end;
v26.render = function(v36)
    local l_headerHeight_0 = v36.props.headerHeight;
    local v38 = v36.props.elementHeight * 7.5 + l_headerHeight_0;
    local v39 = #v36.props.buttonProps * v36.props.elementHeight + l_headerHeight_0;
    local v40 = false;
    if v38 <= v39 then
        v39 = v38;
        v40 = true;
    end;
    local l_maxHeight_0 = v36.props.maxHeight;
    if (l_maxHeight_0 and l_maxHeight_0 > 0) and l_maxHeight_0 < v39 then
        v39 = (math.max(math.floor(((l_maxHeight_0 - v36.props.elementHeight * 0.5) - l_headerHeight_0) / v36.props.elementHeight), 1) + 0.5) * v36.props.elementHeight + l_headerHeight_0;
        v40 = true;
    end;
    local v42 = {};
    for v43, v44 in ipairs(v36.props.buttonProps) do
        local l_join_0 = v6.Dictionary.join;
        local l_v44_0 = v44;
        local v47 = {
            elementHeight = v36.props.elementHeight
        };
        local l_topElementRounded_0 = v36.props.topElementRounded;
        if l_topElementRounded_0 then
            l_topElementRounded_0 = false;
            if v43 == 1 then
                l_topElementRounded_0 = not v40;
            end;
        end;
        v47.hasRoundTop = l_topElementRounded_0;
        l_topElementRounded_0 = v36.props.bottomElementRounded;
        if l_topElementRounded_0 then
            l_topElementRounded_0 = false;
            if v43 == #v36.props.buttonProps then
                l_topElementRounded_0 = not v40;
            end;
        end;
        v47.hasRoundBottom = l_topElementRounded_0;
        v47.hasDivider = not not v36.props.isElementDividerVisible and v43 < #v36.props.buttonProps;
        v47.layoutOrder = v43;
        v47.inputBindingKey = v6.None;
        v47.setButtonRef = v43 == 1 and v36.props.setFirstItemRef or nil;
        v47.isElementBackgroundVisible = v36.props.isElementBackgroundVisible;
        v47.borderCornerRadius = v36.props.borderCornerRadius;
        v47.background = v36.props.background;
        l_join_0 = l_join_0(l_v44_0, v47);
        do
            local l_l_join_0_0 = l_join_0;
            if not v23.migrateToNewSelectionCursor then
                l_v44_0 = nil;
                l_v44_0 = if not not l_l_join_0_0.hasRoundBottom and l_l_join_0_0.hasRoundTop then v16.RoundedRectNoInset else if l_l_join_0_0.hasRoundBottom then v16.BulletDown else if l_l_join_0_0.hasRoundTop then v16.BulletUp else v16.Square;
                l_l_join_0_0 = v6.Dictionary.join(l_l_join_0_0, {
                    cursorKind = l_v44_0,
                    selectionOrder = v36.props.selectionOrder
                });
                do
                    local l_l_v44_0_0 = l_v44_0;
                    v42["cell " .. v43] = v15(function(v51)
                        return v4.createElement(v3.Focusable.Frame, {
                            Size = UDim2.new(v36.props.width, UDim.new(0, v36.props.elementHeight)),
                            BackgroundTransparency = 1,
                            LayoutOrder = v43,
                            [v4.Ref] = v36.gamepadRefs[v43],
                            NextSelectionUp = v43 > 1 and v36.gamepadRefs[v43 - 1] or nil,
                            NextSelectionDown = v43 < #v36.props.buttonProps and v36.gamepadRefs[v43 + 1] or nil,
                            inputBindings = {
                                Activated = v3.Input.onBegin(Enum.KeyCode.ButtonA, v44.onActivated, {
                                    key = v44.inputBindingKey
                                })
                            },
                            SelectionImageObject = v51(l_l_v44_0_0)
                        }, {
                            Cell = v4.createElement(v20, l_l_join_0_0)
                        });
                    end);
                end;
            else
                l_v44_0 = nil;
                l_v44_0 = if not not l_l_join_0_0.hasRoundBottom and l_l_join_0_0.hasRoundTop then v18.RoundedRectNoInset else if l_l_join_0_0.hasRoundBottom then v18.BulletDown else if l_l_join_0_0.hasRoundTop then v18.BulletUp else v18.Square;
                do
                    local l_l_v44_0_1 = l_v44_0;
                    v42["cell " .. v43] = v17(function(v53)
                        local v54 = v53.getCursorByType(l_l_v44_0_1);
                        l_l_join_0_0 = v6.Dictionary.join(l_l_join_0_0, {
                            selectionCursor = v54,
                            selectionOrder = v36.props.selectionOrder
                        });
                        return v4.createElement(v3.Focusable.Frame, {
                            Size = UDim2.new(v36.props.width, UDim.new(0, v36.props.elementHeight)),
                            BackgroundTransparency = 1,
                            LayoutOrder = v43,
                            [v4.Ref] = v36.gamepadRefs[v43],
                            NextSelectionUp = v43 > 1 and v36.gamepadRefs[v43 - 1] or nil,
                            NextSelectionDown = v43 < #v36.props.buttonProps and v36.gamepadRefs[v43 + 1] or nil,
                            inputBindings = {
                                Activated = v3.Input.onBegin(Enum.KeyCode.ButtonA, v44.onActivated, {
                                    key = v44.inputBindingKey
                                })
                            },
                            SelectionImageObject = v54
                        }, {
                            Cell = v4.createElement(v20, l_l_join_0_0)
                        });
                    end);
                end;
            end;
        end;
    end;
    v42.layout = v4.createElement("UIListLayout", {
        HorizontalAlignment = Enum.HorizontalAlignment.Center,
        FillDirection = Enum.FillDirection.Vertical,
        SortOrder = Enum.SortOrder.LayoutOrder
    });
    return v8(function(v55)
        local l_Theme_0 = v55.Theme;
        local l_BackgroundUIDefault_1 = l_Theme_0.BackgroundUIDefault;
        local v58 = v19(v36.props.background, {
            Color = l_BackgroundUIDefault_1.Color,
            Transparency = l_BackgroundUIDefault_1.Transparency
        });
        local l_ImageRectSize_0 = v25.ImageRectSize;
        local l_ImageRectOffset_0 = v25.ImageRectOffset;
        local l_X_0 = l_ImageRectSize_0.X;
        local v62 = l_X_0 / 2;
        local l_isElementBackgroundVisible_0 = v36.props.isElementBackgroundVisible;
        local v64 = (v40 and v36.props.topElementRounded) and l_isElementBackgroundVisible_0;
        local v65 = (v40 and v36.props.bottomElementRounded) and l_isElementBackgroundVisible_0;
        local v66 = (not v64 and 0 or 1) + (not v65 and 0 or 1);
        local l_renderHeader_0 = v36.props.renderHeader;
        local v68 = (not not v23.enableNewMenuLayout and not v64) and (l_renderHeader_0 and true or false);
        if not v36.props.fixedListHeight then
            return v4.createElement("Frame", {
                AnchorPoint = v36.props.anchorPoint,
                BackgroundTransparency = 1,
                LayoutOrder = v36.props.layoutOrder,
                Size = UDim2.new(v36.props.width.Scale, v36.props.width.Offset, 0, v39),
                Position = v36.props.position
            }, {
                DropShadow = not not v36.props.showDropShadow and v4.createElement(v11.Label, {
                    ZIndex = 2,
                    Position = UDim2.new(0.5, 0, 0.5, 0),
                    AnchorPoint = Vector2.new(0.5, 0.5),
                    BackgroundTransparency = 1,
                    Size = UDim2.new(1, 16, 1, 16),
                    Image = v24,
                    ImageColor3 = v55.Theme.DropShadow.Color,
                    ImageTransparency = v55.Theme.DropShadow.Transparency,
                    ScaleType = Enum.ScaleType.Slice,
                    SliceCenter = Rect.new(16, 16, 16, 16)
                }) or nil,
                Background = if not not v23.enableNewMenuLayout and (v64 or v65) then v4.createElement(v21, {
                    zIndex = -1,
                    background = v58,
                    topCornerRadius = if not v64 then nil else UDim.new(0, v36.props.borderCornerRadius),
                    bottomCornerRadius = if not v65 then nil else UDim.new(0, v36.props.borderCornerRadius)
                }) else nil,
                TopRoundedCorner = if not v64 or v23.enableNewMenuLayout then nil else v4.createElement("ImageLabel", {
                    ZIndex = 3,
                    BackgroundTransparency = 1,
                    Size = UDim2.new(1, 0, 0, v36.props.borderCornerRadius),
                    Position = UDim2.fromScale(0, 0),
                    Image = v25.Image,
                    ScaleType = Enum.ScaleType.Slice,
                    SliceScale = 0.5 / v14.ImagesResolutionScale,
                    SliceCenter = Rect.new(v62 - 1, v62 - 1, v62 + 1, v62),
                    ImageRectSize = Vector2.new(l_X_0, v62),
                    ImageRectOffset = l_ImageRectOffset_0,
                    ImageTransparency = v58.Transparency,
                    ImageColor3 = v58.Color
                }),
                ClippingFrame = v4.createElement("Frame", {
                    ZIndex = 3,
                    BackgroundTransparency = 1,
                    Size = UDim2.new(1, 0, 1, -(v36.props.borderCornerRadius * v66)),
                    Position = UDim2.fromScale(0, not v64 and 0 or 0.5),
                    AnchorPoint = Vector2.new(0, not v64 and 0 or 0.5),
                    ClipsDescendants = true
                }, {
                    HeaderFrame = if not v68 then nil else v4.createElement("Frame", {
                        Selectable = false,
                        Size = UDim2.new(1, 0, 0, l_headerHeight_0),
                        Position = UDim2.fromOffset(0, 0),
                        AnchorPoint = Vector2.new(0, 0),
                        BackgroundTransparency = 1,
                        BorderSizePixel = 0
                    }, {
                        Header = l_renderHeader_0()
                    }),
                    ScrollingFrame = v4.createElement("ScrollingFrame", {
                        [v4.Ref] = v36.props.setFrameRef,
                        Selectable = false,
                        BackgroundTransparency = 1,
                        Size = UDim2.new(1, not v64 and 0 or -4, 1, not v68 and 0 or -l_headerHeight_0),
                        Position = if not v68 then nil else UDim2.fromOffset(0, l_headerHeight_0),
                        BorderSizePixel = 0,
                        ScrollBarThickness = 4,
                        ScrollBarImageColor3 = l_Theme_0.UIEmphasis.Color,
                        ScrollBarImageTransparency = l_Theme_0.UIEmphasis.Transparency,
                        ScrollingDirection = Enum.ScrollingDirection.Y,
                        CanvasSize = UDim2.new(1, 0, 0, #v36.props.buttonProps * v36.props.elementHeight),
                        ClipsDescendants = v68
                    }, v42)
                }),
                BottomRoundedCorner = if not v65 or v23.enableNewMenuLayout then nil else v4.createElement("ImageLabel", {
                    ZIndex = 2,
                    BackgroundTransparency = 1,
                    Size = UDim2.new(1, 0, 0, v36.props.borderCornerRadius),
                    Position = UDim2.fromScale(0, 1),
                    AnchorPoint = Vector2.new(0, 1),
                    Image = v25.Image,
                    ScaleType = Enum.ScaleType.Slice,
                    SliceScale = 0.5 / v14.ImagesResolutionScale,
                    SliceCenter = Rect.new(v62 - 1, 0, v62 + 1, 1),
                    ImageRectSize = Vector2.new(l_X_0, v62),
                    ImageRectOffset = l_ImageRectOffset_0 + Vector2.new(0, v62),
                    ImageTransparency = v58.Transparency,
                    ImageColor3 = v58.Color
                })
            });
        else
            return v36:renderFixedHeightMenu(v36.props, v55, v42);
        end;
    end);
end;
return function(v69)
    local l_v69_0 = v69;
    if not (not v23.enableNewMenuLayout or not v69.enableTokenOverride) then
        local v71 = v9();
        local v72 = {};
        for v73, v74 in ipairs(v69.buttonProps) do
            v72[v73] = v6.Dictionary.join(v74, v22.getCellDefaultTokens(v71));
        end;
        l_v69_0 = v6.Dictionary.join(l_v69_0, v22.getBaseMenuDefaultTokens(v71), {
            buttonProps = v72
        });
    end;
    return v5.createElement(v26, l_v69_0);
end;


local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.Roact);
local v3 = require(l_Parent_1.t);
local v4 = require(l_Parent_0.Core.Style.withStyle);
local v5 = require(l_Parent_0.Core.Style.Validator.validateColorInfo);
local v6 = require(l_Parent_0.App.SelectionImage.withSelectionCursorProvider);
local v7 = require(l_Parent_0.App.SelectionImage.CursorKind);
local _ = require(l_Parent_0.App.Style.StyleTypes);
local l_Object_0 = require(l_Parent_1.LuauPolyfill).Object;
local v10 = require(l_Parent_1.UIBlox.Core.ImageSet.ImageSetComponent);
local v11 = require(l_Parent_1.UIBlox.App.ImageSet.Images);
local v12 = require(l_Parent_0.Core.Text.GenericTextLabel.GenericTextLabel);
local v13 = require(l_Parent_0.Utility.divideTransparency);
local v14 = require(l_Parent_1.UIBlox.Core.Style.Validator.validateFontInfo);
local v15 = require(l_Parent_1.UIBlox.Core.Control.Controllable);
local v16 = require(l_Parent_1.UIBlox.Core.Control.Enum.ControlState);
local v17 = require(script.Parent.KeyLabel.KeyLabel);
local v18 = require(script.Parent.RoundedFrame);
local v19 = require(l_Parent_0.UIBloxConfig);
local v20 = v11["component_assets/circle_17"];
local v21 = v2.PureComponent:extend("Cell");
v21.validateProps = v3.strictInterface({
    icon = v3.optional(v3.union(v3.table, v3.string)),
    text = v3.string,
    onActivated = v3.callback,
    keyCodeLabel = v3.optional(v3.union(v3.enum(Enum.KeyCode), v3.strictInterface({
        key = v3.enum(Enum.KeyCode),
        axis = v3.optional(v3.string)
    }))),
    selected = v3.optional(v3.boolean),
    iconColorOverride = v3.optional(v3.Color3),
    textColorOverride = v3.optional(v3.Color3),
    elementHeight = v3.integer,
    hasRoundTop = v3.boolean,
    hasRoundBottom = v3.boolean,
    hasDivider = v3.boolean,
    disabled = v3.optional(v3.boolean),
    stayOnActivated = v3.optional(v3.boolean),
    renderRightSideGadget = v3.optional(v3.callback),
    rightSideGadgetSize = v3.optional(v3.Vector2),
    leftPaddingOffset = v3.optional(v3.number),
    layoutOrder = v3.integer,
    setButtonRef = v3.optional(v3.union(v3.callback, v3.table)),
    cursorKind = if not v19.migrateToNewSelectionCursor then v3.optional(v7.isEnumValue) else nil,
    isElementBackgroundVisible = v3.optional(v3.boolean),
    dividerOffset = v3.optional(v3.number),
    dividerSize = v3.optional(v3.number),
    fontStyle = v3.optional(v3.union(v3.string, v14)),
    iconSize = v3.optional(v3.integer),
    selectedIconSize = v3.optional(v3.integer),
    iconPaddingLeft = v3.optional(v3.integer),
    textPadding = v3.optional(v3.strictInterface({
        left = v3.integer,
        right = v3.integer
    })),
    selectedIconPaddingRight = v3.optional(v3.integer),
    keyLabelPaddingRight = v3.optional(v3.integer),
    textOnlyPadding = v3.optional(v3.integer),
    borderCornerRadius = v3.optional(v3.integer),
    background = v3.optional(v5),
    selectionOrder = v3.optional(v3.number),
    selectionCursor = if not v19.migrateToNewSelectionCursor then nil else v3.optional(v3.any)
});
v21.defaultProps = {
    selected = false,
    disabled = false,
    rightSideGadgetSize = nil,
    leftPaddingOffset = 0,
    isElementBackgroundVisible = true,
    dividerOffset = 0,
    dividerSize = 1,
    iconSize = 36,
    selectedIconSize = 16,
    iconPaddingLeft = 12,
    textPadding = {
        left = 12,
        right = 12
    },
    selectedIconPaddingRight = 24,
    textOnlyPadding = 24,
    keyLabelPaddingRight = 16,
    borderCornerRadius = 4
};
v21.init = function(v22)
    v22.state = {
        controlState = v16.Default,
        keyLabelWidth = 0
    };
    v22.keyLabelSizeChanged = function(v23)
        v22:setState({
            keyLabelWidth = v23.AbsoluteSize.X
        });
    end;
    v22.setControlState = function(v24)
        v22:setState({
            controlState = v24
        });
    end;
end;
v21.getImageProperties = function(v25)
    local l_ImageRectSize_0 = v20.ImageRectSize;
    local l_ImageRectOffset_0 = v20.ImageRectOffset;
    local v28 = 8 * v11.ImagesResolutionScale;
    local v29 = 8 * v11.ImagesResolutionScale;
    local v30 = Rect.new(v28, v29, l_ImageRectSize_0.x - v28, l_ImageRectSize_0.y - v29);
    local l_X_0 = l_ImageRectSize_0.X;
    local v32 = math.floor(l_X_0 / 2);
    local _ = nil;
    local _ = nil;
    local _ = nil;
    if not v25.props.hasRoundTop or not v25.props.hasRoundBottom then
        if not v25.props.hasRoundTop then
            if not v25.props.hasRoundBottom then
                return Vector2.new(1, 1), l_ImageRectOffset_0 + Vector2.new(v32, v32), (Rect.new(0, 0, 0, 0));
            else
                return Vector2.new(l_X_0, v32), l_ImageRectOffset_0 + Vector2.new(0, v32), (Rect.new(v32 - 1, 0, v32 + 1, 1));
            end;
        else
            return Vector2.new(l_X_0, v32), l_ImageRectOffset_0, (Rect.new(v32 - 1, v32 - 1, v32 + 1, v32));
        end;
    else
        return l_ImageRectSize_0, l_ImageRectOffset_0, v30;
    end;
end;
v21.renderRoundedBackground = function(v36, v37, v38)
    assert(v19.enableNewMenuLayout, "enableNewMenuLayout must be enabled to call renderRoundedBackground");
    local v39 = UDim.new(0, v36.props.borderCornerRadius);
    return v2.createElement(v18, {
        zIndex = v37,
        background = v38,
        topCornerRadius = if not v36.props.hasRoundTop then nil else v39,
        bottomCornerRadius = if not v36.props.hasRoundBottom then nil else v39
    });
end;
v21.renderWithSelectionCursor = function(v40, v41)
    return v4(function(v42)
        local l_Theme_0 = v42.Theme;
        local l_Font_0 = v42.Font;
        local l_Settings_0 = v42.Settings;
        local l_textOnlyPadding_0 = v40.props.textOnlyPadding;
        if v40.props.icon then
            l_textOnlyPadding_0 = v40.props.iconPaddingLeft;
        end;
        l_textOnlyPadding_0 = l_textOnlyPadding_0 + v40.props.leftPaddingOffset;
        local v47 = 0;
        if not v40.props.keyCodeLabel then
            if v40.props.selected then
                v47 = v40.props.selectedIconPaddingRight;
            end;
        else
            v47 = v40.props.keyLabelPaddingRight;
        end;
        local v48 = {
            Color = Color3.new(1, 1, 1),
            Transparency = 1
        };
        if v40.state.controlState == v16.Pressed then
            v48 = l_Theme_0.BackgroundOnPress;
        elseif v40.state.controlState == v16.Hover then
            v48 = l_Theme_0.BackgroundOnHover;
        end;
        local v49, v50, v51 = v40:getImageProperties();
        local v52 = 0;
        local v53 = true;
        if v40.props.rightSideGadgetSize ~= nil then
            v52 = ((v40.props.rightSideGadgetSize.X + v40.props.iconPaddingLeft) + v40.props.iconSize) + v40.props.textPadding.left;
        else
            if v40.props.icon then
                v53 = false;
                l_textOnlyPadding_0 = v40.props.iconPaddingLeft;
                v52 = v40.props.iconPaddingLeft + v40.props.iconSize;
            end;
            if v40.props.selected then
                v53 = false;
                v52 = (v52 + v40.props.selectedIconSize) + v40.props.selectedIconPaddingRight;
            end;
            if v40.props.keyCodeLabel then
                v53 = false;
                v52 = (v52 + v40.props.keyLabelPaddingRight) + v40.state.keyLabelWidth;
            end;
            v52 = if not v53 then (v52 + v40.props.textPadding.left) + v40.props.textPadding.right else v52 + v40.props.textOnlyPadding * 2;
        end;
        local l_TextEmphasis_0 = l_Theme_0.TextEmphasis;
        if v40.props.textColorOverride then
            l_TextEmphasis_0 = {
                Color = v40.props.textColorOverride,
                Transparency = l_Theme_0.TextEmphasis.Transparency
            };
        end;
        if not (v40.state.controlState ~= v16.Pressed and not v40.props.disabled) then
            l_TextEmphasis_0 = {
                Color = l_TextEmphasis_0.Color,
                Transparency = v13(l_Theme_0.TextEmphasis.Transparency, 2)
            };
        end;
        local l_BackgroundUIDefault_0 = l_Theme_0.BackgroundUIDefault;
        local v56 = l_Object_0.assign({}, {
            Color = l_BackgroundUIDefault_0.Color,
            Transparency = l_BackgroundUIDefault_0.Transparency
        }, v40.props.background);
        v56.Transparency = v56.Transparency * l_Settings_0.PreferredTransparency;
        local l_isElementBackgroundVisible_0 = v40.props.isElementBackgroundVisible;
        return v2.createElement(v15, {
            controlComponent = {
                component = "ImageButton",
                props = {
                    Size = UDim2.new(1, 0, 0, v40.props.elementHeight),
                    BackgroundTransparency = 1,
                    Image = if not v19.enableNewMenuLayout then v20.Image else nil,
                    ScaleType = Enum.ScaleType.Slice,
                    SliceCenter = v51,
                    ImageRectSize = v49,
                    ImageRectOffset = v50,
                    SliceScale = 1 / v11.ImagesResolutionScale,
                    ImageTransparency = not (l_isElementBackgroundVisible_0 and not v19.enableNewMenuLayout) and 1 or v56.Transparency,
                    ImageColor3 = v56.Color,
                    AutoButtonColor = false,
                    LayoutOrder = v40.props.layoutOrder,
                    BorderSizePixel = 0,
                    [v2.Ref] = v40.props.setButtonRef,
                    [v2.Event.Activated] = v40.props.onActivated,
                    SelectionImageObject = if not v19.migrateToNewSelectionCursor then v41(v40.props.cursorKind) else v40.props.selectionCursor,
                    SelectionOrder = v40.props.selectionOrder
                },
                children = {
                    Background = if not not v19.enableNewMenuLayout and l_isElementBackgroundVisible_0 then v40:renderRoundedBackground(-1, v56) else nil,
                    Divider = v2.createElement("Frame", {
                        BackgroundColor3 = l_Theme_0.Divider.Color,
                        BackgroundTransparency = l_Theme_0.Divider.Transparency,
                        BorderSizePixel = 0,
                        Size = UDim2.new(1, -v40.props.dividerOffset, 0, v40.props.dividerSize),
                        Position = UDim2.new(0, v40.props.dividerOffset, 1, 0),
                        AnchorPoint = Vector2.new(0, 1),
                        Visible = v40.props.hasDivider
                    }),
                    StateOverlay = if not v19.enableNewMenuLayout then v2.createElement("ImageLabel", {
                        BackgroundTransparency = 1,
                        Image = v20.Image,
                        ScaleType = Enum.ScaleType.Slice,
                        SliceCenter = v51,
                        ImageRectSize = v49,
                        ImageRectOffset = v50,
                        SliceScale = 1 / v11.ImagesResolutionScale,
                        ImageColor3 = v48.Color,
                        ImageTransparency = v48.Transparency,
                        BorderSizePixel = 0,
                        Size = UDim2.fromScale(1, 1),
                        ZIndex = 2
                    }) else v40:renderRoundedBackground(2, v48),
                    LeftAlignedContent = v2.createElement("Frame", {
                        BackgroundTransparency = 1,
                        Size = UDim2.fromScale(1, 1)
                    }, {
                        Layout = v2.createElement("UIListLayout", {
                            HorizontalAlignment = Enum.HorizontalAlignment.Left,
                            VerticalAlignment = Enum.VerticalAlignment.Center,
                            FillDirection = Enum.FillDirection.Horizontal,
                            SortOrder = Enum.SortOrder.LayoutOrder,
                            Padding = UDim.new(0, v40.props.textPadding.left)
                        }),
                        LeftPadding = v2.createElement("UIPadding", {
                            PaddingLeft = UDim.new(0, l_textOnlyPadding_0)
                        }),
                        Icon = v40.props.icon and v2.createElement(v10.Label, {
                            Image = v40.props.icon,
                            Size = UDim2.fromOffset(v40.props.iconSize, v40.props.iconSize),
                            BackgroundTransparency = 1,
                            ImageColor3 = v40.props.iconColorOverride or l_Theme_0.IconEmphasis.Color,
                            ImageTransparency = v13(l_Theme_0.IconEmphasis.Transparency, not v40.props.disabled and 1 or 2),
                            LayoutOrder = 1
                        }),
                        Text = v2.createElement(v12, {
                            fontStyle = v40.props.fontStyle or l_Font_0.Header2,
                            colorStyle = l_TextEmphasis_0,
                            BackgroundTransparency = 1,
                            Size = UDim2.new(1, -v52, 1, 0),
                            Text = v40.props.text,
                            TextTruncate = Enum.TextTruncate.AtEnd,
                            TextXAlignment = Enum.TextXAlignment.Left,
                            TextWrapped = false,
                            LayoutOrder = 2
                        })
                    }),
                    RightAlignedContent = v2.createElement("Frame", {
                        BackgroundTransparency = 1,
                        Size = UDim2.fromScale(1, 1)
                    }, {
                        Layout = v2.createElement("UIListLayout", {
                            HorizontalAlignment = Enum.HorizontalAlignment.Right,
                            VerticalAlignment = Enum.VerticalAlignment.Center,
                            FillDirection = Enum.FillDirection.Horizontal,
                            SortOrder = Enum.SortOrder.LayoutOrder,
                            Padding = UDim.new(0, v40.props.textPadding.right)
                        }),
                        RightPadding = v2.createElement("UIPadding", {
                            PaddingRight = UDim.new(0, v47)
                        }),
                        RightSideContent = (not not v40.props.renderRightSideGadget and v40.props.rightSideGadgetSize) and v2.createElement("Frame", {
                            BackgroundTransparency = 1,
                            BorderSizePixel = 0,
                            LayoutOrder = 3,
                            Size = UDim2.fromOffset(v40.props.rightSideGadgetSize.X, v40.props.rightSideGadgetSize.Y)
                        }, v40.props.renderRightSideGadget()) or v2.createFragment({
                            KeyLabel = v40.props.keyCodeLabel and v2.createElement(v17, {
                                keyCode = v40.props.keyCodeLabel,
                                LayoutOrder = 2,
                                [v2.Change.AbsoluteSize] = v40.keyLabelSizeChanged
                            }),
                            SelectedIcon = v2.createElement(v10.Label, {
                                Image = v11["icons/status/success_small"],
                                Size = UDim2.fromOffset(v40.props.selectedIconSize, v40.props.selectedIconSize),
                                LayoutOrder = 1,
                                BackgroundTransparency = 1,
                                ImageColor3 = l_Theme_0.IconEmphasis.Color,
                                ImageTransparency = l_Theme_0.IconEmphasis.Transparency,
                                Visible = v40.props.selected
                            })
                        })
                    })
                }
            },
            onStateChanged = function(_, v59)
                v40.setControlState(v59);
            end,
            isDisabled = v40.props.disabled
        });
    end);
end;
v21.render = function(v60)
    return v6(function(v61)
        return v60:renderWithSelectionCursor(v61);
    end);
end;
return v21;


local l_GuiService_0 = game:GetService("GuiService");
local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v3 = require(l_Parent_1.Roact);
local v4 = require(l_Parent_1.t);
local v5 = require(l_Parent_1.Otter);
local v6 = require(l_Parent_0.Core.Style.withStyle);
local v7 = require(l_Parent_0.Core.Style.Validator.validateColorInfo);
local v8 = require(l_Parent_0.UIBloxConfig);
local v9 = require(script.Parent.BaseMenu);
local v10 = require(script.Parent.MenuDirection);
local v11 = require(script.Parent.validateButtonProps);
local v12 = require(script.Parent.validateMotorOptionProps);
local v13 = {
    open = {
        targetValue = 1,
        springParams = {
            frequency = 4,
            dampingRatio = 1
        }
    },
    close = {
        targetValue = 0,
        springParams = {
            frequency = 2.6,
            dampingRatio = 1
        }
    }
};
local v14 = v3.PureComponent:extend("ContextualMenu");
v14.validateProps = v4.strictInterface({
    buttonProps = v11,
    zIndex = v4.optional(v4.integer),
    open = v4.boolean,
    menuDirection = v4.optional(v10.isEnumValue),
    openPositionY = v4.UDim,
    closeBackgroundVisible = v4.optional(v4.boolean),
    screenSize = v4.Vector2,
    stayOnActivated = v4.optional(v4.boolean),
    onDismiss = v4.optional(v4.callback),
    setFrameRef = v4.optional(v4.union(v4.callback, v4.table)),
    setFirstItemRef = v4.optional(v4.union(v4.callback, v4.table)),
    motorOverrideOptions = v4.optional(v4.strictInterface({
        motorCallback = v4.callback,
        open = v12,
        close = v12
    })),
    horizontalAlignment = v4.optional(v4.enum(Enum.HorizontalAlignment)),
    openPositionX = v4.optional(v4.UDim),
    contextMenuWidthOverride = v4.optional(v4.UDim),
    anchorPointOverride = v4.optional(v4.Vector2),
    topElementRounded = v4.optional(v4.boolean),
    bottomElementRounded = v4.optional(v4.boolean),
    isElementBackgroundVisible = v4.optional(v4.boolean),
    isElementDividerVisible = v4.optional(v4.boolean),
    elementHeight = v4.optional(v4.number),
    borderCornerRadius = v4.optional(v4.integer),
    background = v4.optional(v7),
    enableTokenOverride = v4.optional(v4.boolean),
    renderHeader = v4.optional(v4.callback),
    headerHeight = v4.optional(v4.number)
});
v14.defaultProps = {
    menuDirection = v10.Up,
    zIndex = 2,
    closeBackgroundVisible = true,
    horizontalAlignment = Enum.HorizontalAlignment.Center,
    openPositionX = UDim.new(0, 0)
};
v14.init = function(v15)
    v15.wasDismissed = false;
    local v16, v17 = v3.createBinding(0);
    v15.positionPercentBinding = v16;
    v15.positionPercentBindingUpdate = v17;
    v15.motor = v5.createSingleMotor(0);
    v15.motor:onStep(v15.positionPercentBindingUpdate);
    v15.motor:onComplete(function()
        if v15.wasDismissed then
            v15.wasDismissed = false;
            if v15.props.onDismiss then
                v15.props.onDismiss();
            end;
        end;
    end);
    v15.motorType = v5.spring;
    v15.motorOptions = v13;
    if v15.props.motorOverrideOptions then
        v15.motorType = v15.props.motorOverrideOptions.motorCallback;
        v15.motorOptions = v15.props.motorOverrideOptions;
    end;
    v15.state = {
        absoluteSize = Vector2.new(0, 0),
        absolutePosition = Vector2.new(0, 0)
    };
    v15.visibleBinding = v15.positionPercentBinding:map(function(v18)
        return v18 ~= 0;
    end);
end;
v14.render = function(v19)
    return v6(function(v20)
        local v21 = 0.5;
        local v22 = UDim.new(1, -24);
        local v23 = UDim.new(0, 0);
        local v24 = v19.state.absoluteSize.X > 640;
        if v24 then
            v22 = UDim.new(0, 300);
            v23 = v19.props.openPositionX;
            if v19.props.horizontalAlignment == Enum.HorizontalAlignment.Left then
                v21 = 0;
            elseif v19.props.horizontalAlignment == Enum.HorizontalAlignment.Right then
                v21 = 1;
            end;
        end;
        local v25 = 0;
        if v19.props.menuDirection == v10.Up then
            v25 = 1;
        end;
        local l_Transparency_0 = v20.Theme.Overlay.Transparency;
        if not v19.props.closeBackgroundVisible then
            l_Transparency_0 = 1;
        end;
        v22 = v19.props.contextMenuWidthOverride or v22;
        local v27 = v19.props.anchorPointOverride or Vector2.new(v21, v25);
        local l_l_GuiService_0_GuiInset_0, _ = l_GuiService_0:GetGuiInset();
        local v30 = v19.state.absolutePosition + l_l_GuiService_0_GuiInset_0;
        return v3.createElement("Frame", {
            Size = UDim2.fromScale(1, 1),
            BackgroundTransparency = 1,
            Visible = v19.visibleBinding,
            ZIndex = v19.props.zIndex,
            [v3.Change.AbsoluteSize] = function(v31)
                v19:setState({
                    absoluteSize = v31.AbsoluteSize
                });
            end,
            [v3.Change.AbsolutePosition] = function(v32)
                v19:setState({
                    absolutePosition = v32.AbsolutePosition
                });
            end
        }, {
            Background = v3.createElement("TextButton", {
                ZIndex = 1,
                Text = "",
                BorderSizePixel = 0,
                BackgroundColor3 = v20.Theme.Overlay.Color,
                BackgroundTransparency = l_Transparency_0,
                AutoButtonColor = false,
                Selectable = if not v8.enableNewMenuLayout then nil else false,
                Position = UDim2.fromOffset(-v30.X, -v30.Y),
                Size = UDim2.fromOffset(v19.props.screenSize.X, v19.props.screenSize.Y),
                [v3.Event.Activated] = function()
                    if not v19.wasDismissed then
                        v19.wasDismissed = true;
                        v19.motor:setGoal(v19.motorType(v19.motorOptions.close.targetValue, v19.motorOptions.close.springParams));
                    end;
                end
            }),
            PositionFrame = v3.createElement("Frame", {
                BackgroundTransparency = 1,
                Size = UDim2.fromScale(1, 1),
                Position = UDim2.new(v23.Scale, v23.Offset, v19.props.openPositionY.Scale, v19.props.openPositionY.Offset),
                ZIndex = 2
            }, {
                BaseMenu = v3.createElement(v9, {
                    buttonProps = v19.props.buttonProps,
                    setFirstItemRef = v19.props.setFirstItemRef,
                    setFrameRef = v19.props.setFrameRef,
                    width = v22,
                    position = v19.positionPercentBinding:map(function(v33)
                        local v34 = 0.5;
                        if not (not v24 and not v19.props.anchorPointOverride) then
                            if v19.props.horizontalAlignment == Enum.HorizontalAlignment.Left then
                                v34 = 0;
                            elseif v19.props.horizontalAlignment == Enum.HorizontalAlignment.Right then
                                v34 = 1;
                            end;
                        end;
                        if v19.props.menuDirection == v10.Down then
                            return UDim2.fromScale(v34, v33 - 1);
                        else
                            return UDim2.fromScale(v34, 1 - v33);
                        end;
                    end),
                    anchorPoint = v27,
                    topElementRounded = v19.props.topElementRounded,
                    bottomElementRounded = v19.props.bottomElementRounded,
                    isElementBackgroundVisible = v19.props.isElementBackgroundVisible,
                    isElementDividerVisible = v19.props.isElementDividerVisible,
                    elementHeight = v19.props.elementHeight,
                    borderCornerRadius = v19.props.borderCornerRadius,
                    background = v19.props.background,
                    enableTokenOverride = v19.props.enableTokenOverride,
                    renderHeader = v19.props.renderHeader,
                    headerHeight = v19.props.headerHeight
                })
            })
        });
    end);
end;
v14.didMount = function(v35)
    if v35.props.open then
        v35.wasDismissed = false;
        v35.motor:setGoal(v35.motorType(v35.motorOptions.open.targetValue, v35.motorOptions.open.springParams));
    end;
end;
v14.didUpdate = function(v36, v37, _)
    if v36.props.open ~= v37.open then
        if not v36.props.open then
            v36.motor:setGoal(v36.motorType(v36.motorOptions.close.targetValue, v36.motorOptions.close.springParams));
        else
            v36.wasDismissed = false;
            v36.motor:setGoal(v36.motorType(v36.motorOptions.open.targetValue, v36.motorOptions.open.springParams));
            return ;
        end;
    end;
end;
v14.wilUnmount = function(v39)
    v39.motor:destroy();
end;
return v14;


local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.Roact);
local v3 = require(l_Parent_1.t);
local v4 = require(l_Parent_1.Cryo);
local v5 = require(l_Parent_0.App.ImageSet.Images);
local v6 = require(l_Parent_0.Core.Control.Enum.ControlState);
local v7 = require(l_Parent_0.App.Menu.DropdownMenuList);
local v8 = require(l_Parent_0.App.Menu.DropdownMenuCell);
local v9 = require(l_Parent_0.Core.Style.Validator.validateColorInfo);
local v10 = require(l_Parent_0.Utility.bind);
local v11 = require(l_Parent_0.UIBloxConfig);
local v12 = require(l_Parent_0.Core.Style.useStyle);
local v13 = require(script.Parent.StyleDefaults);
local function _(v14)
    if v14.key ~= nil then
        return v14.key;
    else
        return v14.text;
    end;
end;
local v16 = v2.Component:extend("DropdownMenu");
v16.validateProps = v3.strictInterface({
    placeholder = v3.string,
    onChange = v3.callback,
    height = if not v11.enableNewMenuLayout then v3.UDim else v3.optional(v3.UDim),
    screenSize = v3.Vector2,
    showDropShadow = v3.optional(v3.boolean),
    fixedListHeight = v3.optional(v3.number),
    errorState = v3.optional(v3.boolean),
    isDisabled = v3.optional(v3.boolean),
    onMenuOpenChange = v3.optional(v3.callback),
    menuListBackground = v3.optional(v9),
    cellDatas = v3.array(v3.strictInterface({
        icon = v3.optional(v3.union(v3.table, v3.string)),
        text = v3.string,
        key = v3.optional(v3.string),
        disabled = v3.optional(v3.boolean),
        keyCodeLabel = v3.optional(v3.union(v3.enum(Enum.KeyCode), v3.strictInterface({
            key = v3.enum(Enum.KeyCode),
            axis = v3.optional(v3.string)
        }))),
        iconColorOverride = v3.optional(v3.Color3),
        textColorOverride = v3.optional(v3.Color3)
    })),
    menuStateColors = v3.optional(v3.strictInterface({
        buttonDefault = v3.optional(v9),
        contentDefault = v3.optional(v9),
        alert = v3.optional(v9)
    })),
    enableTokenOverride = v3.optional(v3.boolean),
    isForcedClosed = v3.optional(v3.boolean),
    selectionOrder = v3.optional(v3.number)
});
v16.defaultProps = {
    showDropShadow = false,
    fixedListHeight = nil,
    enableTokenOverride = false
};
v16.didUpdate = function(v17, _, v19)
    if v17.props.onMenuOpenChange and v17.state.menuOpen ~= v19.menuOpen then
        v17.props.onMenuOpenChange(v17.state.menuOpen);
    end;
end;
v16.init = function(v20)
    v20:setState({
        menuOpen = false,
        selectedKey = nil,
        absoluteSize = Vector2.new(0, 0)
    });
    v20.openMenu = function()
        v20:setState({
            menuOpen = true
        });
    end;
    v20.closeMenu = function()
        v20:setState({
            menuOpen = false
        });
    end;
    v20.onSelect = function(v21)
        v20:setState({
            menuOpen = false,
            selectedKey = v21
        });
        v20.props.onChange(v21);
    end;
    v20.mapCellData = function(v22)
        local v23 = if v22.key ~= nil then v22.key else v22.text;
        local v24 = v4.Dictionary.join(v22, {
            key = v4.None
        });
        v24.onActivated = v10(v20.onSelect, v23);
        v24.selected = v20.state.selectedKey == v23;
        return v24;
    end;
    v20.onResize = function(v25)
        v20:setState({
            absoluteSize = v25.AbsoluteSize
        });
    end;
end;
v16.getDerivedStateFromProps = function(v26, v27)
    local v28 = false;
    for _, v30 in v26.cellDatas, nil, nil do
        if if v30.key ~= nil then v30.key else v30.text == v27.selectedKey then
            v28 = true;
            break;
        end;
    end;
    if v28 then
        return nil;
    else
        return {
            selectedKey = v2.None
        };
    end;
end;
v16.render = function(v31)
    local v32 = v4.List.map(v31.props.cellDatas, v31.mapCellData);
    local l_selectionOrder_0 = v31.props.selectionOrder;
    local v35 = v4.List.findWhere(v32, function(v34)
        return v34.selected;
    end);
    local v36 = if v35 ~= nil then v32[v35].text else v31.props.placeholder;
    local v37 = v31.state.absoluteSize.X > 640;
    local v38 = nil;
    local v39 = nil;
    if not v11.enableNewMenuLayout or not v31.props.enableTokenOverride then
        local v40 = "SecondaryDefault";
        local v41 = "SecondaryOnHover";
        if v31.state.menuOpen then
            v41 = v40;
        end;
        if v31.props.errorState then
            v40 = "Alert";
            v41 = "Alert";
        end;
        v38 = {
            [v6.Default] = v40,
            [v6.Hover] = v41
        };
        v39 = {
            [v6.Default] = "TextEmphasis"
        };
    else
        local l_buttonDefault_0 = v31.props.menuStateColors.buttonDefault;
        local l_contentDefault_0 = v31.props.menuStateColors.contentDefault;
        if v31.props.errorState then
            l_buttonDefault_0 = v31.props.menuStateColors.alert;
        end;
        v38 = {
            [v6.Default] = l_buttonDefault_0
        };
        v39 = {
            [v6.Default] = l_contentDefault_0
        };
    end;
    if not (not v31.props.isForcedClosed or not v31.state.menuOpen) then
        v31:setState({
            menuOpen = false
        });
    end;
    return v2.createElement("Frame", {
        Size = UDim2.new(UDim.new(1, 0), v31.props.height),
        BackgroundTransparency = 1,
        [v2.Change.AbsoluteSize] = v31.onResize,
        [v2.Ref] = v31.props[v2.Ref]
    }, {
        InnerFrame = v2.createElement("Frame", {
            Size = UDim2.fromScale(1, 1),
            BackgroundTransparency = 1
        }, {
            SpawnButton = v2.createElement(v8, {
                Size = UDim2.fromScale(1, 1),
                buttonImage = v5["component_assets/circle_17_stroke_1"],
                buttonStateColorMap = v38,
                contentStateColorMap = v39,
                icon = not not v31.state.menuOpen and v5["truncate_arrows/actions_truncationCollapse"] or v5["truncate_arrows/actions_truncationExpand"],
                text = v36,
                isDisabled = v31.props.isDisabled,
                isLoading = false,
                isActivated = v31.state.menuOpen,
                hasContent = v35 ~= nil,
                userInteractionEnabled = true,
                onActivated = function()
                    if not v31.state.menuOpen then
                        v31.openMenu();
                        return ;
                    else
                        v31.closeMenu();
                        return ;
                    end;
                end,
                enableTokenOverride = v31.props.enableTokenOverride,
                SelectionOrder = l_selectionOrder_0
            }),
            DropdownMenuList = v2.createElement(v7, {
                buttonProps = v32,
                zIndex = 2,
                open = v31.state.menuOpen,
                openPositionY = UDim.new(0, 12),
                buttonSize = UDim2.fromScale(1, 1),
                closeBackgroundVisible = false,
                menuListBackground = v31.props.menuListBackground,
                screenSize = v31.props.screenSize,
                showDropShadow = v31.props.showDropShadow,
                fixedListHeight = v31.props.fixedListHeight,
                onDismiss = v31.closeMenu,
                enableTokenOverride = v31.props.enableTokenOverride,
                selectionOrder = if not l_selectionOrder_0 then nil else l_selectionOrder_0 + 1
            }),
            UISizeConstraint = not not v37 and v2.createElement("UISizeConstraint", {
                MaxSize = Vector2.new(300, math.huge)
            }) or nil
        }) or nil
    });
end;
return v2.forwardRef(function(v44, v45)
    local v46 = nil;
    if not v11.enableNewMenuLayout or not v44.enableTokenOverride then
        v46 = v44;
    else
        local v47 = v13.getDropdownMenuDefaultTokens((v12()));
        v46 = v4.Dictionary.join(v44, {
            height = v44.height or v47.height,
            menuStateColors = v4.Dictionary.join(v47.menuStateColors, v44.menuStateColors or {})
        });
    end;
    return v2.createElement(v16, v4.Dictionary.join(v46, {
        [v2.Ref] = v45
    }));
end);