local l___DEV___0 = _G.__DEV__;
local l___YOLO___0 = _G.__YOLO__;
local l_Parent_0 = script.Parent.Parent;
local l_Object_0 = require(l_Parent_0.LuauPolyfill).Object;
local l_console_0 = require(l_Parent_0.Shared).console;
local _ = require(script.Parent.ReactInternalTypes);
local v6 = require(script.Parent.ReactFiberLane);
local l_NoLane_0 = v6.NoLane;
local l_NoLanes_0 = v6.NoLanes;
local l_isSubsetOfLanes_0 = v6.isSubsetOfLanes;
local l_mergeLanes_0 = v6.mergeLanes;
local v11 = nil;
local function _()
    if not v11 then
        v11 = require(script.Parent["ReactFiberNewContext.new"]);
    end;
    v11.enterDisallowedContextReadInDEV();
end;
local function _()
    if not v11 then
        v11 = require(script.Parent["ReactFiberNewContext.new"]);
    end;
    v11.exitDisallowedContextReadInDEV();
end;
local v14 = require(script.Parent.ReactFiberFlags);
local l_Callback_0 = v14.Callback;
local l_ShouldCapture_0 = v14.ShouldCapture;
local l_DidCapture_0 = v14.DidCapture;
local l_debugRenderPhaseSideEffectsForStrictMode_0 = require(l_Parent_0.Shared).ReactFeatureFlags.debugRenderPhaseSideEffectsForStrictMode;
local l_StrictMode_0 = require(script.Parent.ReactTypeOfMode).StrictMode;
local l_markSkippedUpdateLanes_0 = require(script.Parent.ReactFiberWorkInProgress).markSkippedUpdateLanes;
local l_describeError_0 = require(l_Parent_0.Shared).describeError;
local l_ConsolePatchingDev_0 = require(l_Parent_0.Shared).ConsolePatchingDev;
local l_disableLogs_0 = l_ConsolePatchingDev_0.disableLogs;
local l_reenableLogs_0 = l_ConsolePatchingDev_0.reenableLogs;
local v25 = {
    UpdateState = 0,
    ReplaceState = 1,
    ForceUpdate = 2,
    CaptureUpdate = 3
};
local v26 = false;
local v27 = nil;
local v28 = nil;
if l___DEV___0 then
    v27 = false;
    v28 = nil;
    v25.resetCurrentlyProcessingQueue = function()
        v28 = nil;
    end;
end;
local v29 = table.create(210);
local v30 = 210;
for v31 = 1, 210 do
    v29[v31] = {
        eventTime = -1,
        lane = -1,
        tag = -1,
        payload = nil,
        callback = nil,
        next = nil
    };
end;
v25.initializeUpdateQueue = function(v32)
    v32.updateQueue = {
        baseState = v32.memoizedState,
        firstBaseUpdate = nil,
        lastBaseUpdate = nil,
        shared = {
            pending = nil
        },
        effects = nil
    };
end;
v25.cloneUpdateQueue = function(v33, v34)
    local l_updateQueue_0 = v34.updateQueue;
    local l_updateQueue_1 = v33.updateQueue;
    if l_updateQueue_0 == l_updateQueue_1 then
        v34.updateQueue = table.clone(l_updateQueue_1);
    end;
end;
v25.createUpdate = function(v37, v38, v39, v40)
    if v30 > 0 then
        local v41 = v29[v30];
        v29[v30] = nil;
        v30 = v30 - 1;
        v41.eventTime = v37;
        v41.lane = v38;
        v41.tag = 0;
        v41.payload = v39;
        v41.callback = v40;
        return v41;
    else
        return {
            eventTime = v37,
            lane = v38,
            tag = 0,
            payload = v39,
            callback = v40,
            next = nil
        };
    end;
end;
v25.enqueueUpdate = function(v42, v43)
    local l_updateQueue_2 = v42.updateQueue;
    if l_updateQueue_2 == nil then
        return ;
    else
        local l_shared_0 = l_updateQueue_2.shared;
        local l_pending_0 = l_shared_0.pending;
        if l_pending_0 == nil then
            v43.next = v43;
        else
            v43.next = l_pending_0.next;
            l_pending_0.next = v43;
        end;
        l_shared_0.pending = v43;
        if not (not (l___DEV___0 and v28 == l_shared_0) or v27) then
            l_console_0.error("An update (setState, replaceState, or forceUpdate) was scheduled " .. "from inside an update function. Update functions should be pure, " .. "with zero side-effects. Consider using componentDidUpdate or a " .. "callback.");
            v27 = true;
        end;
        return ;
    end;
end;
v25.enqueueCapturedUpdate = function(v47, v48)
    local l_updateQueue_3 = v47.updateQueue;
    local l_alternate_0 = v47.alternate;
    if l_alternate_0 ~= nil then
        local l_updateQueue_4 = l_alternate_0.updateQueue;
        if l_updateQueue_3 == l_updateQueue_4 then
            local v52 = nil;
            local v53 = nil;
            local l_firstBaseUpdate_0 = l_updateQueue_3.firstBaseUpdate;
            if l_firstBaseUpdate_0 ~= nil then
                local l_l_firstBaseUpdate_0_0 = l_firstBaseUpdate_0;
                while true do
                    local v56 = {
                        eventTime = l_l_firstBaseUpdate_0_0.eventTime,
                        lane = l_l_firstBaseUpdate_0_0.lane,
                        tag = l_l_firstBaseUpdate_0_0.tag,
                        payload = l_l_firstBaseUpdate_0_0.payload,
                        callback = l_l_firstBaseUpdate_0_0.callback,
                        next = nil
                    };
                    if v53 == nil then
                        v53 = v56;
                        v52 = v56;
                    else
                        v53.next = v56;
                        v53 = v56;
                    end;
                    l_l_firstBaseUpdate_0_0 = l_l_firstBaseUpdate_0_0.next;
                    if not (l_l_firstBaseUpdate_0_0 ~= nil) then
                        break;
                    end;
                end;
                if v53 == nil then
                    v53 = v48;
                    v52 = v48;
                else
                    v53.next = v48;
                    v53 = v48;
                end;
            else
                v53 = v48;
                v52 = v48;
            end;
            v47.updateQueue = {
                baseState = l_updateQueue_4.baseState,
                firstBaseUpdate = v52,
                lastBaseUpdate = v53,
                shared = l_updateQueue_4.shared,
                effects = l_updateQueue_4.effects
            };
            return ;
        end;
    end;
    local l_lastBaseUpdate_0 = l_updateQueue_3.lastBaseUpdate;
    if l_lastBaseUpdate_0 == nil then
        l_updateQueue_3.firstBaseUpdate = v48;
    else
        l_lastBaseUpdate_0.next = v48;
    end;
    l_updateQueue_3.lastBaseUpdate = v48;
end;
local function v77(v58, _, v60, v61, v62, _)
    local l_tag_0 = v60.tag;
    if l_tag_0 == 1 then
        local l_payload_0 = v60.payload;
        if type(l_payload_0) == "function" then
            if l___DEV___0 then
                if not v11 then
                    v11 = require(script.Parent["ReactFiberNewContext.new"]);
                end;
                v11.enterDisallowedContextReadInDEV();
            end;
            local v66 = l_payload_0(v61, v62);
            if l___DEV___0 then
                if l_debugRenderPhaseSideEffectsForStrictMode_0 and bit32.band(v58.mode, l_StrictMode_0) ~= 0 then
                    l_disableLogs_0();
                    local v67 = nil;
                    local v68 = nil;
                    if l___YOLO___0 then
                        v67 = true;
                        l_payload_0(v61, v62);
                    else
                        local v69, v70 = xpcall(l_payload_0, l_describeError_0, v61, v62);
                        v67 = v69;
                        v68 = v70;
                    end;
                    l_reenableLogs_0();
                    if not v67 then
                        error(v68);
                    end;
                end;
                if not v11 then
                    v11 = require(script.Parent["ReactFiberNewContext.new"]);
                end;
                v11.exitDisallowedContextReadInDEV();
            end;
            return v66;
        else
            return l_payload_0;
        end;
    elseif not (l_tag_0 ~= 3) or l_tag_0 == 0 then
        if l_tag_0 == 3 then
            v58.flags = bit32.bor(bit32.band(v58.flags, (bit32.bnot(l_ShouldCapture_0))), l_DidCapture_0);
        end;
        local l_payload_1 = v60.payload;
        local v72 = nil;
        if type(l_payload_1) == "function" then
            if l___DEV___0 then
                if not v11 then
                    v11 = require(script.Parent["ReactFiberNewContext.new"]);
                end;
                v11.enterDisallowedContextReadInDEV();
            end;
            v72 = l_payload_1(v61, v62);
            if l___DEV___0 then
                if l_debugRenderPhaseSideEffectsForStrictMode_0 and bit32.band(v58.mode, l_StrictMode_0) ~= 0 then
                    l_disableLogs_0();
                    local v73 = nil;
                    local v74 = nil;
                    if l___YOLO___0 then
                        v73 = true;
                        l_payload_1(v61, v62);
                    else
                        local v75, v76 = xpcall(l_payload_1, l_describeError_0, v61, v62);
                        v73 = v75;
                        v74 = v76;
                    end;
                    l_reenableLogs_0();
                    if not v73 then
                        error(v74);
                    end;
                end;
                if not v11 then
                    v11 = require(script.Parent["ReactFiberNewContext.new"]);
                end;
                v11.exitDisallowedContextReadInDEV();
            end;
        else
            v72 = l_payload_1;
        end;
        if v72 == nil then
            return v61;
        else
            return l_Object_0.assign({}, v61, v72);
        end;
    elseif l_tag_0 == 2 then
        v26 = true;
        return v61;
    else
        return v61;
    end;
end;
v25.getStateFromUpdate = v77;
v25.processUpdateQueue = function(v78, v79, v80, v81)
    local l_updateQueue_5 = v78.updateQueue;
    v26 = false;
    if l___DEV___0 then
        v28 = l_updateQueue_5.shared;
    end;
    local l_firstBaseUpdate_1 = l_updateQueue_5.firstBaseUpdate;
    local l_lastBaseUpdate_1 = l_updateQueue_5.lastBaseUpdate;
    local l_pending_1 = l_updateQueue_5.shared.pending;
    if l_pending_1 ~= nil then
        l_updateQueue_5.shared.pending = nil;
        local l_l_pending_1_0 = l_pending_1;
        local l_next_0 = l_l_pending_1_0.next;
        l_l_pending_1_0.next = nil;
        if l_lastBaseUpdate_1 == nil then
            l_firstBaseUpdate_1 = l_next_0;
        else
            l_lastBaseUpdate_1.next = l_next_0;
        end;
        l_lastBaseUpdate_1 = l_l_pending_1_0;
        local l_alternate_1 = v78.alternate;
        if l_alternate_1 ~= nil then
            local l_updateQueue_6 = l_alternate_1.updateQueue;
            local l_lastBaseUpdate_2 = l_updateQueue_6.lastBaseUpdate;
            if l_lastBaseUpdate_2 ~= l_lastBaseUpdate_1 then
                if l_lastBaseUpdate_2 == nil then
                    l_updateQueue_6.firstBaseUpdate = l_next_0;
                else
                    l_lastBaseUpdate_2.next = l_next_0;
                end;
                l_updateQueue_6.lastBaseUpdate = l_l_pending_1_0;
            end;
        end;
    end;
    if l_firstBaseUpdate_1 ~= nil then
        local l_baseState_0 = l_updateQueue_5.baseState;
        local l_l_NoLanes_0_0 = l_NoLanes_0;
        local v93 = nil;
        local v94 = nil;
        local v95 = nil;
        local l_l_firstBaseUpdate_1_0 = l_firstBaseUpdate_1;
        while true do
            local l_lane_0 = l_l_firstBaseUpdate_1_0.lane;
            local l_eventTime_0 = l_l_firstBaseUpdate_1_0.eventTime;
            if l_isSubsetOfLanes_0(v81, l_lane_0) then
                if v95 ~= nil then
                    local v99 = {
                        eventTime = l_eventTime_0,
                        lane = l_NoLane_0,
                        tag = l_l_firstBaseUpdate_1_0.tag,
                        payload = l_l_firstBaseUpdate_1_0.payload,
                        callback = l_l_firstBaseUpdate_1_0.callback,
                        next = nil
                    };
                    v95.next = v99;
                    v95 = v99;
                end;
                l_baseState_0 = v77(v78, l_updateQueue_5, l_l_firstBaseUpdate_1_0, l_baseState_0, v79, v80);
                if l_l_firstBaseUpdate_1_0.callback ~= nil and l_l_firstBaseUpdate_1_0.lane ~= l_NoLane_0 then
                    v78.flags = bit32.bor(v78.flags, l_Callback_0);
                    local l_effects_0 = l_updateQueue_5.effects;
                    if l_effects_0 == nil then
                        l_updateQueue_5.effects = {
                            l_l_firstBaseUpdate_1_0
                        };
                    else
                        table.insert(l_effects_0, l_l_firstBaseUpdate_1_0);
                    end;
                end;
            else
                local v101 = {
                    eventTime = l_eventTime_0,
                    lane = l_lane_0,
                    tag = l_l_firstBaseUpdate_1_0.tag,
                    payload = l_l_firstBaseUpdate_1_0.payload,
                    callback = l_l_firstBaseUpdate_1_0.callback,
                    next = nil
                };
                if v95 == nil then
                    v94 = v101;
                    v95 = v101;
                    v93 = l_baseState_0;
                else
                    v95.next = v101;
                    v95 = v101;
                end;
                l_l_NoLanes_0_0 = l_mergeLanes_0(l_l_NoLanes_0_0, l_lane_0);
            end;
            l_l_firstBaseUpdate_1_0 = l_l_firstBaseUpdate_1_0.next;
            if not (l_l_firstBaseUpdate_1_0 == nil) then
                continue;
            end;
            l_pending_1 = l_updateQueue_5.shared.pending;
            if not (l_pending_1 == nil) then
                local l_l_pending_1_1 = l_pending_1;
                local l_next_1 = l_l_pending_1_1.next;
                l_l_pending_1_1.next = nil;
                l_l_firstBaseUpdate_1_0 = l_next_1;
                l_updateQueue_5.lastBaseUpdate = l_l_pending_1_1;
                l_updateQueue_5.shared.pending = nil;
            else
                break;
            end;
        end;
        if v95 == nil then
            v93 = l_baseState_0;
        end;
        l_updateQueue_5.baseState = v93;
        l_updateQueue_5.firstBaseUpdate = v94;
        l_updateQueue_5.lastBaseUpdate = v95;
        l_markSkippedUpdateLanes_0(l_l_NoLanes_0_0);
        v78.lanes = l_l_NoLanes_0_0;
        v78.memoizedState = l_baseState_0;
    end;
    if l___DEV___0 then
        v28 = nil;
    end;
