local l_Parent_0 = script.Parent.Parent;
local l_lib_0 = l_Parent_0.lib;
local v2 = require(l_Parent_0.src.json);
local v3 = require(l_lib_0.url);
local function _(v4)
    return tonumber(v4) or v4;
end;
local function v7(v6)
    v6 = v6 or "";
    while v6:sub(1, 1) == " " do
        v6 = v6:sub(2);
    end;
    while v6:sub(-1, -1) == " " do
        v6 = v6:sub(1, -2);
    end;
    return v6;
end;
local v8 = {};
v8.__index = v8;
v8.new = function(v9, v10, v11)
    local v12 = setmetatable({}, v8);
    v11 = v11 or {};
    v12.name = v9;
    v12.value = v10;
    v12.domain = v11.domain or "";
    v12.path = v11.path or "";
    return v12;
end;
v8.fromSet = function(v13)
    local v14 = {};
    local v15 = v13:split(";");
    local v16 = v15[1]:split("=");
    local v17 = v7(v16[1]);
    local v18 = v7(v16[2]);
    for v19 = 2, #v15 do
        local v20 = v15[v19]:split("=");
        v14[v7(v20[1]):lower()] = v7(v20[2]);
    end;
    return v8.new(v17, v18, v14);
end;
v8.matches = function(v21, v22)
    if v21.domain then
        local v23 = v3.parse(v22);
        if v21.domain:sub(1, 1) == "." then
            if v23.host:sub(-#v21.domain, -1) ~= v21.domain and v23.host ~= v21.domain:sub(2) then
                return false;
            end;
        elseif v23.host ~= v21.domain then
            return false;
        end;
        if v21.path and not v23.path:sub(1, #v21.path) == v21.path then
            return false;
        else
            return true;
        end;
    else
        return true;
    end;
end;
local v24 = {};
v24.__index = v24;
v24.new = function()
    local v25 = setmetatable({}, v24);
    v25.__cookiejar = true;
    v25.cookies = {};
    return v25;
end;
v24.insert = function(v26, v27, v28, v29)
    v26.cookies[v27] = v8.new(v27, v28, v29);
    return v26;
end;
v24.SetCookie = function(v30, v31)
    local v32 = v8.fromSet(v31);
    v30.cookies[v32.name] = v32;
end;
v24.delete = function(v33, v34)
    v33.cookies[v34] = nil;
end;
v24.string = function(v35, _)
    local v37 = "";
    for _, v39 in pairs(v35.cookies) do
        if v37 then
            v37 = v37 .. "; ";
        end;
        v37 = v37 .. ("%s=%s"):format(v39.name, v39.value);
    end;
    return v37;
end;
v24.__tostring = function(v40)
    return v2.enc(v40.domains);
end;
return v24;


local v0 = require(script.Parent.Parent.Parent.Promise);
createFetch = function(v1)
    return function(v2, v3)
        if v3 == nil then
            v3 = {};
        end;
        local v4 = v3.method or "GET";
        v3.method = nil;
        v3.data = v3.body;
        v3.body = nil;
        return v1(v4, v2, v3):andThen(function(v5)
            local l_text_0 = v5.text;
            v5.text = function()
                return v0.resolve(l_text_0);
            end;
            v5.status = v5.code;
            return v5;
        end);
    end;
end;
return createFetch;


local l_Parent_0 = script.Parent.Parent;
local l_lib_0 = l_Parent_0.lib;
local _ = l_Parent_0.src;
local l_HttpService_0 = game:GetService("HttpService");
local v4 = require(l_lib_0.mimetypes);
local v5 = require(l_lib_0.b64);
local function v9(v6)
    local v7 = "";
    for _ = 1, v6 do
        v7 = v7 .. string.char(math.random(97, 122));
    end;
    return v7;
end;
local v10 = {};
v10.__index = v10;
v10.new = function(...)
    local v11 = setmetatable({}, v10);
    v11.__IsFile = true;
    v11.name = "unknown";
    v11.content = "";
    v11.content_type = nil;
    local v12 = {
        ...
    };
    if #v12 == 1 then
        v11.content = v12[1];
    elseif #v12 >= 2 then
        v11.name = v12[1];
        v11.content = v12[2];
        v11.content_type = v12[3];
    end;
    if not v11.content_type then
        local v13 = v11.name:split(".");
        v11.content_type = v4[v13[#v13]:lower()] or "text/plain";
    end;
    if type(v11.content) ~= "string" then
        error(("[http] Invalid file content for file %s"):format(v11.name));
    end;
    return v11;
end;
v10.__tostring = function(v14)
    return ("File('%s', '%s')"):format(v14.name, v14.content_type);
end;
local v15 = {};
v15.__index = v15;
v15.new = function(v16)
    local v17 = setmetatable({}, v15);
    v17.__FormData = true;
    v16 = v16 or {};
    v17.boundary = "--FormBoundary-" .. v9(28);
    v17.content_type = "application/x-www-form-urlencoded";
    v17.fields = {};
    for v18, v19 in pairs(v16) do
        v17:AddField(v18, v19);
    end;
    return v17;
end;
v15.AddField = function(v20, v21, v22)
    if v22.__IsFile then
        v20.content_type = "multipart/form-data; boundary=\"" .. v20.boundary .. "\"";
    end;
    table.insert(v20.fields, {
        Name = v21,
        Value = v22
    });
end;
v15.build = function(v23)
    local v24 = "";
    if v23.content_type == "application/x-www-form-urlencoded" then
        for _, v26 in ipairs(v23.fields) do
            if v26.Value.__IsFile then
                error("[http] URL encoded forms cannot contain any files");
            end;
            if not (not v26.Name:find("=") and not v26.Name:find("&")) then
                error("[http] Form field names must not contain '=' or '&'");
            end;
            if type(v26.Value) == "table" then
                for _, v28 in ipairs(v26.Value) do
                    if #v24 > 0 then
                        v24 = v24 .. "&";
                    end;
                    v24 = v24 .. v26.Name .. "=" .. l_HttpService_0:UrlEncode(v28);
                end;
            else
                if #v24 > 0 then
                    v24 = v24 .. "&";
                end;
                v24 = v24 .. v26.Name .. "=" .. l_HttpService_0:UrlEncode(v26.Value);
            end;
        end;
        return v24;
    else
        for _, v30 in pairs(v23.fields) do
            v24 = v24 .. "--" .. v23.boundary .. "\r\n";
            local l_Value_0 = v30.Value;
            v24 = v24 .. ("Content-Disposition: form-data; name=\"%s\""):format(v30.Name);
            if v30.Value.__IsFile then
                l_Value_0 = v30.Value.content;
                v24 = v24 .. ("; filename=\"%s\""):format(v30.Value.name) .. "\r\nContent-Type: " .. v30.Value.content_type;
                if v30.Value.content_type:sub(1, 5) ~= "text/" then
                    l_Value_0 = v5.encode(l_Value_0);
                    v24 = v24 .. "\r\nContent-Transfer-Encoding: base64";
                end;
            end;
            v24 = v24 .. "\r\n\r\n" .. l_Value_0 .. "\r\n";
        end;
        return v24 .. "--" .. v23.boundary .. "--";
    end;
end;
return {
    FormData = v15,
    File = v10
};


local l_HttpService_0 = game:GetService("HttpService");
return {
    enc = function(v1)
        return l_HttpService_0:JSONEncode(v1);
    end,
    dec = function(v2)
        return l_HttpService_0:JSONDecode(v2);
    end
};


local v0 = {};
v0.__index = v0;
local function _(v1)
    return v1;
end;
if not v0.ratelimit then
    v0.ratelimit = {};
end;
v0.get = function(v3, v4, v5)
    local v6 = setmetatable({}, v0);
    if not v0.ratelimit[v3] then
        v0.ratelimit[v3] = {};
        v0.ratelimit[v3].windows = {};
    end;
    v0.ratelimit[v3].window_size = v5;
    v0.ratelimit[v3].rate = v4;
    v6.id = v3;
    v6.window_size = v0.ratelimit[v3].window_size;
    v6.rate = v0.ratelimit[v3].rate;
    local _ = v6.id;
    return v6;
end;
v0.window = function(v8)
    return (math.floor(tick() / v8.window_size));
end;
v0.progress = function(v9)
    return (tick() % v9.window_size) / v9.window_size;
end;
v0.increment = function(v10)
    local v11 = v10:window();
    if not v0.ratelimit[v10.id].windows[v11] then
        v0.ratelimit[v10.id].windows[v11] = 0;
    end;
    v0.ratelimit[v10.id].windows[v11] = v0.ratelimit[v10.id].windows[v11] + 1;
    return v0.ratelimit[v10.id].windows[v11];
end;
v0.weighted = function(v12, v13)
    v13 = v13 or 0;
    local v14 = v12:progress();
    local v15 = v12:window();
    return ((v0.ratelimit[v12.id].windows[v15] or 0) + v13) * v14 + (v0.ratelimit[v12.id].windows[v15 - 1] or 0) * (1 - v14);
end;
v0.consumption = function(v16)
    return v16:weighted() / v16.rate;
end;
v0.request = function(v17)
    if v17.rate < v17:weighted(1) then
        return false;
    else
        v17:increment();
        return true;
    end;
end;
return v0;


local l_Parent_0 = script.Parent.Parent;
local _ = l_Parent_0.lib;
local l_src_0 = l_Parent_0.src;
local v3 = require(l_src_0.request);
local v4 = require(l_src_0.cookies);
local v5 = require(l_src_0.ratelimit);
local v6 = require(l_src_0.util);
local function v10(v7)
    local v8 = "";
    for _ = 1, v7 do
        v8 = v8 .. string.char(math.random(97, 122));
    end;
    return v8;
end;
local v11 = {};
v11.__index = v11;
v11.new = function(v12)
    local v13 = setmetatable({}, v11);
    v13.headers = {};
    v13.cookies = v4.new();
    v13.base_url = v12 or "";
    v13._ratelimit = nil;
    v13.ignore_ratelimit = false;
    v13.before_request = nil;
    v13.after_request = nil;
    v13.no_stats = false;
    v13.log = true;
    return v13;
end;
v11.set_ratelimit = function(v14, v15, v16)
    if not v15 then
        v14:disable_ratelimit();
    end;
    v16 = v16 or 60;
    if v14._ratelimit then
        v5.ratelimit[v14._ratelimit.id] = nil;
    end;
    v14._ratelimit = v5.get("http.session-" .. v10(12), v15, v16);
end;
v11.disable_ratelimit = function(v17)
    if v17._ratelimit then
        v5.ratelimit[v17._ratelimit.id] = nil;
        v17._ratelimit = nil;
    end;
end;
v11.set_headers = function(v18, v19)
    for v20, v21 in pairs(v19) do
        v18.headers[v20] = v21;
    end;
    return v18;
end;
v11.Request = function(v22, v23, v24, v25)
    v25 = v25 or {};
    if v24:sub(1, 7) ~= "http://" and v24:sub(1, 8) ~= "https://" then
        v24 = v22.base_url .. v24;
    end;
    local l_log_0 = v22.log;
    if v25.log ~= nil then
        l_log_0 = v25.log;
    end;
    local v27 = v3.new(v23, v24, {
        headers = v22.headers,
        query = v25.query,
        data = v25.data,
        log = l_log_0,
        cookies = v25.cookies or v22.cookies,
        ignore_ratelimit = v25.ignore_ratelimit or v22.ignore_ratelimit,
        no_stats = v22.no_stats or false
    });
    if v22._ratelimit then
        table.insert(v27._ratelimits, v22._ratelimit);
    end;
    v27:set_headers(v25.headers or {});
    v27._callback = function(v28)
        for _, v30 in ipairs(v28.cookies.cookies) do
            table.insert(v22.cookies.cookies, v30);
        end;
    end;
    return v27;
end;
v11.request = function(v31, v32, v33, v34)
    return v31:Request(v32, v33, v34 or {}):send();
end;
v11.send = v6.deprecate(v11.request, "0.5", "Session:send");
v11.promise_request = function(v35, v36, v37, v38)
    return v35:Request(v36, v37, v38 or {}):send(true);
end;
v11.promise_send = v6.deprecate(v11.promise_request, "0.5", "Session:promise_send");
for _, v40 in pairs({
    "GET",
    "POST",
    "HEAD",
    "OPTIONS",
    "PUT",
    "DELETE",
    "PATCH"
}) do
    v11[v40:lower()] = function(v41, v42, v43)
        return v41:send(v40, v42, v43);
    end;
    v11["promise_" .. v40:lower()] = function(v44, v45, v46)
        return v44:promise_send(v40, v45, v46);
    end;
end;
return v11;


return {
    deprecate = function(v0, v1, v2)
        return function(...)
            if not v1 then
                warn(("[http] %s deprecated. See documentation at http://requests.paric.xyz/"):format(v2 or "Function"));
            else
                warn(("[http] %s deprecated in version %s. See documentation at http://requests.paric.xyz/"):format(v2, v1 or "Function"));
            end;
            return v0(...);
        end;
    end
};


local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_0.RobloxApiDump);
local l_getType_0 = require(l_Parent_1.JestGetType).getType;
local v4 = require(l_Parent_1.LuauPolyfill);
local l_Array_0 = v4.Array;
local l_Object_0 = v4.Object;
local v7 = require(l_Parent_0.expect);
local l_equals_0 = v7.equals;
local l_isObjectWithKeys_0 = v7.isObjectWithKeys;
local l_hasPropertyInObject_0 = v7.hasPropertyInObject;
local l_isAsymmetric_0 = v7.isAsymmetric;
local function v17(v12)
    local v13 = v2[v12];
    local v14 = {};
    while v13 do
        for _, v16 in ipairs(v13.Properties) do
            table.insert(v14, v16);
        end;
        v13 = v2[v13.Superclass];
    end;
    table.sort(v14);
    return v14;
end;
local function v43(v18, v19)
    local function v20(v21)
        return function(v22, v23)
            v21 = v21 or {};
            if l_getType_0(v22) == "Instance" and l_isObjectWithKeys_0(v23) then
                local v24 = v17(v22.ClassName);
                local v25 = {};
                for _, v27 in ipairs(v22:getChildren()) do
                    v25[v27.Name] = true;
                end;
                return l_Array_0.every(l_Object_0.keys(v23), function(v28)
                    local v29 = v23[v28];
                    if l_isObjectWithKeys_0(v29) then
                        if not v21[v29] then
                            v21[v29] = true;
                        else
                            return false;
                        end;
                    end;
                    local v30 = false;
                    if v22 ~= nil then
                        if table.find(v24, v28) == nil then
                            v30 = false;
                            if not (v25[v28] ~= nil) then
                                goto label0;
                            end;
                        end;
                        v30 = l_equals_0(v22[v28], v29, {
                            v20(v21)
                        });
                    end;
                    ::label0::;
                    v21[v29] = nil;
                    return v30;
                end);
            else
                return nil;
            end;
        end;
    end;
    local v31 = nil;
    local v32;
    do
        local l_v31_0 = v31;
        v32 = function(v34, v35)
            l_v31_0 = l_v31_0 or {};
            if l_getType_0(v34) == "Instance" and l_isObjectWithKeys_0(v35) then
                local v36 = v17(v34.ClassName);
                local v37 = {};
                for _, v39 in ipairs(v34:getChildren()) do
                    v37[v39.Name] = true;
                end;
                return l_Array_0.every(l_Object_0.keys(v35), function(v40)
                    local v41 = v35[v40];
                    if l_isObjectWithKeys_0(v41) then
                        if not l_v31_0[v41] then
                            l_v31_0[v41] = true;
                        else
                            return false;
                        end;
                    end;
                    local v42 = false;
                    if v34 ~= nil then
                        if table.find(v36, v40) == nil then
                            v42 = false;
                            if not (v37[v40] ~= nil) then
                                goto label1;
                            end;
                        end;
                        v42 = l_equals_0(v34[v40], v41, {
                            v20(l_v31_0)
                        });
                    end;
                    ::label1::;
                    l_v31_0[v41] = nil;
                    return v42;
                end);
            else
                return nil;
            end;
        end;
    end;
    if not v32 then
        return v32;
    else
        return v32(v18, v19);
    end;
end;
local v44 = {};
v44.__index = v44;
v44.new = function(v45, v46)
    table.sort(v46);
    local v47 = {
        ClassName = v45,
        subset = v46
    };
    setmetatable(v47, v44);
    return v47;
end;
local function v48(v49, v50, v51)
    v51 = v51 or {};
    local v52 = {};
    v51[v49] = v52;
    if not l_equals_0(v49, v50) then
        if typeof(v50) == "table" and not l_isAsymmetric_0(v50) then
            local v53 = {};
            for v54, v55 in pairs(v50) do
                if typeof(v55) ~= "table" then
                    v53[v54] = v55;
                end;
            end;
            local v56 = v17(v49.ClassName);
            for _, v58 in ipairs(v49:getChildren()) do
                table.insert(v56, v58.Name);
            end;
            for _, v61 in ipairs(l_Array_0.filter(v56, function(v59)
                return l_hasPropertyInObject_0(v50, v59);
            end)) do
                if v51[v49[v61]] ~= nil then
                    error("Circular reference passed into .toMatchInstance(subset)");
                else
                    local _ = nil;
                    local v63, v64 = v48(v49[v61], v50[v61], v51);
                    v52[v61] = v63;
                    v53[v61] = v64;
                end;
            end;
            local l_ClassName_0 = v49.ClassName;
            if not (not (typeof(v50) == "table") or not rawget(v50, "ClassName")) then
                l_ClassName_0 = rawget(v50, "ClassName");
            end;
            return v44.new(v49.ClassName, v52), v44.new(l_ClassName_0, v53);
        else
            return v49, v50;
        end;
    else
        return v50, v50;
    end;
end;
return {
    getRobloxProperties = v17,
    instanceSubsetEquality = v43,
    InstanceSubset = v44,
    getInstanceSubset = v48
};


local v0 = {};
v0.__index = v0;
v0.new = function(v1)
    local v2 = setmetatable({}, v0);
    v2._writeFn = if v1 ~= nil and typeof(v1.write) == "function" then v1.write else print;
    v2.isTTY = false;
    return v2;
end;
v0.write = function(v3, v4)
    v3._writeFn(v4);
end;
return {
    Writeable = v0
};


local v0 = require(script.Parent.Parent.LuauPolyfill);
local l_Array_0 = v0.Array;
local l_String_0 = v0.String;
dedent = function(v3, ...)
    local v4 = {
        ...
    };
    local v5 = "";
    if not l_Array_0.isArray(v3) then
        v5 = v3;
    else
        for v6 = 1, #v3 do
            v5 = v5 .. v3[v6];
            if v6 <= #v4 then
                v5 = v5 .. v4[v6];
            end;
        end;
    end;
    local v7 = removeTrailingSpacesAndTabs(removeLeadingNewLines(v5));
    local v8 = "";
    for v9 = 1, string.len(v7) do
        local v10 = string.sub(v7, v9, v9);
        if not (v10 ~= " ") or v10 == "\t" then
            v8 = v8 .. v10;
        else
            break;
        end;
    end;
    return removeCommonIndent(v7, v8);
end;
removeLeadingNewLines = function(v11)
    local v12 = l_String_0.findOr(v11, {
        "\n*"
    });
    if v12 ~= nil and v12.index == 1 then
        v11 = string.sub(v11, string.len(v12.match) + 1);
    end;
    return v11;
end;
removeTrailingSpacesAndTabs = function(v13)
    local v14 = nil;
    local v15 = nil;
    local v16 = 1;
    while true do
        v14 = l_String_0.findOr(v13, {
            " +",
            "\t+"
        }, v16);
        if v14 ~= nil then
            v15 = if v15 ~= nil and v15.index + string.len(v15.match) == v14.index then {
                index = v15.index,
                match = v15.match .. v14.match
            } else v14;
            v16 = v14.index + string.len(v14.match);
        end;
        if not (v14 ~= nil and string.len(v13) >= v16) then
            break;
        end;
    end;
    if v15 ~= nil and v15.index + string.len(v15.match) == string.len(v13) + 1 then
        return (string.sub(v13, 1, v15.index - 1));
    else
        return v13;
    end;
end;
removeCommonIndent = function(v17, v18)
    return (string.gsub(string.gsub(v17, v18, "", 1), "\n" .. v18, "\n"));
end;
return {
    dedent = dedent
};


local l_Parent_0 = script.Parent.Parent;
local l_getType_0 = require(l_Parent_0.JestGetType).getType;
local v2 = require(l_Parent_0.LuauPolyfill);
local l_toJSBoolean_0 = v2.Boolean.toJSBoolean;
local l_Array_0 = v2.Array;
local l_Object_0 = v2.Object;
local function v8(v6, v7)
    return rawget(v6, v7) ~= nil;
end;
local function v11(v9, v10)
    return rawget(v9, v10) ~= nil;
end;
local function v16(v12, _)
    local v14 = {};
    for v15 in pairs(v12) do
        if v12[v15] ~= nil then
            table.insert(v14, v15);
        end;
    end;
    return v14;
end;
local function v19(v17, v18)
    return l_getType_0(v18) == v17;
end;
local function v23(v20)
    if l_toJSBoolean_0(v20) and typeof(v20) == "table" then
        local l_status_0, l_result_0 = pcall(function()
            return v20.asymmetricMatch;
        end);
        if not (not l_status_0 or not (l_getType_0(l_result_0) == "function")) then
            return true;
        end;
    end;
    return false;
end;
local function _(v24, v25)
    local v26 = v23(v24);
    local v27 = v23(v25);
    if not v26 or not v27 then
        if not v26 then
            if not v27 then
                return nil;
            else
                return v25:asymmetricMatch(v24);
            end;
        else
            return v24:asymmetricMatch(v25);
        end;
    else
        return nil;
    end;
end;
local function v29(v30, v31, v32, v33, v34, v35)
    local v36 = true;
    local v37 = v23(v30);
    local v38 = v23(v31);
    local v39 = if not not v37 and v38 then nil else if v37 then v30:asymmetricMatch(v31) else if v38 then v31:asymmetricMatch(v30) else nil;
    if v39 ~= nil then
        return v39;
    else
        for _, v41 in ipairs(v34) do
            local v42 = v41(v30, v31);
            if v42 ~= nil then
                return v42;
            end;
        end;
        if not l_Object_0.is(v30, v31) then
            v37 = l_getType_0(v30);
            if v37 ~= l_getType_0(v31) then
                return false;
            elseif l_Array_0.isArray(v30) ~= l_Array_0.isArray(v31) then
                return false;
            elseif not ((v37 ~= "boolean" and v37 ~= "string") and v37 ~= "number") or v37 == "userdata" then
                return l_Object_0.is(v30, v31);
            elseif v37 == "DateTime" then
                return v30 == v31;
            elseif v37 == "regexp" then
                return tostring(v30) == tostring(v31);
            elseif not (typeof(v30) == "table") or typeof(v31) ~= "table" then
                return false;
            else
                v38 = #v32;
                while true do
                    if v38 > 0 then
                        if v32[v38] == v30 then
                            return v33[v38] == v31;
                        elseif v33[v38] == v31 then
                            return false;
                        else
                            v38 = v38 - 1;
                        end;
                    else
                        table.insert(v32, v30);
                        table.insert(v33, v31);
                        if l_Array_0.isArray(v30) and #v30 ~= #v31 then
                            return false;
                        else
                            local v43 = v16(v30, v35);
                            local v44 = #v43;
                            if #v16(v31, v35) ~= v44 then
                                return false;
                            else
                                while true do
                                    if v44 > 0 then
                                        local v45 = v43[v44];
                                        v36 = rawget(v31, v45) ~= nil and v29(v30[v45], v31[v45], v32, v33, v34, v35);
                                        if v36 then
                                            v44 = v44 - 1;
                                        else
                                            return false;
                                        end;
                                    else
                                        table.remove(v32);
                                        table.remove(v33);
                                        return v36;
                                    end;
                                end;
                            end;
                        end;
                    end;
                end;
            end;
        else
            return true;
        end;
    end;
end;
local function v50(v46, v47, v48, v49)
    return v29(v46, v47, {}, {}, v48 or {}, not not (v49 or false) and v8 or v11);
end;
local function v53(v51, v52)
    if not (not l_toJSBoolean_0(v51) or typeof(v51) ~= "table") then
        return v51[v52] ~= nil;
    else
        return false;
    end;
end;
local function _(v54)
    local v55 = false;
    if v54 ~= nil then
        v55 = typeof(v54) == "table";
    end;
    return v55;
end;
local function v59(v57)
    local v58 = false;
    if v57 ~= nil then
        v58 = typeof(v57) == "table";
    end;
    if v58 then
        v58 = true;
        if next(v57) ~= nil then
            v58 = not l_Array_0.isArray(v57);
        end;
    end;
    return v58;
end;
local function v60(v61, v62, v63, v64)
    v63 = v63 or {};
    v64 = v64 or {};
    if not (l_getType_0(v61) == "set") or l_getType_0(v62) ~= "set" then
        return nil;
    else
        local v65 = #v63;
        while true do
            if v65 > 0 then
                if v63[v65] == v61 then
                    return v64[v65] == v62;
                else
                    v65 = v65 - 1;
                end;
            else
                table.insert(v63, v61);
                table.insert(v64, v62);
                local function v68(v66, v67)
                    return v60(v66, v67, {
                        unpack(v63)
                    }, {
                        unpack(v64)
                    });
                end;
                if v61.size ~= nil then
                    if v61.size ~= v62.size then
                        return false;
                    elseif l_getType_0(v61) == "set" then
                        local v69 = true;
                        for _, v71 in v61:ipairs() do
                            if not v62:has(v71) then
                                local v72 = false;
                                for _, v74 in v62:ipairs() do
                                    if v50(v71, v74, {
                                        v68
                                    }) == true then
                                        v72 = true;
                                    end;
                                end;
                                if v72 == false then
                                    v69 = false;
                                    break;
                                end;
                            end;
                        end;
                        table.remove(v63);
                        table.remove(v64);
                        return v69;
                    end;
                end;
                return nil;
            end;
        end;
    end;
end;
local function v93(v75, v76)
    local function v77(v78)
        local v79 = v78 or {};
        return function(v80, v81)
            local v82 = false;
            if v81 ~= nil then
                v82 = typeof(v81) == "table";
            end;
            if v82 then
                v82 = true;
                if next(v81) ~= nil then
                    v82 = not l_Array_0.isArray(v81);
                end;
            end;
            if v82 then
                return l_Array_0.every(l_Object_0.keys(v81), function(v83)
                    local v84 = v81[v83];
                    local v85 = false;
                    if v84 ~= nil then
                        v85 = typeof(v84) == "table";
                    end;
                    if v85 then
                        v85 = true;
                        if next(v84) ~= nil then
                            v85 = not l_Array_0.isArray(v84);
                        end;
                    end;
                    if v85 then
                        if not v79[v81[v83]] then
                            v79[v81[v83]] = true;
                        else
                            return v50(v80[v83], v81[v83], {
                                v60
                            });
                        end;
                    end;
                    v85 = false;
                    if v80 ~= nil then
                        v84 = v80;
                        v85 = if not (not l_toJSBoolean_0(v84) or typeof(v84) ~= "table") then v84[v83] ~= nil else false and v50(v80[v83], v81[v83], {
                            v77(v79)
                        });
                    end;
                    v79[v81[v83]] = nil;
                    return v85;
                end);
            else
                return nil;
            end;
        end;
    end;
    local v86 = {};
    return (function(v87, v88)
        local v89 = false;
        if v88 ~= nil then
            v89 = typeof(v88) == "table";
        end;
        if v89 then
            v89 = true;
            if next(v88) ~= nil then
                v89 = not l_Array_0.isArray(v88);
            end;
        end;
        if v89 then
            return l_Array_0.every(l_Object_0.keys(v88), function(v90)
                local v91 = v88[v90];
                local v92 = false;
                if v91 ~= nil then
                    v92 = typeof(v91) == "table";
                end;
                if v92 then
                    v92 = true;
                    if next(v91) ~= nil then
                        v92 = not l_Array_0.isArray(v91);
                    end;
                end;
                if v92 then
                    if not v86[v88[v90]] then
                        v86[v88[v90]] = true;
                    else
                        return v50(v87[v90], v88[v90], {
                            v60
                        });
                    end;
                end;
                v92 = false;
                if v87 ~= nil then
                    v91 = v87;
                    v92 = if not (not l_toJSBoolean_0(v91) or typeof(v91) ~= "table") then v91[v90] ~= nil else false and v50(v87[v90], v88[v90], {
                        v77(v86)
                    });
                end;
                v86[v88[v90]] = nil;
                return v92;
            end);
        else
            return nil;
        end;
    end)(v75, v76);
end;
local function v94(v95, v96, v97)
    local v98 = v97 or {};
    if not l_Array_0.isArray(v95) then
        if l_getType_0(v95) == "DateTime" then
            return v95;
        else
            local v99 = false;
            if v95 ~= nil then
                v99 = typeof(v95) == "table";
            end;
            if v99 then
                v99 = false;
                if v96 ~= nil then
                    v99 = typeof(v96) == "table";
                end;
                if v99 then
                    if not v50(v95, v96, {
                        v60,
                        v93
                    }) then
                        v99 = {};
                        v98[v95] = v99;
                        for _, v103 in ipairs(l_Array_0.filter(l_Object_0.keys(v95), function(v100)
                            local l_v96_0 = v96;
                            if not (not l_toJSBoolean_0(l_v96_0) or typeof(l_v96_0) ~= "table") then
                                return l_v96_0[v100] ~= nil;
                            else
                                return false;
                            end;
                        end)) do
                            if v98[v95[v103]] ~= nil then
                                v99[v103] = v98[v95[v103]];
                            else
                                v99[v103] = v94(v95[v103], v96[v103], v98);
                            end;
                        end;
                        if #l_Object_0.keys(v99) > 0 then
                            return v99;
                        end;
                    else
                        return v96;
                    end;
                end;
            end;
        end;
    elseif l_Array_0.isArray(v96) and #v96 == #v95 then
        local v104 = {};
        for v105, v106 in ipairs(v96) do
            table.insert(v104, v94(v95[v105], v106));
        end;
        return v104;
    end;
    return v95;
end;
return {
    equals = v50,
    isA = v19,
    isAsymmetric = v23,
    getObjectSubset = v94,
    iterableEquality = v60,
    subsetEquality = v93,
    isObjectWithKeys = v59,
    hasPropertyInObject = v53
};


local l_script_0 = script;
return {
    expect = require(l_script_0.expect),
    RobloxInstance = require(l_script_0.RobloxInstance),
    dedent = require(l_script_0.dedent).dedent,
    Writeable = require(l_script_0.Writeable).Writeable
};


local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_0.RobloxApiDump);
local l_getType_0 = require(l_Parent_1.JestGetType).getType;
local v4 = require(l_Parent_1.LuauPolyfill);
local l_Array_0 = v4.Array;
local l_Object_0 = v4.Object;
local v7 = require(l_Parent_0.expect);
local l_equals_0 = v7.equals;
local l_isObjectWithKeys_0 = v7.isObjectWithKeys;
local l_hasPropertyInObject_0 = v7.hasPropertyInObject;
local l_isAsymmetric_0 = v7.isAsymmetric;
local v12 = {};
local function v15(v13, v14)
    return v13[v14];
end;
local function v21(v16)
    local v17 = v2[v16];
    local v18 = {};
    while v17 do
        for _, v20 in ipairs(v17.Properties) do
            table.insert(v18, v20);
        end;
        v17 = v2[v17.Superclass];
    end;
    table.sort(v18);
    return v18;
end;
local function v30(v22)
    local v23 = v21(v22);
    local v24 = v12[v22];
    if not v24 then
        v24 = {};
        v12[v22] = v24;
        local v25 = Instance.new(v22);
        for _, v27 in ipairs(v23) do
            local l_status_0, l_result_0 = pcall(v15, v25, v27);
            if l_status_0 then
                v24[v27] = l_result_0;
            end;
        end;
        v25:Destroy();
        return v24, v23;
    else
        return v24, v23;
    end;
end;
local function v56(v31, v32)
    local function v33(v34)
        return function(v35, v36)
            v34 = v34 or {};
            if l_getType_0(v35) == "Instance" and l_isObjectWithKeys_0(v36) then
                local v37 = v21(v35.ClassName);
                local v38 = {};
                for _, v40 in ipairs(v35:getChildren()) do
                    v38[v40.Name] = true;
                end;
                return l_Array_0.every(l_Object_0.keys(v36), function(v41)
                    local v42 = v36[v41];
                    if l_isObjectWithKeys_0(v42) then
                        if not v34[v42] then
                            v34[v42] = true;
                        else
                            return false;
                        end;
                    end;
                    local v43 = false;
                    if v35 ~= nil then
                        if table.find(v37, v41) == nil then
                            v43 = false;
                            if not (v38[v41] ~= nil) then
                                goto label0;
                            end;
                        end;
                        v43 = l_equals_0(v35[v41], v42, {
                            v33(v34)
                        });
                    end;
                    ::label0::;
                    v34[v42] = nil;
                    return v43;
                end);
            else
                return nil;
            end;
        end;
    end;
    local v44 = nil;
    local v45;
    do
        local l_v44_0 = v44;
        v45 = function(v47, v48)
            l_v44_0 = l_v44_0 or {};
            if l_getType_0(v47) == "Instance" and l_isObjectWithKeys_0(v48) then
                local v49 = v21(v47.ClassName);
                local v50 = {};
                for _, v52 in ipairs(v47:getChildren()) do
                    v50[v52.Name] = true;
                end;
                return l_Array_0.every(l_Object_0.keys(v48), function(v53)
                    local v54 = v48[v53];
                    if l_isObjectWithKeys_0(v54) then
                        if not l_v44_0[v54] then
                            l_v44_0[v54] = true;
                        else
                            return false;
                        end;
                    end;
                    local v55 = false;
                    if v47 ~= nil then
                        if table.find(v49, v53) == nil then
                            v55 = false;
                            if not (v50[v53] ~= nil) then
                                goto label1;
                            end;
                        end;
                        v55 = l_equals_0(v47[v53], v54, {
                            v33(l_v44_0)
                        });
                    end;
                    ::label1::;
                    l_v44_0[v54] = nil;
                    return v55;
                end);
            else
                return nil;
            end;
        end;
    end;
    if not v45 then
        return v45;
    else
        return v45(v31, v32);
    end;
end;
local v57 = {};
v57.__index = v57;
v57.new = function(v58, v59)
    table.sort(v59);
    local v60 = {
        ClassName = v58,
        subset = v59
    };
    setmetatable(v60, v57);
    return v60;
end;
local function v61(v62, v63, v64)
    local v65 = v64 or {};
    local v66 = {};
    v65[v62] = v66;
    if not l_equals_0(v62, v63) then
        if typeof(v63) == "table" and not l_isAsymmetric_0(v63) then
            local v67 = {};
            for v68, v69 in pairs(v63) do
                if typeof(v69) ~= "table" then
                    v67[v68] = v69;
                end;
            end;
            local v70 = v21(v62.ClassName);
            for _, v72 in ipairs(v62:getChildren()) do
                table.insert(v70, v72.Name);
            end;
            for _, v75 in ipairs(l_Array_0.filter(v70, function(v73)
                return l_hasPropertyInObject_0(v63, v73);
            end)) do
                if v65[v62[v75]] ~= nil then
                    error("Circular reference passed into .toMatchInstance(subset)");
                else
                    local _ = nil;
                    local v77, v78 = v61(v62[v75], v63[v75], v65);
                    v66[v75] = v77;
                    v67[v75] = v78;
                end;
            end;
            local l_ClassName_0 = v62.ClassName;
            if not (not (typeof(v63) == "table") or not rawget(v63, "ClassName")) then
                l_ClassName_0 = rawget(v63, "ClassName");
            end;
            return v57.new(v62.ClassName, v66), v57.new(l_ClassName_0, v67);
        else
            return v62, v63;
        end;
    else
        return v63, v63;
    end;
end;
return {
    getRobloxProperties = v21,
    getRobloxDefaults = v30,
    instanceSubsetEquality = v56,
    InstanceSubset = v57,
    getInstanceSubset = v61
};


return {
    escapePatternCharacters = function(v0)
        return string.gsub(v0, "([%(%)%.%%%+%-%*%?%[%^%$])", "%%%1");
    end
};


local l_Parent_0 = script.Parent.Parent;
local l_getType_0 = require(l_Parent_0.JestGetType).getType;
local v2 = require(l_Parent_0.LuauPolyfill);
local l_toJSBoolean_0 = v2.Boolean.toJSBoolean;
local l_Array_0 = v2.Array;
local l_Object_0 = v2.Object;
local function v8(v6, v7)
    return rawget(v6, v7) ~= nil;
end;
local function v11(v9, v10)
    return rawget(v9, v10) ~= nil;
end;
local function v16(v12, _)
    local v14 = {};
    for v15 in pairs(v12) do
        if v12[v15] ~= nil then
            table.insert(v14, v15);
        end;
    end;
    return v14;
end;
local function v19(v17, v18)
    return l_getType_0(v18) == v17;
end;
local function v23(v20)
    if l_toJSBoolean_0(v20) and typeof(v20) == "table" then
        local l_status_0, l_result_0 = pcall(function()
            return v20.asymmetricMatch;
        end);
        if not (not l_status_0 or not (l_getType_0(l_result_0) == "function")) then
            return true;
        end;
    end;
    return false;
end;
local function _(v24, v25)
    local v26 = v23(v24);
    local v27 = v23(v25);
    if not v26 or not v27 then
        if not v26 then
            if not v27 then
                return nil;
            else
                return v25:asymmetricMatch(v24);
            end;
        else
            return v24:asymmetricMatch(v25);
        end;
    else
        return nil;
    end;
end;
local function v29(v30, v31, v32, v33, v34, v35)
    local v36 = true;
    local v37 = v23(v30);
    local v38 = v23(v31);
    local v39 = if not not v37 and v38 then nil else if v37 then v30:asymmetricMatch(v31) else if v38 then v31:asymmetricMatch(v30) else nil;
    if v39 ~= nil then
        return v39;
    else
        for _, v41 in ipairs(v34) do
            local v42 = v41(v30, v31);
            if v42 ~= nil then
                return v42;
            end;
        end;
        if not l_Object_0.is(v30, v31) then
            v37 = l_getType_0(v30);
            if v37 ~= l_getType_0(v31) then
                return false;
            elseif l_Array_0.isArray(v30) ~= l_Array_0.isArray(v31) then
                return false;
            elseif not ((v37 ~= "boolean" and v37 ~= "string") and v37 ~= "number") or v37 == "userdata" then
                return l_Object_0.is(v30, v31);
            elseif v37 == "DateTime" then
                return v30 == v31;
            elseif v37 == "regexp" then
                return tostring(v30) == tostring(v31);
            elseif not (typeof(v30) == "table") or typeof(v31) ~= "table" then
                return false;
            else
                v38 = #v32;
                while true do
                    if v38 > 0 then
                        if v32[v38] == v30 then
                            return v33[v38] == v31;
                        elseif v33[v38] == v31 then
                            return false;
                        else
                            v38 = v38 - 1;
                        end;
                    else
                        table.insert(v32, v30);
                        table.insert(v33, v31);
                        if l_Array_0.isArray(v30) and #v30 ~= #v31 then
                            return false;
                        else
                            local v43 = v16(v30, v35);
                            local v44 = #v43;
                            if #v16(v31, v35) ~= v44 then
                                return false;
                            else
                                while true do
                                    if v44 > 0 then
                                        local v45 = v43[v44];
                                        v36 = rawget(v31, v45) ~= nil and v29(v30[v45], v31[v45], v32, v33, v34, v35);
                                        if v36 then
                                            v44 = v44 - 1;
                                        else
                                            return false;
                                        end;
                                    else
                                        table.remove(v32);
                                        table.remove(v33);
                                        return v36;
                                    end;
                                end;
                            end;
                        end;
                    end;
                end;
            end;
        else
            return true;
        end;
    end;
end;
local function v50(v46, v47, v48, v49)
    return v29(v46, v47, {}, {}, v48 or {}, not not (v49 or false) and v8 or v11);
end;
local function v53(v51, v52)
    if not (not l_toJSBoolean_0(v51) or typeof(v51) ~= "table") then
        return v51[v52] ~= nil;
    else
        return false;
    end;
end;
local function _(v54)
    local v55 = false;
    if v54 ~= nil then
        v55 = typeof(v54) == "table";
    end;
    return v55;
end;
local function v59(v57)
    local v58 = false;
    if v57 ~= nil then
        v58 = typeof(v57) == "table";
    end;
    if v58 then
        v58 = true;
        if next(v57) ~= nil then
            v58 = not l_Array_0.isArray(v57);
        end;
    end;
    return v58;
end;
local function v60(v61, v62, v63, v64)
    local v65 = v63 or {};
    local v66 = v64 or {};
    if not (l_getType_0(v61) == "set") or l_getType_0(v62) ~= "set" then
        return nil;
    else
        local v67 = #v65;
        while true do
            if v67 > 0 then
                if v65[v67] == v61 then
                    return v66[v67] == v62;
                else
                    v67 = v67 - 1;
                end;
            else
                table.insert(v65, v61);
                table.insert(v66, v62);
                local function v70(v68, v69)
                    return v60(v68, v69, {
                        unpack(v65)
                    }, {
                        unpack(v66)
                    });
                end;
                if v61.size ~= nil then
                    if v61.size ~= v62.size then
                        return false;
                    elseif l_getType_0(v61) == "set" then
                        local v71 = true;
                        for _, v73 in v61:ipairs() do
                            if not v62:has(v73) then
                                local v74 = false;
                                for _, v76 in v62:ipairs() do
                                    if v50(v73, v76, {
                                        v70
                                    }) == true then
                                        v74 = true;
                                    end;
                                end;
                                if v74 == false then
                                    v71 = false;
                                    break;
                                end;
                            end;
                        end;
                        table.remove(v65);
                        table.remove(v66);
                        return v71;
                    end;
                end;
                return nil;
            end;
        end;
    end;
end;
local function v95(v77, v78)
    local function v79(v80)
        local v81 = v80 or {};
        return function(v82, v83)
            local v84 = false;
            if v83 ~= nil then
                v84 = typeof(v83) == "table";
            end;
            if v84 then
                v84 = true;
                if next(v83) ~= nil then
                    v84 = not l_Array_0.isArray(v83);
                end;
            end;
            if v84 then
                return l_Array_0.every(l_Object_0.keys(v83), function(v85)
                    local v86 = v83[v85];
                    local v87 = false;
                    if v86 ~= nil then
                        v87 = typeof(v86) == "table";
                    end;
                    if v87 then
                        v87 = true;
                        if next(v86) ~= nil then
                            v87 = not l_Array_0.isArray(v86);
                        end;
                    end;
                    if v87 then
                        if not v81[v83[v85]] then
                            v81[v83[v85]] = true;
                        else
                            return v50(v82[v85], v83[v85], {
                                v60
                            });
                        end;
                    end;
                    v87 = false;
                    if v82 ~= nil then
                        v86 = v82;
                        v87 = if not (not l_toJSBoolean_0(v86) or typeof(v86) ~= "table") then v86[v85] ~= nil else false and v50(v82[v85], v83[v85], {
                            v79(v81)
                        });
                    end;
                    v81[v83[v85]] = nil;
                    return v87;
                end);
            else
                return nil;
            end;
        end;
    end;
    local v88 = {};
    return (function(v89, v90)
        local v91 = false;
        if v90 ~= nil then
            v91 = typeof(v90) == "table";
        end;
        if v91 then
            v91 = true;
            if next(v90) ~= nil then
                v91 = not l_Array_0.isArray(v90);
            end;
        end;
        if v91 then
            return l_Array_0.every(l_Object_0.keys(v90), function(v92)
                local v93 = v90[v92];
                local v94 = false;
                if v93 ~= nil then
                    v94 = typeof(v93) == "table";
                end;
                if v94 then
                    v94 = true;
                    if next(v93) ~= nil then
                        v94 = not l_Array_0.isArray(v93);
                    end;
                end;
                if v94 then
                    if not v88[v90[v92]] then
                        v88[v90[v92]] = true;
                    else
                        return v50(v89[v92], v90[v92], {
                            v60
                        });
                    end;
                end;
                v94 = false;
                if v89 ~= nil then
                    v93 = v89;
                    v94 = if not (not l_toJSBoolean_0(v93) or typeof(v93) ~= "table") then v93[v92] ~= nil else false and v50(v89[v92], v90[v92], {
                        v79(v88)
                    });
                end;
                v88[v90[v92]] = nil;
                return v94;
            end);
        else
            return nil;
        end;
    end)(v77, v78);
end;
local function v96(v97, v98, v99)
    local v100 = v99 or {};
    if not l_Array_0.isArray(v97) then
        if l_getType_0(v97) == "DateTime" then
            return v97;
        else
            local v101 = false;
            if v97 ~= nil then
                v101 = typeof(v97) == "table";
            end;
            if v101 then
                v101 = false;
                if v98 ~= nil then
                    v101 = typeof(v98) == "table";
                end;
                if v101 then
                    if not v50(v97, v98, {
                        v60,
                        v95
                    }) then
                        v101 = {};
                        v100[v97] = v101;
                        for _, v105 in ipairs(l_Array_0.filter(l_Object_0.keys(v97), function(v102)
                            local l_v98_0 = v98;
                            if not (not l_toJSBoolean_0(l_v98_0) or typeof(l_v98_0) ~= "table") then
                                return l_v98_0[v102] ~= nil;
                            else
                                return false;
                            end;
                        end)) do
                            if v100[v97[v105]] ~= nil then
                                v101[v105] = v100[v97[v105]];
                            else
                                v101[v105] = v96(v97[v105], v98[v105], v100);
                            end;
                        end;
                        if #l_Object_0.keys(v101) > 0 then
                            return v101;
                        end;
                    else
                        return v98;
                    end;
                end;
            end;
        end;
    elseif l_Array_0.isArray(v98) and #v98 == #v97 then
        local v106 = {};
        for v107, v108 in ipairs(v98) do
            table.insert(v106, v96(v97[v107], v108));
        end;
        return v106;
    end;
    return v97;
end;
return {
    equals = v50,
    isA = v19,
    isAsymmetric = v23,
    getObjectSubset = v96,
    iterableEquality = v60,
    subsetEquality = v95,
    isObjectWithKeys = v59,
    hasPropertyInObject = v53
};


return function(v0, v1)
    local l_Name_0 = v0.Name;
    local l_v0_0 = v0;
    while l_v0_0.Parent and l_v0_0 ~= v1 do
        l_v0_0 = l_v0_0.Parent;
        l_Name_0 = l_v0_0.Name .. "/" .. l_Name_0;
    end;
    if v1 ~= nil then
        return l_Name_0;
    else
        return "/" .. l_Name_0;
    end;
end;


local l_script_0 = script;
return {
    dedent = require(l_script_0.dedent).dedent,
    escapePatternCharacters = require(l_script_0.escapePatternCharacters).escapePatternCharacters,
    expect = require(l_script_0.expect),
    getRelativePath = require(l_script_0.getRelativePath),
    RobloxInstance = require(l_script_0.RobloxInstance),
    nodeUtils = require(l_script_0.nodeUtils),
    normalizePromiseError = require(l_script_0.normalizePromiseError),
    Writeable = require(l_script_0.Writeable).Writeable
};


local l_Writeable_0 = require(script.Parent.Writeable).Writeable;
local v1 = {
    stdout = l_Writeable_0.new(),
    stderr = l_Writeable_0.new()
};
local function v3(v2)
    error(("Exited with code: %d"):format(v2));
end;
local l_HttpService_0 = game:GetService("HttpService");
return {
    process = v1,
    exit = v3,
    JSON = {
        stringify = function(v5, ...)
            if select("#", ...) > 0 then
                warn("JSON.stringify doesn't currently support more than 1 argument. All additional arguments will be ignored.");
            end;
            return l_HttpService_0:JSONEncode(v5);
        end,
        parse = function(v6, ...)
            if select("#", ...) > 0 then
                warn("JSON.parse doesn't currently support more than 1 argument. All additional arguments will be ignored.");
            end;
            return l_HttpService_0:JSONDecode(v6);
        end
    }
};


local l_Boolean_0 = require(script.Parent.Parent.LuauPolyfill).Boolean;
local function v3(v1)
    local l_v1_0 = v1;
    while not (l_Boolean_0.toJSBoolean(l_v1_0.trace) or not l_v1_0.parent) do
        l_v1_0 = l_v1_0.parent;
    end;
    return l_v1_0.trace or "";
end;
local function v7(v4)
    local l_v4_0 = v4;
    local l_error_0 = v4.error;
    while not (l_Boolean_0.toJSBoolean(l_v4_0.trace) or not l_v4_0.parent) do
        l_v4_0 = l_v4_0.parent;
        l_error_0 = l_v4_0.error or l_error_0;
    end;
    return l_v4_0.message or l_error_0;
end;
return function(v8)
    v8.message = v7(v8);
    v8.stack = v3(v8);
    return v8;
end;


local function v2(v0, v1, ...)
    if not v1 then
        error(debug.traceback(v0, (...)), 2);
    end;
    if coroutine.status(v0) ~= "dead" then
        error(debug.traceback(v0, "Attempted to yield inside changed event"), 2);
    end;
    return ...;
end;
return function(v3, ...)
    local v4 = coroutine.create(v3);
    return v2(v4, coroutine.resume(v4, ...));
end;


local function v5(v0, ...)
    local v1 = {};
    local v2 = #v0;
    for v3 = 1, v2 do
        v1[v3] = v0[v3];
    end;
    for v4 = 1, select("#", ...) do
        v1[v2 + v4] = select(v4, ...);
    end;
    return v1;
end;
local function v10(v6, v7)
    local v8 = {};
    for v9 = 1, #v6 do
        if v6[v9] ~= v7 then
            table.insert(v8, v6[v9]);
        end;
    end;
    return v8;
end;
local v11 = {};
v11.__index = v11;
v11.new = function(v12)
    local v13 = {
        _listeners = {},
        _store = v12
    };
    setmetatable(v13, v11);
    return v13;
end;
v11.connect = function(v14, v15)
    if typeof(v15) ~= "function" then
        error("Expected the listener to be a function.");
    end;
    if not (not v14._store or not v14._store._isDispatching) then
        error("You may not call store.changed:connect() while the reducer is executing. " .. "If you would like to be notified after the store has been updated, subscribe from a " .. "component and invoke store:getState() in the callback to access the latest state. ");
    end;
    local v16 = {
        callback = v15,
        disconnected = false,
        connectTraceback = debug.traceback(),
        disconnectTraceback = nil
    };
    v14._listeners = v5(v14._listeners, v16);
    return {
        disconnect = function()
            if v16.disconnected then
                error(("Listener connected at: \n%s\n" .. "was already disconnected at: \n%s\n"):format(tostring(v16.connectTraceback), (tostring(v16.disconnectTraceback))));
            end;
            if not (not v14._store or not v14._store._isDispatching) then
                error("You may not unsubscribe from a store listener while the reducer is executing.");
            end;
            v16.disconnected = true;
            v16.disconnectTraceback = debug.traceback();
            v14._listeners = v10(v14._listeners, v16);
        end
    };
end;
v11.fire = function(v17, ...)
    for _, v19 in ipairs(v17._listeners) do
        if not v19.disconnected then
            v19.callback(...);
        end;
    end;
end;
return v11;


local l_RunService_0 = game:GetService("RunService");
local v1 = require(script.Parent.Signal);
local v2 = require(script.Parent.NoYield);
local v10 = {
    reportReducerError = function(_, _, v5)
        error(string.format("Received error: %s\n\n%s", v5.message, v5.thrownValue));
    end,
    reportUpdateError = function(_, _, _, v9)
        error(string.format("Received error: %s\n\n%s", v9.message, v9.thrownValue));
    end
};
local function v12(v11)
    return debug.traceback((tostring(v11)));
end;
local v13 = {
    _flushEvent = l_RunService_0.Heartbeat
};
v13.__index = v13;
v13.new = function(v14, v15, v16, v17, v18)
    assert(typeof(v14) == "function", "Bad argument #1 to Store.new, expected function.");
    local v19 = true;
    if v16 ~= nil then
        v19 = typeof(v16) == "table";
    end;
    assert(v19, "Bad argument #3 to Store.new, expected nil or table.");
    v19 = true;
    if v18 ~= nil then
        v19 = false;
        if typeof(v18) == "table" then
            v19 = v18.__className == "Devtools";
        end;
    end;
    assert(v19, "Bad argument #5 to Store.new, expected nil or Devtools object.");
    if v16 ~= nil then
        for v20 = 1, #v16 do
            assert(typeof(v16[v20]) == "function", ("Expected the middleware ('%s') at index %d to be a function."):format(tostring(v16[v20]), v20));
        end;
    end;
    local v21 = {
        _source = string.match(debug.traceback(), "^.-\n(.-)\n"),
        _errorReporter = v17 or v10,
        _isDispatching = false,
        _lastState = nil
    };
    v21.changed = v1.new(v21);
    v21._reducer = v14;
    v21._flushHandler = function(v22)
        v21.changed:fire(v22, v21._lastState);
    end;
    if v18 then
        v21._devtools = v18;
        v18:_hookIntoStore(v21);
    end;
    v19 = {
        type = "@@INIT"
    };
    v21._actionLog = {
        v19
    };
    local v23, v24 = xpcall(function()
        v21._state = v21._reducer(v15, v19);
    end, v12);
    if not v23 then
        v21._errorReporter.reportReducerError(v15, v19, {
            message = "Caught error in reducer with init",
            thrownValue = v24
        });
        v21._state = v15;
    end;
    v21._lastState = v21._state;
    v21._mutatedSinceFlush = false;
    v21._connections = {};
    setmetatable(v21, v13);
    table.insert(v21._connections, (v21._flushEvent:Connect(function()
        v21:flush();
    end)));
    if v16 then
        local l_dispatch_0 = v21.dispatch;
        local function v26(...)
            return l_dispatch_0(v21, ...);
        end;
        for v27 = #v16, 1, -1 do
            v26 = v16[v27](v26, v21);
        end;
        do
            local l_v26_0 = v26;
            v21.dispatch = function(_, ...)
                return l_v26_0(...);
            end;
        end;
    end;
    return v21;
end;
v13.getState = function(v30)
    if v30._isDispatching then
        error(("You may not call store:getState() while the reducer is executing. " .. "The reducer (%s) has already received the state as an argument. " .. "Pass it down from the top reducer instead of reading it from the store."):format((tostring(v30._reducer))));
    end;
    return v30._state;
end;
v13.dispatch = function(v31, v32)
    if typeof(v32) ~= "table" then
        error(("Actions must be tables. " .. "Use custom middleware for %q actions."):format((typeof(v32))), 2);
    end;
    if v32.type == nil then
        error("Actions may not have an undefined 'type' property. " .. "Have you misspelled a constant? \n" .. tostring(v32), 2);
    end;
    if v31._isDispatching then
        error("Reducers may not dispatch actions.");
    end;
    local l_status_0, l_result_0 = pcall(function()
        v31._isDispatching = true;
        v31._state = v31._reducer(v31._state, v32);
        v31._mutatedSinceFlush = true;
    end);
    v31._isDispatching = false;
    if not l_status_0 then
        v31._errorReporter.reportReducerError(v31._state, v32, {
            message = "Caught error in reducer",
            thrownValue = l_result_0
        });
    end;
    if #v31._actionLog == 3 then
        table.remove(v31._actionLog, 1);
    end;
    table.insert(v31._actionLog, v32);
end;
v13.destruct = function(v35)
    for _, v37 in ipairs(v35._connections) do
        v37:Disconnect();
    end;
    v35._connections = nil;
end;
v13.flush = function(v38)
    if v38._mutatedSinceFlush then
        v38._mutatedSinceFlush = false;
        local l__state_0 = v38._state;
        local v40, v41 = xpcall(function()
            v2(v38._flushHandler, l__state_0);
        end, v12);
        if not v40 then
            v38._errorReporter.reportUpdateError(v38._lastState, l__state_0, v38._actionLog, {
                message = "Caught error flushing store updates",
                thrownValue = v41
            });
        end;
        v38._lastState = l__state_0;
        return ;
    else
        return ;
    end;
end;
return v13;


return function(v0)
    return function(v1, v2)
        if v1 == nil then
            v1 = {};
        end;
        local v3 = {};
        for v4, v5 in pairs(v0) do
            v3[v4] = v5(v1[v4], v2);
        end;
        return v3;
    end;
end;


return function(v0, v1)
    return function(v2, v3)
        if v2 == nil then
            v2 = v0;
        end;
        local v4 = v1[v3.type];
        if not v4 then
            return v2;
        else
            return v4(v2, v3);
        end;
    end;
end;


return {
    Store = require(script.Store),
    createReducer = require(script.createReducer),
    combineReducers = require(script.combineReducers),
    makeActionCreator = require(script.makeActionCreator),
    loggerMiddleware = require(script.loggerMiddleware).middleware,
    thunkMiddleware = require(script.thunkMiddleware),
    makeThunkMiddleware = require(script.makeThunkMiddleware)
};


local v0 = require(script.Parent.prettyPrint);
local v1 = {
    outputFunction = print
};
v1.middleware = function(v2, v3)
    return function(v4)
        local v5 = v2(v4);
        v1.outputFunction(("Action dispatched: %s\nState changed to: %s"):format(v0(v4), v0(v3:getState())));
        return v5;
    end;
end;
return v1;


return function(v0, v1)
    assert(type(v0) == "string", "Bad argument #1: Expected a string name for the action creator");
    assert(type(v1) == "function", "Bad argument #2: Expected a function that creates action objects");
    return (setmetatable({
        name = v0
    }, {
        __call = function(_, ...)
            local v3 = v1(...);
            assert(type(v3) == "table", "Invalid action: An action creator must return a table");
            v3.type = v0;
            return v3;
        end
    }));
end;


local function v1(v0)
    return debug.traceback(v0);
end;
return function(v2)
    return function(v3, v4)
        return function(v5)
            if typeof(v5) == "function" then
                local v6, v7 = xpcall(function()
                    return v5(v4, v2);
                end, v1);
                if v6 then
                    return v7;
                else
                    v4._errorReporter.reportReducerError(v4:getState(), v5, {
                        message = "Caught error in thunk",
                        thrownValue = v7
                    });
                    return nil;
                end;
            else
                return v3(v5);
            end;
        end;
    end;
end;


local function v0(v1, v2)
    v2 = v2 or 0;
    local v3 = {};
    if typeof(v1) == "table" then
        table.insert(v3, "{\n");
        for v4, v5 in pairs(v1) do
            table.insert(v3, ("    "):rep(v2 + 1));
            table.insert(v3, (tostring(v4)));
            table.insert(v3, " = ");
            table.insert(v3, v0(v5, v2 + 1));
            table.insert(v3, "\n");
        end;
        table.insert(v3, ("    "):rep(v2));
        table.insert(v3, "}");
    elseif typeof(v1) == "string" then
        table.insert(v3, string.format("%q", v1));
        table.insert(v3, " (string)");
    else
        table.insert(v3, (tostring(v1)));
        table.insert(v3, " (");
        table.insert(v3, (typeof(v1)));
        table.insert(v3, ")");
    end;
    return table.concat(v3, "");
end;
return v0;


return require(script:FindFirstAncestor("RoduxAliases").Parent.Rodux).makeActionCreator(script.Name, function(v0)
    return {
        payload = {
            userId = v0
        }
    };
end);


return require(script:FindFirstAncestor("RoduxAliases").Parent.Rodux).makeActionCreator(script.Name, function(v0, v1)
    return {
        payload = {
            userId = v0,
            newAlias = v1
        }
    };
end);


return require(script:FindFirstAncestor("RoduxAliases").Parent.Rodux).makeActionCreator(require(script.Parent.ActionDomain) .. script.Name, function(v0)
    return {
        payload = {
            showUserAlias = v0
        }
    };
end);


return {
    AliasRemoved = require(script.AliasRemoved),
    AliasUpdated = require(script.AliasUpdated),
    ReceivedCanShowUserAlias = require(script.ReceivedCanShowUserAlias)
};


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Reducers.Aliases.byUserId);
local _ = require(l_Parent_0.RoduxAliasesTypes);
local v3 = {};
return function(v4)
    return function(v5, v6)
        return {
            byUserId = v1(v4)((v5 or v3).byUserId, v6)
        };
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.getDeepValue);
local _ = require(l_Parent_0.RoduxAliasesTypes);
return function(v3)
    local l_keyPath_0 = v3.keyPath;
    return function(v5, v6)
        return v1(v5, l_keyPath_0 .. ".byUserId")[v6];
    end;
