local v0 = require(script.Parent.Parent.Object.None);
local function v3(v1, v2)
    return type(v1) .. tostring(v1) < type(v2) .. tostring(v2);
end;
return function(v4, v5)
    local l_v3_0 = v3;
    if v5 ~= nil and v5 ~= v0 then
        if typeof(v5) ~= "function" then
            error("invalid argument to Array.sort: compareFunction must be a function");
        end;
        l_v3_0 = function(v7, v8)
            local v9 = v5(v7, v8);
            if typeof(v9) ~= "number" then
                error(("invalid result from compare function, expected number but got %s"):format((typeof(v9))));
            end;
            return v9 < 0;
        end;
    end;
    table.sort(v4, l_v3_0);
    return v4;
end;


return function(v0, v1, v2, ...)
    if #v0 < v1 then
        for v3 = 1, select("#", ...) do
            table.insert(v0, (select(v3, ...)));
        end;
        return {};
    else
        local v4 = #v0;
        if v1 < 1 then
            v1 = math.max(v4 - math.abs(v1), 1);
        end;
        local v5 = {};
        local v6 = v2 or v4;
        if v6 > 0 then
            for _ = v1, math.min(v4, v1 + math.max(0, v6 - 1)) do
                table.insert(v5, (table.remove(v0, v1)));
            end;
        end;
        for v8 = select("#", ...), 1, -1 do
            table.insert(v0, v1, (select(v8, ...)));
        end;
        return v5;
    end;
end;


local v0 = require(script.Parent.isArray);
return function(v1, ...)
    if not (not _G.__DEV__ or v0(v1)) then
        error(string.format("Array.unshift called on non-array %s", (typeof(v1))));
    end;
    local v2 = select("#", ...);
    if v2 > 0 then
        for v3 = v2, 1, -1 do
            table.insert(v1, 1, (select(v3, ...)));
        end;
    end;
    return #v1;
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Array);
local v2 = require(l_Parent_0.Boolean);
local v3 = require(l_Parent_0.Object);
local v4 = require(l_Parent_0.String);
local v5 = require(l_Parent_0.Error);
local v6 = require(l_Parent_0.instanceof);
local v7 = require(l_Parent_0.util.inspect);
local v8 = {
    stderr = {
        isTTY = false,
        columns = 0,
        hasColors = function(...)
            return true;
        end
    }
};
ErrorCaptureStackTrace = function(...)
end;
local function _(v9)
    return v9;
end;
local v11 = "";
local v12 = "";
local v13 = "";
local v14 = "";
local v15 = {
    deepStrictEqual = "Expected values to be strictly deep-equal:",
    strictEqual = "Expected values to be strictly equal:",
    strictEqualObject = "Expected \"actual\" to be reference-equal to \"expected\":",
    deepEqual = "Expected values to be loosely deep-equal:",
    notDeepStrictEqual = "Expected \"actual\" not to be strictly deep-equal to:",
    notStrictEqual = "Expected \"actual\" to be strictly unequal to:",
    notStrictEqualObject = "Expected \"actual\" not to be reference-equal to \"expected\":",
    notDeepEqual = "Expected \"actual\" not to be loosely deep-equal to:",
    notIdentical = "Values have same structure but are not reference-equal:",
    notDeepEqualUnequal = "Expected values not to be loosely deep-equal:"
};
local function v21(v16)
    local v17 = v3.keys(v16);
    local v18 = {};
    for _, v20 in ipairs(v17) do
        v18[v20] = v16[v20];
    end;
    v18.message = v16.message;
    return v18;
end;
local function _(v22)
    return v7(v22, {
        compact = false,
        customInspect = false,
        depth = 1000,
        maxArrayLength = math.huge,
        showHidden = false,
        showProxy = false,
        sorted = true,
        getters = true
    });
