local l_RunService_0 = game:GetService("RunService");
local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_Parent_2 = l_Parent_1.Parent;
local l_Parent_3 = l_Parent_2.Parent;
local v5 = require(l_Parent_3.Roact);
local v6 = require(l_Parent_3.t);
local v7 = require(l_Parent_3.Cryo);
local l_EventConnection_0 = require(l_Parent_3.ReactUtils).EventConnection;
local v9 = require(l_Parent_1.Control.Interactable);
local v10 = require(l_Parent_1.Control.Enum.ControlState);
local v11 = require(script.Parent.getContentStyle);
local v12 = require(l_Parent_2.Core.Style.withStyle);
local v13 = require(l_Parent_1.ImageSet.ImageSetComponent);
local v14 = require(l_Parent_2.App.Loading.ShimmerPanel);
local v15 = require(l_Parent_2.App.ImageSet.Enum.IconSize);
local v16 = require(l_Parent_2.App.ImageSet.getIconSize);
local v17 = require(l_Parent_1.Text.GenericTextLabel.GenericTextLabel);
local v18 = require(l_Parent_2.Core.Animation.withAnimation);
local v19 = require(l_Parent_1.Style.Validator.validateFontInfo);
local v20 = require(l_Parent_2.Core.Style.Validator.validateTypographyInfo);
local v21 = require(l_Parent_1.Button.HoverButtonBackground);
local v22 = require(l_Parent_0.Enum.StandardButtonSize);
local v23 = require(l_Parent_2.UIBloxConfig);
local v24 = require(l_Parent_1.ImageSet.Validator.validateImage);
local v25 = v5.PureComponent:extend("GenericButton");
v25.init = function(v26)
    v26:setState({
        controlState = v10.Initialize,
        absoluteSize = Vector2.new(100, 100),
        targetLoadingProgress = 1,
        isButtonUnfocused = if not v23.useRobloxGuiFocusedChangedEventInGenericButton then nil else l_RunService_0:GetRobloxGuiFocused()
    });
    v26.onStateChanged = function(v27, v28)
        v26:setState({
            controlState = v28
        });
        if v26.props.onStateChanged then
            v26.props.onStateChanged(v27, v28);
        end;
    end;
    v26.onAbsoluteSizeChanged = function(v29)
        v26:setState({
            absoluteSize = v29.AbsoluteSize
        });
        if v26.props[v5.Change.AbsoluteSize] then
            v26.props[v5.Change.AbsoluteSize](v29);
        end;
    end;
    v26.onRobloxGuiFocusedChanged = function(v30)
        if not v30 then
            v26:setState({
                isButtonUnfocused = false
            });
            return ;
        else
            v26:setState({
                targetLoadingProgress = 1,
                isButtonUnfocused = true
            });
            return ;
        end;
    end;
end;
local v31 = v6.interface({
    [v10.Default] = v6.string
});
v25.validateProps = v6.interface({
    icon = v6.optional(v24),
    text = v6.optional(v6.string),
    inputIcon = v6.optional(v24),
    buttonImage = v24,
    fontStyle = v6.optional(v6.union(v6.string, v19, v20)),
    delayedInputImage = v6.optional(v24),
    buttonStateColorMap = v31,
    contentStateColorMap = v6.optional(v31),
    textStateColorMap = v6.optional(v31),
    iconStateColorMap = v6.optional(v31),
    inputIconStateColorMap = v6.optional(v31),
    isDisabled = v6.optional(v6.boolean),
    isLoading = v6.optional(v6.boolean),
    isDelayedInput = v6.optional(v6.boolean),
    isHoverBackgroundEnabled = v6.optional(v6.boolean),
    enableInputDelayed = v6.optional(v6.boolean),
    delayInputSeconds = v6.optional(v6.numberPositive),
    onActivated = v6.callback,
    onStateChanged = v6.optional(v6.callback),
    userInteractionEnabled = v6.optional(v6.boolean),
    standardSize = v6.optional(v22.isEnumValue),
    maxWidth = v6.optional(v6.numberPositive),
    fitContent = v6.optional(v6.boolean),
    buttonTextOverride = v6.optional(v6.strictInterface({
        RichText = v6.optional(v6.boolean),
        Size = v6.optional(v6.UDim2),
        TextSize = v6.optional(v6.number),
        TextWrapped = v6.optional(v6.boolean),
        TextTruncate = v6.optional(v6.enum(Enum.TextTruncate)),
        TextXAlignment = v6.optional(v6.enum(Enum.TextXAlignment))
    })),
    forwardedRef = v6.optional(v6.union(v6.table, v6.callback)),
    feedbackType = v6.optional(v6.string)
});
v25.defaultProps = {
    fontStyle = "Header2",
    isDisabled = false,
    isLoading = false,
    isDelayedInput = false,
    enableInputDelayed = false,
    delayInputSeconds = 3,
    SliceCenter = Rect.new(8, 8, 9, 9)
};
if v23.useRobloxGuiFocusedChangedEventInGenericButton then
    v25.didMount = function(v32)
        v32:setState({
            targetLoadingProgress = (not v32.state.isButtonUnfocused and v32.props.enableInputDelayed) and 0 or 1
        });
    end;
end;
v25.render = function(v33)
    local l_isDelayedInput_0 = v33.props.isDelayedInput;
    local l_enableInputDelayed_0 = v33.props.enableInputDelayed;
    local l_delayInputSeconds_0 = v33.props.delayInputSeconds;
    local l_l_isDelayedInput_0_0 = l_isDelayedInput_0;
    if v23.useRobloxGuiFocusedChangedEventInGenericButton then
        l_l_isDelayedInput_0_0 = l_isDelayedInput_0 and not v33.state.isButtonUnfocused;
    end;
    if not l_l_isDelayedInput_0_0 then
        if not v23.useRobloxGuiFocusedChangedEventInGenericButton then
            return v33:renderButton();
        elseif not v33.state.isButtonUnfocused then
            return v33:renderButton();
        else
            return v33:renderButton(1);
        end;
    else
        local _ = nil;
        return v18({
            loadingProgress = if not v23.useRobloxGuiFocusedChangedEventInGenericButton then not l_enableInputDelayed_0 and 1 or 0 else v33.state.targetLoadingProgress
        }, function(v39)
            return v33:renderButton((math.clamp(v39.loadingProgress, 0, 1)));
        end, {
            frequency = 1 / l_delayInputSeconds_0,
            dampingRatio = 0.8
        });
    end;