end;


local _ = require(script.Parent.RoduxAliasesTypes);
return function(v1)
    return {
        getAliasByUserId = require(script.getAliasByUserId)(v1)
    };
end;


return function(v0, v1)
    local l_v0_0 = v0;
    for _, v4 in ipairs(v1:split(".")) do
        if l_v0_0[v4] then
            l_v0_0 = l_v0_0[v4];
        else
            return nil;
        end;
    end;
    return l_v0_0;
end;


local l_script_0 = script;
local l_Parent_0 = l_script_0.Parent;
local v2 = require(l_Parent_0.llama);
local v3 = require(l_Parent_0.RoduxNetworking);
local v4 = require(l_Parent_0.AliasNetworking);
local v5 = require(l_script_0.Reducers.AliasesReducer);
local v6 = require(l_script_0.Actions);
local v7 = require(l_script_0.Selectors);
local _ = require(l_script_0.RoduxAliasesTypes);
return {
    config = function(v9)
        v9 = v2.Dictionary.join(v9, {
            aliasNetworking = v4.config({
                roduxNetworking = v3.mock()
            })
        });
        return {
            installReducer = function()
                return v5(v9);
            end,
            Actions = v6,
            Selectors = v7(v9)
        };
    end
};


return require(script:FindFirstAncestor("RoduxCall").Parent.Rodux).makeActionCreator(script.Name, function()
    return {
        payload = {}
    };
end);