end;
local function _(v104, v105)
    if type(v104) ~= "function" then
        error(string.format("Invalid argument passed as callback. Expected a function. Instead " .. "received: %s", (tostring(v104))));
    end;
    v104(v105);
end;
v25.resetHasForceUpdateBeforeProcessing = function()
    v26 = false;
end;
v25.checkHasForceUpdateAfterProcessing = function()
    return v26;
end;
v25.commitUpdateQueue = function(_, v108, v109)
    local l_effects_1 = v108.effects;
    v108.effects = nil;
    if l_effects_1 ~= nil then
        for _, v112 in l_effects_1, nil, nil do
            local l_callback_0 = v112.callback;
            if l_callback_0 ~= nil then
                if type(l_callback_0) ~= "function" then
                    error(string.format("Invalid argument passed as callback. Expected a function. Instead " .. "received: %s", (tostring(l_callback_0))));
                end;
                l_callback_0(v109);
            end;
            table.clear(v112);
            table.insert(v29, v112);
            v30 = v30 + 1;
        end;
    end;
end;
return v25;


return {
    FunctionComponent = 0,
    ClassComponent = 1,
    IndeterminateComponent = 2,
    HostRoot = 3,
    HostPortal = 4,
    HostComponent = 5,
    HostText = 6,
    Fragment = 7,
    Mode = 8,
    ContextConsumer = 9,
    ContextProvider = 10,
    ForwardRef = 11,
    Profiler = 12,
    SuspenseComponent = 13,
    MemoComponent = 14,
    SimpleMemoComponent = 15,
    LazyComponent = 16,
    IncompleteClassComponent = 17,
    DehydratedFragment = 18,
    SuspenseListComponent = 19,
    FundamentalComponent = 20,
    ScopeComponent = 21,
    Block = 22,
    OffscreenComponent = 23,
    LegacyHiddenComponent = 24
};


local l_Parent_0 = script.Parent.Parent;
local l_Array_0 = require(l_Parent_0.LuauPolyfill).Array;
local _ = require(script.Parent.ReactInternalTypes);
local v3 = require(l_Parent_0.Scheduler);
local l_decoupleUpdatePriorityFromScheduler_0 = require(l_Parent_0.Shared).ReactFeatureFlags.decoupleUpdatePriorityFromScheduler;
local l_invariant_0 = require(l_Parent_0.Shared).invariant;
local l_describeError_0 = require(l_Parent_0.Shared).describeError;
local v7 = require(script.Parent.ReactFiberLane);
local l_SyncLanePriority_0 = v7.SyncLanePriority;
local l_getCurrentUpdateLanePriority_0 = v7.getCurrentUpdateLanePriority;
local l_setCurrentUpdateLanePriority_0 = v7.setCurrentUpdateLanePriority;
local l_unstable_runWithPriority_0 = v3.unstable_runWithPriority;
local l_unstable_scheduleCallback_0 = v3.unstable_scheduleCallback;
local l_unstable_cancelCallback_0 = v3.unstable_cancelCallback;
local l_unstable_shouldYield_0 = v3.unstable_shouldYield;
local l_unstable_requestPaint_0 = v3.unstable_requestPaint;
local l_unstable_now_0 = v3.unstable_now;
local l_unstable_getCurrentPriorityLevel_0 = v3.unstable_getCurrentPriorityLevel;
local l_unstable_ImmediatePriority_0 = v3.unstable_ImmediatePriority;
local l_unstable_UserBlockingPriority_0 = v3.unstable_UserBlockingPriority;
local l_unstable_NormalPriority_0 = v3.unstable_NormalPriority;
local l_unstable_LowPriority_0 = v3.unstable_LowPriority;
local l_unstable_IdlePriority_0 = v3.unstable_IdlePriority;
local v23 = require(script.Parent["ReactFiberSchedulerPriorities.roblox"]);
local l_ImmediatePriority_0 = v23.ImmediatePriority;
local l_UserBlockingPriority_0 = v23.UserBlockingPriority;
local l_NormalPriority_0 = v23.NormalPriority;
local l_LowPriority_0 = v23.LowPriority;
local l_IdlePriority_0 = v23.IdlePriority;
local l_NoPriority_0 = v23.NoPriority;
local v30 = nil;
local v31 = {};
local v32 = nil;
v32 = if l_unstable_requestPaint_0 ~= nil then l_unstable_requestPaint_0 else function()
end;
local v33 = nil;
local v34 = nil;
local v35 = false;
local v36 = l_unstable_now_0();
local function v37()
    return l_unstable_now_0() - v36;
end;
local function v39()
    local v38 = l_unstable_getCurrentPriorityLevel_0();
    if v38 == l_unstable_ImmediatePriority_0 then
        return l_ImmediatePriority_0;
    elseif v38 == l_unstable_UserBlockingPriority_0 then
        return l_UserBlockingPriority_0;
    elseif v38 == l_unstable_NormalPriority_0 then
        return l_NormalPriority_0;
    elseif v38 == l_unstable_LowPriority_0 then
        return l_LowPriority_0;
    elseif v38 == l_unstable_IdlePriority_0 then
        return l_IdlePriority_0;
    else
        l_invariant_0(false, "Unknown priority level.");
        return l_NoPriority_0;
    end;
end;
reactPriorityToSchedulerPriority = function(v40)
    if v40 == l_ImmediatePriority_0 then
        return l_unstable_ImmediatePriority_0;
    elseif v40 == l_UserBlockingPriority_0 then
        return l_unstable_UserBlockingPriority_0;
    elseif v40 == l_NormalPriority_0 then
        return l_unstable_NormalPriority_0;
    elseif v40 == l_LowPriority_0 then
        return l_unstable_LowPriority_0;
    elseif v40 == l_IdlePriority_0 then
        return l_unstable_IdlePriority_0;
    else
        l_invariant_0(false, "Unknown priority level.");
        return nil;
    end;
end;
local function v43(v41, v42)
    return l_unstable_runWithPriority_0(reactPriorityToSchedulerPriority(v41), v42);
end;
local function v47(v44, v45, v46)
    return l_unstable_scheduleCallback_0(reactPriorityToSchedulerPriority(v44), v45, v46);
end;
local function v49(v48)
    if v33 == nil then
        v33 = {
            v48
        };
        v34 = l_unstable_scheduleCallback_0(l_unstable_ImmediatePriority_0, v30);
    else
        table.insert(v33, v48);
    end;
    return v31;
end;
local function v51(v50)
    if v50 ~= v31 then
        l_unstable_cancelCallback_0(v50);
    end;
end;
local function v53()
    if v34 ~= nil then
        local l_v34_0 = v34;
        v34 = nil;
        l_unstable_cancelCallback_0(l_v34_0);
    end;
    return v30();
end;
v30 = function()
    if not v35 and v33 ~= nil then
        v35 = true;
        local v54 = 1;
        if not l_decoupleUpdatePriorityFromScheduler_0 then
            local v55 = nil;
            local v56 = nil;
            if _G.__YOLO__ then
                v55 = true;
                local l_v33_0 = v33;
                local _ = l_unstable_runWithPriority_0(reactPriorityToSchedulerPriority(l_ImmediatePriority_0), function()
                    for v58, v59 in l_v33_0, nil, nil do
                        v54 = v58;
                        while true do
                            v59 = v59(true);
                            if not (v59 ~= nil) then
                                break;
                            end;
                        end;
                    end;
                end);
                v33 = nil;
            else
                local l_v33_1 = v33;
                local v64, v65 = xpcall(v43, l_describeError_0, l_ImmediatePriority_0, function()
                    for v62, v63 in l_v33_1, nil, nil do
                        v54 = v62;
                        while true do
                            v63 = v63(true);
                            if not (v63 ~= nil) then
                                break;
                            end;
                        end;
                    end;
                end);
                v55 = v64;
                v56 = v65;
                v33 = nil;
            end;
            v35 = false;
            if not v55 then
                if v33 ~= nil then
                    v33 = l_Array_0.slice(v33, v54 + 1);
                end;
                l_unstable_scheduleCallback_0(l_unstable_ImmediatePriority_0, v53);
                error(v56);
            end;
        else
            local v66 = l_getCurrentUpdateLanePriority_0();
            local v67 = true;
            local v68 = nil;
            if _G.__YOLO__ then
                v67 = true;
                local l_v33_2 = v33;
                l_setCurrentUpdateLanePriority_0(l_SyncLanePriority_0);
                local _ = l_unstable_runWithPriority_0(reactPriorityToSchedulerPriority(l_ImmediatePriority_0), function()
                    for v70, v71 in l_v33_2, nil, nil do
                        v54 = v70;
                        while true do
                            v71 = v71(true);
                            if not (v71 ~= nil) then
                                break;
                            end;
                        end;
                        v54 = v54 + 1;
                    end;
                end);
                v33 = nil;
            else
                local l_v33_3 = v33;
                l_setCurrentUpdateLanePriority_0(l_SyncLanePriority_0);
                local v76, v77 = xpcall(v43, l_describeError_0, l_ImmediatePriority_0, function()
                    for v74, v75 in l_v33_3, nil, nil do
                        v54 = v74;
                        while true do
                            v75 = v75(true);
                            if not (v75 ~= nil) then
                                break;
                            end;
                        end;
                    end;
                end);
                v67 = v76;
                v68 = v77;
                v33 = nil;
            end;
            l_setCurrentUpdateLanePriority_0(v66);
            v35 = false;
            if not v67 then
                if v33 ~= nil then
                    v33 = l_Array_0.slice(v33, v54 + 1);
                end;
                l_unstable_scheduleCallback_0(l_unstable_ImmediatePriority_0, v53);
                error(v68);
            end;
        end;
        return true;
    else
        return false;
    end;
end;
return {
    ImmediatePriority = l_ImmediatePriority_0,
    UserBlockingPriority = l_UserBlockingPriority_0,
    NormalPriority = l_NormalPriority_0,
    LowPriority = l_LowPriority_0,
    IdlePriority = l_IdlePriority_0,
    NoPriority = l_NoPriority_0,
    getCurrentPriorityLevel = v39,
    flushSyncCallbackQueue = v53,
    runWithPriority = v43,
    scheduleCallback = v47,
    scheduleSyncCallback = v49,
    cancelCallback = v51,
    now = v37,
    requestPaint = v32,
    shouldYield = l_unstable_shouldYield_0
};