end;
local function v55(v24, v25, v26)
    local v27 = "";
    local v28 = "";
    local v29 = "";
    local v30 = false;
    local v31 = v7(v24, {
        compact = false,
        customInspect = false,
        depth = 1000,
        maxArrayLength = math.huge,
        showHidden = false,
        showProxy = false,
        sorted = true,
        getters = true
    });
    local v32 = v4.split(v31, "\n");
    local v33 = v4.split(v7(v25, {
        compact = false,
        customInspect = false,
        depth = 1000,
        maxArrayLength = math.huge,
        showHidden = false,
        showProxy = false,
        sorted = true,
        getters = true
    }), "\n");
    local v34 = 0;
    local v35 = "";
    if v26 == "strictEqual" and (not (not ((typeof(v24) == "table" and v24 ~= nil) and typeof(v25) == "table") or v25 == nil) or typeof(v24) == "function" and typeof(v25) == "function") then
        v26 = "strictEqualObject";
    end;
    if (#v32 == 1 and #v33 == 1) and v32[1] ~= v33[1] then
        local v36 = v32[1];
        local v37 = if not v2.toJSBoolean(false) then v33[1] else v33[1];
        local v38 = string.len(v36) + string.len(v37);
        if v38 <= 12 then
            if ((not (typeof(v24) == "table") or v24 == nil) and (not (typeof(v25) == "table") or v25 == nil)) and (not (v24 == 0) or v25 ~= 0) then
                return ("%s\n\n"):format(v15[v26]) .. ("%s format(v32[1], v33[1]);
            end;
        elseif v26 ~= "strictEqualObject" and v38 < (not v8.stderr.isTTY and 80 or v8.stderr.columns) then
            while string.sub(v36, v34 + 1, v34 + 1) == string.sub(v37, v34 + 1, v34 + 1) do
                v34 = v34 + 1;
            end;
            if v34 > 2 then
                v35 = ("\n  %s^"):format(string.rep(" ", v34));
                v34 = 0;
            end;
        end;
    end;
    local v39 = v32[#v32];
    local v40 = v33[#v33];
    while v39 == v40 do
        local l_v34_0 = v34;
        v34 = v34 + 1;
        if l_v34_0 < 3 then
            v29 = ("\n  %s%s"):format(v39, v29);
        else
            v27 = v39;
        end;
        table.remove(v32);
        table.remove(v33);
        if #v32 ~= 0 and #v33 ~= 0 then
            v39 = v32[#v32];
            v40 = v33[#v33];
        else
            break;
        end;
    end;
    local v42 = math.max(#v32, #v33);
    if v42 == 0 then
        local v43 = v4.split(v31, "\n");
        if #v43 > 50 then
            v43[47] = ("%s...%s"):format(v11, v14);
            while #v43 > 47 do
                table.remove(v43);
            end;
        end;
        return ("%s\n\n"):format(v15.notIdentical) .. ("%s\n"):format(v1.join(v43, "\n"));
    else
        if v34 >= 5 then
            v29 = ("\n%s...%s%s"):format(v11, v14, v29);
            v30 = true;
        end;
        if v27 ~= "" then
            v29 = ("\n  %s%s"):format(v27, v29);
            v27 = "";
        end;
        local v44 = 0;
        local v45 = 0;
        local v46 = v15[v26] .. ("\n%s+ actual%s %s- expected%s"):format(v12, v14, v13, v14);
        local v47 = (" %s...%s Lines skipped"):format(v11, v14);
        local l_v32_0 = v32;
        local v49 = ("%s+%s"):format(v12, v14);
        local v50 = #v33;
        if #v32 < v42 then
            l_v32_0 = v33;
            v49 = ("%s-%s"):format(v13, v14);
            v50 = #v32;
        end;
        for v51 = 1, v42 do
            v34 = v51;
            if v50 < v51 then
                if v45 > 2 then
                    if v45 > 3 then
                        if v45 > 4 then
                            if v45 == 5 then
                                v28 = v28 .. ("\n  %s"):format(l_v32_0[v51 - 3]);
                                v44 = v44 + 1;
                            else
                                v28 = v28 .. ("\n%s...%s"):format(v11, v14);
                                v30 = true;
                            end;
                        end;
                        v28 = v28 .. ("\n  %s"):format(l_v32_0[v51 - 2]);
                        v44 = v44 + 1;
                    end;
                    v28 = v28 .. ("\n  %s"):format(l_v32_0[v51 - 1]);
                    v44 = v44 + 1;
                end;
                v45 = 0;
                if l_v32_0 == v32 then
                    v28 = v28 .. ("\n%s %s"):format(v49, l_v32_0[v51]);
                else
                    v27 = v27 .. ("\n%s %s"):format(v49, l_v32_0[v51]);
                end;
                v44 = v44 + 1;
            else
                local v52 = v33[v51];
                local v53 = v32[v51];
                local v54 = false;
                if v53 ~= v52 then
                    v54 = not v2.toJSBoolean(v4.endsWith(v53, ",")) or v4.slice(v53, 0, -1) ~= v52;
                end;
                if not (not v54 or not v4.endsWith(v52, ",")) and v4.slice(v52, 0, -1) == v53 then
                    v54 = false;
                    v53 = v53 .. ",";
                end;
                if not v54 then
                    v28 = v28 + v27;
                    v27 = "";
                    v45 = v45 + 1;
                    if v45 <= 2 then
                        v28 = v28 .. ("\n  %s"):format(v53);
                        v44 = v44 + 1;
                    end;
                else
                    if v45 > 2 then
                        if v45 > 3 then
                            if v45 > 4 then
                                if v45 == 5 then
                                    v28 = v28 .. ("\n  %s"):format(v32[v51 - 3]);
                                    v44 = v44 + 1;
                                else
                                    v28 = v28 .. ("\n%s...%s"):format(v11, v14);
                                    v30 = true;
                                end;
                            end;
                            v28 = v28 .. ("\n  %s"):format(v32[v51 - 2]);
                            v44 = v44 + 1;
                        end;
                        v28 = v28 .. ("\n  %s"):format(v32[v51 - 1]);
                        v44 = v44 + 1;
                    end;
                    v45 = 0;
                    v28 = v28 .. ("\n%s+%s %s"):format(v12, v14, v53);
                    v27 = v27 .. ("\n%s-%s %s"):format(v13, v14, v52);
                    v44 = v44 + 2;
                end;
            end;
            if v44 > 50 and v51 < v42 - 2 then
                return ("%s%s\n%s\n%s...%s%s\n"):format(v46, v47, v28, v11, v14, v27) .. ("%s...%s"):format(v11, v14);
            end;
        end;
        return ("%s%s\n%s%s%s%s"):format(v46, not v30 and "" or v47, v28, v27, v29, v35);
    end;
end;
local v56 = setmetatable({}, {
    __index = v5
});
v56.__index = v56;
v56.__tostring = function(v57)
    return v57:toString();
end;
v56.new = function(v58)
    local v59 = nil;
    local l_message_0 = v58.message;
    local l_operator_0 = v58.operator;
    local l_stackStartFn_0 = v58.stackStartFn;
    local l_details_0 = v58.details;
    local l_stackStartFunction_0 = v58.stackStartFunction;
    local l_actual_0 = v58.actual;
    local l_expected_0 = v58.expected;
    if l_message_0 ~= nil then
        v59 = setmetatable(v5.new((tostring(l_message_0))), v56);
    else
        if v8.stderr.isTTY then
            if not v8.stderr:hasColors() then
                v11 = "";
                v12 = "";
                v14 = "";
                v13 = "";
            else
                v11 = "\027[34m";
                v12 = "\027[32m";
                v14 = "\027[39m";
                v13 = "\027[31m";
            end;
        end;
        if not (not (not (not ((((typeof(l_actual_0) == "table" and l_actual_0 ~= nil) and typeof(l_expected_0) == "table") and l_expected_0 ~= nil) and v1.indexOf(v3.keys(l_actual_0), "stack") ~= -1) or not v6(l_actual_0, v5)) and v1.indexOf(v3.keys(l_expected_0), "stack") ~= -1) or not v6(l_expected_0, v5)) then
            l_actual_0 = v21(l_actual_0);
            l_expected_0 = v21(l_expected_0);
        end;
        if not (l_operator_0 ~= "deepStrictEqual") or l_operator_0 == "strictEqual" then
            v59 = setmetatable(v5.new(v55(l_actual_0, l_expected_0, l_operator_0)), v56);
        elseif not (l_operator_0 ~= "notDeepStrictEqual") or l_operator_0 == "notStrictEqual" then
            local v67 = v15[l_operator_0];
            local v68 = v4.split(v7(l_actual_0, {
                compact = false,
                customInspect = false,
                depth = 1000,
                maxArrayLength = math.huge,
                showHidden = false,
                showProxy = false,
                sorted = true,
                getters = true
            }), "\n");
            if l_operator_0 == "notStrictEqual" and (not (not (typeof(l_actual_0) == "table") or l_actual_0 == nil) or typeof(l_actual_0) == "function") then
                v67 = v15.notStrictEqualObject;
            end;
            if #v68 > 50 then
                v68[47] = ("%s...%s"):format(v11, v14);
                while #v68 > 47 do
                    table.remove(v68);
                end;
            end;
            v59 = if #v68 == 1 then setmetatable(v5.new(("%s%s%s"):format(v67, string.len(v68[1]) > 5 and "\n\n" or " ", v68[1])), v56) else setmetatable(v5.new(("%s\n\n%s\n"):format(v67, v1.join(v68, "\n"))), v56);
        else
            local v69 = v7(l_actual_0, {
                compact = false,
                customInspect = false,
                depth = 1000,
                maxArrayLength = math.huge,
                showHidden = false,
                showProxy = false,
                sorted = true,
                getters = true
            });
            local v70 = v7(l_expected_0, {
                compact = false,
                customInspect = false,
                depth = 1000,
                maxArrayLength = math.huge,
                showHidden = false,
                showProxy = false,
                sorted = true,
                getters = true
            });
            local v71 = v15[tostring(l_operator_0)];
            if l_operator_0 == "notDeepEqual" and v69 == v70 then
                v69 = ("%s\n\n%s"):format(v71, v69);
                if string.len(v69) > 1024 then
                    v69 = ("%s..."):format(v4.slice(v69, 0, 1021));
                end;
                v59 = setmetatable(v5.new(v69), v56);
            else
                if string.len(v69) > 512 then
                    v69 = ("%s..."):format(v4.slice(v69, 0, 509));
                end;
                if string.len(v70) > 512 then
                    v70 = ("%s..."):format(v4.slice(v70, 0, 509));
                end;
                if l_operator_0 == "deepEqual" then
                    v69 = ("%s\n\n%s\n\nshould loosely deep-equal\n\n"):format(v71, v69);
                else
                    local v72 = v15[("%sUnequal"):format(l_operator_0)];
                    if not v2.toJSBoolean(v72) then
                        v70 = (" %s %s"):format(l_operator_0, v70);
                    else
                        v69 = ("%s\n\n%s\n\nshould not loosely deep-equal\n\n"):format(v72, v69);
                    end;
                end;
                v59 = setmetatable(v5.new(("%s%s"):format(v69, v70)), v56);
            end;
        end;
    end;
    v59.generatedMessage = not v2.toJSBoolean(l_message_0);
    v59.name = "AssertionError [ERR_ASSERTION]";
    v59.code = "ERR_ASSERTION";
    if l_details_0 ~= nil then
        v59.actual = nil;
        v59.expected = nil;
        v59.operator = nil;
        for v73 = 1, #l_details_0 do
            v59["message " .. tostring(v73)] = l_details_0[v73].message;
            v59["actual " .. tostring(v73)] = l_details_0[v73].actual;
            v59["expected " .. tostring(v73)] = l_details_0[v73].expected;
            v59["operator " .. tostring(v73)] = l_details_0[v73].operator;
            v59["stack trace " .. tostring(v73)] = l_details_0[v73].stack;
        end;
    else
        v59.actual = l_actual_0;
        v59.expected = l_expected_0;
        v59.operator = l_operator_0;
    end;
    ErrorCaptureStackTrace(v59, l_stackStartFn_0 or l_stackStartFunction_0);
    v59.name = "AssertionError";
    return v59;
end;
v56.toString = function(v74)
    return ("%s [%s]: %s"):format(v74.name, v74.code, v74.message);
end;
v56.name = "AssertionError";
return {
    AssertionError = v56
};


local v0 = {};
v0.__index = v0;
v0.__tostring = function(v1)
    return getmetatable(v0).__tostring(v1);
end;
v0.new = function(v2)
    return (setmetatable({
        name = "Error",
        message = v2 or "",
        stack = debug.traceback(nil, 2)
    }, v0));
end;
return (setmetatable(v0, {
    __call = function(_, ...)
        local v4 = v0.new(...);
        v4.stack = debug.traceback(nil, 2);
        return v4;
    end,
    __tostring = function(v5)
        if v5.name ~= nil then
            if v5.message and v5.message ~= "" then
                return string.format("%s: %s", tostring(v5.name), (tostring(v5.message)));
            else
                return (tostring(v5.name));
            end;
        else
            return (tostring("Error"));
        end;
    end
}));


local l_Parent_0 = script.Parent;
local v1 = require(l_Parent_0.Array);
local v2 = require(l_Parent_0.Object);
local v3 = require(l_Parent_0.instanceof);
local v4 = {};
v4.new = function(v5)
    local v6 = {};
    local v7 = {};
    if v5 ~= nil then
        local v8 = nil;
        local v9 = typeof(v5);
        if v9 == "table" then
            if #v5 > 0 and typeof(v5[1]) ~= "table" then
                error("cannot create Map from {K, V} form, it must be { {K, V}... }");
            end;
            v8 = v1.from(v5);
        else
            error(("cannot create array from value of type `%s`"):format(v9));
        end;
        for _, v11 in ipairs(v8) do
            local v12 = v11[1];
            if _G.__DEV__ and v12 == nil then
                error("cannot create Map from a table that isn't an array.");
            end;
            local v13 = v11[2];
            if v7[v12] == nil then
                table.insert(v6, v12);
            end;
            v7[v12] = v13;
        end;
    end;
    return (setmetatable({
        size = #v6,
        _map = v7,
        _array = v6
    }, v4));
end;
v4.set = function(v14, v15, v16)
    if v14._map[v15] == nil then
        v14.size = v14.size + 1;
        table.insert(v14._array, v15);
    end;
    v14._map[v15] = v16;
    return v14;
end;
v4.get = function(v17, v18)
    return v17._map[v18];
end;
v4.clear = function(v19)
    local l_table_0 = table;
    v19.size = 0;
    l_table_0.clear(v19._map);
    l_table_0.clear(v19._array);
end;
v4.delete = function(v21, v22)
    if v21._map[v22] == nil then
        return false;
    else
        v21.size = v21.size - 1;
        v21._map[v22] = nil;
        local v23 = table.find(v21._array, v22);
        if v23 then
            table.remove(v21._array, v23);
        end;
        return true;
    end;
end;
v4.forEach = function(v24, v25, v26)
    if typeof(v25) ~= "function" then
        error("callback is not a function");
    end;
    return v1.forEach(v24._array, function(v27)
        local v28 = v24._map[v27];
        if v26 ~= nil then
            v25(v26, v28, v27, v24);
            return ;
        else
            v25(v28, v27, v24);
            return ;
        end;
    end);
end;
v4.has = function(v29, v30)
    return v29._map[v30] ~= nil;
end;
v4.keys = function(v31)
    return v31._array;
end;
v4.values = function(v32)
    return v1.map(v32._array, function(v33)
        return v32._map[v33];
    end);
end;
v4.entries = function(v34)
    return v1.map(v34._array, function(v35)
        return {
            v35,
            v34._map[v35]
        };
    end);
end;
v4.ipairs = function(v36)
    return ipairs(v36:entries());
end;
v4.__index = function(v37, v38)
    local v39 = rawget(v4, v38);
    if v39 ~= nil then
        return v39;
    else
        return v4.get(v37, v38);
    end;
end;
v4.__newindex = function(v40, v41, v42)
    v40:set(v41, v42);
end;
return {
    Map = v4,
    coerceToMap = function(v43)
        return not not v3(v43, v4) and v43 or v4.new(v2.entries(v43));
    end,
    coerceToTable = function(v44)
        if v3(v44, v4) then
            return v1.reduce(v44:entries(), function(v45, v46)
                v45[v46[1]] = v46[2];
                return v45;
            end, {});
        else
            return v44;
        end;
    end
};


local l_rshift_0 = bit32.rshift;
local l_log_0 = math.log;
local l_floor_0 = math.floor;
return function(v3)
    local v4 = l_rshift_0(v3, 0);
    if v4 == 0 then
        return 32;
    else
        return 31 - l_floor_0(l_log_0(v4) / 0.6931471805599453);
    end;
end;


return {
    isFinite = require(script.isFinite),
    isInteger = require(script.isInteger),
    isNaN = require(script.isNaN),
    isSafeInteger = require(script.isSafeInteger),
    MAX_SAFE_INTEGER = require(script.MAX_SAFE_INTEGER),
    MIN_SAFE_INTEGER = require(script.MIN_SAFE_INTEGER),
    NaN = (0/0),
    toExponential = require(script.toExponential)
};


return function(v0)
    local v1 = false;
    if typeof(v0) == "number" then
        v1 = false;
        if v0 == v0 then
            v1 = false;
            if v0 ~= math.huge then
                v1 = v0 ~= -math.huge;
            end;
        end;
    end;
    return v1;
end;


return function(v0)
    local v1 = false;
    if type(v0) == "number" then
        v1 = false;
        if v0 ~= math.huge then
            v1 = v0 == math.floor(v0);
        end;
    end;
    return v1;
end;


return function(v0)
    local v1 = false;
    if type(v0) == "number" then
        v1 = v0 ~= v0;
    end;
    return v1;
end;


local v0 = require(script.Parent.isInteger);
local v1 = require(script.Parent.MAX_SAFE_INTEGER);
return function(v2)
    return v0(v2) and math.abs(v2) <= v1;
end;


return function(v0, v1)
    local l_v0_0 = v0;
    if typeof(v0) == "string" then
        l_v0_0 = tonumber(v0) or (0/0);
    end;
    if typeof(l_v0_0) ~= "number" then
        return "nan";
    else
        if v1 ~= nil then
            if typeof(v1) ~= "number" then
                error("TypeError: fractionDigits must be a number between 0 and 100");
            end;
            if not (v1 >= 0) or v1 > 100 then
                error("RangeError: fractionDigits must be between 0 and 100");
            end;
        end;
        local _ = nil;
        return (string.format(v1 == nil and "%e" or "%." .. tostring(v1) .. "e", l_v0_0):gsub("%+0", "+"):gsub("%-0", "-"):gsub("0*e", "e"));
    end;
end;


local v0 = require(script.Parent.None);
return function(v1, v2, v3, v4, ...)
    if v2 ~= nil and typeof(v2) == "table" then
        for v5, v6 in pairs(v2) do
            if v6 == v0 then
                v1[v5] = nil;
            else
                v1[v5] = v6;
            end;
        end;
    end;
    if v3 ~= nil and typeof(v3) == "table" then
        for v7, v8 in pairs(v3) do
            if v8 == v0 then
                v1[v7] = nil;
            else
                v1[v7] = v8;
            end;
        end;
    end;
    if v4 ~= nil and typeof(v4) == "table" then
        for v9, v10 in pairs(v4) do
            if v10 == v0 then
                v1[v9] = nil;
            else
                v1[v9] = v10;
            end;
        end;
    end;
    for v11 = 1, select("#", ...) do
        local v12 = select(v11, ...);
        if v12 ~= nil and typeof(v12) == "table" then
            for v13, v14 in pairs(v12) do
                if v14 == v0 then
                    v1[v13] = nil;
                else
                    v1[v13] = v14;
                end;
            end;
        end;
    end;
    return v1;
end;


local _ = require(script.Parent.Parent.Array);
return function(v1)
    assert(v1 ~= nil, "cannot get entries from a nil value");
    local v2 = typeof(v1);
    local v3 = {};
    if v2 == "table" then
        for v4, v5 in pairs(v1) do
            table.insert(v3, {
                v4,
                v5
            });
        end;
        return v3;
    else
        if v2 == "string" then
            for v6 = 1, string.len(v1) do
                v3[v6] = {
                    tostring(v6),
                    (string.sub(v1, v6, v6))
                };
            end;
        end;
        return v3;
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Set);
local v2 = require(l_Parent_0.instanceof);
return function(v3)
    if v3 == nil then
        error("cannot extract keys from a nil value");
    end;
    local v4 = typeof(v3);
    local v5 = {};
    if v4 == "table" then
        if not v2(v3, v1) then
            for v6 in pairs(v3) do
                table.insert(v5, v6);
            end;
            return v5;
        else
            return v5;
        end;
    else
        if v4 == "string" then
            local v7 = v3:len();
            v5 = table.create(v7);
            for v8 = 1, v7 do
                v5[v8] = tostring(v8);
            end;
        end;
        return v5;
    end;
end;


return function(v0)
    local v1 = tostring(v0);
    return (setmetatable(v0, {
        __newindex = function(_, v3, _)
            error(("%q (%s) is not a valid member of %s"):format(tostring(v3), typeof(v3), v1), 2);
        end,
        __metatable = false
    }));
end;


return function(v0)
    if v0 == nil then
        error("cannot extract values from a nil value");
    end;
    local v1 = typeof(v0);
    local v2 = {};
    if v1 == "table" then
        for _, v4 in pairs(v0) do
            table.insert(v2, v4);
        end;
        return v2;
    else
        if v1 == "string" then
            for v5 = 1, v0:len() do
                v2[v5] = v0:sub(v5, v5);
            end;
        end;
        return v2;
    end;
end;


local l_Parent_0 = script.Parent;
local v1 = require(l_Parent_0.Array);
local v2 = require(l_Parent_0.util.inspect);
local v3 = {};
v3.__index = v3;
v3.__tostring = function(v4)
    local v5 = "Set ";
    if #v4._array > 0 then
        v5 = v5 .. "(" .. tostring(#v4._array) .. ") ";
    end;
    return v5 .. v2(v4._array);
end;
v3.new = function(v6)
    local v7 = {};
    local v8 = {};
    if v6 ~= nil then
        local v9 = nil;
        if typeof(v6) == "table" then
            if not v1.isArray(v6) then
                if not (typeof(v6.ipairs) == "function" or not _G.__DEV__) then
                    error("cannot create array from an object-like table");
                end;
            else
                v9 = v1.from(v6);
            end;
        elseif typeof(v6) == "string" then
            v9 = v1.from(v6);
        else
            error(("cannot create array from value of type `%s`"):format((typeof(v6))));
        end;
        if not v9 then
            if typeof(v6) == "table" and typeof(v6.ipairs) == "function" then
                for _, v11 in v6:ipairs() do
                    if not v8[v11] then
                        v8[v11] = true;
                        table.insert(v7, v11);
                    end;
                end;
            end;
        else
            for _, v13 in ipairs(v9) do
                if not v8[v13] then
                    v8[v13] = true;
                    table.insert(v7, v13);
                end;
            end;
        end;
    end;
    return (setmetatable({
        size = #v7,
        _map = v8,
        _array = v7
    }, v3));
end;
v3.add = function(v14, v15)
    if not v14._map[v15] then
        v14.size = v14.size + 1;
        v14._map[v15] = true;
        table.insert(v14._array, v15);
    end;
    return v14;
end;
v3.clear = function(v16)
    v16.size = 0;
    table.clear(v16._map);
    table.clear(v16._array);
end;
v3.delete = function(v17, v18)
    if v17._map[v18] then
        v17.size = v17.size - 1;
        v17._map[v18] = nil;
        local v19 = table.find(v17._array, v18);
        if v19 then
            table.remove(v17._array, v19);
        end;
        return true;
    else
        return false;
    end;
end;
v3.forEach = function(v20, v21, v22)
    if typeof(v21) ~= "function" then
        error("callback is not a function");
    end;
    return v1.forEach(v20._array, function(v23)
        if v22 ~= nil then
            v21(v22, v23, v23, v20);
            return ;
        else
            v21(v23, v23, v20);
            return ;
        end;
    end);
end;
v3.has = function(v24, v25)
    return v24._map[v25] ~= nil;
end;
v3.ipairs = function(v26)
    return ipairs(v26._array);
end;
return v3;


local l_NaN_0 = require(script.Parent.Parent.Number).NaN;
return function(v1, v2)
    if typeof(v2) ~= "number" then
        v2 = 1;
    end;
    local v3, v4 = utf8.len(v1);
    assert(v3 ~= nil, ("string `%s` has an invalid byte at position %s"):format(v1, (tostring(v4))));
    if not (v3 >= v2) or v2 < 1 then
        return l_NaN_0;
    else
        local v5 = utf8.offset(v1, v2);
        local v6 = utf8.codepoint(v1, v5, v5);
        if v6 == nil then
            return l_NaN_0;
        else
            return v6;
        end;
    end;
end;


return function(v0, v1, v2)
    local v3 = v1:len();
    if v3 == 0 then
        return true;
    else
        local v4 = v0:len();
        local v5 = v2 or v4;
        if v4 < v5 then
            v5 = v4;
        end;
        if v5 < 1 then
            return false;
        else
            local v6 = (v5 - v3) + 1;
            return v0:find(v1, v6, true) == v6;
        end;
    end;
end;


return function(v0, v1, v2)
    local v3 = utf8.offset(v0, v2 or 1);
    local v4 = {};
    for _, v6 in ipairs(v1) do
        local v7, v8 = string.find(v0, v6, v3);
        if v7 then
            local v9 = string.sub(v0, 1, v7 - 1);
            local v10, v11 = utf8.len(v9);
            if v10 == nil then
                error(("string `%s` has an invalid byte at position %s"):format(v9, (tostring(v11))));
            end;
            table.insert(v4, {
                index = v10 + 1,
                match = string.sub(v0, v7, v8)
            });
        end;
    end;
    if #v4 == 0 then
        return nil;
    else
        local v12 = nil;
        for _, v14 in ipairs(v4) do
            if v12 == nil then
                v12 = v14;
            end;
            if v14.index < v12.index then
                v12 = v14;
            end;
        end;
        return v12;
    end;
end;


return {
    charCodeAt = require(script.charCodeAt),
    endsWith = require(script.endsWith),
    findOr = require(script.findOr),
    lastIndexOf = require(script.lastIndexOf),
    slice = require(script.slice),
    split = require(script.split),
    startsWith = require(script.startsWith),
    substr = require(script.substr),
    trim = require(script.trim),
    trimEnd = require(script.trimEnd),
    trimStart = require(script.trimStart),
    trimRight = require(script.trimEnd),
    trimLeft = require(script.trimStart)
};


return function(v0, v1, v2)
    local v3 = string.len(v0);
    local v4 = nil;
    v4 = v2 or v3;
    if v2 and v2 < 1 then
        v4 = 1;
    end;
    if v2 and v3 < v2 then
        v4 = v3;
    end;
    if v1 == "" then
        return v4;
    else
        local v5 = nil;
        local v6 = nil;
        local v7 = 0;
        while true do
            v5 = v6;
            local v8, v9 = string.find(v0, v1, v7 + 1, true);
            v6 = v8;
            v7 = v9;
            if not (v6 ~= nil and v4 >= v6) then
                break;
            end;
        end;
        if v5 == nil then
            return -1;
        else
            return v5;
        end;
    end;
end;


return function(v0, v1, v2)
    local v3, v4 = utf8.len(v0);
    assert(v3 ~= nil, ("string `%s` has an invalid byte at position %s"):format(v0, (tostring(v4))));
    local v5 = tonumber(v1);
    assert(typeof(v5) == "number", "startIndexStr should be a number");
    if v5 + v3 < 0 then
        v5 = 1;
    end;
    if v3 < v5 then
        return "";
    else
        local v6 = v3 + 1;
        if v2 ~= nil then
            v6 = tonumber(v2) or (0/0);
        end;
        assert(typeof(v6) == "number", "lastIndexStr should convert to number");
        if v3 < v6 then
            v6 = v3 + 1;
        end;
        return (string.sub(v0, utf8.offset(v0, v5), utf8.offset(v0, v6) - 1));
    end;
end;


local v0 = require(script.Parent.findOr);
local v1 = require(script.Parent.slice);
return function(v2, v3)
    if v3 == nil then
        return {
            v2
        };
    else
        local v4 = nil;
        if typeof(v3) == "string" then
            if v3 == "" then
                return {
                    v2
                };
            else
                v4 = {
                    v3
                };
            end;
        else
            v4 = v3;
        end;
        local v5 = 1;
        local v6 = {};
        local v7 = nil;
        local v8, v9 = utf8.len(v2);
        assert(v8 ~= nil, ("string `%s` has an invalid byte at position %s"):format(v2, (tostring(v9))));
        while true do
            local v10 = v0(v2, v4, v5);
            if v10 ~= nil then
                table.insert(v6, v1(v2, v5, v10.index));
                v5 = v10.index + utf8.len(v10.match);
            else
                table.insert(v6, v1(v2, v5, nil));
            end;
            if v10 ~= nil then
                v7 = v10;
            end;
            if not (v10 ~= nil and v8 >= v5) then
                break;
            end;
        end;
        if v7 ~= nil then
            local v11, v12 = utf8.len(v7.match);
            assert(v11 ~= nil, ("string `%s` has an invalid byte at position %s"):format(v7.match, (tostring(v12))));
            if v7.index + v11 == v8 + 1 then
                table.insert(v6, "");
            end;
        end;
        return v6;
    end;
end;


return function(v0, v1, v2)
    if string.len(v1) == 0 then
        return true;
    else
        local v3 = nil;
        v3 = (not (v2 ~= nil) or v2 < 1) and 1 or v2;
        if string.len(v0) < v3 then
            return false;
        else
            return v0:find(v1, v3, true) == v3;
        end;
    end;
end;


return function(v0, v1, v2)
    if v2 and v2 <= 0 then
        return "";
    else
        return (string.sub(v0, v1, not not v2 and (v1 + v2) - 1 or nil));
    end;
end;


local v0 = require(script.Parent.trimStart);
local v1 = require(script.Parent.trimEnd);
return function(v2)
    return v0(v1(v2));
end;


local v0 = require(script.Parent.Symbol);
local v1 = {};
return {
    getOrInit = function(v2)
        if v1[v2] == nil then
            v1[v2] = v0.new(v2);
        end;
        return v1[v2];
    end,
    __clear = function()
        v1 = {};
    end
};


return {
    new = function(v0)
        local v1 = newproxy(true);
        local v2 = "Symbol()";
        if v0 then
            v2 = ("Symbol(%s)"):format(v0);
        end;
        getmetatable(v1).__tostring = function()
            return v2;
        end;
        return v1;
    end
};


local v0 = require(script.Symbol);
local v1 = require(script.GlobalRegistry);
local v4 = setmetatable({}, {
    __call = function(_, v3)
        return v0.new(v3);
    end
});
v4.for_ = v1.getOrInit;
return v4;


local v0 = newproxy(false);
return function(v1)
    return {
        setTimeout = function(v2, v3, ...)
            local v4 = {
                ...
            };
            local v5 = {
                [v0] = 1
            };
            if v3 == nil then
                v3 = 0;
            end;
            v1(v3 / 1000, function()
                if v5[v0] == 1 then
                    v2(unpack(v4));
                    v5[v0] = 2;
                end;
            end);
            return v5;
        end,
        clearTimeout = function(v6)
            if v6[v0] == 1 then
                v6[v0] = 3;
            end;
        end
    };
end;


local v0 = {};
v0.__index = v0;
v0.new = function()
    return (setmetatable({
        _weakMap = setmetatable({}, {
            __mode = "k"
        })
    }, v0));
end;
v0.get = function(v1, v2)
    return v1._weakMap[v2];
end;
v0.set = function(v3, v4, v5)
    v3._weakMap[v4] = v5;
    return v3;
end;
v0.has = function(v6, v7)
    return v6._weakMap[v7] ~= nil;
end;
return v0;


local l_inspect_0 = require(script.Parent.Parent.util).inspect;
return function()
    local v1 = {};
    local v2 = 0;
    local function _()
        return string.rep("  ", v2);
    end;
    v1.log = function(v4, ...)
        local _ = nil;
        print(string.rep("  ", v2) .. if typeof(v4) == "string" then string.format(v4, ...) else l_inspect_0(v4));
    end;
    v1.debug = function(v6, ...)
        local _ = nil;
        print(string.rep("  ", v2) .. if typeof(v6) == "string" then string.format(v6, ...) else l_inspect_0(v6));
    end;
    v1.info = function(v8, ...)
        local _ = nil;
        print(string.rep("  ", v2) .. if typeof(v8) == "string" then string.format(v8, ...) else l_inspect_0(v8));
    end;
    v1.warn = function(v10, ...)
        local _ = nil;
        warn(string.rep("  ", v2) .. if typeof(v10) == "string" then string.format(v10, ...) else l_inspect_0(v10));
    end;
    v1.error = function(v12, ...)
        local _ = nil;
        warn(string.rep("  ", v2) .. if typeof(v12) == "string" then string.format(v12, ...) else l_inspect_0(v12));
    end;
    v1.group = function(v14, ...)
        local _ = nil;
        print(string.rep("  ", v2) .. if typeof(v14) == "string" then string.format(v14, ...) else l_inspect_0(v14));
        v2 = v2 + 1;
    end;
    v1.groupCollapsed = function(v16, ...)
        local _ = nil;
        print(string.rep("  ", v2) .. if typeof(v16) == "string" then string.format(v16, ...) else l_inspect_0(v16));
        v2 = v2 + 1;
    end;
    v1.groupEnd = function()
        if v2 > 0 then
            v2 = v2 - 1;
        end;
    end;
    return v1;
end;


local v0 = require(script.Parent.String.charCodeAt);
local v1 = require(script.Parent.Error);
local l_HttpService_0 = game:GetService("HttpService");
return function(v3)
    local v4 = utf8.len(v3);
    if not (v4 ~= 0) or v4 == nil then
        return "";
    else
        local v5 = v0(v3, 1);
        if v4 == 1 then
            if v5 == 55296 then
                error(v1.new("URI malformed"));
            end;
            if v5 == 57343 then
                error(v1.new("URI malformed"));
            end;
        end;
        if v5 >= 56320 and v5 < 57343 then
            error(v1.new("URI malformed"));
        end;
        return (l_HttpService_0:UrlEncode(v3):gsub("%%2D", "-"):gsub("%%5F", "_"):gsub("%%2E", "."):gsub("%%21", "gsub("%%7E", "~"):gsub("%%2A", "*"):gsub("%%27", "'"):gsub("%%28", "("):gsub("%%29", ")"));
    end;
end;


return function(v0, v1, v2)
    local v3 = {};
    v3.__index = v3;
    v3.__tostring = function(v4)
        return getmetatable(v0).__tostring(v4);
    end;
    local v5 = {};
    v3.new = function(...)
        local v6 = {};
        v2(v6, ...);
        return (setmetatable(v6, v3));
    end;
    if not (not (typeof((getmetatable(v0))) == "table") or not getmetatable(v0).__call) then
        v5.__call = function(_, ...)
            return v3.new(...);
        end;
    end;
    v5.__index = v0;
    v5.__tostring = function(v8)
        if v8 == v3 then
            return (tostring(v1));
        else
            return getmetatable(v0).__tostring(v8);
        end;
    end;
    setmetatable(v3, v5);
    return v3;
end;


local v0 = require(script.Array);
local v1 = require(script.AssertionError);
local v2 = require(script.Error);
local v3 = require(script.Map);
local v4 = require(script.Object);
local _ = require(script.Promise);
local v6 = require(script.Set);
local v7 = require(script.Symbol);
local v8 = require(script.Timers);
return {
    Array = v0,
    AssertionError = v1,
    Boolean = require(script.Boolean),
    console = require(script.console),
    Error = v2,
    extends = require(script.extends),
    instanceof = require(script.instanceof),
    Math = require(script.Math),
    Number = require(script.Number),
    Object = v4,
    Map = v3.Map,
    coerceToMap = v3.coerceToMap,
    coerceToTable = v3.coerceToTable,
    Set = v6,
    WeakMap = require(script.WeakMap),
    String = require(script.String),
    Symbol = v7,
    setTimeout = v8.setTimeout,
    clearTimeout = v8.clearTimeout,
    setInterval = v8.setInterval,
    clearInterval = v8.clearInterval,
    util = require(script.util)
};


return function(v0, v1)
    assert(typeof(v1) == "table", "Received a non-table as the second argument for instanceof");
    if typeof(v0) ~= "table" then
        return false;
    else
        local l_status_0, l_result_0 = pcall(function()
            local v2 = false;
            if v1.new ~= nil then
                v2 = v0.new == v1.new;
            end;
            return v2;
        end);
        if not l_status_0 or not l_result_0 then
            local v5 = {
                tbl = true
            };
            while true do
                if v0 and typeof(v0) == "table" then
                    v0 = getmetatable(v0);
                    if typeof(v0) == "table" then
                        v0 = v0.__index;
                        if v0 == v1 then
                            return true;
                        end;
                    end;
                    if typeof(v0) == "table" then
                        if not v5[v0] then
                            v5[v0] = true;
                        else
                            return false;
                        end;
                    end;
                else
                    return false;
                end;
            end;
        else
            return true;
        end;
    end;
end;


local l_HttpService_0 = game:GetService("HttpService");
local v1 = require(script.Parent.Parent.Array);
local v2 = nil;
local v3 = nil;
local v4 = nil;
local v5 = nil;
local v6 = nil;
local function v11(v7, v8)
    local v9 = v8 or {
        depth = 2
    };
    local v10 = v9.depth or 2;
    v9.depth = if v10 >= 0 then v10 else 2;
    return v2(v7, {}, v9);
end;
local function _(v12, v13)
    local v14 = false;
    if type(v12) == "number" then
        v14 = false;
        if v12 <= v13 then
            v14 = false;
            if v12 >= 1 then
                v14 = math.floor(v12) == v12;
            end;
        end;
    end;
    return v14;
end;
local function _(v16)
    local v17 = 1;
    local v18 = rawget(v16, v17);
    while v18 ~= nil do
        v17 = v17 + 1;
        v18 = rawget(v16, v17);
    end;
    return v17 - 1;
end;
local function v24(v20, v21)
    local v22 = type(v20);
    local v23 = type(v21);
    if v22 == v23 and (not (v22 ~= "number") or v22 == "string") then
        return v20 < v21;
    else
        return v22 < v23;
    end;
end;
local function _(v25)
    return next, v25, nil;
end;
local function v36(v27)
    local v28 = {};
    local v29 = 0;
    local v30 = 1;
    local v31 = rawget(v27, v30);
    while v31 ~= nil do
        v30 = v30 + 1;
        v31 = rawget(v27, v30);
    end;
    local v32 = v30 - 1;
    for v33, _ in next, v27, nil do
        local v35 = false;
        if type(v33) == "number" then
            v35 = false;
            if v33 <= v32 then
                v35 = false;
                if v33 >= 1 then
                    v35 = math.floor(v33) == v33;
                end;
            end;
        end;
        if not v35 then
            v29 = v29 + 1;
            v28[v29] = v33;
        end;
    end;
    table.sort(v28, v24);
    return v28, v29, v32;
end;
v2 = function(v37, v38, v39)
    local v40 = typeof(v37);
    if v40 == "string" then
        return l_HttpService_0:JSONEncode(v37);
    elseif v40 == "number" then
        if v37 ~= v37 then
            return "NaN";
        elseif v37 == math.huge then
            return "Infinity";
        elseif v37 == -math.huge then
            return "-Infinity";
        else
            return (tostring(v37));
        end;
    elseif v40 == "function" then
        local v41 = "[function";
        local v42 = debug.info(v37, "n");
        if v42 ~= nil and v42 ~= "" then
            v41 = v41 .. " " .. v42;
        end;
        return v41 .. "]";
    elseif v40 == "table" then
        return v3(v37, v38, v39);
    else
        return (tostring(v37));
    end;
end;
v3 = function(v43, v44, v45)
    if table.find(v44, v43) ~= nil then
        return "[Circular]";
    else
        local v46 = {
            unpack(v44)
        };
        table.insert(v46, v43);
        if typeof(v43.toJSON) == "function" then
            local v47 = v43:toJSON(v43);
            if v47 ~= v43 then
                if typeof(v47) == "string" then
                    return v47;
                else
                    return v2(v47, v46, v45);
                end;
            end;
        elseif v1.isArray(v43) then
            return v4(v43, v46, v45);
        end;
        return v5(v43, v46, v45);
    end;
end;
v5 = function(v48, v49, v50)
    local v51 = "";
    local v52 = getmetatable(v48);
    if not v52 or not rawget(v52, "__tostring") then
        local v53, v54, v55 = v36(v48);
        if v55 == 0 and v54 == 0 then
            return v51 .. "{}";
        elseif v50.depth < #v49 then
            return v51 .. "[" .. v6(v48) .. "]";
        else
            local v56 = {};
            for v57 = 1, v55 do
                table.insert(v56, (v2(v48[v57], v49, v50)));
            end;
            for v58 = 1, v54 do
                local v59 = v53[v58];
                table.insert(v56, v59 .. ": " .. v2(v48[v59], v49, v50));
            end;
            return v51 .. "{ " .. table.concat(v56, ", ") .. " }";
        end;
    else
        return (tostring(v48));
    end;
end;
v4 = function(v60, v61, v62)
    local v63 = #v60;
    if v63 == 0 then
        return "[]";
    elseif v62.depth < #v61 then
        return "[Array]";
    else
        local v64 = math.min(10, v63);
        local v65 = v63 - v64;
        local v66 = {};
        for v67 = 1, v64 do
            v66[v67] = v2(v60[v67], v61, v62);
        end;
        if v65 == 1 then
            table.insert(v66, "... 1 more item");
        elseif v65 > 1 then
            table.insert(v66, ("... %s more items"):format((tostring(v65))));
        end;
        return "[" .. table.concat(v66, ", ") .. "]";
    end;
end;
v6 = function(_)
    return "Object";
end;
return v11;


local l_Parent_0 = script.Parent;
local v1 = require(l_Parent_0.isArray);
local _ = require(l_Parent_0.Parent.types);
local v3 = "Array.concat(...) only works with array-like tables but " .. "it received an object-like table.\nYou can avoid this error by wrapping the " .. "object-like table into an array. Example: `concat({1, 2}, {a = true})` should " .. "be `concat({1, 2}, { {a = true} }`";
return function(v4, ...)
    local v5 = nil;
    local v6 = 0;
    if not v1(v4) then
        v6 = v6 + 1;
        v5 = {
            [v6] = v4
        };
    else
        v5 = table.clone(v4);
        v6 = #v4;
    end;
    for v7 = 1, select("#", ...) do
        local v8 = select(v7, ...);
        local v9 = typeof(v8);
        if not (v8 == nil) then
            if v9 == "table" then
                if not (not _G.__DEV__ or v1(v8)) then
                    error(v3);
                end;
                for v10 = 1, #v8 do
                    v6 = v6 + 1;
                    v5[v6] = v8[v10];
                end;
            else
                v6 = v6 + 1;
                v5[v6] = v8;
            end;
        end;
    end;
    return v5;
end;


local _ = require(script.Parent.Parent.types);
return function(v1, v2, v3)
    if _G.__DEV__ then
        if typeof(v1) ~= "table" then
            error(string.format("Array.every called on %s", (typeof(v1))));
        end;
        if typeof(v2) ~= "function" then
            error("callback is not a function");
        end;
    end;
    local v4 = #v1;
    local v5 = 1;
    while true do
        if v5 <= v4 then
            local v6 = v1[v5];
            local _ = nil;
            if not (v6 ~= nil) or if v3 ~= nil then v2(v3, v6, v5, v1) else v2(v6, v5, v1) then
                v5 = v5 + 1;
            else
                return false;
            end;
        else
            return true;
        end;
    end;
end;


local _ = require(script.Parent.Parent.types);
return function(v1, v2, v3)
    if _G.__DEV__ then
        if typeof(v1) ~= "table" then
            error(string.format("Array.filter called on %s", (typeof(v1))));
        end;
        if typeof(v2) ~= "function" then
            error("callback is not a function");
        end;
    end;
    local v4 = #v1;
    local v5 = {};
    local v6 = 1;
    if v3 == nil then
        for v7 = 1, v4 do
            local v8 = v1[v7];
            if not (not (v8 ~= nil) or not v2(v8, v7, v1)) then
                v5[v6] = v8;
                v6 = v6 + 1;
            end;
        end;
        return v5;
    else
        for v9 = 1, v4 do
            local v10 = v1[v9];
            if not (not (v10 ~= nil) or not v2(v3, v10, v9, v1)) then
                v5[v6] = v10;
                v6 = v6 + 1;
            end;
        end;
        return v5;
    end;
end;


local _ = require(script.Parent.Parent.types);
return function(v1, v2)
    for v3 = 1, #v1 do
        local v4 = v1[v3];
        if v2(v4, v3, v1) then
            return v4;
        end;
    end;
    return nil;
end;


local _ = require(script.Parent.Parent.types);
return function(v1, v2)
    for v3 = 1, #v1 do
        if v2(v1[v3], v3, v1) then
            return v3;
        end;
    end;
    return -1;
end;


local _ = require(script.Parent.Parent.types);
return function(v1, v2, v3)
    if _G.__DEV__ then
        if typeof(v1) ~= "table" then
            error(string.format("Array.forEach called on %s", (typeof(v1))));
        end;
        if typeof(v2) ~= "function" then
            error("callback is not a function");
        end;
    end;
    local v4 = #v1;
    local v5 = 1;
    while v5 <= v4 do
        local v6 = v1[v5];
        if v3 ~= nil then
            v2(v3, v6, v5, v1);
        else
            v2(v6, v5, v1);
        end;
        if #v1 < v4 then
            v4 = #v1;
        end;
        v5 = v5 + 1;
    end;
end;


local _ = require(script.Parent.Parent.Parent.types);
return function(v1, v2, v3)
    local v4 = {};
    if not v2 then
        return (table.clone(v1));
    else
        local v5 = #v1;
        v4 = table.create(v5);
        for v6 = 1, v5 do
            if v3 ~= nil then
                v4[v6] = v2(v3, v1[v6], v6);
            else
                v4[v6] = v2(v1[v6], v6);
            end;
        end;
        return v4;
    end;
end;


local _ = require(script.Parent.Parent.Parent.types);
return function(v1, v2, v3)
    local v4 = {};
    if not v2 then
        v4 = {};
        for v5, v6 in v1, nil, nil do
            v4[v5] = v6;
        end;
        return v4;
    else
        v4 = {};
        for v7, v8 in v1, nil, nil do
            if v3 ~= nil then
                v4[v7] = v2(v3, v8, v7);
            else
                v4[v7] = v2(v8, v7);
            end;
        end;
        return v4;
    end;
end;


local _ = require(script.Parent.Parent.Parent.types);
return function(v1, v2, v3)
    local v4 = {};
    if not v2 then
        return (table.clone(v1._array));
    else
        v4 = {};
        for v5, v6 in v1, nil, nil do
            if v3 ~= nil then
                v4[v5] = v2(v3, v6, v5);
            else
                v4[v5] = v2(v6, v5);
            end;
        end;
        return v4;
    end;
end;


local _ = require(script.Parent.Parent.Parent.types);
return function(v1, v2, v3)
    local v4 = {};
    local v5 = #v1;
    v4 = table.create(v5);
    if not v2 then
        for v6 = 1, v5 do
            v4[v6] = string.sub(v1, v6, v6);
        end;
        return v4;
    else
        for v7 = 1, v5 do
            if v3 ~= nil then
                v4[v7] = v2(v3, string.sub(v1, v7, v7), v7);
            else
                v4[v7] = v2(string.sub(v1, v7, v7), v7);
            end;
        end;
        return v4;
    end;
end;


local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_0.isArray);
local v3 = require(l_Parent_1.instanceof);
local v4 = require(l_Parent_1.Set);
local v5 = require(l_Parent_1.Map);
local v6 = require(script.fromString);
local v7 = require(script.fromSet);
local v8 = require(script.fromMap);
local v9 = require(script.fromArray);
local _ = require(l_Parent_1.types);
return function(v11, v12, v13)
    if v11 == nil then
        error("cannot create array from a nil value");
    end;
    local v14 = typeof(v11);
    local _ = nil;
    if not (v14 == "table") or not v2(v11) then
        if not v3(v11, v4) then
            if not v3(v11, v5) then
                if v14 == "string" then
                    return (v6(v11, v12, v13));
                else
                    return {};
                end;
            else
                return (v8(v11, v12, v13));
            end;
        else
            return (v7(v11, v12, v13));
        end;
    else
        return (v9(v11, v12, v13));
    end;
end;


local _ = require(script.Parent.Parent.types);
local v1 = require(script.Parent.indexOf);
return function(v2, v3, v4)
    return v1(v2, v3, v4) ~= -1;
end;


local _ = require(script.Parent.Parent.types);
return function(v1, v2, v3)
    local v4 = v3 or 1;
    local v5 = #v1;
    if v4 < 1 then
        v4 = math.max(v5 - math.abs(v4), 1);
    end;
    for v6 = v4, v5 do
        if v1[v6] == v2 then
            return v6;
        end;
    end;
    return -1;
end;


local _ = require(script.Parent.Parent.types);
local v1 = require(script.Parent.map);
return function(v2, v3)
    if #v2 == 0 then
        return "";
    else
        return table.concat(v1(v2, function(v4)
            return (tostring(v4));
        end), v3 or ",");
    end;
end;


local _ = require(script.Parent.Parent.types);
return function(v1, v2, v3)
    if _G.__DEV__ then
        if typeof(v1) ~= "table" then
            error(string.format("Array.map called on %s", (typeof(v1))));
        end;
        if typeof(v2) ~= "function" then
            error("callback is not a function");
        end;
    end;
    local v4 = #v1;
    local v5 = {};
    local v6 = 1;
    while v6 <= v4 do
        local v7 = v1[v6];
        if v7 ~= nil then
            local _ = nil;
            v5[v6] = if v3 ~= nil then v2(v3, v7, v6, v1) else v2(v7, v6, v1);
        end;
        v6 = v6 + 1;
    end;
    return v5;
end;


local _ = require(script.Parent.Parent.types);
return function(v1, v2, v3)
    if _G.__DEV__ then
        if typeof(v1) ~= "table" then
            error(string.format("Array.reduce called on %s", (typeof(v1))));
        end;
        if typeof(v2) ~= "function" then
            error("callback is not a function");
        end;
    end;
    local v4 = #v1;
    local v5 = nil;
    local v6 = 1;
    if v3 ~= nil then
        v5 = v3;
    else
        v6 = 2;
        if v4 == 0 then
            error("reduce of empty array with no initial value");
        end;
        v5 = v1[1];
    end;
    for v7 = v6, v4 do
        v5 = v2(v5, v1[v7], v7, v1);
    end;
    return v5;
end;


local _ = require(script.Parent.Parent.types);
return function(v1)
    local v2 = #v1;
    local v3 = 1;
    while v3 < v2 do
        local v4 = v1[v2];
        local v5 = v1[v3];
        v1[v3] = v4;
        v1[v2] = v5;
        v3 = v3 + 1;
        v2 = v2 - 1;
    end;
    return v1;
end;


local l_Parent_0 = script.Parent;
local v1 = require(l_Parent_0.isArray);
local _ = require(l_Parent_0.Parent.types);
return function(v3)
    if not (not _G.__DEV__ or v1(v3)) then
        error(string.format("Array.shift called on non-array %s", (typeof(v3))));
    end;
    if #v3 > 0 then
        return table.remove(v3, 1);
    else
        return nil;
    end;
end;


local _ = require(script.Parent.Parent.types);
return function(v1, v2, v3)
    if typeof(v1) ~= "table" then
        error(string.format("Array.slice called on %s", (typeof(v1))));
    end;
    local v4 = #v1;
    local v5 = v2 or 1;
    local v6 = nil;
    v6 = if not (v3 ~= nil) or v4 + 1 < v3 then v4 + 1 else v3;
    if v4 + 1 < v5 then
        return {};
    else
        local v7 = {};
        if v5 < 1 then
            v5 = math.max(v4 - math.abs(v5), 1);
        end;
        if v6 < 1 then
            v6 = math.max(v4 - math.abs(v6), 1);
        end;
        local l_v5_0 = v5;
        local v9 = 1;
        while l_v5_0 < v6 do
            v7[v9] = v1[l_v5_0];
            l_v5_0 = l_v5_0 + 1;
            v9 = v9 + 1;
        end;
        return v7;
    end;
end;


local _ = require(script.Parent.Parent.types);
return function(v1, v2, v3)
    if typeof(v1) ~= "table" then
        error(string.format("Array.some called on %s", (typeof(v1))));
    end;
    if typeof(v2) ~= "function" then
        error("callback is not a function");
    end;
    for v4, v5 in v1, nil, nil do
        if v3 ~= nil then
            if not (not (v5 ~= nil) or not v2(v3, v5, v4, v1)) then
                return true;
            end;
        elseif not (not (v5 ~= nil) or not v2(v5, v4, v1)) then
            return true;
        end;
    end;
    return false;
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Object.None);
local _ = require(l_Parent_0.types);
local function v5(v3, v4)
    return type(v3) .. tostring(v3) < type(v4) .. tostring(v4);
end;
return function(v6, v7)
    local l_v5_0 = v5;
    if v7 ~= nil and v7 ~= v1 then
        if typeof(v7) ~= "function" then
            error("invalid argument to Array.sort: compareFunction must be a function");
        end;
        l_v5_0 = function(v9, v10)
            local v11 = v7(v9, v10);
            if typeof(v11) ~= "number" then
                error(("invalid result from compare function, expected number but got %s"):format((typeof(v11))));
            end;
            return v11 < 0;
        end;
    end;
    table.sort(v6, l_v5_0);
    return v6;
end;


local _ = require(script.Parent.Parent.types);
return function(v1, v2, v3, ...)
    if #v1 < v2 then
        for v4 = 1, select("#", ...) do
            table.insert(v1, (select(v4, ...)));
        end;
        return {};
    else
        local v5 = #v1;
        if v2 < 1 then
            v2 = math.max(v5 - math.abs(v2), 1);
        end;
        local v6 = {};
        local v7 = v3 or v5;
        if v7 > 0 then
            for _ = v2, math.min(v5, v2 + math.max(0, v7 - 1)) do
                table.insert(v6, (table.remove(v1, v2)));
            end;
        end;
        for v9 = select("#", ...), 1, -1 do
            table.insert(v1, v2, (select(v9, ...)));
        end;
        return v6;
    end;
end;


local l_Parent_0 = script.Parent;
local v1 = require(l_Parent_0.isArray);
local _ = require(l_Parent_0.Parent.types);
return function(v3, ...)
    if not (not _G.__DEV__ or v1(v3)) then
        error(string.format("Array.unshift called on non-array %s", (typeof(v3))));
    end;
    local v4 = select("#", ...);
    if v4 > 0 then
        for v5 = v4, 1, -1 do
            table.insert(v3, 1, (select(v5, ...)));
        end;
    end;
    return #v3;
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Array);
local v2 = require(l_Parent_0.Boolean);
local v3 = require(l_Parent_0.Object);
local v4 = require(l_Parent_0.String);
local v5 = require(l_Parent_0.Error);
local v6 = require(l_Parent_0.instanceof);
local v7 = require(l_Parent_0.util.inspect);
local _ = require(l_Parent_0.types);
local v9 = {
    stderr = {
        isTTY = false,
        columns = 0,
        hasColors = function(...)
            return true;
        end
    }
};
ErrorCaptureStackTrace = function(...)
end;
local function _(v10)
    return v10;
end;
local v12 = "";
local v13 = "";
local v14 = "";
local v15 = "";
local v16 = {
    deepStrictEqual = "Expected values to be strictly deep-equal:",
    strictEqual = "Expected values to be strictly equal:",
    strictEqualObject = "Expected \"actual\" to be reference-equal to \"expected\":",
    deepEqual = "Expected values to be loosely deep-equal:",
    notDeepStrictEqual = "Expected \"actual\" not to be strictly deep-equal to:",
    notStrictEqual = "Expected \"actual\" to be strictly unequal to:",
    notStrictEqualObject = "Expected \"actual\" not to be reference-equal to \"expected\":",
    notDeepEqual = "Expected \"actual\" not to be loosely deep-equal to:",
    notIdentical = "Values have same structure but are not reference-equal:",
    notDeepEqualUnequal = "Expected values not to be loosely deep-equal:"
};
local _ = function(v17)
    local v18 = v3.keys(v17);
    local v19 = {};
    for _, v21 in v18, nil, nil do
        v19[v21] = v17[v21];
    end;
    v19.message = v17.message;
    return v19;
end;
local function _(v23)
    return v7(v23, {
        compact = false,
        customInspect = false,
        depth = 1000,
        maxArrayLength = math.huge,
        showHidden = false,
        showProxy = false,
        sorted = true,
        getters = true
    });
end;
local function v56(v25, v26, v27)
    local v28 = "";
    local v29 = "";
    local v30 = "";
    local v31 = false;
    local v32 = v7(v25, {
        compact = false,
        customInspect = false,
        depth = 1000,
        maxArrayLength = math.huge,
        showHidden = false,
        showProxy = false,
        sorted = true,
        getters = true
    });
    local v33 = v4.split(v32, "\n");
    local v34 = v4.split(v7(v26, {
        compact = false,
        customInspect = false,
        depth = 1000,
        maxArrayLength = math.huge,
        showHidden = false,
        showProxy = false,
        sorted = true,
        getters = true
    }), "\n");
    local v35 = 0;
    local v36 = "";
    if v27 == "strictEqual" and (not (not ((typeof(v25) == "table" and v25 ~= nil) and typeof(v26) == "table") or v26 == nil) or typeof(v25) == "function" and typeof(v26) == "function") then
        v27 = "strictEqualObject";
    end;
    if (#v33 == 1 and #v34 == 1) and v33[1] ~= v34[1] then
        local v37 = v33[1];
        local v38 = if not v2.toJSBoolean(false) then v34[1] else v34[1];
        local v39 = string.len(v37) + string.len(v38);
        if v39 <= 12 then
            if ((not (typeof(v25) == "table") or v25 == nil) and (not (typeof(v26) == "table") or v26 == nil)) and (not (v25 == 0) or v26 ~= 0) then
                return ("%s\n\n"):format(v16[v27]) .. ("%s format(v33[1], v34[1]);
            end;
        elseif v27 ~= "strictEqualObject" and v39 < (not v9.stderr.isTTY and 80 or v9.stderr.columns) then
            while string.sub(v37, v35 + 1, v35 + 1) == string.sub(v38, v35 + 1, v35 + 1) do
                v35 = v35 + 1;
            end;
            if v35 > 2 then
                v36 = ("\n  %s^"):format(string.rep(" ", v35));
                v35 = 0;
            end;
        end;
    end;
    local v40 = v33[#v33];
    local v41 = v34[#v34];
    while v40 == v41 do
        local l_v35_0 = v35;
        v35 = v35 + 1;
        if l_v35_0 < 3 then
            v30 = ("\n  %s%s"):format(v40, v30);
        else
            v28 = v40;
        end;
        table.remove(v33);
        table.remove(v34);
        if #v33 ~= 0 and #v34 ~= 0 then
            v40 = v33[#v33];
            v41 = v34[#v34];
        else
            break;
        end;
    end;
    local v43 = math.max(#v33, #v34);
    if v43 == 0 then
        local v44 = v4.split(v32, "\n");
        if #v44 > 50 then
            v44[47] = ("%s...%s"):format(v12, v15);
            while #v44 > 47 do
                table.remove(v44);
            end;
        end;
        return ("%s\n\n"):format(v16.notIdentical) .. ("%s\n"):format(v1.join(v44, "\n"));
    else
        if v35 >= 5 then
            v30 = ("\n%s...%s%s"):format(v12, v15, v30);
            v31 = true;
        end;
        if v28 ~= "" then
            v30 = ("\n  %s%s"):format(v28, v30);
            v28 = "";
        end;
        local v45 = 0;
        local v46 = 0;
        local v47 = v16[v27] .. ("\n%s+ actual%s %s- expected%s"):format(v13, v15, v14, v15);
        local v48 = (" %s...%s Lines skipped"):format(v12, v15);
        local l_v33_0 = v33;
        local v50 = ("%s+%s"):format(v13, v15);
        local v51 = #v34;
        if #v33 < v43 then
            l_v33_0 = v34;
            v50 = ("%s-%s"):format(v14, v15);
            v51 = #v33;
        end;
        for v52 = 1, v43 do
            v35 = v52;
            if v51 < v52 then
                if v46 > 2 then
                    if v46 > 3 then
                        if v46 > 4 then
                            if v46 == 5 then
                                v29 = v29 .. ("\n  %s"):format(l_v33_0[v52 - 3]);
                                v45 = v45 + 1;
                            else
                                v29 = v29 .. ("\n%s...%s"):format(v12, v15);
                                v31 = true;
                            end;
                        end;
                        v29 = v29 .. ("\n  %s"):format(l_v33_0[v52 - 2]);
                        v45 = v45 + 1;
                    end;
                    v29 = v29 .. ("\n  %s"):format(l_v33_0[v52 - 1]);
                    v45 = v45 + 1;
                end;
                v46 = 0;
                if l_v33_0 == v33 then
                    v29 = v29 .. ("\n%s %s"):format(v50, l_v33_0[v52]);
                else
                    v28 = v28 .. ("\n%s %s"):format(v50, l_v33_0[v52]);
                end;
                v45 = v45 + 1;
            else
                local v53 = v34[v52];
                local v54 = v33[v52];
                local v55 = false;
                if v54 ~= v53 then
                    v55 = not v2.toJSBoolean(v4.endsWith(v54, ",")) or v4.slice(v54, 0, -1) ~= v53;
                end;
                if not (not v55 or not v4.endsWith(v53, ",")) and v4.slice(v53, 0, -1) == v54 then
                    v55 = false;
                    v54 = v54 .. ",";
                end;
                if not v55 then
                    v29 = v29 .. v28;
                    v28 = "";
                    v46 = v46 + 1;
                    if v46 <= 2 then
                        v29 = v29 .. ("\n  %s"):format(v54);
                        v45 = v45 + 1;
                    end;
                else
                    if v46 > 2 then
                        if v46 > 3 then
                            if v46 > 4 then
                                if v46 == 5 then
                                    v29 = v29 .. ("\n  %s"):format(v33[v52 - 3]);
                                    v45 = v45 + 1;
                                else
                                    v29 = v29 .. ("\n%s...%s"):format(v12, v15);
                                    v31 = true;
                                end;
                            end;
                            v29 = v29 .. ("\n  %s"):format(v33[v52 - 2]);
                            v45 = v45 + 1;
                        end;
                        v29 = v29 .. ("\n  %s"):format(v33[v52 - 1]);
                        v45 = v45 + 1;
                    end;
                    v46 = 0;
                    v29 = v29 .. ("\n%s+%s %s"):format(v13, v15, v54);
                    v28 = v28 .. ("\n%s-%s %s"):format(v14, v15, v53);
                    v45 = v45 + 2;
                end;
            end;
            if v45 > 50 and v52 < v43 - 2 then
                return ("%s%s\n%s\n%s...%s%s\n"):format(v47, v48, v29, v12, v15, v28) .. ("%s...%s"):format(v12, v15);
            end;
        end;
        return ("%s%s\n%s%s%s%s"):format(v47, not v31 and "" or v48, v29, v28, v30, v36);
    end;
end;
local v57 = setmetatable({}, {
    __index = v5
});
v57.__index = v57;
v57.__tostring = function(v58)
    return v58:toString();
end;
v57.new = function(v59)
    local v60 = nil;
    local l_message_0 = v59.message;
    local l_operator_0 = v59.operator;
    local l_stackStartFn_0 = v59.stackStartFn;
    local l_actual_0 = v59.actual;
    local l_expected_0 = v59.expected;
    if l_message_0 ~= nil then
        v60 = setmetatable(v5.new((tostring(l_message_0))), v57);
    else
        if v9.stderr.isTTY then
            if not v9.stderr:hasColors() then
                v12 = "";
                v13 = "";
                v15 = "";
                v14 = "";
            else
                v12 = "\027[34m";
                v13 = "\027[32m";
                v15 = "\027[39m";
                v14 = "\027[31m";
            end;
        end;
        if not (not (not (not ((((typeof(l_actual_0) == "table" and l_actual_0 ~= nil) and typeof(l_expected_0) == "table") and l_expected_0 ~= nil) and v1.indexOf(v3.keys(l_actual_0), "stack") ~= -1) or not v6(l_actual_0, v5)) and v1.indexOf(v3.keys(l_expected_0), "stack") ~= -1) or not v6(l_expected_0, v5)) then
            local l_l_actual_0_0 = l_actual_0;
            local v67 = v3.keys(l_l_actual_0_0);
            local v68 = {};
            for _, v70 in v67, nil, nil do
                v68[v70] = l_l_actual_0_0[v70];
            end;
            v68.message = l_l_actual_0_0.message;
            l_actual_0 = v68;
            l_l_actual_0_0 = l_expected_0;
            v67 = v3.keys(l_l_actual_0_0);
            v68 = {};
            for _, v72 in v67, nil, nil do
                v68[v72] = l_l_actual_0_0[v72];
            end;
            v68.message = l_l_actual_0_0.message;
            l_expected_0 = v68;
        end;
        if not (l_operator_0 ~= "deepStrictEqual") or l_operator_0 == "strictEqual" then
            v60 = setmetatable(v5.new(v56(l_actual_0, l_expected_0, l_operator_0)), v57);
        elseif not (l_operator_0 ~= "notDeepStrictEqual") or l_operator_0 == "notStrictEqual" then
            local v73 = v16[l_operator_0];
            local v74 = v4.split(v7(l_actual_0, {
                compact = false,
                customInspect = false,
                depth = 1000,
                maxArrayLength = math.huge,
                showHidden = false,
                showProxy = false,
                sorted = true,
                getters = true
            }), "\n");
            if l_operator_0 == "notStrictEqual" and (not (not (typeof(l_actual_0) == "table") or l_actual_0 == nil) or typeof(l_actual_0) == "function") then
                v73 = v16.notStrictEqualObject;
            end;
            if #v74 > 50 then
                v74[47] = ("%s...%s"):format(v12, v15);
                while #v74 > 47 do
                    table.remove(v74);
                end;
            end;
            v60 = if #v74 == 1 then setmetatable(v5.new(("%s%s%s"):format(v73, string.len(v74[1]) > 5 and "\n\n" or " ", v74[1])), v57) else setmetatable(v5.new(("%s\n\n%s\n"):format(v73, v1.join(v74, "\n"))), v57);
        else
            local v75 = v7(l_actual_0, {
                compact = false,
                customInspect = false,
                depth = 1000,
                maxArrayLength = math.huge,
                showHidden = false,
                showProxy = false,
                sorted = true,
                getters = true
            });
            local v76 = v7(l_expected_0, {
                compact = false,
                customInspect = false,
                depth = 1000,
                maxArrayLength = math.huge,
                showHidden = false,
                showProxy = false,
                sorted = true,
                getters = true
            });
            local v77 = v16[tostring(l_operator_0)];
            if l_operator_0 == "notDeepEqual" and v75 == v76 then
                v75 = ("%s\n\n%s"):format(v77, v75);
                if string.len(v75) > 1024 then
                    v75 = ("%s..."):format(v4.slice(v75, 0, 1021));
                end;
                v60 = setmetatable(v5.new(v75), v57);
            else
                if string.len(v75) > 512 then
                    v75 = ("%s..."):format(v4.slice(v75, 0, 509));
                end;
                if string.len(v76) > 512 then
                    v76 = ("%s..."):format(v4.slice(v76, 0, 509));
                end;
                if l_operator_0 == "deepEqual" then
                    v75 = ("%s\n\n%s\n\nshould loosely deep-equal\n\n"):format(v77, v75);
                else
                    local v78 = v16[("%sUnequal"):format((tostring(l_operator_0)))];
                    if not v2.toJSBoolean(v78) then
                        v76 = (" %s %s"):format(tostring(l_operator_0), v76);
                    else
                        v75 = ("%s\n\n%s\n\nshould not loosely deep-equal\n\n"):format(v78, v75);
                    end;
                end;
                v60 = setmetatable(v5.new(("%s%s"):format(v75, v76)), v57);
            end;
        end;
    end;
    v60.generatedMessage = not v2.toJSBoolean(l_message_0);
    v60.name = "AssertionError [ERR_ASSERTION]";
    v60.code = "ERR_ASSERTION";
    v60.actual = l_actual_0;
    v60.expected = l_expected_0;
    v60.operator = l_operator_0;
    ErrorCaptureStackTrace(v60, l_stackStartFn_0);
    v60.name = "AssertionError";
    return v60;
end;
v57.toString = function(v79)
    return ("%s [%s]: %s"):format(v79.name, v79.code, v79.message);
end;
v57.name = "AssertionError";
return {
    AssertionError = v57
};


local l_Parent_0 = script.Parent.Parent;
local v1 = require(script.Parent);
local v2 = require(l_Parent_0.Object);
local v3 = require(l_Parent_0.instanceof);
local _ = require(l_Parent_0.types);
return function(v5)
    return not not v3(v5, v1) and v5 or v1.new(v2.entries(v5));
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(script.Parent);
local v2 = require(l_Parent_0.instanceof);
local v3 = require(l_Parent_0.Array.reduce);
local _ = require(l_Parent_0.types);
return function(v5)
    if v2(v5, v1) then
        return v3(v5:entries(), function(v6, v7)
            v6[v7[1]] = v7[2];
            return v6;
        end, {});
    else
        return v5;
    end;
end;


local l_Parent_0 = script.Parent;
local v1 = require(l_Parent_0.Array.forEach);
local v2 = require(l_Parent_0.Array.map);
local _ = require(l_Parent_0.types);
local v4 = {};
v4.new = function(v5)
    local v6 = nil;
    local v7 = {};
    if v5 ~= nil then
        if _G.__DEV__ then
            local v8 = typeof(v5);
            if v8 == "table" then
                if #v5 > 0 and typeof(v5[1]) ~= "table" then
                    error("cannot create Map from {K, V} form, it must be { {K, V}... }");
                end;
            else
                error(("cannot create array from value of type `%s`"):format(v8));
            end;
        end;
        local v9 = table.clone(v5);
        v6 = table.create(#v9);
        for _, v11 in v9, nil, nil do
            local v12 = v11[1];
            if _G.__DEV__ and v12 == nil then
                error("cannot create Map from a table that isn't an array.");
            end;
            local v13 = v11[2];
            if v7[v12] == nil then
                table.insert(v6, v12);
            end;
            v7[v12] = v13;
        end;
    else
        v6 = {};
    end;
    return (setmetatable({
        size = #v6,
        _map = v7,
        _array = v6
    }, v4));
end;
v4.set = function(v14, v15, v16)
    if v14._map[v15] == nil then
        v14.size = v14.size + 1;
        table.insert(v14._array, v15);
    end;
    v14._map[v15] = v16;
    return v14;
end;
v4.get = function(v17, v18)
    return v17._map[v18];
end;
v4.clear = function(v19)
    local l_table_0 = table;
    v19.size = 0;
    l_table_0.clear(v19._map);
    l_table_0.clear(v19._array);
end;
v4.delete = function(v21, v22)
    if v21._map[v22] == nil then
        return false;
    else
        v21.size = v21.size - 1;
        v21._map[v22] = nil;
        local v23 = table.find(v21._array, v22);
        if v23 then
            table.remove(v21._array, v23);
        end;
        return true;
    end;
end;
v4.forEach = function(v24, v25, v26)
    if _G.__DEV__ and typeof(v25) ~= "function" then
        error("callback is not a function");
    end;
    v1(v24._array, function(v27)
        local v28 = v24._map[v27];
        if v26 ~= nil then
            v25(v26, v28, v27, v24);
            return ;
        else
            v25(v28, v27, v24);
            return ;
        end;
    end);
end;
v4.has = function(v29, v30)
    return v29._map[v30] ~= nil;
end;
v4.keys = function(v31)
    return v31._array;
end;
v4.values = function(v32)
    return v2(v32._array, function(v33)
        return v32._map[v33];
    end);
end;
v4.entries = function(v34)
    return v2(v34._array, function(v35)
        return {
            v35,
            v34._map[v35]
        };
    end);
end;
v4.ipairs = function(v36)
    if _G.__DEV__ then
        warn(debug.traceback("`for _,_ in myMap:ipairs() do` is deprecated and will be removed in a future release, please use `for _,_ in myMap do` instead\n", 2));
    end;
    return ipairs(v36:entries());
end;
v4.__iter = function(v37)
    return next, v37:entries();
end;
v4.__index = function(v38, v39)
    local v40 = rawget(v4, v39);
    if v40 ~= nil then
        return v40;
    else
        return v4.get(v38, v39);
    end;
end;
v4.__newindex = function(v41, v42, v43)
    v41:set(v42, v43);
end;
return v4;


local v0 = require(script.Parent.None);
local _ = require(script.Parent.Parent.types);
return function(v2, v3, v4, v5, ...)
    if v3 ~= nil and typeof(v3) == "table" then
        for v6, v7 in pairs(v3) do
            if v7 == v0 then
                v2[v6] = nil;
            else
                v2[v6] = v7;
            end;
        end;
    end;
    if v4 ~= nil and typeof(v4) == "table" then
        for v8, v9 in pairs(v4) do
            if v9 == v0 then
                v2[v8] = nil;
            else
                v2[v8] = v9;
            end;
        end;
    end;
    if v5 ~= nil and typeof(v5) == "table" then
        for v10, v11 in pairs(v5) do
            if v11 == v0 then
                v2[v10] = nil;
            else
                v2[v10] = v11;
            end;
        end;
    end;
    for v12 = 1, select("#", ...) do
        local v13 = select(v12, ...);
        if v13 ~= nil and typeof(v13) == "table" then
            for v14, v15 in pairs(v13) do
                if v15 == v0 then
                    v2[v14] = nil;
                else
                    v2[v14] = v15;
                end;
            end;
        end;
    end;
    return v2;
end;


local _ = require(script.Parent.Parent.types);
return function(v1)
    assert(v1 ~= nil, "cannot get entries from a nil value");
    local v2 = typeof(v1);
    local v3 = {};
    if v2 == "table" then
        for v4, v5 in pairs(v1) do
            table.insert(v3, {
                v4,
                v5
            });
        end;
        return v3;
    else
        if v2 == "string" then
            for v6 = 1, string.len(v1) do
                v3[v6] = {
                    tostring(v6),
                    (string.sub(v1, v6, v6))
                };
            end;
        end;
        return v3;
    end;
end;


local _ = require(script.Parent.Parent.types);
return function(v1)
    return (table.freeze(v1));
end;


local _ = require(script.Parent.Parent.types);
return function(v1)
    return table.isfrozen(v1);
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Set);
local v2 = require(l_Parent_0.instanceof);
local _ = require(l_Parent_0.types);
return function(v4)
    if v4 == nil then
        error("cannot extract keys from a nil value");
    end;
    local v5 = typeof(v4);
    local v6 = nil;
    if v5 == "table" then
        v6 = {};
        if not v2(v4, v1) then
            for v7 in pairs(v4) do
                table.insert(v6, v7);
            end;
            return v6;
        else
            return v6;
        end;
    else
        if v5 == "string" then
            local v8 = v4:len();
            v6 = table.create(v8);
            for v9 = 1, v8 do
                v6[v9] = tostring(v9);
            end;
        end;
        return v6;
    end;
end;


local _ = require(script.Parent.Parent.types);
return function(v1)
    local v2 = tostring(v1);
    return (setmetatable(v1, {
        __newindex = function(_, v4, _)
            error(("%q (%s) is not a valid member of %s"):format(tostring(v4), typeof(v4), v2), 2);
        end,
        __metatable = false
    }));
end;


local _ = require(script.Parent.Parent.types);
return function(v1)
    if v1 == nil then
        error("cannot extract values from a nil value");
    end;
    local v2 = typeof(v1);
    local v3 = nil;
    if v2 == "table" then
        v3 = {};
        for _, v5 in pairs(v1) do
            table.insert(v3, v5);
        end;
        return v3;
    else
        if v2 == "string" then
            local v6 = v1:len();
            v3 = table.create(v6);
            for v7 = 1, v6 do
                v3[v7] = v1:sub(v7, v7);
            end;
        end;
        return v3;
    end;
end;


local l_Parent_0 = script.Parent;
local v1 = require(l_Parent_0.Array.isArray);
local v2 = require(l_Parent_0.Array.from.fromString);
local v3 = require(l_Parent_0.Array.forEach);
local _ = require(l_Parent_0.types);
local v5 = require(l_Parent_0.util.inspect);
local v9 = {
    __iter = function(v6)
        return next, v6._array;
    end,
    __tostring = function(v7)
        local v8 = "Set ";
        if #v7._array > 0 then
            v8 = v8 .. "(" .. tostring(#v7._array) .. ") ";
        end;
        return v8 .. v5(v7._array);
    end
};
v9.__index = v9;
v9.new = function(v10)
    local v11 = nil;
    local v12 = {};
    if v10 ~= nil then
        local v13 = nil;
        if typeof(v10) == "table" then
            if not v1(v10) then
                local v14 = getmetatable(v10);
                if not v14 or not rawget(v14, "__iter") then
                    if _G.__DEV__ then
                        error("cannot create array from an object-like table");
                    end;
                else
                    v13 = v10;
                end;
            else
                v13 = table.clone(v10);
            end;
        elseif typeof(v10) == "string" then
            v13 = v2(v10);
        else
            error(("cannot create array from value of type `%s`"):format((typeof(v10))));
        end;
        if not v13 then
            v11 = {};
        else
            v11 = table.create(#v13);
            for _, v16 in v13, nil, nil do
                if not v12[v16] then
                    v12[v16] = true;
                    table.insert(v11, v16);
                end;
            end;
        end;
    else
        v11 = {};
    end;
    return (setmetatable({
        size = #v11,
        _map = v12,
        _array = v11
    }, v9));
end;
v9.add = function(v17, v18)
    if not v17._map[v18] then
        v17.size = v17.size + 1;
        v17._map[v18] = true;
        table.insert(v17._array, v18);
    end;
    return v17;
end;
v9.clear = function(v19)
    v19.size = 0;
    table.clear(v19._map);
    table.clear(v19._array);
end;
v9.delete = function(v20, v21)
    if v20._map[v21] then
        v20.size = v20.size - 1;
        v20._map[v21] = nil;
        local v22 = table.find(v20._array, v21);
        if v22 then
            table.remove(v20._array, v22);
        end;
        return true;
    else
        return false;
    end;
end;
v9.forEach = function(v23, v24, v25)
    if typeof(v24) ~= "function" then
        error("callback is not a function");
    end;
    v3(v23._array, function(v26)
        if v25 ~= nil then
            v24(v25, v26, v26, v23);
            return ;
        else
            v24(v26, v26, v23);
            return ;
        end;
    end);
end;
v9.has = function(v27, v28)
    return v27._map[v28] ~= nil;
end;
v9.ipairs = function(v29)
    if _G.__DEV__ then
        warn(debug.traceback("`for _,_ in mySet:ipairs() do` is deprecated and will be removed in a future release, please use `for _,_ in mySet do` instead\n", 2));
    end;
    return ipairs(v29._array);
end;
return v9;


local v0 = "([" .. ("$%^()-[].?"):gsub("(.)", "%%%1") .. "])";
return function(v1, v2, v3)
    local v4 = utf8.offset(v1, v3 or 1);
    local v5 = {};
    for _, v7 in v2, nil, nil do
        local v8, v9 = string.find(v1, v7:gsub(v0, "%%%1"), v4);
        if v8 then
            local v10 = string.sub(v1, 1, v8 - 1);
            local v11, v12 = utf8.len(v10);
            if v11 == nil then
                error(("string `%s` has an invalid byte at position %s"):format(v10, (tostring(v12))));
            end;
            table.insert(v5, {
                index = v11 + 1,
                match = string.sub(v1, v8, v9)
            });
        end;
    end;
    if #v5 == 0 then
        return nil;
    else
        local v13 = nil;
        for _, v15 in v5, nil, nil do
            if v13 == nil then
                v13 = v15;
            end;
            if v15.index < v13.index then
                v13 = v15;
            end;
        end;
        return v13;
    end;
end;


local v0 = "([" .. ("$%^()-[].?"):gsub("(.)", "%%%1") .. "])";
return function(v1, v2, v3)
    local v4, v5 = utf8.len(v1);
    assert(v4 ~= nil, ("string `%s` has an invalid byte at position %s"):format(v1, (tostring(v5))));
    if v4 == 0 then
        return false;
    elseif #v2 == 0 then
        return true;
    else
        local v6 = 1;
        if v3 ~= nil then
            v6 = tonumber(v3) or 1;
            if v4 < v6 then
                return false;
            end;
        end;
        if v6 < 1 then
            v6 = 1;
        end;
        local v7, _ = string.find(v1, v2:gsub(v0, "%%%1"), (utf8.offset(v1, v6)));
        return v7 ~= nil;
    end;
end;


return {
    charCodeAt = require(script.charCodeAt),
    endsWith = require(script.endsWith),
    findOr = require(script.findOr),
    includes = require(script.includes),
    lastIndexOf = require(script.lastIndexOf),
    slice = require(script.slice),
    split = require(script.split),
    startsWith = require(script.startsWith),
    substr = require(script.substr),
    trim = require(script.trim),
    trimEnd = require(script.trimEnd),
    trimStart = require(script.trimStart),
    trimRight = require(script.trimEnd),
    trimLeft = require(script.trimStart)
};


local v0 = require(script.Parent.findOr);
local v1 = require(script.Parent.slice);
local l_Parent_0 = script.Parent.Parent;
local _ = require(l_Parent_0.types);
local l_MAX_SAFE_INTEGER_0 = require(l_Parent_0.Number).MAX_SAFE_INTEGER;
return function(v5, v6, v7)
    if v6 == nil then
        return {
            v5
        };
    elseif v7 == 0 then
        return {};
    else
        local v8 = if not (v7 ~= nil) or v7 < 0 then l_MAX_SAFE_INTEGER_0 else v7;
        local v9 = nil;
        if typeof(v6) == "string" then
            if v6 == "" then
                local v10 = {};
                for v11 in v5:gmatch(".") do
                    table.insert(v10, v11);
                end;
                return v10;
            else
                v9 = {
                    v6
                };
            end;
        else
            v9 = v6;
        end;
        local v12 = 1;
        local v13 = {};
        local v14 = nil;
        local v15, v16 = utf8.len(v5);
        assert(v15 ~= nil, ("string `%s` has an invalid byte at position %s"):format(v5, (tostring(v16))));
        while true do
            local v17 = v0(v5, v9, v12);
            if v17 ~= nil then
                table.insert(v13, v1(v5, v12, v17.index));
                v12 = v17.index + utf8.len(v17.match);
            else
                table.insert(v13, v1(v5, v12, nil));
            end;
            if v17 ~= nil then
                v14 = v17;
            end;
            if not ((v17 ~= nil and v15 >= v12) and v8 > #v13) then
                break;
            end;
        end;
        if v14 ~= nil then
            local v18, v19 = utf8.len(v14.match);
            assert(v18 ~= nil, ("string `%s` has an invalid byte at position %s"):format(v14.match, (tostring(v19))));
            if v14.index + v18 == v15 + 1 then
                table.insert(v13, "");
            end;
        end;
        return v13;
    end;
end;


local v0 = newproxy(false);
return function(v1)
    return {
        setInterval = function(v2, v3, ...)
            local v4 = {
                ...
            };
            local v5 = {
                [v0] = 1
            };
            if v3 == nil then
                v3 = 0;
            end;
            local v6 = v3 / 1000;
            local v7 = nil;
            v7 = function()
                v1(v6, function()
                    if v5[v0] == 1 then
                        v2(unpack(v4));
                        v7();
                    end;
                end);
            end;
            v7();
            return v5;
        end,
        clearInterval = function(v8)
            if v8 == nil then
                return ;
            else
                if v8[v0] == 1 then
                    v8[v0] = 3;
                end;
                return ;
            end;
        end
    };
end;


local v0 = newproxy(false);
return function(v1)
    return {
        setTimeout = function(v2, v3, ...)
            local v4 = {
                ...
            };
            local v5 = {
                [v0] = 1
            };
            if v3 == nil then
                v3 = 0;
            end;
            v1(v3 / 1000, function()
                if v5[v0] == 1 then
                    v2(unpack(v4));
                    v5[v0] = 2;
                end;
            end);
            return v5;
        end,
        clearTimeout = function(v6)
            if v6 == nil then
                return ;
            else
                if v6[v0] == 1 then
                    v6[v0] = 3;
                end;
                return ;
            end;
        end
    };
end;


local v0 = require(script.Array);
local v1 = require(script.AssertionError);
local v2 = require(script.Error);
local v3 = require(script.Object);
local _ = require(script.Promise);
local v5 = require(script.Set);
local v6 = require(script.Symbol);
local v7 = require(script.Timers);
local v8 = require(script.WeakMap);
local v9 = require(script.Map);
local v10 = require(script.Map.coerceToMap);
local v11 = require(script.Map.coerceToTable);
local _ = require(script.types);
return {
    Array = v0,
    AssertionError = v1,
    Boolean = require(script.Boolean),
    console = require(script.console),
    Error = v2,
    extends = require(script.extends),
    instanceof = require(script.instanceof),
    Math = require(script.Math),
    Number = require(script.Number),
    Object = v3,
    Map = v9,
    coerceToMap = v10,
    coerceToTable = v11,
    Set = v5,
    WeakMap = v8,
    String = require(script.String),
    Symbol = v6,
    setTimeout = v7.setTimeout,
    clearTimeout = v7.clearTimeout,
    setInterval = v7.setInterval,
    clearInterval = v7.clearInterval,
    util = require(script.util)
};


return function(v0, v1)
    if _G.__DEV__ then
        assert(typeof(v1) == "table", "Received a non-table as the second argument for instanceof");
    end;
    if typeof(v0) ~= "table" then
        return false;
    else
        local l_status_0, l_result_0 = pcall(function()
            local v2 = false;
            if v1.new ~= nil then
                v2 = v0.new == v1.new;
            end;
            return v2;
        end);
        if not l_status_0 or not l_result_0 then
            local v5 = {
                tbl = true
            };
            while true do
                if v0 and typeof(v0) == "table" then
                    v0 = getmetatable(v0);
                    if typeof(v0) == "table" then
                        v0 = v0.__index;
                        if v0 == v1 then
                            return true;
                        end;
                    end;
                    if typeof(v0) == "table" then
                        if not v5[v0] then
                            v5[v0] = true;
                        else
                            return false;
                        end;
                    end;
                else
                    return false;
                end;
            end;
        else
            return true;
        end;
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local _ = require(l_Parent_0.types);
local l_HttpService_0 = game:GetService("HttpService");
local v3 = require(l_Parent_0.Array.isArray);
local v4 = nil;
local v5 = nil;
local v6 = nil;
local v7 = nil;
local v8 = nil;
local function v13(v9, v10)
    local v11 = v10 or {
        depth = 2
    };
    local v12 = v11.depth or 2;
    v11.depth = if v12 >= 0 then v12 else 2;
    return v4(v9, {}, v11);
end;
local function _(v14, v15)
    local v16 = false;
    if type(v14) == "number" then
        v16 = false;
        if v14 <= v15 then
            v16 = false;
            if v14 >= 1 then
                v16 = math.floor(v14) == v14;
            end;
        end;
    end;
    return v16;
end;
local function _(v18)
    local v19 = 1;
    local v20 = rawget(v18, v19);
    while v20 ~= nil do
        v19 = v19 + 1;
        v20 = rawget(v18, v19);
    end;
    return v19 - 1;
end;
local function v26(v22, v23)
    local v24 = type(v22);
    local v25 = type(v23);
    if v24 == v25 and (not (v24 ~= "number") or v24 == "string") then
        return v22 < v23;
    else
        return v24 < v25;
    end;
end;
local function _(v27)
    return next, v27, nil;
end;
local function v38(v29)
    local v30 = {};
    local v31 = 0;
    local v32 = 1;
    local v33 = rawget(v29, v32);
    while v33 ~= nil do
        v32 = v32 + 1;
        v33 = rawget(v29, v32);
    end;
    local v34 = v32 - 1;
    for v35, _ in next, v29, nil do
        local v37 = false;
        if type(v35) == "number" then
            v37 = false;
            if v35 <= v34 then
                v37 = false;
                if v35 >= 1 then
                    v37 = math.floor(v35) == v35;
                end;
            end;
        end;
        if not v37 then
            v31 = v31 + 1;
            v30[v31] = v35;
        end;
    end;
    table.sort(v30, v26);
    return v30, v31, v34;
end;
v4 = function(v39, v40, v41)
    local v42 = typeof(v39);
    if v42 == "string" then
        return l_HttpService_0:JSONEncode(v39);
    elseif v42 == "number" then
        if v39 ~= v39 then
            return "NaN";
        elseif v39 == math.huge then
            return "Infinity";
        elseif v39 == -math.huge then
            return "-Infinity";
        else
            return (tostring(v39));
        end;
    elseif v42 == "function" then
        local v43 = "[function";
        local v44 = debug.info(v39, "n");
        if v44 ~= nil and v44 ~= "" then
            v43 = v43 .. " " .. v44;
        end;
        return v43 .. "]";
    elseif v42 == "table" then
        return v5(v39, v40, v41);
    else
        return (tostring(v39));
    end;
end;
v5 = function(v45, v46, v47)
    if table.find(v46, v45) ~= nil then
        return "[Circular]";
    else
        local v48 = {
            unpack(v46)
        };
        table.insert(v48, v45);
        if typeof(v45.toJSON) == "function" then
            local v49 = v45:toJSON(v45);
            if v49 ~= v45 then
                if typeof(v49) == "string" then
                    return v49;
                else
                    return v4(v49, v48, v47);
                end;
            end;
        elseif v3(v45) then
            return v6(v45, v48, v47);
        end;
        return v7(v45, v48, v47);
    end;
end;
v7 = function(v50, v51, v52)
    local v53 = "";
    local v54 = getmetatable(v50);
    if not v54 or not rawget(v54, "__tostring") then
        local v55, v56, v57 = v38(v50);
        if v57 == 0 and v56 == 0 then
            return v53 .. "{}";
        elseif v52.depth < #v51 then
            return v53 .. "[" .. v8(v50) .. "]";
        else
            local v58 = {};
            for v59 = 1, v57 do
                table.insert(v58, (v4(v50[v59], v51, v52)));
            end;
            for v60 = 1, v56 do
                local v61 = v55[v60];
                table.insert(v58, v61 .. ": " .. v4(v50[v61], v51, v52));
            end;
            return v53 .. "{ " .. table.concat(v58, ", ") .. " }";
        end;
    else
        return (tostring(v50));
    end;
end;
v6 = function(v62, v63, v64)
    local v65 = #v62;
    if v65 == 0 then
        return "[]";
    elseif v64.depth < #v63 then
        return "[Array]";
    else
        local v66 = math.min(10, v65);
        local v67 = v65 - v66;
        local v68 = {};
        for v69 = 1, v66 do
            v68[v69] = v4(v62[v69], v63, v64);
        end;
        if v67 == 1 then
            table.insert(v68, "... 1 more item");
        elseif v67 > 1 then
            table.insert(v68, ("... %s more items"):format((tostring(v67))));
        end;
        return "[" .. table.concat(v68, ", ") .. "]";
    end;
end;
v8 = function(_)
    return "Object";
end;
return v13;