return require(script:FindFirstAncestor("RoduxCall").Parent.Rodux).makeActionCreator(script.Name, function(v0)
    return {
        payload = {
            call = v0
        }
    };
end);


return {
    ClearSuggestedCallees = require(script.ClearSuggestedCallees),
    UpdateCall = require(script.UpdateCall)
};


return {
    Accept = "Accept",
    AcceptSuccess = "AcceptSuccess",
    Cancel = "Cancel",
    ConnectionConfirm = "ConnectionConfirm",
    Decline = "Decline",
    Duplicate = "Duplicate",
    Fail = "Fail",
    Finish = "Finish",
    Init = "Init",
    InitSucess = "InitSuccess",
    Miss = "Miss",
    Receive = "Receive",
    Reject = "Reject",
    Suppress = "Suppress",
    TeleportSuccess = "TeleportSuccess"
};


return {
    Offline = "Offline",
    Online = "Online",
    InGame = "InGame",
    InStudio = "InStudio",
    Invisible = "Invisible"
};


return {
    Idle = "Idle",
    Ringing = "Ringing",
    Accepting = "Accepting",
    Initializing = "Initializing",
    Connecting = "Connecting",
    Teleporting = "Teleporting",
    Active = "Active"
};


return {
    CallAction = require(script.CallAction),
    RecordStatus = require(script.RecordStatus),
    Status = require(script.Status),
    PresenceType = require(script.PresenceType)
};