local v0 = {};
local l_Parent_0 = script.Parent.Parent;
local l_WeakMap_0 = require(l_Parent_0.LuauPolyfill).WeakMap;
local _ = require(script.Parent.ReactFiberLane);
local _ = require(script.Parent.ReactInternalTypes);
local _ = require(l_Parent_0.Shared);
local l_enableSchedulingProfiler_0 = require(l_Parent_0.Shared).ReactFeatureFlags.enableSchedulingProfiler;
local l_ReactVersion_0 = require(l_Parent_0.Shared).ReactVersion;
local l_getComponentName_0 = require(l_Parent_0.Shared).getComponentName;
local v9 = _G.performance ~= nil;
local v11 = _G.performance or {
    mark = function(v10)
        debug.profilebegin(v10);
        debug.profileend();
    end
};
formatLanes = function(v12)
    return (tostring(v12));
end;
if not (not l_enableSchedulingProfiler_0 or not v9) then
    v11.mark("--react-init-" .. tostring(l_ReactVersion_0));
end;
v0.markCommitStarted = function(v13)
    if not (not l_enableSchedulingProfiler_0 or not v9) then
        v11.mark("--commit-start-" .. formatLanes(v13));
    end;
end;
v0.markCommitStopped = function()
    if not (not l_enableSchedulingProfiler_0 or not v9) then
        v11.mark("--commit-stop");
    end;
end;
local v14 = l_WeakMap_0.new();
local v15 = 0;
getWakeableID = function(v16)
    if not v14:has(v16) then
        v14:set(v16, v15);
        v15 = v15 + 1;
    end;
    return v14:get(v16);
end;
v0.markComponentSuspended = function(v17, v18)
    if not (not l_enableSchedulingProfiler_0 or not v9) then
        local v19 = getWakeableID(v18);
        local v20 = l_getComponentName_0(v17.type) or "Unknown";
        v11.mark("--suspense-suspend-" .. tostring(v19) .. "-" .. v20);
        v18:andThen(function()
            v11.mark("--suspense-resolved-" .. tostring(v19) .. "-" .. v20);
        end, function()
            v11.mark("--suspense-rejected-" .. tostring(v19) .. "-" .. v20);
        end);
    end;
end;
v0.markLayoutEffectsStarted = function(v21)
    if not (not l_enableSchedulingProfiler_0 or not v9) then
        v11.mark("--layout-effects-start-" .. formatLanes(v21));
    end;
end;
v0.markLayoutEffectsStopped = function()
    if not (not l_enableSchedulingProfiler_0 or not v9) then
        v11.mark("--layout-effects-stop");
    end;
end;
v0.markPassiveEffectsStarted = function(v22)
    if not (not l_enableSchedulingProfiler_0 or not v9) then
        v11.mark("--passive-effects-start-" .. formatLanes(v22));
    end;
end;
v0.markPassiveEffectsStopped = function()
    if not (not l_enableSchedulingProfiler_0 or not v9) then
        v11.mark("--passive-effects-stop");
    end;
end;
v0.markRenderStarted = function(v23)
    if not (not l_enableSchedulingProfiler_0 or not v9) then
        v11.mark("--render-start-" .. formatLanes(v23));
    end;
end;
v0.markRenderYielded = function()
    if not (not l_enableSchedulingProfiler_0 or not v9) then
        v11.mark("--render-yield");
    end;
end;
v0.markRenderStopped = function()
    if not (not l_enableSchedulingProfiler_0 or not v9) then
        v11.mark("--render-stop");
    end;
end;
v0.markRenderScheduled = function(v24)
    if not (not l_enableSchedulingProfiler_0 or not v9) then
        v11.mark("--schedule-render-" .. formatLanes(v24));
    end;
end;
v0.markForceUpdateScheduled = function(v25, v26)
    if not (not l_enableSchedulingProfiler_0 or not v9) then
        v11.mark("--schedule-forced-update-" .. formatLanes(v26) .. "-" .. (l_getComponentName_0(v25.type) or "Unknown"));
    end;
end;
v0.markStateUpdateScheduled = function(v27, v28)
    if not (not l_enableSchedulingProfiler_0 or not v9) then
        v11.mark("--schedule-state-update-" .. formatLanes(v28) .. "-" .. (l_getComponentName_0(v27.type) or "Unknown"));
    end;
end;
return v0;


local _ = require(script.ReactInternalTypes);
local _ = require(script.ReactRootTags);
return function(v2)
    local v3 = require(script.ReactFiberHostConfig);
    for v4, v5 in v2, nil, nil do
        v3[v4] = v5;
    end;
    return require(script.ReactFiberReconciler);
end;


local l_Parent_0 = script.Parent.Parent.Parent;
local _ = require(l_Parent_0.Shared);
local _ = require(script.Parent["ReactRobloxHostTypes.roblox"]);
local v3 = nil;
v3 = require(script.Parent.ReactRobloxRoot);
local l_createRoot_0 = v3.createRoot;
local l_createBlockingRoot_0 = v3.createBlockingRoot;
local l_createLegacyRoot_0 = v3.createLegacyRoot;
local l_isValidContainer_0 = v3.isValidContainer;
local v8 = require(script.Parent.Parent["ReactReconciler.roblox"]);
local l_batchedUpdates_0 = v8.batchedUpdates;
local l_injectIntoDevTools_0 = v8.injectIntoDevTools;
local l_flushPassiveEffects_0 = v8.flushPassiveEffects;
local l_IsThisRendererActing_0 = v8.IsThisRendererActing;
local l_createPortal_0 = v8.createPortal;
local l_ReactVersion_0 = require(l_Parent_0.Shared).ReactVersion;
local l_invariant_0 = require(l_Parent_0.Shared).invariant;
local l_enableNewReconciler_0 = require(l_Parent_0.Shared).ReactFeatureFlags.enableNewReconciler;
local v17 = require(script.Parent.ReactRobloxComponentTree);
local l_getInstanceFromNode_0 = v17.getInstanceFromNode;
local l_getNodeFromInstance_0 = v17.getNodeFromInstance;
local l_getFiberCurrentPropsFromNode_0 = v17.getFiberCurrentPropsFromNode;
local l_getClosestInstanceFromNode_0 = v17.getClosestInstanceFromNode;
local v26 = {
    createPortal = function(v22, v23, v24)
        l_invariant_0(l_isValidContainer_0(v23), "Target container is not a Roblox Instance.");
        return l_createPortal_0(v22, v23, nil, v24);
    end,
    unstable_batchedUpdates = l_batchedUpdates_0,
    __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = {
        Events = {
            getInstanceFromNode = l_getInstanceFromNode_0,
            getNodeFromInstance = l_getNodeFromInstance_0,
            getFiberCurrentPropsFromNode = l_getFiberCurrentPropsFromNode_0,
            flushPassiveEffects = l_flushPassiveEffects_0,
            IsThisRendererActing = l_IsThisRendererActing_0
        }
    },
    version = l_ReactVersion_0,
    createRoot = l_createRoot_0,
    createBlockingRoot = l_createBlockingRoot_0,
    createLegacyRoot = l_createLegacyRoot_0,
    Event = require(l_Parent_0.Shared).Event,
    Change = require(l_Parent_0.Shared).Change,
    Tag = require(l_Parent_0.Shared).Tag,
    unstable_isNewReconciler = l_enableNewReconciler_0,
    act = function(_)
        error("ReactRoblox.act is only available in testing environments, not " .. "production. Enable the `__ROACT_17_MOCK_SCHEDULER__` global in your " .. "test configuration in order to use `act`.");
    end
};
if _G.__ROACT_17_MOCK_SCHEDULER__ then
    v26.act = v8.act;
end;
local _ = l_injectIntoDevTools_0({
    findFiberByHostInstance = l_getClosestInstanceFromNode_0,
    bundleType = not _G.__DEV__ and 0 or 1,
    version = l_ReactVersion_0,
    rendererPackageName = "ReactRoblox"
});
if _G.__DEV__ then
end;
return v26;


local l_Object_0 = require(script.Parent.Parent.Parent.LuauPolyfill).Object;
local v1 = require(script.Parent.roblox.RobloxComponentProps);
local _ = require(script.Parent["ReactRobloxHostTypes.roblox"]);
return {
    setInitialProperties = v1.setInitialProperties,
    diffProperties = function(_, _, v5, v6, _)
        local v8 = nil;
        for v9, _ in v5, nil, nil do
            if v6[v9] == nil then
                v8 = v8 or table.create(2);
                table.insert(v8, v9);
                table.insert(v8, l_Object_0.None);
            end;
        end;
        for v11, v12 in v6, nil, nil do
            if v12 ~= if v5 ~= nil then v5[v11] else nil then
                v8 = v8 or table.create(2);
                table.insert(v8, v11);
                table.insert(v8, v12);
            end;
        end;
        return v8;
    end,
    updateProperties = v1.updateProperties,
    cleanupHostComponent = v1.cleanupHostComponent
};


local l_Parent_0 = script.Parent.Parent.Parent;
local _ = require(script.Parent["ReactRobloxHostTypes.roblox"]);
local _ = require(l_Parent_0.ReactReconciler);
local v3 = require(l_Parent_0.Shared);
local v4 = nil;
local v5 = nil;
local v6 = nil;
local v7 = nil;
local v8 = nil;
local v9 = nil;
local l_invariant_0 = v3.invariant;
local v11 = {};
local v12 = {};
local v13 = {};
local v14 = {};
local v15 = string.sub(tostring(math.random()), 3);
local v16 = "__reactFiber$" .. v15;
local v17 = "__reactContainer$" .. v15;
v11.precacheFiberNode = function(v18, v19)
    v13[v19] = v18;
end;
v11.uncacheFiberNode = function(v20)
    v13[v20] = nil;
    v14[v20] = nil;
end;
v11.markContainerAsRoot = function(v21, v22)
    v12[v22] = v21;
end;
v11.unmarkContainerAsRoot = function(v23)
    v12[v23] = nil;
end;
v11.isContainerMarkedAsRoot = function(v24)
    return not not v12[v24];
end;
v11.getClosestInstanceFromNode = function(v25)
    local v26 = v13[v25];
    if not v26 then
        local l_Parent_1 = v25.Parent;
        while true do
            if not l_Parent_1 then
                return nil;
            else
                v26 = v13[l_Parent_1];
                if not v26 then
                    v25 = l_Parent_1;
                    l_Parent_1 = v25.Parent;
                else
                    local l_alternate_0 = v26.alternate;
                    if not (v26.child == nil) or l_alternate_0 ~= nil and l_alternate_0.child ~= nil then
                        if v9 == nil then
                            v9 = require(script.Parent.ReactRobloxHostConfig).getParentSuspenseInstance;
                        end;
                        local v29 = v9(v25);
                        while v29 ~= nil do
                            local v30 = v13[v29];
                            if not v30 then
                                v29 = v9(v29);
                            else
                                return v30;
                            end;
                        end;
                    end;
                    return v26;
                end;
            end;
        end;
    else
        return v26;
    end;
end;
v11.getInstanceFromNode = function(v31)
    if v4 == nil then
        v4 = require(script.Parent.Parent["ReactReconciler.roblox"]).ReactWorkTags;
        v5 = v4.HostComponent;
        v6 = v4.HostComponent;
        v7 = v4.HostComponent;
        v8 = v4.HostComponent;
    end;
    local v32 = v31[v16] or v31[v17];
    if not v32 then
        return nil;
    elseif not ((v32.tag ~= v5 and v32.tag ~= v6) and v32.tag ~= v8) or v32.tag == v7 then
        return v32;
    else
        return nil;
    end;
end;
v11.getNodeFromInstance = function(v33)
    if not (v33.tag ~= v5) or v33.tag == v6 then
        return v33.stateNode;
    else
        l_invariant_0(false, "getNodeFromInstance: Invalid argument.");
        error("getNodeFromInstance: Invalid argument.");
        return ;
    end;
end;
v11.getFiberCurrentPropsFromNode = function(v34)
    return v14[v34];
end;
v11.updateFiberProps = function(v35, v36)
    v14[v35] = v36;
end;
return v11;


local function _(v0)
    print("");
    print("");
    print("UNIMPLEMENTED ERROR: " .. tostring(v0));
    error("FIXME (roblox): " .. v0 .. " is unimplemented", 2);
end;
local l_CollectionService_0 = game:GetService("CollectionService");
local l_Parent_0 = script.Parent.Parent.Parent;
local v4 = require(l_Parent_0.LuauPolyfill);
local l_inspect_0 = v4.util.inspect;
local l_console_0 = require(l_Parent_0.Shared).console;
local l_Object_0 = v4.Object;
local l_setTimeout_0 = v4.setTimeout;
local l_clearTimeout_0 = v4.clearTimeout;
local _ = require(script.Parent["ReactRobloxHostTypes.roblox"]);
local v11 = require(script.Parent.ReactRobloxComponentTree);
local l_precacheFiberNode_0 = v11.precacheFiberNode;
local l_uncacheFiberNode_0 = v11.uncacheFiberNode;
local l_updateFiberProps_0 = v11.updateFiberProps;
local v15 = require(script.Parent.ReactRobloxComponent);
local l_setInitialProperties_0 = v15.setInitialProperties;
local l_diffProperties_0 = v15.diffProperties;
local l_updateProperties_0 = v15.updateProperties;
local l_cleanupHostComponent_0 = v15.cleanupHostComponent;
local l_enableCreateEventHandleAPI_0 = require(l_Parent_0.Shared).ReactFeatureFlags.enableCreateEventHandleAPI;
local _ = function(v21)
    if typeof(v21) ~= "Instance" then
        return ;
    else
        l_uncacheFiberNode_0(v21);
        for _, v23 in v21:GetDescendants() do
            l_uncacheFiberNode_0(v23);
        end;
        return ;
    end;