end;
v25.renderButton = function(v40, v41)
    return v12(function(v42)
        assert(v6.table(v42), "Style provider is missing.");
        local l_controlState_0 = v40.state.controlState;
        local l_text_0 = v40.props.text;
        local l_icon_0 = v40.props.icon;
        local l_inputIcon_0 = v40.props.inputIcon;
        local l_isLoading_0 = v40.props.isLoading;
        local l_isDisabled_0 = v40.props.isDisabled;
        local l_isDelayedInput_1 = v40.props.isDelayedInput;
        local l_userInteractionEnabled_0 = v40.props.userInteractionEnabled;
        local l_buttonImage_0 = v40.props.buttonImage;
        local l_fontStyle_0 = v40.props.fontStyle;
        local l_delayedInputImage_0 = v40.props.delayedInputImage;
        local l_buttonStateColorMap_0 = v40.props.buttonStateColorMap;
        local l_contentStateColorMap_0 = v40.props.contentStateColorMap;
        local v56 = v40.props.textStateColorMap or l_contentStateColorMap_0;
        local v57 = v40.props.iconStateColorMap or l_contentStateColorMap_0;
        local v58 = v40.props.inputIconStateColorMap or l_contentStateColorMap_0;
        local l_Size_0 = v40.props.Size;
        local l_standardSize_0 = v40.props.standardSize;
        local v61 = v40.props.maxWidth or 640;
        local l_fitContent_0 = v40.props.fitContent;
        if l_text_0 then
            assert(v31(v56), "textStateColorMap is missing or invalid.");
        end;
        if l_icon_0 then
            assert(v31(v57), "iconStateColorMap is missing or invalid.");
        end;
        if l_inputIcon_0 then
            assert(v31(v58), "inputIconStateColorMap is missing or invalid.");
        end;
        if l_isDelayedInput_1 and l_delayedInputImage_0 == nil then
            l_isDelayedInput_1 = false;
        end;
        if l_isLoading_0 then
            l_isDisabled_0 = true;
        end;
        if l_isDisabled_0 then
            l_isDelayedInput_1 = false;
        end;
        if type(l_fontStyle_0) == "string" then
            l_fontStyle_0 = v42.Font[l_fontStyle_0];
        end;
        local l_l_delayedInputImage_0_0 = l_delayedInputImage_0;
        if v41 == 1 then
            l_l_delayedInputImage_0_0 = l_buttonImage_0;
        end;
        if l_isDelayedInput_1 and v41 ~= 0 then
            l_userInteractionEnabled_0 = false;
        end;
        local v64 = v11(l_buttonStateColorMap_0, l_controlState_0, v42);
        local v65 = l_text_0 and v11(v56, l_controlState_0, v42);
        local v66 = l_icon_0 and v11(v57, l_controlState_0, v42);
        local v67 = l_inputIcon_0 and v11(v58, l_controlState_0, v42);
        local v68 = false;
        if l_controlState_0 == v10.Hover then
            v68 = v40.props.isHoverBackgroundEnabled == true;
        end;
        local v69 = 5;
        if l_standardSize_0 then
            local v70 = nil;
            local v71 = nil;
            if l_standardSize_0 == v22.Regular then
                v70 = 48;
                v69 = 12;
                l_fontStyle_0 = v42.Font.Header2;
                v71 = false;
            elseif l_standardSize_0 == v22.Small then
                v70 = 36;
                v69 = 8;
                l_fontStyle_0 = v42.Font.Header2;
                v71 = false;
            elseif l_standardSize_0 == v22.XSmall then
                v70 = 28;
                v69 = 8;
                l_fontStyle_0 = v42.Font.CaptionHeader;
                v71 = true;
            end;
            if l_fitContent_0 == nil then
                l_fitContent_0 = v71;
            end;
            l_Size_0 = UDim2.new(not l_fitContent_0 and 1 or 0, 0, 0, v70);
        end;
        local v72 = nil;
        if not l_isLoading_0 then
            local l_X_0 = v40.state.absoluteSize.X;
            if not (not l_standardSize_0 or not l_fitContent_0) then
                l_X_0 = v61;
            end;
            local v74 = v40.state.absoluteSize.Y - 10;
            local v75 = l_X_0 - 2 * v69;
            if l_icon_0 then
                v75 = v75 - (5 + v16(v15.Medium));
            end;
            v72 = v40.props[v5.Children] or {
                ButtonMiddleContent = v5.createElement("Frame", {
                    AutomaticSize = if not l_fitContent_0 then nil else Enum.AutomaticSize.X,
                    Size = if not l_fitContent_0 then UDim2.fromScale(1, 1) else UDim2.fromScale(0, 1),
                    BackgroundTransparency = 1
                }, v40.props[v5.Children] or {
                    UIListLayout = v5.createElement("UIListLayout", {
                        FillDirection = Enum.FillDirection.Horizontal,
                        VerticalAlignment = Enum.VerticalAlignment.Center,
                        HorizontalAlignment = Enum.HorizontalAlignment.Center,
                        SortOrder = Enum.SortOrder.LayoutOrder,
                        Padding = UDim.new(0, 5)
                    }),
                    Icon = not not l_icon_0 and v5.createElement(v13.Label, {
                        Size = UDim2.new(0, v16(v15.Medium), 0, v16(v15.Medium)),
                        BackgroundTransparency = 1,
                        Image = l_icon_0,
                        ImageColor3 = v66.Color,
                        ImageTransparency = v66.Transparency,
                        LayoutOrder = 1
                    }) or nil,
                    Text = not not l_text_0 and v5.createElement(v17, v7.Dictionary.join({
                        BackgroundTransparency = 1,
                        Text = l_text_0,
                        fontStyle = l_fontStyle_0,
                        colorStyle = v65,
                        LayoutOrder = 2,
                        maxSize = Vector2.new(v75, v74),
                        TextWrapped = if not l_standardSize_0 then nil else false,
                        TextTruncate = if not l_standardSize_0 then nil else Enum.TextTruncate.AtEnd,
                        TextXAlignment = if not not l_standardSize_0 and l_icon_0 then Enum.TextXAlignment.Left else nil
                    }, v40.props.buttonTextOverride or {})) or nil
                }),
                ButtonIcon = not not l_inputIcon_0 and v5.createElement(v13.Label, {
                    AnchorPoint = Vector2.new(1, 0.5),
                    Position = UDim2.new(1, -4, 0.5, 0),
                    Size = UDim2.new(0, v16(v15.Medium), 0, v16(v15.Medium)),
                    BackgroundTransparency = 1,
                    Image = l_inputIcon_0,
                    ImageColor3 = v67.Color,
                    ImageTransparency = v67.Transparency
                }) or nil
            };
        else
            v72 = {
                isLoadingShimmer = v5.createElement(v14, {
                    Size = UDim2.new(1, 0, 1, 0)
                })
            };
        end;
        return v5.createElement(v9, v7.Dictionary.join(v40.props, {
            forwardedRef = v7.None,
            icon = v7.None,
            text = v7.None,
            inputIcon = v7.None,
            buttonImage = v7.None,
            fontStyle = v7.None,
            delayedInputImage = v7.None,
            buttonStateColorMap = v7.None,
            contentStateColorMap = v7.None,
            textStateColorMap = v7.None,
            iconStateColorMap = v7.None,
            inputIconStateColorMap = v7.None,
            onActivated = v7.None,
            isLoading = v7.None,
            isHoverBackgroundEnabled = v7.None,
            isDelayedInput = v7.None,
            enableInputDelayed = v7.None,
            delayInputSeconds = v7.None,
            standardSize = v7.None,
            maxWidth = v7.None,
            fitContent = v7.None,
            buttonTextOverride = v7.None,
            [v5.Children] = v7.None,
            Size = l_Size_0,
            AutomaticSize = if not l_fitContent_0 then nil else Enum.AutomaticSize.X,
            [v5.Ref] = v40.props.forwardedRef,
            isDisabled = l_isDisabled_0,
            onStateChanged = v40.onStateChanged,
            userInteractionEnabled = l_userInteractionEnabled_0,
            Image = l_buttonImage_0,
            ScaleType = Enum.ScaleType.Slice,
            ImageColor3 = v64.Color,
            ImageTransparency = v64.Transparency,
            BackgroundTransparency = 1,
            AutoButtonColor = false,
            [v5.Event.Activated] = v40.props.onActivated,
            [v5.Change.AbsoluteSize] = v40.onAbsoluteSizeChanged
        }), {
            UISizeConstraint = if not not l_standardSize_0 and v61 then v5.createElement("UISizeConstraint", {
                MaxSize = Vector2.new(v61, math.huge)
            }) else nil,
            UIPadding = if not l_standardSize_0 then nil else v5.createElement("UIPadding", {
                PaddingLeft = UDim.new(0, v69),
                PaddingRight = UDim.new(0, v69)
            }),
            ButtonContent = v5.createElement("Frame", {
                AutomaticSize = if not l_fitContent_0 then nil else Enum.AutomaticSize.X,
                Size = if not l_fitContent_0 then UDim2.fromScale(1, 1) else UDim2.fromScale(0, 1),
                BackgroundTransparency = 1
            }, v72),
            LoadingImage = l_isDelayedInput_1 and v5.createElement(v13.Label, {
                Size = UDim2.new(v41, 0, 1, 0),
                Position = UDim2.new(1, 0, 0.5, 0),
                AnchorPoint = Vector2.new(1, 0.5),
                BackgroundTransparency = 1,
                Image = l_l_delayedInputImage_0_0,
                ImageColor3 = Color3.new(0, 0, 0),
                ImageTransparency = 0.5,
                ScaleType = Enum.ScaleType.Slice,
                SliceCenter = v40.props.SliceCenter
            }),
            HoverBackground = not not v68 and v5.createElement(v21) or nil,
            EventConnection = not not v23.useRobloxGuiFocusedChangedEventInGenericButton and v5.createElement(l_EventConnection_0, {
                event = l_RunService_0.RobloxGuiFocusedChanged,
                callback = v40.onRobloxGuiFocusedChanged
            }) or nil
        });
    end);
end;
if v23.useRobloxGuiFocusedChangedEventInGenericButton then
    v25.didUpdate = function(v76, v77, v78)
        if v76.props.enableInputDelayed ~= v77.enableInputDelayed then
            v76:setState({
                targetLoadingProgress = not v76.props.enableInputDelayed and 1 or 0
            });
        end;
        if not (not (not (v76.state.isButtonUnfocused or not v78.isButtonUnfocused) and v76.state.targetLoadingProgress == 1) or not v76.props.enableInputDelayed) then
            v76:setState({
                targetLoadingProgress = 0
            });
        end;
    end;
end;
return v5.forwardRef(function(v79, v80)
    return v5.createElement(v25, v7.Dictionary.join(v79, {
        forwardedRef = v80
    }));
end);


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent.Parent;
local v2 = require(l_Parent_1.Roact);
local v3 = require(l_Parent_0.Style.withStyle);
local v4 = require(l_Parent_1.UIBlox.UIBloxConfig);
local v5 = v2.PureComponent:extend("HoverButtonBackground");
v5.render = function(_)
    return v3(function(v7)
        local l_BackgroundOnHover_0 = v7.Theme.BackgroundOnHover;
        return v2.createElement("Frame", {
            Size = UDim2.fromScale(1, 1),
            BackgroundColor3 = l_BackgroundOnHover_0.Color,
            BackgroundTransparency = l_BackgroundOnHover_0.Transparency,
            ZIndex = if not v4.useNewThemeColorPalettes then nil else -1
        }, {
            corner = v2.createElement("UICorner", {
                CornerRadius = UDim.new(0, 8)
            })
        });
    end);
end;
return v5;


local v0 = require(script.Parent.Parent.Control.Enum.ControlState);
return function(v1, v2, v3)
    local v4 = v1[v2] or v1[v0.Default];
    local v5 = {
        Color = v3.Theme[v4].Color,
        Transparency = v3.Theme[v4].Transparency
    };
    if not (v2 ~= v0.Disabled) or v2 == v0.Pressed then
        v5.Transparency = 0.5 * v5.Transparency + 0.5;
    end;
    return v5;