local l_script_FirstAncestor_0 = script:FindFirstAncestor("RoduxCall");
local l_Parent_0 = l_script_FirstAncestor_0.Parent;
local l_Status_0 = require(l_script_FirstAncestor_0.Enums).Status;
local v3 = require(l_Parent_0.t);
local v4 = {};
v4.new = function(v5)
    assert(v4.isValid(v5));
    v4.__index = v4;
    setmetatable(v5, v4);
    return v5;
end;
v4.mock = function(v6)
    v6 = v6 or {};
    return (v4.new({
        status = v6.status or l_Status_0.Active,
        callerId = v6.callerId or 123,
        calleeId = v6.calleeId or 456,
        placeId = v6.placeId or 789,
        reservedServerAccessCode = v6.reservedServerAccessCode or nil,
        callId = v6.callId or nil,
        callerCombinedName = v6.callerCombinedName or nil,
        calleeCombinedName = v6.calleeCombinedName or nil,
        instanceId = v6.instanceId or nil,
        createdUtc = v6.createdUtc or 0,
        activeUtc = v6.activeUtc or 0
    }));
end;
v4.format = function(v7)
    return (v4.new({
        status = v7.status,
        callerId = v7.callerId,
        calleeId = v7.calleeId,
        placeId = v7.placeId,
        reservedServerAccessCode = v7.reservedServerAccessCode,
        callId = v7.callId,
        callerCombinedName = v7.callerCombinedName,
        calleeCombinedName = v7.calleeCombinedName,
        instanceId = v7.instanceId,
        createdUtc = v7.createdUtc,
        activeUtc = v7.activeUtc
    }));