end;
local v25 = {};
l_Object_0.assign(v25, require(l_Parent_0.Shared).ReactFiberHostConfig.WithNoPersistence);
v25.getRootHostContext = function(v26)
    return v26.ClassName;
end;
v25.getChildHostContext = function(v27, _, _)
    return v27;
end;
v25.getPublicInstance = function(v30)
    return v30;
end;
v25.prepareForCommit = function(_)
    if l_enableCreateEventHandleAPI_0 then
        print("");
        print("");
        print("UNIMPLEMENTED ERROR: " .. tostring("enableCreateEventHandleAPI"));
        error("FIXME (roblox): " .. "enableCreateEventHandleAPI" .. " is unimplemented", 2);
    end;
    return nil;
end;
v25.beforeActiveInstanceBlur = function()
    if l_enableCreateEventHandleAPI_0 then
        print("");
        print("");
        print("UNIMPLEMENTED ERROR: " .. tostring("enableCreateEventHandleAPI"));
        error("FIXME (roblox): " .. "enableCreateEventHandleAPI" .. " is unimplemented", 2);
    end;
end;
v25.afterActiveInstanceBlur = function()
    if l_enableCreateEventHandleAPI_0 then
        print("");
        print("");
        print("UNIMPLEMENTED ERROR: " .. tostring("enableCreateEventHandleAPI"));
        error("FIXME (roblox): " .. "enableCreateEventHandleAPI" .. " is unimplemented", 2);
    end;
end;
v25.resetAfterCommit = function(_)
end;
v25.createInstance = function(v33, v34, _, _, v37)
    local v38 = Instance.new(v33);
    if not v37.key then
        local l_return__0 = v37.return_;
        while l_return__0 do
            if not l_return__0.key then
                l_return__0 = l_return__0.return_;
            else
                v38.Name = l_return__0.key;
                break;
            end;
        end;
    else
        v38.Name = v37.key;
    end;
    l_precacheFiberNode_0(v37, v38);
    l_updateFiberProps_0(v38, v34);
    return v38;
end;
v25.appendInitialChild = function(v40, v41)
    v41.Parent = v40;
end;
v25.finalizeInitialChildren = function(v42, v43, v44, v45, _)
    l_setInitialProperties_0(v42, v43, v44, v45);
    return false;
end;
v25.prepareUpdate = function(v47, v48, v49, v50, v51, _)
    return l_diffProperties_0(v47, v48, v49, v50, v51);
end;
v25.shouldSetTextContent = function(_, _)
    return false;
end;
v25.createTextInstance = function(_, _, _, _)
    print("");
    print("");
    print("UNIMPLEMENTED ERROR: " .. tostring("createTextInstance"));
    error("FIXME (roblox): " .. "createTextInstance" .. " is unimplemented", 2);
    return nil;
end;
v25.isPrimaryRenderer = true;
v25.warnsIfNotActing = true;
v25.scheduleTimeout = l_setTimeout_0;
v25.cancelTimeout = l_clearTimeout_0;
v25.noTimeout = -1;
v25.supportsMutation = true;
v25.commitMount = function(_, _, _, _)
    print("");
    print("");
    print("UNIMPLEMENTED ERROR: " .. tostring("commitMount"));
    error("FIXME (roblox): " .. "commitMount" .. " is unimplemented", 2);
end;
v25.commitUpdate = function(v63, v64, _, v66, v67, _)
    l_updateFiberProps_0(v63, v67);
    l_updateProperties_0(v63, v64, v66);
end;
local function v70(v69)
    if typeof(v69) ~= "Instance" then
        l_console_0.warn("Could not check tags on non-instance %s.", l_inspect_0(v69));
        return ;
    else
        if not v69:IsDescendantOf(game) and #l_CollectionService_0:GetTags(v69) > 0 then
            l_console_0.warn("Tags applied to orphaned %s \"%s\" cannot be accessed via" .. " CollectionService:GetTagged. If you're relying on tag" .. " behavior in a unit test, consider mounting your test " .. "root into the DataModel.", v69.ClassName, v69.Name);
        end;
        return ;
    end;
end;
v25.appendChild = function(v71, v72)
    v72.Parent = v71;
    if _G.__DEV__ then
        v70(v72);
    end;
end;
v25.appendChildToContainer = function(v73, v74)
    v25.appendChild(v73, v74);
end;
v25.insertBefore = function(v75, v76, _)
    v76.Parent = v75;
    if _G.__DEV__ then
        v70(v76);
    end;
end;
v25.insertInContainerBefore = function(v78, v79, v80)
    v25.insertBefore(v78, v79, v80);
end;
v25.removeChild = function(_, v82)
    if not (typeof(v82) ~= "Instance") then
        l_uncacheFiberNode_0(v82);
        for _, v84 in v82:GetDescendants() do
            l_uncacheFiberNode_0(v84);
        end;
    end;
    l_cleanupHostComponent_0(v82);
    v82.Parent = nil;
    v82:Destroy();
end;
v25.removeChildFromContainer = function(v85, v86)
    v25.removeChild(v85, v86);
end;
v25.clearSuspenseBoundary = function(_, _)
    print("");
    print("");
    print("UNIMPLEMENTED ERROR: " .. tostring("clearSuspenseBoundary"));
    error("FIXME (roblox): " .. "clearSuspenseBoundary" .. " is unimplemented", 2);
end;
v25.clearSuspenseBoundaryFromContainer = function(_, _)
    print("");
    print("");
    print("UNIMPLEMENTED ERROR: " .. tostring("clearSuspenseBoundaryFromContainer"));
    error("FIXME (roblox): " .. "clearSuspenseBoundaryFromContainer" .. " is unimplemented", 2);
end;
v25.hideInstance = function(_)
    print("");
    print("");
    print("UNIMPLEMENTED ERROR: " .. tostring("hideInstance"));
    error("FIXME (roblox): " .. "hideInstance" .. " is unimplemented", 2);
end;
v25.hideTextInstance = function(_)
    print("");
    print("");
    print("UNIMPLEMENTED ERROR: " .. tostring("hideTextInstance"));
    error("FIXME (roblox): " .. "hideTextInstance" .. " is unimplemented", 2);
end;
v25.unhideInstance = function(_, _)
    print("");
    print("");
    print("UNIMPLEMENTED ERROR: " .. tostring("unhideInstance"));
    error("FIXME (roblox): " .. "unhideInstance" .. " is unimplemented", 2);
end;
v25.unhideTextInstance = function(_, _)
    print("");
    print("");
    print("UNIMPLEMENTED ERROR: " .. tostring("unhideTextInstance"));
    error("FIXME (roblox): " .. "unhideTextInstance" .. " is unimplemented", 2);
end;
v25.clearContainer = function(v97)
    for _, v99 in v97:GetChildren() do
        v25.removeChild(v97, v99);
    end;
end;
v25.preparePortalMount = function(_)
end;
return v25;


local l_Parent_0 = script.Parent.Parent.Parent;
local _ = require(l_Parent_0.ReactReconciler);
local _ = require(l_Parent_0.Shared);
return {};


local l_Parent_0 = script.Parent.Parent.Parent;
local _ = require(script.Parent["ReactRobloxHostTypes.roblox"]);
local _ = require(l_Parent_0.ReactReconciler);
local _ = require(l_Parent_0.Shared);
local _ = require(l_Parent_0.ReactReconciler);
local v5 = require(script.Parent.ReactRobloxComponentTree);
local l_markContainerAsRoot_0 = v5.markContainerAsRoot;
local l_unmarkContainerAsRoot_0 = v5.unmarkContainerAsRoot;
local v8 = require(script.Parent.Parent["ReactReconciler.roblox"]);
local l_createContainer_0 = v8.createContainer;
local l_updateContainer_0 = v8.updateContainer;
local l_invariant_0 = require(l_Parent_0.Shared).invariant;
local l_enableEagerRootListeners_0 = require(l_Parent_0.Shared).ReactFeatureFlags.enableEagerRootListeners;
local l_BlockingRoot_0 = v8.ReactRootTags.BlockingRoot;
local l_ConcurrentRoot_0 = v8.ReactRootTags.ConcurrentRoot;
local l_LegacyRoot_0 = v8.ReactRootTags.LegacyRoot;
local v16 = nil;
local v17 = {};
v17.__index = v17;
v17.new = function(v18, v19)
    local v20 = setmetatable({}, v17);
    v20._internalRoot = v16(v18, l_ConcurrentRoot_0, v19);
    return v20;
end;
local function _(v21, v22, v23)
    local v24 = setmetatable({}, v17);
    v24._internalRoot = v16(v21, v22, v23);
    return v24;
end;
v17.render = function(v26, v27)
    l_updateContainer_0(v27, v26._internalRoot, nil);
end;
v17.unmount = function(v28)
    local l__internalRoot_0 = v28._internalRoot;
    local l_containerInfo_0 = l__internalRoot_0.containerInfo;
    l_updateContainer_0(nil, l__internalRoot_0, nil, function()
        l_unmarkContainerAsRoot_0(l_containerInfo_0);
    end);
end;
v16 = function(v31, v32, v33)
    local v34 = false;
    if v33 ~= nil then
        v34 = v33.hydrate == true;
    end;
    local v35 = if v33 ~= nil then v33.hydrationOptions else nil;
    local v36 = (v33 ~= nil and v33.hydrationOptions ~= nil) and v33.hydrationOptions.mutableSources or nil;
    local v37 = l_createContainer_0(v31, v32, v34, v35);
    l_markContainerAsRoot_0(v37.current, v31);
    if l_enableEagerRootListeners_0 then
    end;
    if v36 then
    end;
    return v37;
end;
local v49 = {
    isValidContainer = function(v38)
        return typeof(v38) == "Instance";
    end,
    createRoot = function(v39, v40)
        l_invariant_0(typeof(v39) == "Instance", "createRoot(...): Target container is not a Roblox Instance.");
        warnIfReactDOMContainerInDEV(v39);
        return v17.new(v39, v40);
    end,
    createBlockingRoot = function(v41, v42)
        l_invariant_0(typeof(v41) == "Instance", "createRoot(...): Target container is not a Roblox Instance.");
        warnIfReactDOMContainerInDEV(v41);
        local l_l_BlockingRoot_0_0 = l_BlockingRoot_0;
        local v44 = setmetatable({}, v17);
        v44._internalRoot = v16(v41, l_l_BlockingRoot_0_0, v42);
        return v44;
    end,
    createLegacyRoot = function(v45, v46)
        local l_l_LegacyRoot_0_0 = l_LegacyRoot_0;
        local v48 = setmetatable({}, v17);
        v48._internalRoot = v16(v45, l_l_LegacyRoot_0_0, v46);
        return v48;
    end
};
warnIfReactDOMContainerInDEV = function(_)
    if _G.__DEV__ then
    end;
end;
return v49;


local l___DEV___0 = _G.__DEV__;
local l_CollectionService_0 = game:GetService("CollectionService");
local l_Parent_0 = script.Parent.Parent.Parent.Parent;
local v3 = require(l_Parent_0.LuauPolyfill);
local l_Object_0 = v3.Object;
local l_Set_0 = v3.Set;
local l_String_0 = v3.String;
local l_inspect_0 = v3.util.inspect;
local l_console_0 = require(l_Parent_0.Shared).console;
local v9 = require(l_Parent_0.React);
local l_ReactSymbols_0 = require(l_Parent_0.Shared).ReactSymbols;
local v11 = require(script.Parent.SingleEventManager);
local l_Type_0 = require(l_Parent_0.Shared).Type;
local v13 = require(script.Parent.getDefaultInstanceProperty);
local _ = require(script.Parent.Parent["ReactRobloxHostTypes.roblox"]);
local l_Tag_0 = require(l_Parent_0.React).Tag;
local v16 = {};
local v17 = {};
local function v18(...)
    return ...;
end;
local function v24(v19, v20, v21)
    if v21 == nil then
        local _, v23 = v13(v19.ClassName, v20);
        v21 = v23;
    end;
    v19[v20] = v21;
end;
local function _(v25, v26)
    local v27 = v17[v25];
    if v27 ~= nil then
        v27[v26]();
        v27[v26] = nil;
    end;