end;


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.Roact);
local v4 = require(l_Parent_2.Cryo);
local v5 = require(l_Parent_2.t);
local v6 = require(l_Parent_0.Text.GenericTextLabel.GenericTextLabel);
local v7 = require(l_Parent_0.Control.Interactable);
local v8 = require(l_Parent_1.Core.Style.Validator.validateColorInfo);
local v9 = require(l_Parent_1.Core.Style.Validator.validateFontInfo);
local v10 = v3.PureComponent:extend("GenericCell");
v10.validateProps = v5.strictInterface({
    onActivated = v5.optional(v5.callback),
    isSelected = v5.optional(v5.boolean),
    isDisabled = v5.optional(v5.boolean),
    onStateChanged = v5.callback,
    titleText = v5.optional(v5.string),
    subtitleText = v5.optional(v5.string),
    renderRightContent = v5.optional(v5.callback),
    rightContentWidth = v5.optional(v5.number),
    renderLeftContent = v5.optional(v5.callback),
    leftContentWidth = v5.optional(v5.number),
    colorStyle = v8,
    textStyle = v5.optional(v8),
    fontStyle = v5.optional(v9),
    subtitleTextStyle = v5.optional(v8),
    subtitleFontStyle = v5.optional(v9),
    dividerStyle = v5.table,
    controlRef = v5.optional(v5.table),
    NextSelectionLeft = v5.optional(v5.table),
    NextSelectionRight = v5.optional(v5.table),
    NextSelectionUp = v5.optional(v5.table),
    NextSelectionDown = v5.optional(v5.table),
    SelectionImageObject = v5.optional(v5.table)
});
v10.defaultProps = {
    rightContentWidth = 0,
    leftContentWidth = 0,
    isDisabled = false
};
v10.render = function(v11)
    assert(v11.validateProps(v11.props));
    return v3.createElement("Frame", {
        Size = UDim2.new(1, 0, 1, 0),
        BorderSizePixel = 0,
        BackgroundTransparency = 1
    }, {
        Interactable = v3.createElement(v7, {
            Size = UDim2.new(1, 0, 1, 0),
            BackgroundColor3 = v11.props.colorStyle.Color,
            BackgroundTransparency = v11.props.colorStyle.Transparency,
            BorderSizePixel = 0,
            AutoButtonColor = false,
            [v3.Event.Activated] = not v11.props.isDisabled and v11.props.onActivated,
            [v3.Ref] = v11.props.controlRef,
            NextSelectionUp = v11.props.NextSelectionUp,
            NextSelectionDown = v11.props.NextSelectionDown,
            NextSelectionLeft = v11.props.NextSelectionLeft,
            NextSelectionRight = v11.props.NextSelectionRight,
            SelectionImageObject = v11.props.SelectionImageObject,
            isDisabled = v11.props.isDisabled,
            onStateChanged = v11.props.onStateChanged
        }, {
            Contents = v3.createElement("Frame", {
                BackgroundTransparency = 1,
                Size = UDim2.new(1, 0, 1, 0),
                LayoutOrder = 1
            }, {
                UIPadding = v3.createElement("UIPadding", {
                    PaddingLeft = UDim.new(0, 24),
                    PaddingRight = UDim.new(0, 24),
                    PaddingTop = UDim.new(0, 12),
                    PaddingBottom = UDim.new(0, 12)
                }),
                UIListLayout = v3.createElement("UIListLayout", {
                    SortOrder = Enum.SortOrder.LayoutOrder,
                    FillDirection = Enum.FillDirection.Horizontal,
                    VerticalAlignment = Enum.VerticalAlignment.Center
                }),
                Frame = v3.createElement("Frame", {
                    Size = UDim2.new(1, -v11.props.rightContentWidth - v11.props.leftContentWidth, 1, 0),
                    BackgroundTransparency = 1,
                    LayoutOrder = 2
                }, {
                    UIListLayout = v3.createElement("UIListLayout", {
                        SortOrder = Enum.SortOrder.LayoutOrder,
                        FillDirection = Enum.FillDirection.Vertical,
                        VerticalAlignment = Enum.VerticalAlignment.Center
                    }),
                    TitleText = v11.props.titleText and v3.createElement(v6, {
                        Size = UDim2.new(1, 0, 1, 0),
                        colorStyle = v11.props.textStyle,
                        fontStyle = v11.props.fontStyle,
                        Text = v11.props.titleText,
                        LayoutOrder = 1,
                        TextXAlignment = Enum.TextXAlignment.Left
                    }),
                    SubTitleText = v11.props.subtitleText and v3.createElement(v6, {
                        Size = UDim2.new(1, 0, 1, 0),
                        colorStyle = v11.props.subtitleTextStyle,
                        fontStyle = v11.props.subtitleFontStyle,
                        Text = v11.props.subtitleText,
                        LayoutOrder = 2,
                        TextXAlignment = Enum.TextXAlignment.Left
                    })
                }),
                RightContent = v11.props.renderRightContent and v11.props.renderRightContent(),
                LeftContent = v11.props.renderLeftContent and v11.props.renderLeftContent()
            }),
            Divider = v3.createElement("Frame", {
                Size = UDim2.new(1, -24, 0, 1),
                Position = UDim2.new(0, 24, 1, -1),
                BorderSizePixel = 0,
                BackgroundColor3 = v11.props.dividerStyle.Color,
                BackgroundTransparency = v11.props.dividerStyle.Transparency
            })
        })
    });
end;
return v3.forwardRef(function(v12, v13)
    return v3.createElement(v10, v4.Dictionary.join(v12, {
        controlRef = v13
    }));
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.Cryo);
local v4 = require(l_Parent_1.t);
local v5 = require(l_Parent_0.Core.Style.withStyle);
local v6 = require(l_Parent_1.UIBlox.Core.Control.Enum.ControlState);
local v7 = require(l_Parent_1.UIBlox.Core.Cell.GenericCell);
local v8 = require(l_Parent_1.UIBlox.Core.ImageSet.ImageSetComponent);
local v9 = v2.PureComponent:extend("GenericSelectionCell");
local v10 = {
    [v6.Default] = "BackgroundDefault",
    [v6.Hover] = "BackgroundOnHover",
    [v6.Pressed] = "BackgroundOnPress"
};
local v11 = {
    [v6.Default] = "IconDefault",
    [v6.Hover] = "IconEmphasis",
    [v6.Pressed] = "IconDefault"
};
local function v17(v12, v13, v14)
    local v15 = v12[v13] or v12[v6.Default];
    local v16 = {
        Color = v14.Theme[v15].Color,
        Transparency = v14.Theme[v15].Transparency
    };
    if not (v13 ~= v6.Default) or v13 == v6.Disabled then
        v16.Transparency = 1;
    end;
    return v16;
end;
local function v23(v18, v19, v20)
    local v21 = v18[v19] or v18[v6.Default];
    local v22 = {
        Color = v20.Theme[v21].Color,
        Transparency = v20.Theme[v21].Transparency
    };
    if not (v19 ~= v6.Disabled) or v19 == v6.Pressed then
        v22.Transparency = 0.5 * v22.Transparency + 0.5;
    end;
    return v22;
end;
local function _(v24, v25)
    local v26 = {
        Color = v24.Color,
        Transparency = v24.Transparency
    };
    if not (v25 ~= v6.Disabled) or v25 == v6.Pressed then
        v26.Transparency = 0.5 * v26.Transparency + 0.5;
    end;
    return v26;
end;
v9.validateProps = v4.strictInterface({
    text = v4.string,
    subtitleText = v4.optional(v4.string),
    defaultImage = v4.union(v4.string, v4.table),
    selectedImage = v4.union(v4.string, v4.table),
    defaultImageSize = v4.number,
    selectedImageSize = v4.number,
    onActivated = v4.optional(v4.callback),
    isSelected = v4.optional(v4.boolean),
    isDisabled = v4.optional(v4.boolean),
    useDefaultControlState = v4.optional(v4.boolean),
    controlRef = v4.optional(v4.table),
    NextSelectionLeft = v4.optional(v4.table),
    NextSelectionRight = v4.optional(v4.table),
    NextSelectionUp = v4.optional(v4.table),
    NextSelectionDown = v4.optional(v4.table),
    SelectionImageObject = v4.optional(v4.table)
});
v9.defaultProps = {
    isSelected = false
};
v9.init = function(v28)
    v28.state = {
        controlState = v6.Default
    };
    v28.onStateChanged = function(_, v30)
        v28:setState({
            controlState = v30
        });
    end;