end;
v4.isValid = v3.strictInterface({
    status = v3.string,
    callerId = v3.optional(v3.number),
    calleeId = v3.optional(v3.number),
    placeId = v3.optional(v3.number),
    reservedServerAccessCode = v3.optional(v3.string),
    callId = v3.optional(v3.string),
    callerCombinedName = v3.optional(v3.string),
    calleeCombinedName = v3.optional(v3.string),
    instanceId = v3.optional(v3.string),
    createdUtc = v3.optional(v3.number),
    activeUtc = v3.optional(v3.number)
});
return v4;


local l_script_FirstAncestor_0 = script:FindFirstAncestor("RoduxCall");
local l_Parent_0 = l_script_FirstAncestor_0.Parent;
local v2 = require(l_Parent_0.t);
local v3 = require(l_Parent_0.Cryo);
local v4 = require(l_script_FirstAncestor_0.Enums);
local v5 = {};
v5.new = function(v6)
    assert(v5.isValid(v6));
    v5.__index = v5;
    setmetatable(v6, v5);
    return v6;
end;
v5.mock = function(v7)
    v7 = v7 or {};
    return (v5.new({
        userId = v7.userId or 12345,
        userPresenceType = v7.userPresenceType or "Offline",
        lastLocation = ""
    }));
end;
v5.format = function(v8)
    return v3.Dictionary.join(v8, {
        userPresenceType = v4.PresenceType[v8.userPresenceType]
    });