end;
local function v37(v29, v30, v31)
    local function v36(v32)
        local v33, v34 = xpcall(v24, v18, v29, v30, v32);
        if not v33 then
            local v35 = string.format("Error updating binding or ref assigned to key %s of '%s' (%s).\n\nUpdated value:\n  %s\n\nError:\n  %s\n\n%s\n", v30, v29.Name, v29.ClassName, tostring(v32), v34, v31._source or "<enable DEV mode for stack>");
            l_console_0.error(v35);
            error(v35, 0);
        end;
    end;
    if v17[v29] == nil then
        v17[v29] = {};
    end;
    v17[v29][v30] = v9.__subscribeToBinding(v31, v36);
    v36(v31:getValue());
end;
local function v47(v38, v39, v40)
    if (l___DEV___0 and v40 ~= nil) and typeof(v40) ~= "string" then
        l_console_0.error("Type provided for ReactRoblox.Tag is invalid - tags should be " .. "specified as a single string, with individual tags delimited " .. "by spaces. Instead received:\n%s", l_inspect_0(v40));
        return ;
    else
        local v41 = l_Set_0.new(l_String_0.split(v39 or "", " "));
        local v42 = l_Set_0.new(l_String_0.split(v40 or "", " "));
        for _, v44 in v41, nil, nil do
            if not v42:has(v44) then
                l_CollectionService_0:RemoveTag(v38, v44);
            end;
        end;
        for _, v46 in v42, nil, nil do
            if not v41:has(v46) then
                l_CollectionService_0:AddTag(v38, v46);
            end;
        end;
        return ;
    end;
end;
local _ = function(v48)
    for _, v50 in l_CollectionService_0:GetTags(v48) do
        l_CollectionService_0:RemoveTag(v48, v50);
    end;
end;
local function v65(v52, v53, v54, v55)
    local v56 = l_Type_0.of(v53);
    if not (v56 ~= l_Type_0.HostEvent) or v56 == l_Type_0.HostChangeEvent then
        local v57 = v16[v52];
        if v57 == nil then
            v57 = v11.new(v52);
            v16[v52] = v57;
        end;
        local l_name_0 = v53.name;
        if v56 == l_Type_0.HostChangeEvent then
            v57:connectPropertyChange(l_name_0, v54);
            return ;
        else
            v57:connectEvent(l_name_0, v54);
            return ;
        end;
    else
        local v59 = false;
        if typeof(v54) == "table" then
            v59 = v54["$$typeof"] == l_ReactSymbols_0.REACT_BINDING_TYPE;
        end;
        local v60 = false;
        if v55 ~= nil then
            v60 = false;
            if typeof(v55) == "table" then
                v60 = v55["$$typeof"] == l_ReactSymbols_0.REACT_BINDING_TYPE;
            end;
        end;
        if v60 then
            local v61 = v17[v52];
            if v61 ~= nil then
                v61[v53]();
                v61[v53] = nil;
            end;
        end;
        if not v59 then
            if v53 == l_Tag_0 then
                v47(v52, v55, v54);
                return ;
            else
                local l_v54_0 = v54;
                if l_v54_0 == nil then
                    local _, v64 = v13(v52.ClassName, v53);
                    l_v54_0 = v64;
                end;
                v52[v53] = l_v54_0;
                return ;
            end;
        else
            v37(v52, v53, v54);
            return ;
        end;
    end;
end;
local function v70(v66, v67)
    for v68, v69 in v67, nil, nil do
        if v68 ~= "ref" and v68 ~= "children" then
            v65(v66, v68, v69);
        end;
    end;
end;
local function v78(v71, _, v73, _)
    local v75, v76 = xpcall(v70, v18, v71, v73);
    if not v75 then
        local v77 = string.format("Error applying initial props to Roblox Instance '%s' (%s):\n  %s\n", v71.Name, v71.ClassName, v76);
        l_console_0.error(v77);
        error(v77, 0);
    end;
    if v16[v71] ~= nil then
        v16[v71]:resume();
    end;
end;
local function v85(v79, v80, v81)
    for v82 = 1, #v80, 2 do
        local v83 = v80[v82];
        local v84 = v80[v82 + 1];
        if v84 == l_Object_0.None then
            v84 = nil;
        end;
        if v83 ~= "ref" and v83 ~= "children" then
            v65(v79, v83, v84, v81[v83]);
        end;
    end;
end;
return {
    setInitialProperties = v78,
    updateProperties = function(v86, v87, v88)
        if v16[v86] ~= nil then
            v16[v86]:suspend();
        end;
        local v89, v90 = xpcall(v85, v18, v86, v87, v88);
        if not v89 then
            local v91 = string.format("Error updating props on Roblox Instance '%s' (%s):\n  %s\n", v86.Name, v86.ClassName, v90);
            l_console_0.error(v91);
            error(v91, 0);
        end;
        if v16[v86] ~= nil then
            v16[v86]:resume();
        end;
    end,
    cleanupHostComponent = function(v92)
        if v16[v92] ~= nil then
            v16[v92] = nil;
        end;
        if v17[v92] ~= nil then
            v17[v92] = nil;
        end;
        if typeof(v92) ~= "Instance" then
            return ;
        else
            for _, v94 in l_CollectionService_0:GetTags(v92) do
                l_CollectionService_0:RemoveTag(v92, v94);
            end;
            for _, v96 in v92:GetDescendants() do
                if v16[v96] ~= nil then
                    v16[v96] = nil;
                end;
                if v17[v96] ~= nil then
                    v17[v96] = nil;
                end;
                for _, v98 in l_CollectionService_0:GetTags(v92) do
                    l_CollectionService_0:RemoveTag(v92, v98);
                end;
            end;
            return ;
        end;
    end,
    _instanceToEventManager = v16,
    _instanceToBindings = v17
};


local l_console_0 = require(script.Parent.Parent.Parent.Parent.Shared).console;
local v1 = {
    Disabled = "Disabled",
    Suspended = "Suspended",
    Enabled = "Enabled"
};
local v2 = {};
v2.__index = v2;
v2.new = function(v3)
    return (setmetatable({
        _suspendedEventQueue = {},
        _connections = {},
        _listeners = {},
        _status = v1.Disabled,
        _isResuming = false,
        _instance = v3
    }, v2));
end;
v2.connectEvent = function(v4, v5, v6)
    v4:_connect(v5, v4._instance[v5], v6);
end;
v2.connectPropertyChange = function(v7, v8, v9)
    local l_status_0, l_result_0 = pcall(v7._instance.GetPropertyChangedSignal, v7._instance, v8);
    if not l_status_0 then
        error(string.format("Cannot get changed signal on property %q: %s", tostring(v8), l_result_0), 0);
    end;
    v7:_connect("Change." .. v8, l_result_0, v9);
end;
v2._connect = function(v12, v13, v14, v15)
    if v15 == nil then
        if v12._connections[v13] ~= nil then
            v12._connections[v13]:Disconnect();
            v12._connections[v13] = nil;
        end;
        v12._listeners[v13] = nil;
        return ;
    else
        if v12._connections[v13] == nil then
            v12._connections[v13] = v14:Connect(function(...)
                if v12._status == v1.Enabled then
                    v12._listeners[v13](v12._instance, ...);
                    return ;
                else
                    if v12._status == v1.Suspended then
                        table.insert(v12._suspendedEventQueue, {
                            v13,
                            select("#", ...),
                            ...
                        });
                    end;
                    return ;
                end;
            end);
        end;
        v12._listeners[v13] = v15;
        return ;
    end;
end;
v2.suspend = function(v16)
    v16._status = v1.Suspended;
end;
v2.resume = function(v17)
    if not v17._isResuming then
        v17._isResuming = true;
        for _, v19 in v17._suspendedEventQueue, nil, nil do
            local v20 = v17._listeners[v19[1]];
            local v21 = v19[2];
            if v20 ~= nil then
                local v22, v23 = coroutine.resume(coroutine.create(v20), v17._instance, unpack(v19, 3, 2 + v21));
                if not v22 then
                    l_console_0.warn("%s", v23);
                end;
            end;
        end;
        v17._isResuming = false;
        v17._status = v1.Enabled;
        table.clear(v17._suspendedEventQueue);
        return ;
    else
        return ;
    end;
end;
return v2;


local v0 = require(script.Parent.Parent.Parent.Parent.Shared).Symbol.named("Nil");
local v1 = {};
local function v4(v2, v3)
    return v2[v3];
end;
return function(v5, v6)
    local v7 = v1[v5];
    if not v7 then
        v7 = {};
        v1[v5] = v7;
    else
        local v8 = v7[v6];
        if v8 == v0 then
            return true, nil;
        elseif v8 ~= nil then
            return true, v8;
        end;
    end;
    local v9 = Instance.new(v5);
    local l_status_0, l_result_0 = pcall(v4, v9, v6);
    v9:Destroy();
    if l_status_0 then
        if l_result_0 == nil then
            v7[v6] = v0;
            return l_status_0, l_result_0;
        else
            v7[v6] = l_result_0;
        end;
    end;
    return l_status_0, l_result_0;
end;


local _ = require(script.client["ReactRobloxHostTypes.roblox"]);
return require(script.client.ReactRoblox);


local l_Parent_0 = script.Parent.Parent;
local l_console_0 = require(l_Parent_0.LuauPolyfill).console;
local v2 = require(l_Parent_0.Promise);
local v3 = {};
local l_act_0 = require(script.Parent.jsHelpers["react-dom"]["test-utils"]).act;
local v5 = l_act_0 ~= nil;
local v6 = false;
local v7 = nil;
local function v21(v8)
    if v5 == true then
        if v7 == nil then
            return v2.new(function(v9, v10)
                local l_error_0 = l_console_0.error;
                l_console_0.error = function(...)
                    local v12 = table.pack(...);
                    local v13 = typeof(v12[1]) == "string";
                    if v13 and string.find(v12[1], "Warning: Do not await the result of calling ReactTestUtils.act") == 1 then
                        v7 = false;
                        return ;
                    elseif v13 and string.find(v12[1], "Warning: The callback passed to ReactTestUtils.act(...) function must not return anything") == 1 then
                        return ;
                    else
                        l_error_0(...);
                        return ;
                    end;
                end;
                local v14 = nil;
                local v15 = nil;
                local l_status_0, l_result_0 = pcall(function()
                    v15 = l_act_0(function()
                        v14 = v8();
                        return v14;
                    end);
                end);
                if l_status_0 then
                    v15:andThen(function()
                        l_console_0.error = l_error_0;
                        v7 = true;
                        v9();
                    end, function(v18)
                        l_console_0.error = l_error_0;
                        v7 = true;
                        v10(v18);
                    end);
                    if v7 == false then
                        l_console_0.error = l_error_0;
                        if not v6 then
                            l_console_0.error("It looks like you're using a version of react-dom that supports the \"act\" function, but not an awaitable version of \"act\" which you will need. Please upgrade to at least react-dom@16.9.0 to remove this warning.");
                            v6 = true;
                        end;
                        v14:andThen(function()
                            v2.resolve():andThen(function()
                                l_act_0(function()
                                end);
                                v9();
                            end);
                        end, v10);
                    end;
                    return ;
                else
                    l_console_0.error = l_error_0;
                    v10(l_result_0);
                    return ;
                end;
            end);
        elseif v7 == false then
            local v19 = nil;
            l_act_0(function()
                v19 = v8();
            end);
            return (v19:andThen(function()
                return v2.resolve():andThen(function()
                    l_act_0(function()
                    end);
                end);
            end));
        else
            return l_act_0(v8);
        end;
    else
        local v20 = nil;
        l_act_0(function()
            v20 = v8();
        end);
        return v20:andThen(function()
            return v2.resolve():andThen(function()
                l_act_0(function()
                end);
            end);
        end);
    end;
end;
v3.default = l_act_0;
v3.asyncAct = v21;
return v3;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.LuauPolyfill);
local l_Array_0 = v1.Array;
local l_Object_0 = v1.Object;
local v4 = {};
local l_fireEvent_0 = require(l_Parent_0.DomTestingLibrary).fireEvent;
local v7 = setmetatable({}, {
    __call = function(_, ...)
        return l_fireEvent_0(...);
    end
});
l_Array_0.forEach(l_Object_0.keys(l_fireEvent_0), function(v8)
    v7[v8] = function(...)
        return l_fireEvent_0[v8](...);
    end;
end);
local l_mouseEnter_0 = v7.mouseEnter;
local l_mouseLeave_0 = v7.mouseLeave;
v7.mouseEnter = function(...)
    l_mouseEnter_0(...);
    return v7.mouseOver(...);
end;
v7.mouseLeave = function(...)
    l_mouseLeave_0(...);
    return v7.mouseOut(...);