end;
v9.render = function(v31)
    assert(v31.validateProps(v31.props));
    return v5(function(v32)
        local l_Font_0 = v32.Font;
        local l_Theme_0 = v32.Theme;
        local v35 = not not v31.props.useDefaultControlState and v6.Default or v31.state.controlState;
        local v36 = v23(v11, v35, v32);
        local v37 = v17(v10, v35, v32);
        local l_TextEmphasis_0 = l_Theme_0.TextEmphasis;
        local v39 = {
            Color = l_TextEmphasis_0.Color,
            Transparency = l_TextEmphasis_0.Transparency
        };
        if not (v35 ~= v6.Disabled) or v35 == v6.Pressed then
            v39.Transparency = 0.5 * v39.Transparency + 0.5;
        end;
        local l_v39_0 = v39;
        v39 = l_Theme_0.TextDefault;
        local v41 = {
            Color = v39.Color,
            Transparency = v39.Transparency
        };
        if not (v35 ~= v6.Disabled) or v35 == v6.Pressed then
            v41.Transparency = 0.5 * v41.Transparency + 0.5;
        end;
        return v2.createElement(v7, {
            titleText = v31.props.text,
            colorStyle = v37,
            textStyle = l_v39_0,
            fontStyle = l_Font_0.Header2,
            subtitleText = v31.props.subtitleText,
            subtitleTextStyle = v41,
            subtitleFontStyle = l_Font_0.Body,
            rightContentWidth = v31.props.defaultImageSize,
            onActivated = v31.props.onActivated,
            dividerStyle = l_Theme_0.Divider,
            isDisabled = v31.props.isDisabled,
            [v2.Ref] = v31.props.controlRef,
            NextSelectionUp = v31.props.NextSelectionUp,
            NextSelectionDown = v31.props.NextSelectionDown,
            NextSelectionLeft = v31.props.NextSelectionLeft,
            NextSelectionRight = v31.props.NextSelectionRight,
            SelectionImageObject = v31.props.SelectionImageObject,
            renderRightContent = function()
                return v2.createElement("Frame", {
                    BackgroundTransparency = 1,
                    Size = UDim2.new(0, v31.props.defaultImageSize, 1, 0),
                    LayoutOrder = 3
                }, {
                    SelectionImage = v2.createElement(v8.Label, {
                        BackgroundTransparency = 1,
                        Image = v31.props.defaultImage,
                        Size = UDim2.new(0, v31.props.defaultImageSize, 0, v31.props.defaultImageSize),
                        ImageColor3 = v36.Color,
                        ImageTransparency = v36.Transparency,
                        AnchorPoint = Vector2.new(0.5, 0.5),
                        Position = UDim2.new(0.5, 0, 0.5, 0)
                    }, {
                        SelectedImage = v31.props.isSelected and v2.createElement(v8.Label, {
                            BackgroundTransparency = 1,
                            Image = v31.props.selectedImage,
                            Size = UDim2.new(0, v31.props.selectedImageSize, 0, v31.props.selectedImageSize),
                            ImageColor3 = v36.Color,
                            ImageTransparency = v36.Transparency,
                            AnchorPoint = Vector2.new(0.5, 0.5),
                            Position = UDim2.new(0.5, 0, 0.5, 0)
                        })
                    })
                });
            end,
            onStateChanged = v31.onStateChanged
        });
    end);
end;
return v2.forwardRef(function(v42, v43)
    return v2.createElement(v9, v3.Dictionary.join(v42, {
        controlRef = v43
    }));
end);


local v0 = {};
v0.new = function(v1)
    local v2 = {
        defaultConfig = v1,
        defaultConfigKeys = {}
    };
    for v3 in pairs(v1) do
        table.insert(v2.defaultConfigKeys, v3);
    end;
    v2._currentConfig = setmetatable({}, {
        __index = function(_, v5)
            error(("Invalid global configuration key %q. Valid configuration keys are: %s"):format(tostring(v5), table.concat(v2.defaultConfigKeys, ", ")), 3);
        end
    });
    v2.set = function(...)
        return v0.set(v2, ...);
    end;
    v2.get = function(...)
        return v0.get(v2, ...);
    end;
    v2.scoped = function(...)
        return v0.scoped(v2, ...);
    end;
    v2.set(v1);
    return v2;
end;
v0.set = function(v6, v7)
    local v8 = {};
    local v9 = {};
    for v10, v11 in pairs(v7) do
        if v6.defaultConfig[v10] == nil then
            table.insert(v8, v10);
        elseif typeof(v11) ~= "boolean" then
            table.insert(v9, tostring(v10) .. " (type " .. typeof(v11) .. ")");
        else
            v6._currentConfig[v10] = v11;
        end;
    end;
    if next(v8) ~= nil then
        error(("Invalid global configuration keys %s. Valid configuration keys are: %s"):format(table.concat(v8, ", "), table.concat(v6.defaultConfigKeys, ", ")), 3);
    end;
    if next(v9) ~= nil then
        error(("Invalid global configuration types for keys %s. All configuration values must be boolean."):format(table.concat(v9, ", ")), 3);
    end;
end;
v0.get = function(v12)
    return v12._currentConfig;
end;
return v0;


local v0 = require(script.Parent.Config);
local function _(v1)
    if v1:sub(-1, -1) == "\n" then
        return v1:sub(1, -2);
    else
        return v1;
    end;