end;
v5.isValid = v2.strictInterface({
    userId = v2.number,
    userPresenceType = function(v9)
        return v4.PresenceType[v9] ~= nil;
    end,
    lastLocation = v2.string
});
return v5;


return {
    CallStateModel = require(script.CallStateModel),
    SuggestedCalleeModel = require(script.SuggestedCalleeModel)
};


local l_script_FirstAncestor_0 = script:FindFirstAncestor("RoduxCall");
local v1 = require(l_script_FirstAncestor_0.Parent.Rodux);
local l_CallStateModel_0 = require(l_script_FirstAncestor_0.Models).CallStateModel;
local l_UpdateCall_0 = require(l_script_FirstAncestor_0.Actions).UpdateCall;
local _ = require(script.Parent.Parent.roduxCallTypes);
return function()
    return v1.createReducer(nil, {
        [l_UpdateCall_0.name] = function(_, v6)
            return l_CallStateModel_0.format(v6.payload.call);
        end
    });
end;


local v0 = require(script:FindFirstAncestor("RoduxCall").Parent.Rodux);
local v1 = require(script.currentCall);
local v2 = require(script.suggestedCallees);
return function(v3)
    return v0.combineReducers({
        currentCall = v1(),
        suggestedCallees = v2(v3)
    });
end;


local v0 = require(script.Actions);
local v1 = require(script.Enums);
local v2 = require(script.Reducers);
local v3 = require(script.Models);
local l_Parent_0 = script.Parent;
local v5 = require(l_Parent_0.Cryo);
local v6 = require(l_Parent_0.RoduxNetworking);
local v7 = require(l_Parent_0.NetworkingCall);
return {
    config = function(v8)
        v8 = v5.Dictionary.join(v8, {
            NetworkingCall = v7.config({
                roduxNetworking = v6.mock()
            })
        });
        return {
            installReducer = function()
                return v2(v8);
            end,
            Actions = v0,
            Enums = v1,
            Models = v3
        };
    end
};


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Parent.Rodux);
local _ = require(l_Parent_0.Types.ContactTypes);
return v1.makeActionCreator(require(script.Parent.ActionDomain) .. script.Name, function(v3)
    return {
        payload = v3
    };
end);


return require(script.Parent.Parent.Parent.Rodux).makeActionCreator(require(script.Parent.ActionDomain) .. script.Name, function(v0)
    return {
        payload = v0
    };
end);


return {
    DeviceContactsReceived = require(script.DeviceContactsReceived),
    RequestSent = require(script.RequestSent)
};


local l_Parent_0 = script.Parent.Parent.Parent;
local v1 = require(script.Parent.getMockName);
local _ = require(script.Parent.Parent.Types.ContactTypes);
local v3 = require(l_Parent_0.Dash);
local v4 = {};
v4.new = function(v5)
    v4.__index = v4;
    local v6 = {
        id = v5.id,
        phoneNumbers = v5.phoneNumbers,
        contactName = v5.contactName
    };
    setmetatable(v6, v4);
    return v6;