end;
local l_pointerEnter_0 = v7.pointerEnter;
local l_pointerLeave_0 = v7.pointerLeave;
v7.pointerEnter = function(...)
    l_pointerEnter_0(...);
    return v7.pointerOver(...);
end;
v7.pointerLeave = function(...)
    l_pointerLeave_0(...);
    return v7.pointerOut(...);
end;
local l_blur_0 = v7.blur;
local l_focus_0 = v7.focus;
v7.blur = function(...)
    v7.focusOut(...);
    return l_blur_0(...);
end;
v7.focus = function(...)
    v7.focusIn(...);
    return l_focus_0(...);
end;
v4.fireEvent = v7;
return v4;


local l_Parent_0 = script.Parent;
local l_afterEach_0 = require(l_Parent_0.JestGlobals).afterEach;
local l_Object_0 = require(l_Parent_0.LuauPolyfill).Object;
local v3 = require(script.jsHelpers.isCallable);
local v4 = {};
local l_cleanup_0 = require(script.pure).cleanup;
if not (_G.RTL_SKIP_AUTO_CLEANUP or not v3(l_afterEach_0)) then
    l_afterEach_0(function()
        l_cleanup_0();
    end);
end;
l_Object_0.assign(v4, require(script.pure));
local _ = require(script.types);
return v4;


local v0 = {};
local function v1(v2, v3, v4)
    local l_v2_Children_0 = v2:GetChildren();
    if #l_v2_Children_0 == 0 then
        return nil;
    else
        for v6 = 1, #l_v2_Children_0 do
            if not v4 or not v2.Name then
                local v7 = v1(l_v2_Children_0[v6], v3, true);
                if v7 then
                    return v7;
                end;
            else
                return v2;
            end;
        end;
        return nil;
    end;
end;
v0.getElementByName = function(v8, v9, _)
    return (v1(v8, v9));
end;
return v0;


local l_document_0 = require(script.Parent.Parent.Parent.DomTestingLibrary).document;
return {
    toBeInTheDocument = function(v1, v2, _)
        local v4 = {
            isNot = v1.isNot,
            promise = v1.promise
        };
        return {
            message = function()
                return v1.utils.matcherHint("toBeInTheDocument", nil, nil, v4) .. "\n\n" .. (not v1.isNot and "element could not be found in the document" or "element was found in the document");
            end,
            pass = v2:IsDescendantOf(l_document_0)
        };
    end,
    toBeEmptyDOMElement = function(v5, v6, _)
        local v8 = {
            isNot = v5.isNot,
            promise = v5.promise
        };
        return {
            message = function()
                return v5.utils.matcherHint("toBeEmptyDOMElement", nil, nil, v8) .. "\n\n" .. (not v5.isNot and "element is not empty" or "element is empty");
            end,
            pass = #v6:GetChildren() == 0
        };
    end,
    toHaveTextContent = function(v9, v10, v11)
        if v10:IsA("TextBox") then
            error("toHaveTextContent is not meant to be used with TextBox");
        end;
        local l_Text_0 = v10.Text;
        local v13 = not v11;
        if not v13 then
            v13 = true;
            if v11 ~= "" then
                v13 = l_Text_0 == "";
            end;
        end;
        local v14 = nil;
        if typeof(v11) == "string" then
            v14 = string.find(l_Text_0, v11, 1, true);
        elseif typeof(v11) == "table" and typeof(v11.test) == "function" then
            v14 = v11:test(l_Text_0);
        else
            error("Unhandled expected value type: string or regex is required");
        end;
        local v15 = {
            isNot = v9.isNot,
            promise = v9.promise
        };
        return {
            message = function()
                return v9.utils.matcherHint("toHaveTextContent", nil, nil, v15) .. "\n\n" .. if not v13 then "Expected element " .. (not v9.isNot and "to" or "not to") .. " have text content" else "Checking with empty string will always match, use .toBeEmptyDOMElement() instead";
            end,
            pass = not v13 and not not v14
        };
    end
};


local l_Array_0 = require(script.Parent.Parent.Parent.LuauPolyfill).Array;
return {
    toMatchInlineSnapshot = function(_, v2, v3)
        local function v4(v5)
            if typeof(v5) == "string" then
                return v5;
            elseif not l_Array_0.isArray(v5) then
                error("toMatchInlineSnapshot does not support " .. typeof(v5) .. ", please implement it yourself");
                return ;
            else
                return (("Array [\n%s\n]"):format(l_Array_0.join(l_Array_0.map(v5, function(v6)
                    return v4(v6);
                end), ",")));
            end;
        end;
        local function _(v7, v8)
            return v4(v7) == v8;
        end;
        return {
            pass = v4(v2) == v3,
            message = function()
                return "expected " .. v3 .. " to equal " .. v4(v2);
            end
        };
    end
};


local l_Parent_0 = script.Parent.Parent.Parent.Parent.Parent;
local v1 = require(l_Parent_0.LuauPolyfill);
local l_Boolean_0 = v1.Boolean;
local l_console_0 = v1.console;
local v4 = require(l_Parent_0.Promise);
local v5 = {};
local v6 = require(l_Parent_0.Shared);
local l_ReactSharedInternals_0 = v6.ReactSharedInternals;
local l_enqueueTask_0 = v6.enqueueTask;
local v9 = require(l_Parent_0.Scheduler);
local v10 = require(l_Parent_0.ReactRoblox);
local l_Events_0 = v10.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Events;
local l_IsThisRendererActing_0 = l_Events_0.IsThisRendererActing;
local l_flushPassiveEffects_0 = l_Events_0.flushPassiveEffects;
local l_unstable_batchedUpdates_0 = v10.unstable_batchedUpdates;
local l_IsSomeRendererActing_0 = l_ReactSharedInternals_0.IsSomeRendererActing;
local v16 = typeof(v9.unstable_flushAllWithoutAsserting) == "function";
local function _()
    local v17 = false;
    while l_flushPassiveEffects_0() do
        v17 = true;
    end;
    return v17;
end;
local function v19(v20)
    local l_status_0, l_result_0 = pcall(function()
        local v21 = false;
        while l_flushPassiveEffects_0() do
            v21 = true;
        end;
        l_enqueueTask_0(function()
            local v22 = false;
            while l_flushPassiveEffects_0() do
                v22 = true;
            end;
            if not v22 then
                v20();
                return ;
            else
                v19(v20);
                return ;
            end;
        end);
    end);
    if not l_status_0 then
        v20(l_result_0);
    end;
end;
local v25 = 0;
local v26 = false;
v5.default = function(v27)
    if not _G.__DEV__ and v26 == false then
        v26 = true;
        l_console_0.error("act(...) is not supported in production builds of React, and might not behave as expected.");
    end;
    local l_v25_0 = v25;
    local v29 = nil;
    local v30 = nil;
    v25 = v25 + 1;
    v29 = l_IsSomeRendererActing_0.current;
    v30 = l_IsThisRendererActing_0.current;
    l_IsSomeRendererActing_0.current = true;
    l_IsThisRendererActing_0.current = true;
    local function _()
        v25 = v25 - 1;
        l_IsSomeRendererActing_0.current = v29;
        l_IsThisRendererActing_0.current = v30;
        if _G.__DEV__ and l_v25_0 < v25 then
            l_console_0.error("You seem to have overlapping act() calls, this is not supported. " .. "Be sure to await previous act() calls before making a new one. ");
        end;
    end;
    local v32 = nil;
    local l_status_1, l_result_1 = pcall(function()
        v32 = l_unstable_batchedUpdates_0(v27);
    end);
    if not l_status_1 then
        v25 = v25 - 1;
        l_IsSomeRendererActing_0.current = v29;
        l_IsThisRendererActing_0.current = v30;
        if _G.__DEV__ and l_v25_0 < v25 then
            l_console_0.error("You seem to have overlapping act() calls, this is not supported. " .. "Be sure to await previous act() calls before making a new one. ");
        end;
        error(l_result_1);
    end;
    if (v32 ~= nil and typeof(v32) == "table") and typeof(v32.andThen) == "function" then
        local v35 = false;
        if _G.__DEV__ and typeof(v4) ~= "nil" then
            v4.delay(0):andThen(function()
                if v35 == false then
                    l_console_0.error("You called act(async () => ...) without await. " .. "This could lead to unexpected testing behaviour, interleaving multiple act " .. "calls and mixing their scopes. You should - await act(async () => ...);");
                end;
            end);
        end;
        return v4.new(function(v36, v37)
            v35 = true;
            v32:andThen(function()
                if not (v25 <= 1) or v16 == true and v29 == true then
                    v25 = v25 - 1;
                    l_IsSomeRendererActing_0.current = v29;
                    l_IsThisRendererActing_0.current = v30;
                    if _G.__DEV__ and l_v25_0 < v25 then
                        l_console_0.error("You seem to have overlapping act() calls, this is not supported. " .. "Be sure to await previous act() calls before making a new one. ");
                    end;
                    v36();
                    return ;
                else
                    local function v39(v38)
                        v25 = v25 - 1;
                        l_IsSomeRendererActing_0.current = v29;
                        l_IsThisRendererActing_0.current = v30;
                        if _G.__DEV__ and l_v25_0 < v25 then
                            l_console_0.error("You seem to have overlapping act() calls, this is not supported. " .. "Be sure to await previous act() calls before making a new one. ");
                        end;
                        if not l_Boolean_0.toJSBoolean(v38) then
                            v36();
                            return ;
                        else
                            v37(v38);
                            return ;
                        end;
                    end;
                    local l_status_2, l_result_2 = pcall(function()
                        local v40 = false;
                        while l_flushPassiveEffects_0() do
                            v40 = true;
                        end;
                        l_enqueueTask_0(function()
                            local v41 = false;
                            while l_flushPassiveEffects_0() do
                                v41 = true;
                            end;
                            if not v41 then
                                v39();
                                return ;
                            else
                                v19(v39);
                                return ;
                            end;
                        end);
                    end);
                    if not l_status_2 then
                        v39(l_result_2);
                    end;
                    return ;
                end;
            end, function(v44)
                v25 = v25 - 1;
                l_IsSomeRendererActing_0.current = v29;
                l_IsThisRendererActing_0.current = v30;
                if _G.__DEV__ and l_v25_0 < v25 then
                    l_console_0.error("You seem to have overlapping act() calls, this is not supported. " .. "Be sure to await previous act() calls before making a new one. ");
                end;
                v37(v44);
            end);
        end);
    else
        if _G.__DEV__ and v32 ~= nil then
            l_console_0.error("The callback passed to act(...) function " .. "must return undefined, or a Promise. You returned %s", v32);
        end;
        local l_status_3, l_result_3 = pcall(function()
            if v25 == 1 and (not (v16 ~= false) or v29 == false) then
                local v45 = false;
                while l_flushPassiveEffects_0() do
                    v45 = true;
                end;
            end;
            v25 = v25 - 1;
            l_IsSomeRendererActing_0.current = v29;
            l_IsThisRendererActing_0.current = v30;
            if _G.__DEV__ and l_v25_0 < v25 then
                l_console_0.error("You seem to have overlapping act() calls, this is not supported. " .. "Be sure to await previous act() calls before making a new one. ");
            end;
        end);
        if not l_status_3 then
            v25 = v25 - 1;
            l_IsSomeRendererActing_0.current = v29;
            l_IsThisRendererActing_0.current = v30;
            if _G.__DEV__ and l_v25_0 < v25 then
                l_console_0.error("You seem to have overlapping act() calls, this is not supported. " .. "Be sure to await previous act() calls before making a new one. ");
            end;
            error(l_result_3);
        end;
        return {
            andThen = function(_, v49)
                if _G.__DEV__ then
                    l_console_0.error("Do not await the result of calling act(...) with sync logic, it is not a Promise.");
                end;
                v49();
            end
        };
    end;