end;
return function(v3, v4, v5)
    if typeof(v4) ~= "string" then
        error("Bad argument #2 - expected a string for the name of the library");
    end;
    if typeof(v5) ~= "table" then
        error("Bad argument #3 - expected a default config table for the library");
    end;
    local v6 = {};
    local v7 = v0.new(v5);
    v6.init = function(v8)
        setmetatable(v6, nil);
        if v8 then
            v7.set(v8);
        end;
        v6.Config = v7.get();
        local v9 = v3(v6.Config);
        for v10, v11 in pairs(v9) do
            v6[v10] = v11;
        end;
        local v12 = debug.traceback();
        local v13 = if v12:sub(-1, -1) == "\n" then v12:sub(1, -2) else v12;
        v6.init = function(v14)
            if v14 == v8 then
                return ;
            else
                local v15 = debug.traceback();
                warn(string.format("%s has already been configured\nFirst init traceback:\n%s\nCurrent init traceback:\n%s", v4, v13, if v15:sub(-1, -1) == "\n" then v15:sub(1, -2) else v15));
                return ;
            end;
        end;
        if not _G.__UIBLOX_TRACK_USAGE__ then
            return (setmetatable(v6, {
                __index = function(_, v17)
                    error(("%q (%s) is not a valid member of %s"):format(tostring(v17), typeof(v17), v4), 2);
                end,
                __newindex = function(_, v19, _)
                    error(("%q (%s) is not a valid member of %s"):format(tostring(v19), typeof(v19), v4), 2);
                end
            }));
        else
            return (setmetatable(v6, (getmetatable(v9))));
        end;
    end;
    return (setmetatable(v6, {
        __index = function(_, _)
            error(("You must call %s.init(config) before using itformat(v4), 2);
        end,
        __newindex = function(_, _, _)
            error(("You must call %s.init(config) before using itformat(v4), 2);
        end
    }));
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 v3 = require(l_Parent_2.Roact);
local v4 = require(l_Parent_2.Cryo);
local v5 = require(l_Parent_2.t);
local v6 = require(l_Parent_0.Enum.ControlState);
local v7 = require(l_Parent_1.StateTable.StateTable);
local v8 = v3.PureComponent:extend("Controllable");
v8.init = function(v9)
    v9.isMounted = false;
    local l_Initialize_0 = v6.Initialize;
    v9.state = {
        currentState = l_Initialize_0
    };
    local v11 = string.format("Controllable(%s)", (tostring(v9)));
    v9.setDisabled = function(v12)
        if not v12 then
            v9.stateTable.events.Enable();
            return ;
        else
            v9.stateTable.events.Disable();
            return ;
        end;
    end;
    v9.stateTable = v7.new(v11, l_Initialize_0, {}, {
        [v6.Initialize] = {
            Enable = {
                nextState = v6.Default
            },
            Disable = {
                nextState = v6.Disabled
            }
        },
        [v6.Default] = {
            OnPressed = {
                nextState = v6.Pressed
            },
            StartHover = {
                nextState = v6.Hover
            },
            OnSelectionGained = {
                nextState = v6.Selected
            },
            Disable = {
                nextState = v6.Disabled
            }
        },
        [v6.Hover] = {
            OnSelectionGained = {
                nextState = v6.Selected
            },
            OnPressed = {
                nextState = v6.Pressed
            },
            EndHover = {
                nextState = v6.Default
            },
            Disable = {
                nextState = v6.Disabled
            }
        },
        [v6.Pressed] = {
            OnSelectionGained = {
                nextState = v6.SelectedPressed
            },
            OnReleased = {
                nextState = v6.Default
            },
            OnReleasedHover = {
                nextState = v6.Hover
            },
            Disable = {
                nextState = v6.Disabled
            }
        },
        [v6.Selected] = {
            OnSelectionLost = {
                nextState = v6.Default
            },
            OnPressed = {
                nextState = v6.SelectedPressed
            },
            Disable = {
                nextState = v6.Disabled
            }
        },
        [v6.SelectedPressed] = {
            OnSelectionLost = {
                nextState = v6.Default
            },
            OnReleased = {
                nextState = v6.Selected
            },
            Disable = {
                nextState = v6.Disabled
            }
        },
        [v6.Disabled] = {
            Enable = {
                nextState = v6.Default
            }
        }
    });
    v9.stateTable:onStateChange(function(v13, v14)
        v9:setState({
            currentState = v14
        });
        if v9.props.onStateChanged then
            v9.props.onStateChanged(v13, v14);
        end;
    end);
end;
v8.validateProps = v5.strictInterface({
    controlComponent = v5.strictInterface({
        component = v5.union(v5.callback, v5.string, v5.table),
        props = v5.optional(v5.table),
        children = v5.optional(v5.table)
    }),
    onStateChanged = v5.callback,
    isDisabled = v5.optional(v5.boolean),
    userInteractionEnabled = v5.optional(v5.boolean)
});
v8.defaultProps = {
    userInteractionEnabled = true,
    isDisabled = false
};
v8.render = function(v15)
    local l_controlComponent_0 = v15.props.controlComponent;
    local l_userInteractionEnabled_0 = v15.props.userInteractionEnabled;
    if v15.state.currentState == v6.Initialize then
        return nil;
    else
        local v18 = l_controlComponent_0.props and l_controlComponent_0.props.Selectable;
        if v18 == nil then
            v18 = true;
        end;
        return v3.createElement(l_controlComponent_0.component, v4.Dictionary.join(v15.props, l_controlComponent_0.props or {}, {
            Selectable = v18,
            Active = not v15.props.isDisabled,
            [v3.Event.MouseEnter] = function(...)
                if l_userInteractionEnabled_0 then
                    v15.stateTable.events.StartHover();
                    if l_controlComponent_0.props[v3.Event.MouseEnter] ~= nil then
                        return l_controlComponent_0.props[v3.Event.MouseEnter](...);
                    else
                        return nil;
                    end;
                else
                    return nil;
                end;
            end,
            [v3.Event.MouseLeave] = function(...)
                if l_userInteractionEnabled_0 then
                    v15.stateTable.events.EndHover();
                    if l_controlComponent_0.props[v3.Event.MouseLeave] ~= nil then
                        return l_controlComponent_0.props[v3.Event.MouseLeave](...);
                    else
                        return nil;
                    end;
                else
                    return nil;
                end;
            end,
            [v3.Event.InputBegan] = function(...)
                if l_userInteractionEnabled_0 then
                    local v19 = select(2, ...);
                    if not (v19.UserInputType ~= Enum.UserInputType.MouseButton1 and v19.UserInputType ~= Enum.UserInputType.Touch) or v19.KeyCode == Enum.KeyCode.ButtonA then
                        v15.stateTable.events.OnPressed();
                    end;
                    if l_controlComponent_0.props[v3.Event.InputBegan] ~= nil then
                        return l_controlComponent_0.props[v3.Event.InputBegan](...);
                    else
                        return nil;
                    end;
                else
                    return nil;
                end;
            end,
            [v3.Event.InputEnded] = function(...)
                if l_userInteractionEnabled_0 then
                    local v20 = select(2, ...);
                    if v20.UserInputType == Enum.UserInputType.MouseButton1 then
                        v15.stateTable.events.OnReleasedHover();
                    elseif not (v20.UserInputType ~= Enum.UserInputType.Touch and v20.KeyCode ~= Enum.KeyCode.ButtonA) or v20.UserInputType == Enum.UserInputType.MouseMovement then
                        v15.stateTable.events.OnReleased();
                    end;
                    if l_controlComponent_0.props[v3.Event.InputEnded] ~= nil then
                        return l_controlComponent_0.props[v3.Event.InputEnded](...);
                    else
                        return nil;
                    end;
                else
                    return nil;
                end;
            end,
            [v3.Event.SelectionGained] = function(...)
                if l_userInteractionEnabled_0 then
                    v15.stateTable.events.OnSelectionGained();
                    if l_controlComponent_0.props[v3.Event.SelectionGained] ~= nil then
                        return l_controlComponent_0.props[v3.Event.SelectionGained](...);
                    else
                        return nil;
                    end;
                else
                    return nil;
                end;
            end,
            [v3.Event.SelectionLost] = function(...)
                if l_userInteractionEnabled_0 then
                    v15.stateTable.events.OnSelectionLost();
                    if l_controlComponent_0.props[v3.Event.SelectionLost] ~= nil then
                        return l_controlComponent_0.props[v3.Event.SelectionLost](...);
                    else
                        return nil;
                    end;
                else
                    return nil;
                end;
            end,
            [v3.Event.Activated] = function(...)
                if l_userInteractionEnabled_0 then
                    if not (l_controlComponent_0.props[v3.Event.Activated] and v15.state.currentState ~= v6.Disabled) or not v15.isMounted then
                        return nil;
                    else
                        return l_controlComponent_0.props[v3.Event.Activated](...);
                    end;
                else
                    return nil;
                end;
            end,
            [v3.Ref] = l_controlComponent_0.props.forwardedRef,
            forwardedRef = v4.None,
            userInteractionEnabled = v4.None,
            isDisabled = v4.None,
            onStateChanged = v4.None,
            [v3.Children] = v4.None,
            controlComponent = v4.None
        }), l_controlComponent_0.children);
    end;
end;
v8.didMount = function(v21)
    v21.isMounted = true;
    v21.setDisabled(v21.props.isDisabled);
end;
v8.didUpdate = function(v22, v23)
    if v22.props.isDisabled ~= v23.isDisabled then
        v22.setDisabled(v22.props.isDisabled);
    end;
end;
v8.willUnmount = function(v24)
    v24.isMounted = false;
end;
return v8;


return require(script.Parent.Parent.Parent.Parent.Parent.enumerate)(script.Name, {
    "Initialize",
    "Default",
    "Pressed",
    "Hover",
    "Selected",
    "SelectedPressed",
    "Disabled"
});


return {
    Idle = "Idle",
    PointerHover = "PointerHover",
    PointerHoverEnd = "PointerHoverEnd",
    PrimaryPressed = "PrimaryPressed",
    PrimaryReleased = "PrimaryReleased",
    PrimaryReleasedHover = "PrimaryReleasedHover",
    SelectionGained = "SelectionGained",
    SelectionLost = "SelectionLost",
    Enabled = "Enabled",
    Disabled = "Disabled"
};


return require(script.Parent.Parent.Parent.Parent.Parent.enumerate)(script.Name, {
    "Single",
    "Multiple",
    "None"
});


local l_Parent_0 = script.Parent.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.React);
local l_useForwardRef_0 = require(l_Parent_1.ReactUtils).useForwardRef;
local v4 = require(l_Parent_0.Core.Control.Enum.ControlState);
local v5 = require(l_Parent_0.Core.Control.Enum.ControlStateEvent);
local v6 = require(l_Parent_0.Core.Control.createGuiControlStateTable);
return function(v7, v8, v9)
    local v10 = v2.useRef(v4.Initialize);
    local v11 = v2.useRef(v9);
    local v12 = v2.useRef(false);
    local v15 = v2.useCallback(function(v13, v14)
        v10.current = v14;
        v8(v13, v14);
    end, {
        v8
    });
    local v16 = v2.useMemo(function()
        return v6(v15);
    end, {});
    v2.useEffect(function()
        v16:onStateChange(v15);
    end, {
        v15
    });
    local v23 = v2.useCallback(function(v17)
        local v18 = {};
        if v17 then
            table.insert(v18, v17.InputBegan:Connect(function(v19)
                if v11.current then
                    if not ((v19.UserInputType ~= Enum.UserInputType.MouseButton1 and v19.UserInputType ~= Enum.UserInputType.Touch) and v19.KeyCode ~= Enum.KeyCode.ButtonA) or v19.KeyCode == Enum.KeyCode.Return then
                        v16.events[v5.PrimaryPressed]();
                    end;
                    return ;
                else
                    return nil;
                end;
            end));
            table.insert(v18, v17.InputEnded:Connect(function(v20)
                if v11.current then
                    if v20.UserInputType == Enum.UserInputType.MouseButton1 then
                        v16.events[v5.PrimaryReleasedHover]();
                        return ;
                    else
                        if not (v20.UserInputType ~= Enum.UserInputType.Touch and v20.KeyCode ~= Enum.KeyCode.ButtonA) or v20.KeyCode == Enum.KeyCode.Return then
                            v16.events[v5.PrimaryReleased]();
                        end;
                        return ;
                    end;
                else
                    return nil;
                end;
            end));
            table.insert(v18, v17.SelectionGained:Connect(function()
                if v11.current then
                    v16.events[v5.SelectionGained]();
                    return ;
                else
                    return nil;
                end;
            end));
            table.insert(v18, v17.SelectionLost:Connect(function()
                if v11.current then
                    v16.events[v5.SelectionLost]();
                    return ;
                else
                    return nil;
                end;
            end));
            table.insert(v18, v17.MouseEnter:Connect(function()
                if v11.current then
                    v12.current = true;
                    v16.events[v5.PointerHover]();
                    return ;
                else
                    return nil;
                end;
            end));
            table.insert(v18, v17.MouseLeave:Connect(function()
                if v11.current then
                    v12.current = false;
                    v16.events[v5.PointerHoverEnd]();
                    return ;
                else
                    return nil;
                end;
            end));
        end;
        return function()
            for _, v22 in ipairs(v18) do
                v22:Disconnect();
            end;
        end;
    end, {
        v16,
        v12
    });
    v2.useEffect(function()
        v11.current = v9;
    end, {
        v9
    });
    return l_useForwardRef_0(v7, v23), v16;
end;


local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.Parent.React);
local v3 = require(l_Parent_1.Core.Control.Enum.ControlState);
local v4 = require(l_Parent_0.Control.Hooks.useGuiControlState);
return function(v5, v6, v7)
    local v8, v9 = v2.useBinding(v3.Initialize);
    local v12, _ = v4(v5, v2.useCallback(function(v10, v11)
        v9((tostring(v11)));
        if v6 then
            v6(v10, v11);
        end;
    end, {}), v7);
    return v12, v8;
end;


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.Parent.Parent.React);
local v3 = require(l_Parent_0.FeedbackManagerInjectionContext);
local v4 = require(l_Parent_1.Control.Enum.ControlState);
local function v8(v5, v6)
    local _ = nil;
    if not (v6 ~= v4.Pressed) or v6 == v4.SelectedPressed then
        return "Press";
    elseif (not (v6 ~= v4.Hover) or v6 == v4.Selected) and v5 == v4.Default then
        return "Hover";
    elseif (not (v5 ~= v4.Pressed) or v5 == v4.SelectedPressed) and v6 ~= v4.Disabled then
        return "Release";
    else
        return nil;
    end;
end;
return function()
    local v9 = v2.useContext(v3);
    return v2.useCallback(function(v10, v11, v12)
        local v13 = v8(v11, v12);
        if v13 then
            v9(v10 or "Default", v13);
        end;
    end, {
        v9
    });
end;


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.UIBloxConfig);
local l_Parent_2 = l_Parent_1.Parent;
if (v2.refactorInteractable or false) == false then
    return require(script.Parent.Interactable_DEPRECATED);