end;
v4.mock = function(v7)
    local v8 = v1();
    return v4.new((v3.join({
        id = v8,
        contactName = v8,
        phoneNumbers = {
            123456
        }
    }, v7)));
end;
v4.formatFromDevice = function(v9)
    return v4.new({
        id = v4.generateId(v9),
        contactName = (v9.firstname or "") .. " " .. (v9.lastname or ""),
        phoneNumbers = v9.phonenumber
    });
end;
v4.generateId = function(v10)
    return (v10.firstname or "") .. (v10.lastname or "") .. tostring(v10.phonenumber[1]);
end;
return v4;


local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_Types_0 = l_Parent_0.Types;
local v3 = require(l_Parent_1.Rodux);
local v4 = require(script.Parent.utils.setContactsInStore);
local v5 = require(script.Parent.utils.updateContactsInStore);
local _ = require(l_Types_0.ActionTypes);
local _ = require(l_Types_0.ReducerTypes);
local v8 = {};
return function(v9)
    local l_networkingContacts_0 = v9.networkingContacts;
    return v3.createReducer(v8, {
        [l_networkingContacts_0.FindContactFriends.Succeeded.name] = function(_, v12)
            return v4(v12);
        end,
        [l_networkingContacts_0.GetContactEntitiesByContactId.Succeeded.name] = function(v13, v14)
            return v5(v13, v14);
        end
    });
end;


local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_Types_0 = l_Parent_0.Types;
local v3 = require(l_Parent_1.Rodux);
local _ = require(l_Types_0.ReducerTypes);
local _ = require(l_Types_0.ActionTypes);
local l_DeviceContactsReceived_0 = require(l_Parent_0.Actions).DeviceContactsReceived;
local v7 = require(l_Parent_1.Dash);
local v8 = require(l_Parent_0.Models.DeviceContact);
local v9 = {};
return function(_)
    return v3.createReducer(v9, {
        [l_DeviceContactsReceived_0.name] = function(_, v12)
            local l_payload_0 = v12.payload;
            local v14 = {};
            v7.forEach(l_payload_0, function(v15)
                local v16 = v8.formatFromDevice(v15);
                v14[v16.id] = v16;
            end);
            return v14;
        end
    });
end;


local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_Types_0 = l_Parent_0.Types;
local v3 = require(l_Parent_1.Rodux);
local _ = require(l_Types_0.ReducerTypes);
local _ = require(l_Types_0.ActionTypes);
local l_RequestSent_0 = require(l_Parent_0.Actions).RequestSent;
local v7 = require(l_Parent_1.Dash);
local v8 = {};
return function(_)
    return v3.createReducer(v8, {
        [l_RequestSent_0.name] = function(v10, v11)
            return v7.join(v10, {
                [v11.payload.id] = true
            });
        end
    });
end;


local l_Parent_0 = script.Parent.Parent;
local l_Types_0 = l_Parent_0.Types;
local v2 = require(l_Parent_0.Reducers.Contacts.byContactId);
local v3 = require(l_Parent_0.Reducers.Contacts.byDeviceContactId);
local v4 = require(l_Parent_0.Reducers.Contacts.hasSentRequest);
local _ = require(l_Types_0.ReducerTypes);
local v6 = require(l_Parent_0.Reducers.Contacts.deviceContactToRobloxContact);
local v7 = {
    byContactId = {},
    byDeviceContactId = {},
    hasSentRequest = {},
    deviceContactToRobloxContact = {}
};
return function(v8)
    return function(v9, v10)
        local v11 = v9 or v7;
        return {
            byContactId = v2(v8)(v11.byContactId, v10),
            byDeviceContactId = v3(v8)(v11.byDeviceContactId, v10),
            hasSentRequest = v4(v8)(v11.hasSentRequest, v10),
            deviceContactToRobloxContact = v6(v8)(v11.deviceContactToRobloxContact, v10)
        };
    end;
end;


local _ = require(script.Parent.Parent.Types.ContactTypes);
return function(v1)
    return v1.phoneNumbers[1];
end;


return function(v0)
    return {
        sortContacts = require(script.sortContacts)(v0),
        getPhoneNumber = require(script.getPhoneNumber)
    };
end;


local v0 = require(script.Parent.Parent.getDeepValue);
return function(v1)
    local l_keyPath_0 = v1.keyPath;
    return function(v3)
        local v4 = v0(v3, l_keyPath_0 .. ".byContactId") or {};
        local v5 = {};
        for v6, v7 in pairs(v4) do
            table.insert(v5, {
                contactId = v6,
                contactName = v7.contactName
            });
        end;
        table.sort(v5, function(v8, v9)
            if not (not v8.contactName or not v9.contactName) and v8.contactName ~= v9.contactName then
                return v8.contactName < v9.contactName;
            else
                return v8.contactId < v9.contactId;
            end;
        end);
        return v5;
    end;
end;


local l_Parent_0 = script.Parent;
local v1 = require(l_Parent_0.Dash);
local v2 = require(l_Parent_0.RoduxNetworking);
local v3 = require(l_Parent_0.NetworkingContacts);
local v4 = require(script.Reducers.ContactsReducer);
local v5 = require(script.Selectors);
return {
    config = function(v6)
        v6 = v1.join(v6, {
            networkingContacts = v3.config({
                roduxNetworking = v2.mock()
            })
        });
        return {
            installReducer = function()
                return v4(v6);
            end,
            Selectors = v5(v6),
            Models = require(script.Models),
            Actions = require(script.Actions)
        };
    end
};


local v0 = require(script.Parent.Parent.getDeepValue);
return function(v1)
    local l_keyPath_0 = v1.keyPath;
    return function(v3)
        local v4 = v0(v3, l_keyPath_0 .. ".byContactId") or {};
        local v5 = {};
        for v6, v7 in pairs(v4) do
            table.insert(v5, {
                contactId = v6,
                contactName = v7.contactName,
                headshotThumbnailUrl = v7.headshotThumbnailUrl,
                avatarThumbnailUrl = v7.avatarThumbnailUrl
            });
        end;
        table.sort(v5, function(v8, v9)
            if not (not v8.contactName or not v9.contactName) and v8.contactName ~= v9.contactName then
                return v8.contactName < v9.contactName;
            else
                return v8.contactId < v9.contactId;
            end;
        end);
        return v5;
    end;
end;


local v0 = {
    __className = "Devtools"
};
v0.__index = v0;
v0.new = function()
    local v1 = setmetatable({
        _events = table.create(100),
        _eventsIndex = 0,
        _pluginBridge = nil,
        _pluginBridgeListener = nil,
        _pluginBridgeBatchPackets = {},
        _pluginBridgeBatchProcess = nil,
        _source = debug.traceback()
    }, v0);
    v1:_findPluginBridge(function(v2)
        v1:_connectPluginBridge(v2);
    end);
    return v1;
end;
v0._findPluginBridge = function(v3, v4)
    if not v3._pluginBridge then
        local v5 = workspace.CurrentCamera or workspace;
        local l___RoduxDevtoolsPluginBridge_0 = v5:FindFirstChild("__RoduxDevtoolsPluginBridge");
        if not l___RoduxDevtoolsPluginBridge_0 or not l___RoduxDevtoolsPluginBridge_0:IsA("BindableEvent") then
            task.defer(function()
                local v7 = v5:WaitForChild("__RoduxDevtoolsPluginBridge", 10);
                if v3._events == nil then
                    return ;
                elseif not v7 or not v7:IsA("BindableEvent") then
                    return ;
                else
                    v3._pluginBridge = v7;
                    v4(v7);
                    return ;
                end;
            end);
            return ;
        else
            v3._pluginBridge = l___RoduxDevtoolsPluginBridge_0;
            v4(l___RoduxDevtoolsPluginBridge_0);
            return ;
        end;
    else
        v4(v3._pluginBridge);
        return ;
    end;
end;
v0._connectPluginBridge = function(v8, v9)
    if v9 then
        if v8._pluginBridgeListener then
            v8._pluginBridgeListener:Disconnect();
            v8._pluginBridgeListener = nil;
        end;
        if v8._pluginBridgeBatchProcess then
            v8._pluginBridgeBatchProcess:Disconnect();
            v8._pluginBridgeBatchProcess = nil;
        end;
        v8._pluginBridgeListener = v9.Event:Connect(function(v10, ...)
            if v10 == "DevtoolsCall" then
                local v11 = {
                    ...
                };
                local v12 = v8[v11[1]];
                if v12 then
                    table.remove(v11, 1);
                    pcall(v12, v8, table.unpack(v11));
                else
                    return ;
                end;
            end;
        end);
        v8._pluginBridgeBatchProcess = game:GetService("RunService").Heartbeat:Connect(function()
            if next(v8._pluginBridgeBatchPackets) == nil then
                return ;
            else
                v9:Fire("PluginBatchPackets", v8._pluginBridgeBatchPackets);
                table.clear(v8._pluginBridgeBatchPackets);
                return ;
            end;
        end);
        if #v8._events > 0 then
            local v13 = {};
            for v14, v15 in v8._events, nil, nil do
                v13[v14] = {
                    isStub = true,
                    eventType = v15.eventType,
                    props = {
                        elapsedMs = v15.props.elapsedMs,
                        name = v15.props.name
                    }
                };
            end;
            v8:_firePluginBridge("updateEvents", v13);
        end;
        return ;
    else
        return ;
    end;
end;
v0._firePluginBridge = function(v16, v17, v18)
    if v16._pluginBridge then
        table.insert(v16._pluginBridgeBatchPackets, {
            type = v17,
            props = v18
        });
        return ;
    else
        return ;
    end;
end;
v0._hookIntoStore = function(v19, v20)
    v19._store = v20;
    local v21 = string.split(debug.traceback(), "\n");
    v19._source = v21[1];
    for _, v23 in v21, nil, nil do
        if not (string.find(v23, "RoduxDevtools.-hookIntoStore") or string.find(v23, "Store.-new")) then
            v19._source = v23;
            break;
        end;
    end;
    v19._originalReducer = v20._reducer;
    v20._reducer = function(v24, v25)
        local v26 = os.clock();
        local v27 = v19._originalReducer(v24, v25);
        v19:_addEvent("Reduce", {
            name = v25.type or tostring(v25),
            elapsedMs = (os.clock() - v26) * 1000,
            action = v25,
            state = v27
        });
        return v27;
    end;
    v19._originalFlushHandler = v20._flushHandler;
    v20._flushHandler = function(...)
        local v28 = os.clock();
        v19._originalFlushHandler(...);
        v19:_addEvent("Flush", {
            name = "@@FLUSH",
            elapsedMs = (os.clock() - v28) * 1000,
            listenerCount = #v20.changed._listeners,
            listeners = table.clone(v20.changed._listeners)
        });
    end;
end;
v0._addEvent = function(v29, v30, v31)
    local v32 = {
        eventType = v30,
        source = v29._source,
        timestamp = DateTime.now().UnixTimestampMillis,
        props = v31
    };
    local v33 = nil;
    for v34 = v29._eventsIndex or 0, 1, -1 do
        local v35 = v29._events[v34];
        if v35.props.state then
            v33 = v35.props.state;
            break;
        end;
    end;
    v32.props.lastState = v33;
    v29._eventsIndex = (v29._eventsIndex or 0) + 1;
    v29._events[v29._eventsIndex] = v32;
    v29:_firePluginBridge("updateEvent", {
        index = v29._eventsIndex,
        event = {
            isStub = true,
            eventType = v30,
            props = {
                elapsedMs = v32.props.elapsedMs,
                name = v32.props.name
            }
        }
    });
end;
v0._fillPluginStubAtIndex = function(v36, v37)
    local v38 = v36._events[v37];
    if v38 then
        v36:_firePluginBridge("updateEvent", {
            index = v37,
            event = v38
        });
        return ;
    else
        return ;
    end;