end;
return v5;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.LuauPolyfill);
local l_Error_0 = v1.Error;
local l_Array_0 = v1.Array;
local l_Object_0 = v1.Object;
local l_Set_0 = v1.Set;
local l_console_0 = v1.console;
local v7 = require(l_Parent_0.Promise);
local v8 = require(l_Parent_0.ReactRoblox);
local v9 = {};
local v10 = require(l_Parent_0.React);
local v11 = require(l_Parent_0.DomTestingLibrary);
local l_getQueriesForElement_0 = v11.getQueriesForElement;
local l_prettyDOM_0 = v11.prettyDOM;
local l_configure_0 = v11.configure;
local v15 = require(script.Parent["act-compat"]);
local l_default_0 = v15.default;
local l_asyncAct_0 = v15.asyncAct;
local l_fireEvent_0 = require(script.Parent["fire-event"]).fireEvent;
local v19 = nil;
l_configure_0({
    asyncWrapper = function(v20)
        return v7.resolve():andThen(function()
            local v21 = nil;
            l_asyncAct_0(function()
                return v7.resolve():andThen(function()
                    v21 = v20():expect();
                end);
            end):expect();
            return v21;
        end);
    end,
    eventWrapper = function(v22)
        local v23 = nil;
        l_default_0(function()
            v23 = v22();
        end);
        return v23;
    end
});
local v24 = l_Set_0.new();
local v25 = nil;
local function v26(v27, v28)
    local v29 = if v28 == nil then {} else v28;
    local l_container_0 = v29.container;
    local v31 = if v29.baseElement == nil then v29.container else v29.baseElement;
    local l_queries_0 = v29.queries;
    local v33 = not (v29.hydrate == nil) and v29.hydrate;
    local l_wrapper_0 = v29.wrapper;
    if not v31 then
        v31 = v11.document;
    end;
    if not l_container_0 then
        l_container_0 = Instance.new("Folder");
        l_container_0.Parent = v31;
        v25 = v8.createLegacyRoot(l_container_0);
    end;
    v24:add(l_container_0);
    local function _(v35)
        if not l_wrapper_0 then
            return v35;
        else
            return (v10.createElement(l_wrapper_0, nil, v35));
        end;
    end;
    l_default_0(function()
        if not v33 then
            local l_v25_0 = v25;
            local l_v27_0 = v27;
            l_v25_0:render(if not l_wrapper_0 then l_v27_0 else v10.createElement(l_wrapper_0, nil, l_v27_0));
            return ;
        else
            error(l_Error_0.new("hydrate not supported"));
            return ;
        end;
    end);
    return l_Object_0.assign({}, {
        container = l_container_0,
        baseElement = v31,
        debug = function(v39, v40, v41)
            if v39 == nil then
                v39 = v31;
            end;
            if not l_Array_0.isArray(v39) then
                return (l_console_0.log(l_prettyDOM_0(v39, v40, v41)));
            else
                return (l_Array_0.forEach(v39, function(v42)
                    return l_console_0.log(l_prettyDOM_0(v42, v40, v41));
                end));
            end;
        end,
        unmount = function()
            l_default_0(function()
                v25:unmount();
            end);
        end,
        rerender = function(v43)
            v26(if not l_wrapper_0 then v43 else v10.createElement(l_wrapper_0, nil, v43), {
                container = l_container_0,
                baseElement = v31
            });
        end,
        asFragment = function()
            warn("asFragment not supported");
        end
    }, l_getQueriesForElement_0(v31, l_queries_0));
end;
local function v44()
    v24:forEach(v19);
end;
v19 = function(v45)
    l_default_0(function()
        v25:unmount();
    end);
    if v45.Parent == v11.document then
        v45.Parent = nil;
    end;
    v24:delete(v45);
end;
l_Object_0.assign(v9, require(l_Parent_0.DomTestingLibrary));
v9.render = v26;
v9.cleanup = v44;
v9.act = l_default_0;
v9.fireEvent = l_fireEvent_0;
return v9;


local l_Parent_0 = script.Parent.Parent;
local l_Object_0 = require(l_Parent_0.LuauPolyfill).Object;
local v2 = {};
local _ = require(l_Parent_0.DomTestingLibrary).queries;
local _ = require(script.Parent.jsHelpers["react-dom"]["test-utils"]).act;
l_Object_0.assign(v2, require(l_Parent_0.DomTestingLibrary));
return v2;


local v0 = require(script:FindFirstAncestor("ReactUtils").Parent.React);
return function(v1)
    local l_children_0 = v1.children;
    for v3 = #v1.providers, 1, -1 do
        l_children_0 = v0.cloneElement(v1.providers[v3], nil, l_children_0);
    end;
    return l_children_0;
end;


local v0 = require(script.Parent.useEventConnection);
return function(v1)
    v0(v1.event, v1.callback, {
        v1.event,
        v1.callback
    });
end;


return {
    useHistory = require(script.useHistory),
    useSelection = require(script.useSelection),
    waitForEvents = require(script.waitForEvents),
    useDebounce = require(script.useDebounce),
    useDebouncedState = require(script.useDebouncedState),
    useDelayedActionHandler = require(script.useDelayedActionHandler),
    useEventConnection = require(script.useEventConnection),
    useForwardRef = require(script.useForwardRef),
    useInitializedValue = require(script.useInitializedValue),
    useLazyRef = require(script.useLazyRef),
    usePrevious = require(script.usePrevious),
    useProperties = require(script.useProperties),
    usePropertiesDeferred = require(script.usePropertiesDeferred),
    useStackState = require(script.useStackState),
    useToggleState = require(script.useToggleState),
    ContextStack = require(script.ContextStack),
    EventConnection = require(script.EventConnection),
    createUnimplemented = require(script.createUnimplemented),
    createUniqueKey = require(script.createUniqueKey),
    LUAU_ANALYZE_ERROR = require(script.LUAU_ANALYZE_ERROR)
};


local v0 = require(script:FindFirstAncestor("ReactUtils").Parent.React);
return function(v1, v2)
    local v3, v4 = v0.useState(v1);
    v0.useLayoutEffect(function()
        local function v5()
            v4(v1);
        end;
        if not (v2 ~= nil) or v2 == 0 then
            v4(v1);
            return ;
        else
            local v6 = task.delay(v2, v5);
            return function()
                task.cancel(v6);
            end;
        end;
    end, {
        v1,
        v2
    });
    return v3;
end;


local v0 = require(script:FindFirstAncestor("ReactUtils").Parent.React);
local v1 = require(script.Parent.useDebounce);
return function(v2, v3)
    local v4, v5 = v0.useState(v2);
    return v1(v4, v3), v5;
end;


local v0 = require(script:FindFirstAncestor("ReactUtils").Parent.React);
return function(v1, v2, v3)
    local v4 = v0.useRef(nil);
    local v5 = v0.useRef(0);
    local function v8()
        local v6 = os.clock();
        if (v2 ~= nil and v5.current ~= nil) and v6 - v5.current < v2 then
            return ;
        else
            v5.current = v6;
            local l_current_0 = v4.current;
            if l_current_0 ~= nil then
                task.cancel(l_current_0);
            end;
            v4.current = task.delay(v1, function()
                v3();
            end);
            return ;
        end;
    end;
    v0.useEffect(function()
        return function()
            local l_current_1 = v4.current;
            if l_current_1 ~= nil then
                task.cancel(l_current_1);
            end;
        end;
    end, {
        v4
    });
    return v8;
end;


local v0 = require(script:FindFirstAncestor("ReactUtils").Parent.React);
return function(v1, v2, v3)
    local v4 = v0.useMemo(function()
        return v2;
    end, v3);
    v0.useEffect(function()
        local v5 = v1:Connect(v4);
        return function()
            v5:Disconnect();
        end;
    end, {
        v1,
        v4
    });
end;


local v0 = require(script:FindFirstAncestor("ReactUtils").Parent.React);
return function(v1, v2)
    local v3 = v0.useRef(nil);
    local v4 = v0.useRef(nil);
    local v6 = v0.useCallback(function(v5)
        if v4.current then
            v4.current();
            v4.current = nil;
        end;
        if v5 then
            v3.current = v5;
            v4.current = v2(v5);
        end;
    end, {
        v2
    });
    v0.useImperativeHandle(v1, function()
        return v3.current;
    end);
    return v6;
end;


local l_ChangeHistoryService_0 = game:GetService("ChangeHistoryService");
local l_script_FirstAncestor_0 = script:FindFirstAncestor("ReactUtils");
local v2 = require(l_script_FirstAncestor_0.Parent.React);
local l_LUAU_ANALYZE_ERROR_0 = l_script_FirstAncestor_0.LUAU_ANALYZE_ERROR;
return function(v4, v5, v6)
    local v7 = v2.useRef(v4);
    local v8 = v2.useRef({});
    local v9 = v2.useRef({});
    v2.useEffect(function()
        local v15 = l_ChangeHistoryService_0.OnUndo:Connect(function(v10)
            local l_current_0 = v8.current;
            local l_current_1 = v9.current;
            assert(l_current_0 ~= nil, l_LUAU_ANALYZE_ERROR_0);
            assert(l_current_1 ~= nil, l_LUAU_ANALYZE_ERROR_0);
            if not l_current_0[v10] or #l_current_0[v10] == 0 then
                return ;
            else
                if not l_current_1[v10] then
                    l_current_1[v10] = {};
                end;
                local v13 = #l_current_0[v10];
                local v14 = l_current_0[v10][v13];
                table.insert(l_current_1[v10], v7.current);
                table.remove(l_current_0[v10], v13);
                v7.current = v14;
                v5(v14);
                v8.current = l_current_0;
                v9.current = l_current_1;
                return ;
            end;
        end);
        local v21 = l_ChangeHistoryService_0.OnRedo:Connect(function(v16)
            local l_current_2 = v8.current;
            local l_current_3 = v9.current;
            assert(l_current_2 ~= nil, l_LUAU_ANALYZE_ERROR_0);
            assert(l_current_3 ~= nil, l_LUAU_ANALYZE_ERROR_0);
            if not l_current_3[v16] or #l_current_3[v16] == 0 then
                return ;
            else
                local v19 = #l_current_3[v16];
                local v20 = l_current_3[v16][v19];
                table.insert(l_current_2[v16], v7.current);
                table.remove(l_current_3[v16], v19);
                assert(v20 ~= nil, l_LUAU_ANALYZE_ERROR_0);
                v7.current = v20;
                v5(v20);
                v8.current = l_current_2;
                v9.current = l_current_3;
                return ;
            end;
        end);
        return function()
            v15:Disconnect();
            v21:Disconnect();
        end;
    end, v6);
    v2.useEffect(function()
        v8.current = {};
        v9.current = {};
    end, v6);
    return (v2.useCallback(function(v22, v23)
        local l_current_4 = v8.current;
        assert(l_current_4 ~= nil, l_LUAU_ANALYZE_ERROR_0);
        if not l_current_4[v22] then
            l_current_4[v22] = {};
        end;
        v9.current = {};
        l_ChangeHistoryService_0:SetWaypoint(v22);
        if typeof(v7.current) == "table" then
            table.insert(l_current_4[v22], table.clone(v7.current));
        else
            table.insert(l_current_4[v22], v7.current);
        end;
        v7.current = v23;
        v8.current = l_current_4;
    end, v6));
end;


local v0 = require(script.Parent.useLazyRef);
return function(v1)
    return v0(v1).current;
end;


local v0 = require(script:FindFirstAncestor("ReactUtils").Parent.React);
return function(v1)
    local v2 = v0.useRef(nil);
    if v2.current == nil then
        v2.current = v1();
    end;
    assert(v2.current ~= nil, "Ref must be defined after initialization function is called");
    return v2;
end;


local v0 = require(script:FindFirstAncestor("ReactUtils").Parent.React);
return function(v1)
    local v2 = v0.useRef(nil);
    v0.useEffect(function()
        v2.current = v1;
    end);
    return v2.current;
end;


local _ = require(script:FindFirstAncestor("ReactUtils").Parent.React);
local v1 = require(script.Parent.usePropertiesBase);
return function(v2, v3, ...)
    return v1(v2, v3, false, ...);
end;


local l_Parent_0 = script:FindFirstAncestor("ReactUtils").Parent;
local v1 = require(l_Parent_0.React);
local l_Array_0 = require(l_Parent_0.LuauPolyfill).Array;
local v3 = require(script.Parent.useForwardRef);
return function(v4, v5, v6, ...)
    local v7 = l_Array_0.concat({}, ...);
    return v3(v4, (v1.useCallback(function(v8)
        local function v10()
            v5(table.unpack(l_Array_0.map(v7, function(v9)
                return v8[v9];
            end)));
        end;
        local v11 = nil;
        local function v13()
            if not v11 then
                v11 = task.defer(function()
                    v11 = nil;
                    v5(table.unpack(l_Array_0.map(v7, function(v12)
                        return v8[v12];
                    end)));
                end);
            end;
        end;
        local v15 = l_Array_0.map(v7, function(v14)
            return v8:GetPropertyChangedSignal(v14):Connect(if not v6 then v10 else v13);
        end);
        v5(table.unpack(l_Array_0.map(v7, function(v16)
            return v8[v16];
        end)));
        return function()
            for _, v18 in v15, nil, nil do
                v18:Disconnect();
            end;
            if v11 then
                task.cancel(v11);
            end;
        end;
    end, {
        v5,
        table.concat(v7, ",")
    })));
end;


local _ = require(script:FindFirstAncestor("ReactUtils").Parent.React);
local v1 = require(script.Parent.usePropertiesBase);
return function(v2, v3, ...)
    return v1(v2, v3, true, ...);
end;