else
    local v4 = require(l_Parent_2.Cryo);
    local v5 = require(l_Parent_2.React);
    local _ = require(l_Parent_0.Control.Enum.ControlState);
    local v7 = require(l_Parent_1.Core.Control.Enum.ControlStateEvent);
    local v8 = require(l_Parent_0.Control.Hooks.useGuiControlState);
    local v9 = require(l_Parent_0.Control.Hooks.useInteractionFeedback);
    local v10 = require(l_Parent_1.Core.ImageSet.ImageSetComponent);
    return v5.forwardRef(function(v11, v12)
        local v13 = v5.useRef(nil);
        local v14 = v5.useRef(nil);
        local v15 = if not v2.enableInteractionFeedback then nil else v9();
        local v16 = v5.useRef(not (v11.userInteractionEnabled ~= nil) or v11.userInteractionEnabled);
        local v19, v20 = v8(v13, v5.useCallback(function(v17, v18)
            if v2.enableInteractionFeedback then
                v15(v11.feedbackType, v17, v18);
            end;
            if v11.onStateChanged then
                v11.onStateChanged(v17, v18);
            end;
        end, {
            v11.onStateChanged,
            v15,
            v11.feedbackType
        }), v16.current);
        v5.useImperativeHandle(v12, function()
            return v13.current;
        end, {});
        local v21 = v5.useCallback(function(...)
            if v16.current ~= false and not v11.isDisabled then
                if not v11[v5.Event.Activated] then
                    return nil;
                else
                    return v11[v5.Event.Activated](...);
                end;
            else
                return nil;
            end;
        end, {
            v11[v5.Event.Activated],
            v11.isDisabled
        });
        v5.useEffect(function()
            if v11.isDisabled ~= nil then
                v14.current = v11.isDisabled;
                if not v11.isDisabled then
                    v20.events[v7.Enabled]();
                    return ;
                else
                    v20.events[v7.Disabled]();
                    return ;
                end;
            elseif v14.current == nil then
                v14.current = false;
                v20.events[v7.Enabled]();
                return ;
            else
                if v14.current == true then
                    v14.current = false;
                    v20.events[v7.Enabled]();
                end;
                return ;
            end;
        end, {
            v11.isDisabled
        });
        v5.useEffect(function()
            if v11.userInteractionEnabled ~= nil then
                v16.current = v11.userInteractionEnabled;
                return ;
            else
                v16.current = true;
                return ;
            end;
        end, {
            v11.userInteractionEnabled
        });
        return v5.createElement(v11.component or v10.Button, (v4.Dictionary.join(v11, {
            ref = v19,
            onStateChanged = v4.None,
            isDisabled = v4.None,
            userInteractionEnabled = v4.None,
            feedbackType = v4.None,
            Active = if v11.isDisabled ~= nil then not v11.isDisabled else nil,
            [v5.Event.Activated] = v21
        })));
    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_1.Cryo);
local v5 = require(l_Parent_0.Core.Control.Enum.ControlState);
local v6 = require(script.Parent.InteractableListItem);
local v7 = require(script.Parent.Enum.SelectionMode);
local v8 = v2.PureComponent:extend("InteractableList");
v8.validateProps = v3.strictInterface({
    itemList = v3.table,
    renderItem = v3.callback,
    renderList = v3.optional(v3.callback),
    selection = v3.optional(v3.table),
    selectionMode = v3.optional(v7.isEnumValue),
    onSelectionChanged = v3.optional(v3.callback),
    size = v3.optional(v3.UDim2),
    position = v3.optional(v3.UDim2),
    layoutOrder = v3.optional(v3.integer),
    padding = v3.optional(v3.UDim),
    fillDirection = v3.optional(v3.enum(Enum.FillDirection)),
    horizontalAlignment = v3.optional(v3.enum(Enum.HorizontalAlignment)),
    verticalAlignment = v3.optional(v3.enum(Enum.VerticalAlignment)),
    sortOrder = v3.optional(v3.enum(Enum.SortOrder)),
    automaticSize = v3.optional(v3.enum(Enum.AutomaticSize)),
    itemSize = v3.optional(v3.UDim2)
});
v8.defaultProps = {
    renderList = function(v9, v10, v11)
        local v12 = {
            v2.createElement("UIListLayout", {
                Padding = v11.padding,
                FillDirection = v11.fillDirection,
                HorizontalAlignment = v11.horizontalAlignment,
                VerticalAlignment = v11.verticalAlignment,
                SortOrder = v11.sortOrder,
                key = "$layout"
            })
        };
        for v13 in pairs(v9) do
            table.insert(v12, v10(v13));
        end;
        return v2.createElement("Frame", {
            Size = v11.size,
            Position = v11.position,
            BackgroundTransparency = 1,
            AutomaticSize = v11.automaticSize,
            BorderSizePixel = 0
        }, v12);
    end,
    size = UDim2.fromScale(1, 1),
    itemSize = UDim2.fromScale(1, 1),
    selectionMode = v7.Single
};
v8.init = function(v14)
    local v15 = {
        interactable = {},
        selection = {}
    };
    if v14.props.selectionMode == v7.Single then
        local v16 = next(v14.props.itemList);
        if v16 ~= nil then
            v15.selection = {
                v16
            };
        end;
    end;
    v14:setState(v15);
    v14.setInteractableState = function(v17, v18)
        v14:setState(function(v19)
            return {
                interactable = v4.Dictionary.join(v19.interactable, {
                    [v17] = v18
                })
            };
        end);
    end;
    v14.setSelection = function(v20)
        v14:setState({
            selection = v20
        });
    end;
end;
v8.getSelection = function(v21)
    if not v21.props.selection then
        if v21.props.selectionMode == v7.None then
            return {};
        else
            local v23 = v4.List.filter(v21.state.selection, function(v22)
                return v21.props.itemList[v22] ~= nil;
            end);
            if v21.props.selectionMode == v7.Single then
                local v24 = v23[#v23];
                if v24 == nil then
                    v24 = next(v21.props.itemList);
                end;
                if v24 ~= nil then
                    return {
                        v24
                    };
                else
                    return {};
                end;
            else
                return v23;
            end;
        end;
    else
        return v21.props.selection;
    end;
end;
v8.didMount = function(v25)
    if not (not (v25.props.selection == nil) or not v25.props.onSelectionChanged) then
        v25.props.onSelectionChanged(v25:getSelection());
    end;
end;
v8.render = function(v26)
    return v26.props.renderList(v26.props.itemList, function(v27)
        return v2.createElement(v6, {
            id = v27,
            item = v26.props.itemList[v27],
            interactableState = v26.state.interactable[v27] or v5.Default,
            selection = v26:getSelection(),
            renderItem = v26.props.renderItem,
            itemSize = not not v26.props.itemList[v27] and v26.props.itemList[v27].itemSize or v26.props.itemSize,
            selectionMode = v26.props.selectionMode,
            onSelectionChanged = v26.props.onSelectionChanged,
            setInteractableState = v26.setInteractableState,
            setSelection = v26.setSelection,
            key = tostring(v27)
        });
    end, v26.props);
end;
return v8;


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.Cryo);
local v4 = require(l_Parent_0.Core.Control.Interactable);
local v5 = require(script.Parent.Enum.SelectionMode);
local v6 = v2.PureComponent:extend("InteractableListItem");
v6.init = function(v7)
    v7.onStateChanged = function(_, v9)
        v7.props.setInteractableState(v7.props.id, v9);
    end;
    v7.onActivated = function()
        local l_selection_0 = v7.props.selection;
        local v11 = {
            v7.props.id
        };
        if v7.props.selectionMode == v5.Multiple then
            v11 = v3.List.filter(l_selection_0, function(v12)
                return v12 ~= v7.props.id;
            end);
            if #v11 == #l_selection_0 then
                table.insert(v11, v7.props.id);
            end;
        end;
        if v7.props.onSelectionChanged then
            v7.props.onSelectionChanged(v11, l_selection_0);
        end;
        if v7.props.selectionMode ~= v5.None then
            v7.props.setSelection(v11);
        end;
    end;
end;
v6.render = function(v13)
    local v14, v15 = v13.props.renderItem(v13.props.item, v13.props.interactableState, v3.List.find(v13.props.selection, v13.props.id) ~= nil, v13.props.id);
    return v2.createElement(v4, v3.Dictionary.join({
        Size = v13.props.itemSize,
        BackgroundTransparency = 1,
        BorderSizePixel = 0
    }, v15 or {}, {
        onStateChanged = v13.onStateChanged,
        [v2.Event.Activated] = v13.onActivated
    }), v14);
end;
return v6;


local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.Cryo);
local v3 = require(l_Parent_1.Roact);
local v4 = require(l_Parent_1.t);
local v5 = require(l_Parent_0.Core.ImageSet.ImageSetComponent);
local v6 = require(l_Parent_0.Core.Control.Controllable);
local v7 = v3.PureComponent:extend("Interactable");
v7.validateProps = v4.interface({
    isDisabled = v4.optional(v4.boolean),
    onStateChanged = v4.callback
});
v7.render = function(v8)
    return v3.createElement(v6, {
        onStateChanged = v8.props.onStateChanged,
        isDisabled = v8.props.isDisabled,
        userInteractionEnabled = v8.props.userInteractionEnabled,
        controlComponent = {
            component = v5.Button,
            props = v8.props,
            children = v8.props[v3.Children] or {}
        }
    });
end;
return v3.forwardRef(function(v9, v10)
    return v3.createElement(v7, v2.Dictionary.join(v9, {
        forwardedRef = v10
    }));
end);