end;
v0._setState = function(v39, v40, v41)
    if not v41 then
        v41 = v39._store._state;
    end;
    v39._store._state = v40;
    v39._store._lastState = v41;
    v39._store._mutatedSinceFlush = true;
end;
v0.Clear = function(v42)
    v42._eventsIndex = 0;
    v42._events = table.create(100);
end;
v0.Destroy = function(v43)
    if v43._pluginBridgeListener then
        v43._pluginBridgeListener:Disconnect();
    end;
    if v43._pluginBridgeBatchProcess then
        v43._pluginBridgeBatchProcess:Disconnect();
    end;
    v43:Clear();
    table.clear(v43);
    setmetatable(v43, nil);
end;
v0.GetLoggedEvents = function(v44)
    return table.clone(v44._events);
end;
v0.GetLoggedEventsOfType = function(v45, v46)
    local v47 = {};
    local v48 = 0;
    for _, v50 in v45._events, nil, nil do
        if v50.eventType == v46 then
            v48 = v48 + 1;
            v47[v48] = v50;
        end;
    end;
    return v47;
end;
v0.GetReducedActionsOfType = function(v51, v52)
    local v53 = {};
    local v54 = 0;
    for _, v56 in v51._events, nil, nil do
        if type(v56.props.action) == "table" and v56.props.action.type == v52 then
            v54 = v54 + 1;
            v53[v54] = v56;
        end;
    end;
    return v53;
end;
v0.RevertToStateAtIndex = function(v57, v58)
    if type(v58) ~= "number" then
        return ;
    else
        local v59 = os.clock();
        local v60 = nil;
        local v61 = nil;
        local v62 = nil;
        for v63 = v58, 1, -1 do
            v60 = v57._events[v63];
            if v60.props.state then
                v61 = v60.props.state;
                v62 = v63;
                break;
            end;
        end;
        if v61 then
            local v64 = nil;
            for v65 = v62 - 1, 1, -1 do
                local v66 = v57._events[v65];
                if v66.props.state then
                    v64 = v66.props.state;
                    break;
                end;
            end;
            v57:_setState(v61, v64);
            v57:_addEvent("Reduce", {
                isDevtools = true,
                name = "@@REVERT_TO_STATE",
                elapsedMs = (os.clock() - v59) * 1000,
                action = {
                    type = "@@REVERT_TO_STATE",
                    revertTarget = {
                        name = v60.props.name,
                        action = v60.props.action,
                        eventIndex = v62
                    }
                },
                state = v61
            });
            return ;
        else
            return ;
        end;
    end;
end;
v0.ReplaceActionAtIndex = function(v67, v68, v69)
    if type(v68) ~= "number" then
        return ;
    elseif v69 ~= nil and type(v69) ~= "table" then
        return ;
    else
        local v70 = v67._events[v68];
        if not (v70 ~= nil) or v70.props.action == nil then
            return ;
        else
            v70.altered = v70.altered or {};
            v70.altered.replaceAction = v69;
            v67:_firePluginBridge("updateEvent", {
                index = v68,
                event = v70
            });
            v67:_recomputeStateWithAlterations();
            return ;
        end;
    end;
end;
v0.UndoActionAtIndex = function(v71, v72)
    if type(v72) ~= "number" then
        return ;
    else
        local v73 = v71._events[v72];
        if not (v73 ~= nil) or v73.props.action == nil then
            return ;
        else
            v73.altered = v73.altered or {};
            if not v73.altered.skipped then
                v73.altered.skipped = true;
                v71:_firePluginBridge("updateEvent", {
                    index = v72,
                    event = v73
                });
                v71:_recomputeStateWithAlterations();
                return ;
            else
                return ;
            end;
        end;
    end;
end;
v0.RedoActionAtIndex = function(v74, v75)
    if type(v75) ~= "number" then
        return ;
    else
        local v76 = v74._events[v75];
        if not (v76 ~= nil) or v76.props.action == nil then
            return ;
        else
            v76.altered = v76.altered or {};
            if v76.altered.skipped == false then
                return ;
            else
                v76.altered.skipped = false;
                v74:_firePluginBridge("updateEvent", {
                    index = v75,
                    event = v76
                });
                v74:_recomputeStateWithAlterations();
                return ;
            end;
        end;
    end;
end;
v0._recomputeStateWithAlterations = function(v77)
    if #v77._events == 0 then
        return ;
    else
        local v78 = os.clock();
        local v79 = nil;
        local v80 = nil;
        for v81, v82 in v77._events, nil, nil do
            if not v82.altered or not next(v82.altered) then
                if v82.props.state then
                    v80 = v82.props.state;
                end;
            else
                v79 = v81;
                break;
            end;
        end;
        if v79 and v80 then
            local l_v79_0 = v79;
            local v84 = #v77._events;
            local v85 = nil;
            local v86 = {};
            local v87 = {};
            for v88 = l_v79_0, v84 do
                local v89 = v77._events[v88];
                if v89 then
                    local l_action_0 = v89.props.action;
                    if not (not (l_action_0 ~= nil) or v89.props.isDevtools) then
                        if not v89.altered or not v89.altered.skipped then
                            if not (not v89.altered or not v89.altered.replaceAction) then
                                table.insert(v87, {
                                    name = v89.props.name,
                                    originalAction = v89.props.action,
                                    replacedAction = v89.altered.replaceAction,
                                    eventIndex = v88
                                });
                                l_action_0 = v89.altered.replaceAction;
                            end;
                            v85 = table.clone(v80);
                            v80 = v77._originalReducer(v80, l_action_0);
                        else
                            table.insert(v86, {
                                name = v89.props.name,
                                action = v89.props.action,
                                eventIndex = v88
                            });
                        end;
                    end;
                end;
            end;
            v77:_setState(v80, v85);
            v77:_addEvent("Reduce", {
                isDevtools = true,
                name = "@@RECOMPUTE_STATE_WITH_ALTERATIONS",
                elapsedMs = (os.clock() - v78) * 1000,
                action = {
                    type = "@@RECOMPUTE_STATE_WITH_ALTERATIONS",
                    skippedActions = v86,
                    replacedActions = v87
                },
                state = v80
            });
            return ;
        else
            return ;
        end;
    end;
end;
return v0;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Parent.Rodux);
local _ = require(l_Parent_0.roduxFriendsTypes);
return v1.makeActionCreator(script.Name, function(v3)
    return v3;
end);


return require(script:FindFirstAncestor("RoduxFriends").Parent.Rodux).makeActionCreator(script.Name, function(v0)
    return {
        ids = v0
    };
end);


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Parent.Rodux);
local _ = require(l_Parent_0.roduxFriendsTypes);
return v1.makeActionCreator(script.Name, function(v3, v4)
    return {
        payload = {
            userId1 = v3,
            userId2 = v4
        }
    };
end);


return require(script:FindFirstAncestor("RoduxFriends").Parent.Rodux).makeActionCreator(script.Name, function(v0, v1)
    return {
        payload = {
            userId1 = v0,
            userId2 = v1
        }
    };
end);


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Parent.Rodux);
local _ = require(l_Parent_0.roduxFriendsTypes);
return v1.makeActionCreator(script.Name, function(v3)
    return {
        payload = v3
    };
end);


return require(script:FindFirstAncestor("RoduxFriends").Parent.Rodux).makeActionCreator(script.Name, function(v0)
    assert(type(v0) == "number", "Request count must be a number");
    return {
        payload = {
            count = v0
        }
    };
end);


return function(_)
    return {
        FriendshipCreated = require(script.FriendshipCreated),
        FriendshipDestroyed = require(script.FriendshipDestroyed),
        RequestReceivedCountUpdated = require(script.RequestReceivedCountUpdated),
        FriendRequestCreated = require(script.FriendRequestCreated),
        FriendRequestDeclined = require(script.FriendRequestDeclined),
        RecommendationCreated = require(script.RecommendationCreated),
        RecommendationDestroyed = require(script.RecommendationDestroyed),
        RecommendationSourceCreated = require(script.RecommendationSourceCreated)
    };
end;


return require(script.Parent.Parent.Parent.enumerate)(script.Name, {
    None = "None",
    MutualFriends = "MutualFriends",
    Frequents = "Frequents",
    Contacts = "Contacts"
});


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


local l_script_FirstAncestor_0 = script:FindFirstAncestor("RoduxFriends");
local l_Parent_0 = l_script_FirstAncestor_0.Parent;
local v2 = require(script.Parent.mockId);
local _ = require(script.Parent.Parent.roduxFriendsTypes);
local v4 = require(l_Parent_0.llama);
local v5 = require(l_script_FirstAncestor_0.Enums.RecommendationContextType);
local v6 = {};
v6.new = function(v7)
    assert(v6.isValid(v7));
    v6.__index = v6;
    local v8 = {
        id = v7.id,
        entityId = v7.entityId,
        rank = v7.rank,
        contextType = v7.contextType,
        mutualFriendsList = v7.mutualFriendsList,
        mutualFriendsCount = v7.mutualFriendsCount,
        thumbnailEntities = v7.thumbnailEntities,
        entityDisplayName = v7.entityDisplayName
    };
    setmetatable(v8, v6);
    return v8;
end;
v6.mock = function(v9)
    local v10 = v4.Dictionary.join({
        id = v2(),
        contextType = v5.MutualFriends
    }, v9);
    return (v6.new({
        id = v10.id,
        mutualFriendsList = v10.mutualFriendsList,
        rank = v10.rank or tonumber(v10.id),
        contextType = v10.contextType,
        mutualFriendsCount = if not v10.mutualFriendsCount then v10.mutualFriendsList and #v10.mutualFriendsList or 0 else v10.mutualFriendsCount
    }));
end;
v6.isValid = function(v11)
    if v11 then
        if v11.id then
            if v11.rank then
                if v11.contextType and v5.isEnumValue(v11.contextType) then
                    if v11.mutualFriendsList and type(v11.mutualFriendsList) ~= "table" then
                        return false, "mutualFriendList must be a table of strings";
                    elseif v11.mutualFriendsCount and type(v11.mutualFriendsCount) ~= "number" then
                        return false, "mutualFriendsCount must be a number";
                    elseif not (v11.contextType == v5.Contacts) or v11.entityId then
                        return true, "Valid Recommendation";
                    else
                        return false, "entity Id must be given for Contacts recommendation type";
                    end;
                else
                    return false, "Expected contextType to be given";
                end;
            else
                return false, "Expected user's rank to be given";
            end;
        else
            return false, "Expected user's id to be given";
        end;
    else
        return false, "Expected recommendation information to be given";
    end;
end;
v6.isEqual = function(v12, v13)
    local v14 = false;
    if v12.id == v13.id then
        v14 = v4.List.equals(v12.mutualFriendsList, v13.mutualFriendsList);
        if v14 then
            v14 = false;
            if v12.rank == v13.rank then
                v14 = false;
                if v12.contextType == v13.contextType then
                    v14 = v12.mutualFriendsCount == v13.mutualFriendsCount;
                end;
            end;
        end;
    end;
    return v14;
end;
v6.format = function(v15)
    local v16 = if not v15.contextType then v5.None else v5.fromRawValue(v15.contextType) or v5.None;
    return v6.new(v4.Dictionary.join(v15, {
        id = v15.id,
        entityId = if v15.contactId ~= "" then v15.contactId else nil,
        contextType = v16,
        mutualFriendsCount = if not v15.mutualFriendsCount then if v15.mutualFriendsList then #v15.mutualFriendsList else 0 else v15.mutualFriendsCount,
        contactId = contactId,
        thumbnailEntities = v15.thumbnailEntities,
        entityDisplayName = if v16 == v5.Contacts then v15.displayName else nil
    }));
end;
return v6;