local l_script_FirstAncestor_0 = script:FindFirstAncestor("ReactUtils");
local v1 = require(l_script_FirstAncestor_0.Parent.React);
local v2 = require(l_script_FirstAncestor_0.useEventConnection);
return function(v3)
    local v4 = v3 or game:GetService("Selection");
    local v5, v6 = v1.useState(function()
        return v4:Get();
    end);
    v2(v4.SelectionChanged, function()
        v6(v4:Get());
    end, {});
    return v5;
end;


local l_script_FirstAncestor_0 = script:FindFirstAncestor("ReactUtils");
local v1 = require(l_script_FirstAncestor_0.Parent.React);
local l_LUAU_ANALYZE_ERROR_0 = l_script_FirstAncestor_0.LUAU_ANALYZE_ERROR;
return function(v3)
    local v4 = v1.useRef(v3 or {});
    assert(v4.current ~= nil, l_LUAU_ANALYZE_ERROR_0);
    local v5, v6 = v1.useState(#v4.current);
    return {
        push = v1.useCallback(function(v7)
            table.insert(v4.current, v7);
            v6(#v4.current);
        end, {}),
        pop = v1.useCallback(function()
            local v8 = table.remove(v4.current);
            v6(#v4.current);
            return v8;
        end, {}),
        getTop = v1.useCallback(function()
            return v4.current[#v4.current];
        end, {}),
        clear = v1.useCallback(function()
            table.clear(v4.current);
            v6(0);
        end, {}),
        size = v5
    };
end;


local v0 = require(script:FindFirstAncestor("ReactUtils").Parent.React);
return function(v1)
    local v2, v3 = v0.useState(v1);
    return {
        enabled = v2,
        enable = v0.useCallback(function()
            v3(true);
        end, {}),
        disable = v0.useCallback(function()
            v3(false);
        end, {})
    };
end;


local v0 = require(script:FindFirstAncestor("ReactUtils").Parent.ReactRoblox);
return (setmetatable({
    act = function()
        v0.act(function()
            task.wait(0);
        end);
    end
}, {
    __call = function()
        task.wait(0);
    end
}));


local l_Parent_0 = script.Parent;
local l_getDefaultValue_0 = require(l_Parent_0.Parent.SharedUtils).getDefaultValue;
local v2 = require(l_Parent_0.Artifacts);
local v3 = require(l_Parent_0.RequestWriter);
local _ = require(l_Parent_0.Resolver);
local v5 = require(l_Parent_0.tryGetService);
local v6 = {
    useRequestsOnce = false
};
local v7 = {};
local v8 = {
    __index = v7
};
v7.new = function(v9)
    return (setmetatable({
        _resolver = v9,
        _fileSystemService = v5("FileSystemService")
    }, v8));
end;
v7.load = function(v10, v11, v12)
    local v13 = v10._resolver:getInstance(v11);
    if v13 == nil then
        return nil;
    else
        local v14 = l_getDefaultValue_0(v12, v6);
        local v15 = v2.new(v13);
        if l_getDefaultValue_0(v14.useRequestsOnce, v6.useRequestsOnce) then
            v15:useRequestsOnce();
        end;
        return v15;
    end;
end;
v7.getWriter = function(v16, v17)
    return v3.new(v16._resolver:getLocation(v17));
end;
v7.delete = function(v18, v19)
    local v20 = v18._resolver:getLocation(v19);
    if not v18._fileSystemService then
        local v21 = v18._resolver:getInstance(v19);
        if v21 ~= nil then
            v21:ClearAllChildren();
        end;
    else
        local v22 = v20:resolvePath();
        if v18._fileSystemService:Exists(v22) then
            v18._fileSystemService:RemoveAll(v22);
            return ;
        end;
    end;
end;
return v7;


local l_Parent_0 = script.Parent;
local l_try_0 = require(l_Parent_0.Parent.SharedUtils).try;
local v2 = require(l_Parent_0.tryGetService);
local _ = require(l_Parent_0.Location);
local v4 = require(l_Parent_0.PathUtils);
local l_SEPARATOR_0 = v4.SEPARATOR;
local v6 = {};
local v7 = {
    __index = v6
};
v6.new = function(v8)
    return (setmetatable({
        _location = v8,
        _fileSystemService = v2("FileSystemService"),
        _fileSyncService = v2("FileSyncService"),
        _warn = warn
    }, v7));
end;
v6.write = function(v9, v10)
    if not v9._fileSystemService then
        local v11 = "Attempting to write file in an environment where FileSystemService is " .. "inaccessible.\n\n" .. "Instead, the file content has been written to a ModuleScript instance in the DataModel. ";
        if not v9._fileSyncService then
            v9._warn(" " .. v11 .. "Since FileSyncService is not available, the new ModuleScript will only live " .. "in the current DataModel");
        else
            v9._warn(v11 .. "Since FileSyncService is available, the new ModuleScript should sync back " .. "to the file system.");
        end;
        v9._location:getOrCreateInstance("ModuleScript").Source = v10;
        return ;
    else
        local v12 = v9._location:resolvePath();
        assert(v12:sub(-1) ~= l_SEPARATOR_0, ("File location `%s` cannot end with `%s`"):format(v12, l_SEPARATOR_0));
        v9:_ensureParentDirectoryExists(v12);
        v9._fileSystemService:WriteFile(v12, v10);
        return ;
    end;
end;
v6._ensureParentDirectoryExists = function(v13, v14)
    local v15 = v4.parent(v14);
    if v15 == nil then
        return ;
    else
        local v17, v18 = l_try_0(function()
            local l__fileSystemService_0 = v13._fileSystemService;
            if not l__fileSystemService_0:Exists(v15) then
                l__fileSystemService_0:CreateDirectories(v15);
            end;
        end);
        if not v17 then
            if string.find(v18.message, "Error(13): Access Denied. Path is outside of sandbox.", 1, true) then
                v18.message = "Access Denied. Path is outside of sandbox: " .. v14 .. "\n\nProvided file system path is invalid: you likely need to provide a different" .. " argument to --fs.readwrite.\nYou may need to pass in `--fs.readwrite=$PWD`";
            end;
            error(v18);
            return ;
        else
            return ;
        end;
    end;
end;
return v6;


local v0 = {};
local v1 = {
    __index = v0
};
local v2 = {
    new = function()
        return (setmetatable({
            _callbacks = {}
        }, v1));
    end
};
v0.fire = function(v3, ...)
    for _, v5 in v3._callbacks, nil, nil do
        v5(...);
    end;
end;
v0.connect = function(v6, v7)
    table.insert(v6._callbacks, v7);
    local v8 = true;
    return function()
        if not v8 then
            error("Attempt to disconnect an already disconnected connection");
        end;
        v8 = false;
        local v9 = table.find(v6._callbacks, v7);
        if v9 ~= nil then
            table.remove(v6._callbacks, v9);
        end;
    end;
end;
return v2;


local v0 = require(script.Parent.PathUtils);
local v1 = {};
local v2 = {
    __index = v1
};
v1.new = function(v3, v4, v5)
    return (setmetatable({
        _relativePath = v0.trimEndSeparator(v3),
        _rootPath = v4,
        _rootInstance = v5
    }, v2));
end;
v1.join = function(v6, ...)
    return v1.new(v0.join(v6._relativePath, ...), v6._rootPath, v6._rootInstance);
end;
v1.resolvePath = function(v7)
    return v0.join(v7._rootPath, v7._relativePath);
end;
v1.getInstance = function(v8)
    local l__rootInstance_0 = v8._rootInstance;
    for _, v11 in ipairs(v0.getComponents(v8._relativePath)) do
        if v11 == "" then
            error(("invalid path location provided `%s`"):format(v8._relativePath), 2);
        end;
        l__rootInstance_0 = l__rootInstance_0:FindFirstChild(v11);
        if l__rootInstance_0 == nil then
            return nil;
        end;
    end;
    return l__rootInstance_0;
end;
v1.getOrCreateInstance = function(v12, v13)
    local v14 = v12:_ensureParentInstance();
    local v15 = v0.fileStem(v12._relativePath);
    local l_v14_FirstChild_0 = v14:FindFirstChild(v15);
    if not l_v14_FirstChild_0 or not l_v14_FirstChild_0:IsA(v13) then
        local v17 = Instance.new(v13);
        v17.Name = v15;
        v17.Parent = v14;
        return v17;
    else
        return l_v14_FirstChild_0;
    end;
end;
v1._ensureParentInstance = function(v18)
    local v19 = v0.parent(v18._relativePath);
    if v19 == nil then
        error(("invalid path location provided `%s` (unable to obtain parent path)"):format(v18._relativePath), 2);
    end;
    if v19 == "" then
        return v18._rootInstance;
    else
        local l__rootInstance_1 = v18._rootInstance;
        for _, v22 in ipairs(v0.getComponents(v19)) do
            if v22 == "" then
                error(("invalid path location provided `%s`"):format(v18._relativePath), 2);
            end;
            local l_l__rootInstance_1_FirstChild_0 = l__rootInstance_1:FindFirstChild(v22);
            if l_l__rootInstance_1_FirstChild_0 == nil then
                l_l__rootInstance_1_FirstChild_0 = Instance.new("Folder");
                l_l__rootInstance_1_FirstChild_0.Name = v22;
                l_l__rootInstance_1_FirstChild_0.Parent = l__rootInstance_1;
            end;
            l__rootInstance_1 = l_l__rootInstance_1_FirstChild_0;
        end;
        return l__rootInstance_1;
    end;
end;
return v1;


local v0 = require(script.isValidLuauIdentifier);
local function v3(v1, v2)
    return v1[1] < v2[1];
end;
local v4 = {};
local v5 = {
    __index = v4
};
v4.new = function()
    return (setmetatable({
        _indentation = "\t",
        _indentationLevel = 0
    }, v5));
end;
v4.serialize = function(v6, v7)
    local v8 = typeof(v7);
    if v8 == "string" then
        return ("%q"):format(v7);
    elseif v8 == "number" then
        return (tostring(v7));
    elseif v8 == "boolean" then
        if not v7 then
            return "false";
        else
            return "true";
        end;
    elseif v8 == "table" then
        if next(v7) == nil then
            return "{}";
        else
            local v9 = {
                "{"
            };
            v6._indentationLevel = v6._indentationLevel + 1;
            local v10 = v6:_ident();
            local v11 = {};
            local v12 = nil;
            for v13, v14 in ipairs(v7) do
                v11[v13] = true;
                if v12 ~= nil and v13 ~= v12 + 1 then
                    for _ = v12 + 1, v13 do
                        table.insert(v9, v10 .. v6:serialize(nil) .. ",");
                    end;
                end;
                table.insert(v9, v10 .. v6:serialize(v14) .. ",");
                v12 = v13;
            end;
            local v16 = {};
            for v17, v18 in pairs(v7) do
                if not v11[v17] then
                    table.insert(v16, {
                        v6:_serializeTableKey(v17),
                        (v6:serialize(v18))
                    });
                end;
            end;
            table.sort(v16, v3);
            for _, v20 in ipairs(v16) do
                table.insert(v9, ("%s%s = %s,"):format(v10, v20[1], v20[2]));
            end;
            v6._indentationLevel = v6._indentationLevel - 1;
            table.insert(v9, v6:_ident() .. "}");
            return table.concat(v9, "\n");
        end;
    elseif v8 == "EnumItem" then
        return ("Enum.%s.%s"):format(tostring(v7.EnumType), v7.Name);
    elseif v8 == "Enum" then
        return "Enum." .. tostring(v7);
    elseif v8 == "nil" then
        return "nil";
    else
        error(("unable to serialize value of type `%s`"):format(v8));
        return ;
    end;
end;
v4._serializeTableKey = function(v21, v22)
    if not (typeof(v22) == "string") or not v0(v22) then
        return "[" .. v21:serialize(v22) .. "]";
    else
        return v22;
    end;
end;
v4._ident = function(v23)
    return v23._indentation:rep(v23._indentationLevel);
end;
return v4;


local v0 = {
    ["and"] = true,
    ["break"] = true,
    ["do"] = true,
    ["else"] = true,
    ["elseif"] = true,
    ["end"] = true,
    ["false"] = true,
    ["for"] = true,
    ["function"] = true,
    ["if"] = true,
    ["in"] = true,
    ["local"] = true,
    ["nil"] = true,
    ["not"] = true,
    ["or"] = true,
    ["repeat"] = true,
    ["return"] = true,
    ["then"] = true,
    ["true"] = true,
    ["until"] = true,
    ["while"] = true
};
return function(v1)
    return v1:match("^[%a_][%w_]*$") and v0[v1] == nil;
end;


local v0 = require(script.LuauSerializer);
local v1 = {};
local v2 = {
    __index = v1
};
v1.new = function()
    return (setmetatable({
        _inner = v0.new()
    }, v2));
end;
v1.serialize = function(v3, v4)
    return "return " .. v3._inner:serialize(v4) .. "\n";
end;
return v1;