local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_Parent_2 = l_Parent_1.Parent;
local l_Parent_3 = l_Parent_2.Parent;
local v4 = require(l_Parent_3.React);
local v5 = require(l_Parent_3.Cryo);
local v6 = require(l_Parent_1.Style.useStyle);
local v7 = require(l_Parent_2.App.SelectionCursor.useCursor);
local v8 = require(l_Parent_0.Interactable);
local v9 = require(l_Parent_0.Enum.ControlState);
local v10 = {
    anchorPoint = Vector2.new(0.5, 0.5),
    position = UDim2.fromScale(0.5, 0.5),
    size = UDim2.fromScale(1, 1),
    isDisabled = false,
    selectable = true,
    affordance = "Background",
    stateStyle = "Standard",
    outset = {
        top = UDim.new(0, 0),
        right = UDim.new(0, 0),
        bottom = UDim.new(0, 0),
        left = UDim.new(0, 0)
    }
};
local v11 = v9.Initialize.rawValue();
return (v4.forwardRef(function(v12, v13)
    local v14 = v5.Dictionary.join(v10, v12);
    local l_StateLayer_0 = v6().Tokens.Component.StateLayer;
    local l_Color_0 = l_StateLayer_0[v14.stateStyle][v11].Color;
    local v17, v18 = v4.useBinding(l_Color_0.Color3);
    local v19, v20 = v4.useBinding(l_Color_0.Transparency);
    local v21 = v7(v14.cornerRadius);
    local v22 = {
        ref = v13,
        AnchorPoint = v14.anchorPoint,
        Position = v14.position,
        Size = v14.size,
        LayoutOrder = v14.layoutOrder,
        ZIndex = v14.zIndex,
        BackgroundTransparency = 1
    };
    local v23 = {};
    if v14.cornerRadius ~= nil then
        v23.UICorner = v4.createElement("UICorner", {
            CornerRadius = v14.cornerRadius
        });
    end;
    if v14.affordance == "Border" then
        v23.UIStroke = v4.createElement("UIStroke", {
            Thickness = l_StateLayer_0.Base.BorderWidth,
            Color = v17,
            Transparency = v19
        });
        v22.BackgroundTransparency = 1;
    elseif v14.affordance == "Background" then
        v22.BackgroundColor3 = v17;
        v22.BackgroundTransparency = v19;
    end;
    local l_outset_0 = v14.outset;
    v23.Button = v4.createElement(v8, {
        Size = UDim2.new((1 + l_outset_0.left.Scale) + l_outset_0.right.Scale, l_outset_0.left.Offset + l_outset_0.right.Offset, (1 + l_outset_0.top.Scale) + l_outset_0.bottom.Scale, l_outset_0.top.Offset + l_outset_0.bottom.Offset),
        Position = UDim2.new(-l_outset_0.left.Scale, -l_outset_0.left.Offset, -l_outset_0.top.Scale, -l_outset_0.top.Offset),
        BackgroundTransparency = 1,
        Selectable = not v14.isDisabled and v14.selectable,
        SelectionImageObject = v21,
        [v4.Event.Activated] = v14.onActivated,
        onStateChanged = v4.useCallback(function(v25, v26)
            local l_Color_1 = l_StateLayer_0[v14.stateStyle][v26.rawValue()].Color;
            v18(l_Color_1.Color3);
            v20(l_Color_1.Transparency);
            if v14.onStateChanged then
                v14.onStateChanged(v25, v26);
            end;
        end, {
            l_StateLayer_0,
            v18,
            v20,
            v14.stateStyle,
            v14.onStateChanged
        }),
        isDisabled = v14.isDisabled,
        userInteractionEnabled = not v14.isDisabled
    });
    return v4.createElement("Frame", v22, v23);
end));


local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent.Parent;
local v2 = require(l_Parent_0.Enum.ControlState);
local v3 = require(l_Parent_0.Enum.ControlStateEvent);
local v4 = require(l_Parent_1.StateTable.StateTable);
return function(v5)
    local v6 = nil;
    v6 = v4.new("GuiStateTable", v2.Initialize, {}, {
        [v2.Initialize] = {
            [v3.Idle] = {
                nextState = v2.Default
            },
            [v3.Enabled] = {
                nextState = v2.Default
            },
            [v3.Disabled] = {
                nextState = v2.Disabled
            }
        },
        [v2.Default] = {
            [v3.PrimaryPressed] = {
                nextState = v2.Pressed
            },
            [v3.PointerHover] = {
                nextState = v2.Hover
            },
            [v3.SelectionGained] = {
                nextState = v2.Selected
            },
            [v3.Disabled] = {
                nextState = v2.Disabled
            }
        },
        [v2.Hover] = {
            [v3.SelectionGained] = {
                nextState = v2.Selected
            },
            [v3.PrimaryPressed] = {
                nextState = v2.Pressed
            },
            [v3.PointerHoverEnd] = {
                nextState = v2.Default
            },
            [v3.Disabled] = {
                nextState = v2.Disabled
            }
        },
        [v2.Pressed] = {
            [v3.SelectionGained] = {
                nextState = v2.SelectedPressed
            },
            [v3.PrimaryReleasedHover] = {
                nextState = v2.Hover
            },
            [v3.PrimaryReleased] = {
                nextState = v2.Default
            },
            [v3.Disabled] = {
                nextState = v2.Disabled
            }
        },
        [v2.Selected] = {
            [v3.SelectionLost] = {
                nextState = v2.Default
            },
            [v3.PrimaryPressed] = {
                nextState = v2.SelectedPressed
            },
            [v3.Disabled] = {
                nextState = v2.Disabled
            }
        },
        [v2.SelectedPressed] = {
            [v3.SelectionLost] = {
                nextState = v2.Default
            },
            [v3.PrimaryReleasedHover] = {
                nextState = v2.Selected
            },
            [v3.PrimaryReleased] = {
                nextState = v2.Selected
            },
            [v3.Disabled] = {
                nextState = v2.Disabled
            }
        },
        [v2.Disabled] = {
            [v3.Enabled] = {
                nextState = v2.Default
            }
        }
    });
    v6:onStateChange(v5);
    return v6;
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Parent.Parent.React);
local v2 = require(l_Parent_0.Control.Enum.ControlState);
return function()
    local v3, v4 = v1.useState(v2.Initialize);
    return v3, (v1.useCallback(function(_, v6)
        v4(v6);
    end, {}));
end;


local l_Parent_0 = script.Parent;
local v1 = require(l_Parent_0.Parent.Parent.Parent.React);
local v2 = require(l_Parent_0.Enum.Emoji);
local v3 = require(l_Parent_0.constants);
local function _(v4)
    if not v2.isEnumValue(v4) then
        return "";
    else
        return v3[v4.rawValue()];
    end;
end;
return function(v6)
    local l_createElement_0 = v1.createElement;
    local v8 = not v6.onActivated and "TextLabel" or "TextButton";
    local v9 = {
        Size = UDim2.fromScale(0, 1)
    };
    local l_emoji_0 = v6.emoji;
    v9.Text = not v2.isEnumValue(l_emoji_0) and "" or v3[l_emoji_0.rawValue()];
    v9.TextColor3 = Color3.fromHex("#fff");
    v9.AutomaticSize = Enum.AutomaticSize.X;
    v9.Font = v6.textFont;
    v9.TextSize = v6.textSize;
    v9.Position = v6.Position;
    v9.BackgroundTransparency = 1;
    v9[v1.Event.Activated] = v6.onActivated;
    return l_createElement_0(v8, v9);
end;


return require(script.Parent.Parent.Parent.Parent.Parent.enumerate)(script.Name, {
    "Verified",
    "Premium"
});


return {
    Verified = utf8.char(57344),
    Premium = utf8.char(57345)
};


local v0 = require(script.Parent.createImageSetComponent);
local l_GuiService_0 = game:GetService("GuiService");
local l_script_FirstAncestor_0 = script:FindFirstAncestor("CorePackages");
local v3 = require(script.Parent.Parent.Parent.App.ImageSet.Images);
local l_status_0, l_result_0 = pcall(l_GuiService_0.GetResolutionScale, l_GuiService_0);
if not (l_status_0 and l_script_FirstAncestor_0) then
    l_result_0 = 1;
end;
l_result_0 = v3.ImagesResolutionScale;
return {
    Button = v0("ImageButton", l_result_0),
    Label = v0("ImageLabel", l_result_0)
};


local l_Parent_0 = script.Parent;
local v1 = require(l_Parent_0.Parent.Parent.Parent.Parent.t);
return v1.union(v1.string, (require(l_Parent_0.validateImageSetData)));


local v0 = require(script.Parent.Parent.Parent.Parent.Parent.t);
return (v0.strictInterface({
    ImageRectOffset = v0.Vector2,
    ImageRectSize = v0.Vector2,
    Image = v0.string
}));


local l_Parent_0 = script.Parent.Parent.Parent;
local v1 = require(l_Parent_0.Parent.Roact);
local v2 = require(l_Parent_0.App.ImageSet.scaleSliceToResolution);
return function(v3, v4)
    assert(v4 > 0, "resolutionScale for ImageSet must be greater than 0 got " .. tostring(v4));
    return v1.forwardRef(function(v5, v6)
        local v7 = {
            [v1.Ref] = v6,
            [v1.Children] = v5[v1.Children]
        };
        local v8 = nil;
        local v9 = false;
        for v10, v11 in pairs(v5) do
            if v10 == "Image" and typeof(v11) == "table" then
                v9 = true;
                v8 = v11;
            else
                v7[v10] = v11;
            end;
        end;
        if v9 then
            for v12, v13 in pairs(v8) do
                if v7[v12] then
                    if v12 == "ImageRectOffset" then
                        v7[v12] = v13 + v7[v12] * v4;
                    elseif v12 == "ImageRectSize" then
                        v7[v12] = v7[v12] * v4;
                    end;
                else
                    v7[v12] = v13;
                end;
            end;
        end;
        if v9 then
            v7 = v2(v7, v4);
        end;
        return v1.createElement(v3, v7);
    end);
end;


return (require(script.Parent.Parent.Parent.Parent.Parent.Roact).createContext({
    absoluteSize = Vector2.new(0, 0)
}));


local v0 = require(script.Parent.Parent.Parent.Parent.Parent.Roact);
local v1 = require(script.Parent.LayerCollectorContext);
local l_GuiService_0 = game:GetService("GuiService");
local v3 = v0.PureComponent:extend("LayerCollectorProvider");
v3.init = function(v4)
    v4.rootRef = v0.createRef();
    v4.state = {
        absoluteSize = Vector2.new(0, 0)
    };
end;
v3.watchLayerCollector = function(v5, v6)
    local l_AbsoluteSize_0 = v6.AbsoluteSize;
    local l_status_0, l_result_0 = pcall(function()
        return v6.IgnoreGuiInset;
    end);
    if not (not l_status_0 or not l_result_0) then
        local l_l_GuiService_0_GuiInset_0, _ = l_GuiService_0:GetGuiInset();
        l_AbsoluteSize_0 = l_AbsoluteSize_0 + l_l_GuiService_0_GuiInset_0;
    end;
    v5:setState({
        absoluteSize = l_AbsoluteSize_0
    });
    v5.absoluteSizeConnection = v6:GetPropertyChangedSignal("AbsoluteSize"):Connect(function()
        l_AbsoluteSize_0 = v6.AbsoluteSize;
        local l_status_1, l_result_1 = pcall(function()
            return v6.IgnoreGuiInset;
        end);
        if not (not l_status_1 or not l_result_1) then
            local l_l_GuiService_0_GuiInset_1, _ = l_GuiService_0:GetGuiInset();
            l_AbsoluteSize_0 = l_AbsoluteSize_0 + l_l_GuiService_0_GuiInset_1;
        end;
        v5:setState({
            absoluteSize = l_AbsoluteSize_0
        });
    end);
end;
v3.didMount = function(v16)
    local l_current_0 = v16.rootRef.current;
    local l_l_current_0_FirstAncestorWhichIsA_0 = l_current_0:FindFirstAncestorWhichIsA("LayerCollector");
    if l_l_current_0_FirstAncestorWhichIsA_0 == nil then
        v16.ancestryConnection = l_current_0.AncestryChanged:Connect(function()
            l_l_current_0_FirstAncestorWhichIsA_0 = l_current_0:FindFirstAncestorWhichIsA("LayerCollector");
            if l_l_current_0_FirstAncestorWhichIsA_0 ~= nil then
                v16.ancestryConnection:Disconnect();
                v16.ancestryConnection = nil;
                v16:watchLayerCollector(l_l_current_0_FirstAncestorWhichIsA_0);
            end;
        end);
    else
        v16:watchLayerCollector(l_l_current_0_FirstAncestorWhichIsA_0);
    end;
end;
v3.render = function(v19)
    return v0.createElement(v1.Provider, {
        value = {
            absoluteSize = v19.state.absoluteSize
        }
    }, {
        LayerCollectorChildRef = v0.createElement("Frame", {
            Visible = false,
            [v0.Ref] = v19.rootRef
        }),
        Children = v0.createFragment(v19.props[v0.Children])
    });
end;
return v3;


local v0 = require(script.Parent.Parent.Parent.Parent.Parent.React);
local v1 = require(script.Parent.LayerCollectorContext);
return function()
    return (v0.useContext(v1));
end;


local v0 = require(script.Parent.Parent.Parent.Parent.Parent.Roact);
local v1 = require(script.Parent.LayerCollectorContext);
return function(v2)
    return v0.createElement(v1.Consumer, {
        render = v2
    });
end;


local l_Parent_0 = script.Parent.Parent.Parent.Parent.Parent;
local v1 = require(l_Parent_0.t);
local l_Array_0 = require(l_Parent_0.LuauPolyfill).Array;
local _ = function(v3, v4)
    for _, v6 in v3, nil, nil do
        if v6 == v4 then
            return true;
        end;
    end;
    return false;
end;
local _ = function(v8, v9)
    if not v8 or not v9 then
        return true;
    elseif typeof(v9) == "table" then
        for _, v11 in v9, nil, nil do
            if v11 == v8 then
                return true;
            end;
        end;
        return false;
    else
        return v9 == v8;
    end;
end;
local function v13(v14, v15, v16, v17, v18)
    local v19 = v14[v17];
    local v20 = if v19 ~= nil then v18 else -1;
    l_Array_0.forEach(v14, function(v21)
        local l_v15_0 = v15;
        local l_breakpoint_0 = v21.breakpoint;
        local v24;
        if not l_v15_0 or not l_breakpoint_0 then
            v24 = true;
        elseif typeof(l_breakpoint_0) == "table" then
            for _, v26 in l_breakpoint_0, nil, nil do
                if v26 == l_v15_0 then
                    v24 = true;
                    goto label0 --[[  true, false  ]];
                end;
            end;
            v24 = false;
        else
            v24 = l_breakpoint_0 == l_v15_0;
        end;
        ::label0::;
        if v24 then
            l_v15_0 = v16;
            l_breakpoint_0 = v21.kind;
            if not l_v15_0 or not l_breakpoint_0 then
                v24 = true;
            elseif typeof(l_breakpoint_0) == "table" then
                for _, v28 in l_breakpoint_0, nil, nil do
                    if v28 == l_v15_0 then
                        v24 = true;
                        goto label1 --[[  true, false  ]];
                    end;
                end;
                v24 = false;
            else
                v24 = l_breakpoint_0 == l_v15_0;
            end;
            ::label1::;
            if v24 then
                v24, l_v15_0 = v13(v21, v15, v16, v17, v18 + 1);
                if v20 < l_v15_0 then
                    v19 = v24;
                    v20 = l_v15_0;
                end;
            end;
        end;
    end);
    return v19, v20;
end;
local v29 = {
    name = "_default",
    min = math.huge,
    max = 0
};
local function v35(v30, v31)
    local v34 = l_Array_0.find(v30, function(v32)
        local v33 = false;
        if type(v32) == "table" then
            v33 = false;
            if type(v32.breakpoint) == "string" then
                v33 = false;
                if v31 <= (v32.max or math.huge) then
                    v33 = (v32.min or 0) <= v31;
                end;
            end;
        end;
        return v33;
    end);
    if not v34 then
        return v29;
    else
        return {
            name = v34.breakpoint,
            min = v34.min or 0,
            max = v34.max or math.huge
        };
    end;
end;
local v37 = {
    [v1.strictInterface({
        Scale = v1.number,
        Offset = v1.number
    })] = function(v36)
        return UDim.new(v36.Scale, v36.Offset);
    end
};
return {
    getValue = function(v38, v39)
        local l_config_0 = v38.config;
        local l_breakpoint_1 = v38.breakpoint;
        local l_kind_0 = v38.kind;
        local v43 = l_config_0[v39];
        local v44 = v43 ~= nil and 0 or -1;
        local l_forEach_0 = l_Array_0.forEach;
        local l_l_config_0_0 = l_config_0;
        local v47 = 0;
        local v48;
        do
            local l_v43_0, l_v44_0 = v43, v44;
            l_forEach_0(l_l_config_0_0, function(v51)
                local l_l_breakpoint_1_0 = l_breakpoint_1;
                local l_breakpoint_2 = v51.breakpoint;
                local v54;
                if not l_l_breakpoint_1_0 or not l_breakpoint_2 then
                    v54 = true;
                elseif typeof(l_breakpoint_2) == "table" then
                    for _, v56 in l_breakpoint_2, nil, nil do
                        if v56 == l_l_breakpoint_1_0 then
                            v54 = true;
                            goto label2 --[[  true, false  ]];
                        end;
                    end;
                    v54 = false;
                else
                    v54 = l_breakpoint_2 == l_l_breakpoint_1_0;
                end;
                ::label2::;
                if v54 then
                    l_l_breakpoint_1_0 = l_kind_0;
                    l_breakpoint_2 = v51.kind;
                    if not l_l_breakpoint_1_0 or not l_breakpoint_2 then
                        v54 = true;
                    elseif typeof(l_breakpoint_2) == "table" then
                        for _, v58 in l_breakpoint_2, nil, nil do
                            if v58 == l_l_breakpoint_1_0 then
                                v54 = true;
                                goto label3 --[[  true, false  ]];
                            end;
                        end;
                        v54 = false;
                    else
                        v54 = l_breakpoint_2 == l_l_breakpoint_1_0;
                    end;
                    ::label3::;
                    if v54 then
                        v54, l_l_breakpoint_1_0 = v13(v51, l_breakpoint_1, l_kind_0, v39, v47 + 1);
                        if l_v44_0 < l_l_breakpoint_1_0 then
                            l_v43_0 = v54;
                            l_v44_0 = l_l_breakpoint_1_0;
                        end;
                    end;
                end;
            end);
            v48 = l_v43_0;
            local _ = l_v44_0;
        end;
        for v60, v61 in v37, nil, nil do
            if v60(v48) then
                return v61(v48);
            end;
        end;
        return v48;
    end,
    findBreakpoint = v35
};


return require(script.Parent.Parent.Parent.Parent.Parent.Roact).createContext({
    config = {},
    breakpoint = nil,
    kind = nil,
    scrollable = false,
    multiLine = false,
    relativeHeight = nil,
    subPixelOffset = 0
});