local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_getType_0 = require(l_Parent_1.JestGetType).getType;
local v3 = require(l_Parent_1.LuauPolyfill);
local l_instanceof_0 = v3.instanceof;
local l_Error_0 = v3.Error;
local _ = require(l_Parent_1.RegExp);
local v7 = require(l_Parent_1.JestMatcherUtils);
local l_EXPECTED_COLOR_0 = v7.EXPECTED_COLOR;
local l_RECEIVED_COLOR_0 = v7.RECEIVED_COLOR;
local l_matcherErrorMessage_0 = v7.matcherErrorMessage;
local l_matcherHint_0 = v7.matcherHint;
local l_printDiffOrStringify_0 = v7.printDiffOrStringify;
local l_printExpected_0 = v7.printExpected;
local l_printReceived_0 = v7.printReceived;
local l_printWithType_0 = v7.printWithType;
local l_stringify_0 = v7.stringify;
local l_formatStackTrace_0 = require(l_Parent_1.JestMessageUtil).formatStackTrace;
local v18 = require(l_Parent_0.print);
local l_printExpectedConstructorName_0 = v18.printExpectedConstructorName;
local l_printExpectedConstructorNameNot_0 = v18.printExpectedConstructorNameNot;
local l_printReceivedConstructorName_0 = v18.printReceivedConstructorName;
local l_printReceivedConstructorNameNot_0 = v18.printReceivedConstructorNameNot;
local l_printReceivedStringContainExpectedResult_0 = v18.printReceivedStringContainExpectedResult;
local l_printReceivedStringContainExpectedSubstring_0 = v18.printReceivedStringContainExpectedSubstring;
local _ = require(l_Parent_0.types);
local l_isError_0 = require(l_Parent_0.utils).isError;
local v27 = nil;
local v28 = nil;
local v29 = nil;
local v30 = nil;
local v31 = nil;
local v32 = nil;
local v33 = nil;
local v34 = nil;
local v35 = nil;
local function v38(v36)
    local v37 = false;
    if v36 ~= nil then
        v37 = true;
        if typeof(v36.message) ~= "string" then
            v37 = typeof(v36.message) == "table";
        end;
    end;
    if (v37 and typeof(v36.name) == "string") and typeof(v36.stack) == "string" then
        return {
            hasMessage = v37,
            isError = true,
            message = v36.message,
            value = v36
        };
    elseif not v37 then
        return {
            hasMessage = v37,
            isError = false,
            message = tostring(v36),
            value = v36
        };
    else
        return {
            hasMessage = v37,
            isError = false,
            message = v36.message,
            value = v36
        };
    end;
end;
local function v67(v39, v40)
    return function(v41, v42, v43)
        local v44 = {
            isNot = v41.isNot,
            promise = v41.promise
        };
        local v45 = nil;
        if not v40 or not l_isError_0(v42) then
            if not (typeof(v42) ~= "function") or not (not (typeof(v42) == "table") or not getmetatable(v42)) and getmetatable(v42).__call then
                local function _(v46)
                    return string.match(v46, "[^\n]+");
                end;
                local function v54(v48, v49)
                    local v50 = "";
                    local v51 = "";
                    local v52 = string.match(v48, "[^\n]+");
                    for v53 in string.gmatch(v49, "[^\n]+") do
                        if v53 == v52 then
                            return v51;
                        else
                            v51 = v50;
                            v50 = v50 .. "\n" .. v53;
                        end;
                    end;
                    return nil;
                end;
                local v55 = nil;
                do
                    local l_v55_0 = v55;
                    local v64, v65 = xpcall(function()
                        l_v55_0 = debug.traceback(nil, 2);
                        v42();
                    end, function(v57)
                        if v57 == nil then
                            v57 = "nil";
                        elseif l_getType_0(v57) ~= "error" and (not (typeof(v57) == "table") or not v57.message) then
                            if typeof(v57) == "string" then
                                local _, _, v60 = v57:find("[%S+\\.]+:[0-9]+:%s(.*)");
                                if v60 ~= nil then
                                    v57 = v60;
                                end;
                            elseif typeof(v57) == "table" then
                                v57 = l_stringify_0(v57);
                            end;
                        elseif v57.stack == nil then
                            v57.stack = v54(l_v55_0, debug.traceback());
                            return v57;
                        else
                            if not v57.stack:find("ThrowMatchers%-test%.js") then
                                v57.stack = v54(l_v55_0, v57.stack);
                            end;
                            return v57;
                        end;
                        local v61 = l_Error_0(v57);
                        local _, v63 = string.find(v61.stack, string.match(v61.stack, "[^\n]+"), 1, true);
                        v61.stack = string.sub(v61.stack, (v63 + 1) + 1);
                        v61.stack = v54(l_v55_0, v61.stack);
                        v61["$$robloxInternalJestError"] = true;
                        return v61;
                    end);
                    if not v64 then
                        v45 = v38(v65);
                    end;
                end;
            elseif not v40 then
                local _ = nil;
                error(l_Error_0(l_matcherErrorMessage_0(l_matcherHint_0(v39, nil, v43 == nil and "" or "expected", v44), l_RECEIVED_COLOR_0("received") .. " value must be a function", l_printWithType_0("Received", v42, l_printReceived_0))));
            end;
        else
            v45 = v38(v42);
        end;
        if v43 == nil then
            return v32(v39, v44, v45);
        elseif typeof(v43) == "table" and typeof(v43.asymmetricMatch) == "function" then
            return v28(v39, v44, v45, v43);
        elseif typeof(v43) == "string" then
            return v31(v39, v44, v45, v43);
        elseif l_getType_0(v43) == "regexp" then
            return v27(v39, v44, v45, v43);
        elseif not (typeof(v43) == "table") or v43.message then
            if typeof(v43) == "table" then
                return v29(v39, v44, v45, v43);
            else
                error(l_Error_0(l_matcherErrorMessage_0(l_matcherHint_0(v39, nil, nil, v44), l_EXPECTED_COLOR_0("expected") .. " value must be a string or regular expression or class or error", l_printWithType_0("Expected", v43, l_printExpected_0))));
                return ;
            end;
        else
            return v30(v39, v44, v45, v43);
        end;
    end;
end;
local v68 = {};
local v69 = nil;
local v70 = "toThrow";
local l_v69_0 = v69 --[[ copy: 41 -> 43 ]];
local l_v70_0 = v70 --[[ copy: 42 -> 44 ]];
v68.toThrow = function(v73, v74, v75)
    local v76 = {
        isNot = v73.isNot,
        promise = v73.promise
    };
    local v77 = nil;
    if not l_v69_0 or not l_isError_0(v74) then
        if not (typeof(v74) ~= "function") or not (not (typeof(v74) == "table") or not getmetatable(v74)) and getmetatable(v74).__call then
            local function _(v78)
                return string.match(v78, "[^\n]+");
            end;
            local function v86(v80, v81)
                local v82 = "";
                local v83 = "";
                local v84 = string.match(v80, "[^\n]+");
                for v85 in string.gmatch(v81, "[^\n]+") do
                    if v85 == v84 then
                        return v83;
                    else
                        v83 = v82;
                        v82 = v82 .. "\n" .. v85;
                    end;
                end;
                return nil;
            end;
            local v87 = nil;
            do
                local l_v87_0 = v87;
                local v96, v97 = xpcall(function()
                    l_v87_0 = debug.traceback(nil, 2);
                    v74();
                end, function(v89)
                    if v89 == nil then
                        v89 = "nil";
                    elseif l_getType_0(v89) ~= "error" and (not (typeof(v89) == "table") or not v89.message) then
                        if typeof(v89) == "string" then
                            local _, _, v92 = v89:find("[%S+\\.]+:[0-9]+:%s(.*)");
                            if v92 ~= nil then
                                v89 = v92;
                            end;
                        elseif typeof(v89) == "table" then
                            v89 = l_stringify_0(v89);
                        end;
                    elseif v89.stack == nil then
                        v89.stack = v86(l_v87_0, debug.traceback());
                        return v89;
                    else
                        if not v89.stack:find("ThrowMatchers%-test%.js") then
                            v89.stack = v86(l_v87_0, v89.stack);
                        end;
                        return v89;
                    end;
                    local v93 = l_Error_0(v89);
                    local _, v95 = string.find(v93.stack, string.match(v93.stack, "[^\n]+"), 1, true);
                    v93.stack = string.sub(v93.stack, (v95 + 1) + 1);
                    v93.stack = v86(l_v87_0, v93.stack);
                    v93["$$robloxInternalJestError"] = true;
                    return v93;
                end);
                if not v96 then
                    v77 = v38(v97);
                end;
            end;
        elseif not l_v69_0 then
            local _ = nil;
            error(l_Error_0(l_matcherErrorMessage_0(l_matcherHint_0(l_v70_0, nil, v75 == nil and "" or "expected", v76), l_RECEIVED_COLOR_0("received") .. " value must be a function", l_printWithType_0("Received", v74, l_printReceived_0))));
        end;
    else
        v77 = v38(v74);
    end;
    if v75 == nil then
        return v32(l_v70_0, v76, v77);
    elseif typeof(v75) == "table" and typeof(v75.asymmetricMatch) == "function" then
        return v28(l_v70_0, v76, v77, v75);
    elseif typeof(v75) == "string" then
        return v31(l_v70_0, v76, v77, v75);
    elseif l_getType_0(v75) == "regexp" then
        return v27(l_v70_0, v76, v77, v75);
    elseif not (typeof(v75) == "table") or v75.message then
        if typeof(v75) == "table" then
            return v29(l_v70_0, v76, v77, v75);
        else
            error(l_Error_0(l_matcherErrorMessage_0(l_matcherHint_0(l_v70_0, nil, nil, v76), l_EXPECTED_COLOR_0("expected") .. " value must be a string or regular expression or class or error", l_printWithType_0("Expected", v75, l_printExpected_0))));
            return ;
        end;
    else
        return v30(l_v70_0, v76, v77, v75);
    end;
end;
v69 = nil;
v70 = "toThrowError";
v68.toThrowError = function(v99, v100, v101)
    local v102 = {
        isNot = v99.isNot,
        promise = v99.promise
    };
    local v103 = nil;
    if not v69 or not l_isError_0(v100) then
        if not (typeof(v100) ~= "function") or not (not (typeof(v100) == "table") or not getmetatable(v100)) and getmetatable(v100).__call then
            local function _(v104)
                return string.match(v104, "[^\n]+");
            end;
            local function v112(v106, v107)
                local v108 = "";
                local v109 = "";
                local v110 = string.match(v106, "[^\n]+");
                for v111 in string.gmatch(v107, "[^\n]+") do
                    if v111 == v110 then
                        return v109;
                    else
                        v109 = v108;
                        v108 = v108 .. "\n" .. v111;
                    end;
                end;
                return nil;
            end;
            local v113 = nil;
            do
                local l_v113_0 = v113;
                local v122, v123 = xpcall(function()
                    l_v113_0 = debug.traceback(nil, 2);
                    v100();
                end, function(v115)
                    if v115 == nil then
                        v115 = "nil";
                    elseif l_getType_0(v115) ~= "error" and (not (typeof(v115) == "table") or not v115.message) then
                        if typeof(v115) == "string" then
                            local _, _, v118 = v115:find("[%S+\\.]+:[0-9]+:%s(.*)");
                            if v118 ~= nil then
                                v115 = v118;
                            end;
                        elseif typeof(v115) == "table" then
                            v115 = l_stringify_0(v115);
                        end;
                    elseif v115.stack == nil then
                        v115.stack = v112(l_v113_0, debug.traceback());
                        return v115;
                    else
                        if not v115.stack:find("ThrowMatchers%-test%.js") then
                            v115.stack = v112(l_v113_0, v115.stack);
                        end;
                        return v115;
                    end;
                    local v119 = l_Error_0(v115);
                    local _, v121 = string.find(v119.stack, string.match(v119.stack, "[^\n]+"), 1, true);
                    v119.stack = string.sub(v119.stack, (v121 + 1) + 1);
                    v119.stack = v112(l_v113_0, v119.stack);
                    v119["$$robloxInternalJestError"] = true;
                    return v119;
                end);
                if not v122 then
                    v103 = v38(v123);
                end;
            end;
        elseif not v69 then
            local _ = nil;
            error(l_Error_0(l_matcherErrorMessage_0(l_matcherHint_0(v70, nil, v101 == nil and "" or "expected", v102), l_RECEIVED_COLOR_0("received") .. " value must be a function", l_printWithType_0("Received", v100, l_printReceived_0))));
        end;
    else
        v103 = v38(v100);
    end;
    if v101 == nil then
        return v32(v70, v102, v103);
    elseif typeof(v101) == "table" and typeof(v101.asymmetricMatch) == "function" then
        return v28(v70, v102, v103, v101);
    elseif typeof(v101) == "string" then
        return v31(v70, v102, v103, v101);
    elseif l_getType_0(v101) == "regexp" then
        return v27(v70, v102, v103, v101);
    elseif not (typeof(v101) == "table") or v101.message then
        if typeof(v101) == "table" then
            return v29(v70, v102, v103, v101);
        else
            error(l_Error_0(l_matcherErrorMessage_0(l_matcherHint_0(v70, nil, nil, v102), l_EXPECTED_COLOR_0("expected") .. " value must be a string or regular expression or class or error", l_printWithType_0("Expected", v101, l_printExpected_0))));
            return ;
        end;
    else
        return v30(v70, v102, v103, v101);
    end;
end;
v27 = function(v125, v126, v127, v128)
    local v129 = false;
    if v127 ~= nil then
        v129 = v128:test(v127.message);
    end;
    local _ = nil;
    return {
        message = not v129 and function()
            local v131 = l_matcherHint_0(v125, nil, nil, v126) .. "\n\n" .. v33("Expected pattern: ", v128);
            if v127 == nil then
                return v131 .. "\n" .. "Received function never threw";
            elseif not v127.hasMessage or v127.value["$$robloxInternalJestError"] then
                return v131 .. v34("Received value:   ", v127, "message") .. v35(v127);
            else
                return v131 .. v34("Received message: ", v127, "message") .. v35(v127);
            end;
        end or function()
            local v132 = l_matcherHint_0(v125, nil, nil, v126) .. "\n\n" .. v33("Expected pattern: never ", v128);
            if (not (v127 ~= nil) or not v127.hasMessage) or v127.value["$$robloxInternalJestError"] then
                return v132 .. v34("Received value:         ", v127, "message") .. v35(v127);
            else
                return v132 .. v34("Received message:       ", v127, "message", v128) .. v35(v127);
            end;
        end,
        pass = v129
    };
end;
v28 = function(v133, v134, v135, v136)
    local v137 = false;
    if v135 ~= nil then
        v137 = v136:asymmetricMatch(v135.value);
    end;
    local _ = nil;
    return {
        message = not v137 and function()
            local v139 = l_matcherHint_0(v133, nil, nil, v134) .. "\n\n" .. v33("Expected asymmetric matcher: ", v136) .. "\n";
            if v135 == nil then
                return v139 .. "Received function never threw";
            elseif not v135.hasMessage or v135.value["$$robloxInternalJestError"] then
                return v139 .. v34("Thrown value: ", v135, "message") .. v35(v135);
            else
                return v139 .. v34("Received name:    ", v135, "name") .. v34("Received message: ", v135, "message") .. v35(v135);
            end;
        end or function()
            local v140 = l_matcherHint_0(v133, nil, nil, v134) .. "\n\n" .. v33("Expected asymmetric matcher: never ", v136) .. "\n";
            if (not (v135 ~= nil) or not v135.hasMessage) or v135.value["$$robloxInternalJestError"] then
                return v140 .. v34("Thrown value: ", v135, "message") .. v35(v135);
            else
                return v140 .. v34("Received name:    ", v135, "name") .. v34("Received message: ", v135, "message") .. v35(v135);
            end;
        end,
        pass = v137
    };
end;
v29 = function(v141, v142, v143, v144)
    local v145 = false;
    if v143 ~= nil then
        v145 = v143.message == v144.message;
    end;
    local _ = nil;
    return {
        message = not v145 and function()
            local v147 = l_matcherHint_0(v141, nil, nil, v142) .. "\n\n";
            if v143 == nil then
                return v147 .. v33("Expected message: ", v144.message) .. "\n" .. "Received function never threw";
            elseif not v143.hasMessage or v143.value["$$robloxInternalJestError"] then
                return v147 .. v33("Expected message: ", v144.message) .. v34("Received value:   ", v143, "message") .. v35(v143);
            else
                return v147 .. l_printDiffOrStringify_0(v144.message, v143.message, "Expected message", "Received message", true) .. "\n" .. v35(v143);
            end;
        end or function()
            local v148 = l_matcherHint_0(v141, nil, nil, v142) .. "\n\n" .. v33("Expected message: never ", v144.message);
            if (not (v143 ~= nil) or not v143.hasMessage) or v143.value["$$robloxInternalJestError"] then
                return v148 .. v34("Received value:         ", v143, "message") .. v35(v143);
            else
                return v148 .. v35(v143);
            end;
        end,
        pass = v145
    };
end;
v30 = function(v149, v150, v151, v152)
    local function _(v153)
        return (v153 and getmetatable(v153)) and getmetatable(v153).__index;
    end;
    local v155 = false;
    if v151 ~= nil then
        v155 = false;
        if v151.value ~= nil then
            v155 = l_instanceof_0(v151.value, v152);
        end;
    end;
    local _ = nil;
    return {
        message = not v155 and function()
            local v157 = l_matcherHint_0(v149, nil, nil, v150) .. "\n\n" .. l_printExpectedConstructorName_0("Expected constructor", v152);
            if v151 == nil then
                return v157 .. "\n" .. "Received function never threw";
            else
                if v151.value ~= nil then
                    local l_value_0 = v151.value;
                    if not (not ((l_value_0 and getmetatable(l_value_0)) and getmetatable(l_value_0).__index) or v151.value["$$robloxInternalJestError"]) then
                        v157 = v157 .. l_printReceivedConstructorName_0("Received constructor", (getmetatable(v151.value)));
                    end;
                end;
                v157 = v157 .. "\n";
                if not v151.hasMessage or v151.value["$$robloxInternalJestError"] then
                    return v157 .. v34("Received value: ", v151, "message") .. v35(v151);
                else
                    return v157 .. v34("Received message: ", v151, "message") .. v35(v151);
                end;
            end;
        end or function()
            local v159 = l_matcherHint_0(v149, nil, nil, v150) .. "\n\n" .. l_printExpectedConstructorNameNot_0("Expected constructor", v152);
            if v151 ~= nil then
                local l_value_1 = v151.value;
                if (l_value_1 and getmetatable(l_value_1)) and getmetatable(l_value_1).__index then
                    l_value_1 = v152;
                    if not (not (((l_value_1 and getmetatable(l_value_1)) and getmetatable(l_value_1).__index) and getmetatable(v151.value).__index ~= v152) or v151.value["$$robloxInternalJestError"]) then
                        v159 = v159 .. l_printReceivedConstructorNameNot_0("Received constructor", getmetatable(v151.value), v152);
                    end;
                end;
            end;
            v159 = v159 .. "\n";
            if (not (v151 ~= nil) or not v151.hasMessage) or v151.value["$$robloxInternalJestError"] then
                return v159 .. v34("Received value: ", v151, "message") .. v35(v151);
            else
                return v159 .. v34("Received message: ", v151, "message") .. v35(v151);
            end;
        end,
        pass = v155
    };
end;
v31 = function(v161, v162, v163, v164)
    local v165 = false;
    if not (not (v163 ~= nil and typeof(v163.message) == "string") or not v163.message:find(v164, 1, true)) then
        v165 = true;
    end;
    local _ = nil;
    return {
        message = not v165 and function()
            local v167 = l_matcherHint_0(v161, nil, nil, v162) .. "\n\n" .. v33("Expected substring: ", v164);
            if v163 == nil then
                return v167 .. "\n" .. "Received function never threw";
            elseif not v163.hasMessage or v163.value["$$robloxInternalJestError"] then
                return v167 .. v34("Received value:     ", v163, "message") .. v35(v163);
            else
                return v167 .. v34("Received message:   ", v163, "message") .. v35(v163);
            end;
        end or function()
            local v168 = l_matcherHint_0(v161, nil, nil, v162) .. "\n\n" .. v33("Expected substring: never ", v164);
            if (not (v163 ~= nil) or not v163.hasMessage) or v163.value["$$robloxInternalJestError"] then
                return v168 .. v34("Received value:           ", v163, "message") .. v35(v163);
            else
                return v168 .. v34("Received message:         ", v163, "message", v164) .. v35(v163);
            end;
        end,
        pass = v165
    };
end;
v32 = function(v169, v170, v171)
    local v172 = v171 ~= nil;
    local _ = nil;
    return {
        message = not v172 and function()
            return l_matcherHint_0(v169, nil, "", v170) .. "\n\n" .. "Received function never threw";
        end or function()
            local v174 = l_matcherHint_0(v169, nil, "", v170) .. "\n\n";
            if (not (v171 ~= nil) or not v171.hasMessage) or v171.value["$$robloxInternalJestError"] then
                return v174 .. v34("Thrown value: ", v171, "message") .. v35(v171);
            else
                return v174 .. v34("Error name:    ", v171, "name") .. v34("Error message: ", v171, "message") .. v35(v171);
            end;
        end,
        pass = v172
    };
end;
v33 = function(v175, v176)
    return v175 .. l_printExpected_0(v176) .. "\n";
end;
v34 = function(v177, v178, v179, v180)
    if v178 == nil then
        return "";
    elseif v179 == "message" then
        local l_message_0 = v178.message;
        if typeof(v180) == "string" then
            local v182 = l_message_0:find(v180);
            if v182 then
                return v177 .. l_printReceivedStringContainExpectedSubstring_0(l_message_0, v182, #v180) .. "\n";
            end;
        elseif l_getType_0(v180) == "regexp" then
            return v177 .. l_printReceivedStringContainExpectedResult_0(l_message_0, v180:exec(l_message_0)) .. "\n";
        end;
        return v177 .. l_printReceived_0(l_message_0) .. "\n";
    elseif v179 == "name" then
        if not v178.isError then
            return "";
        else
            return v177 .. l_printReceived_0(v178.value.name) .. "\n";
        end;
    elseif v179 == "value" then
        if not v178.isError then
            return v177 .. l_printReceived_0(v178.value) .. "\n";
        else
            return "";
        end;
    else
        return "";
    end;
end;
v35 = function(v183)
    if v183 ~= nil and v183.isError then
        return l_formatStackTrace_0(v183.value.stack);
    else
        return "";
    end;
end;
return {
    createMatcher = v67,
    matchers = v68
};


local l_Parent_0 = script.Parent.Parent;
local _ = require(l_Parent_0.RegExp);
local _ = require(l_Parent_0.LuauPolyfill);
return {};


local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.LuauPolyfill);
local l_Array_0 = v2.Array;
local l_Object_0 = v2.Object;
local v5 = require(l_Parent_1.RegExp);
local v6 = require(l_Parent_1.RobloxShared);
local l_equals_0 = require(l_Parent_0.jasmineUtils).equals;
local v8 = nil;
local function v9(v10, v11)
    if not l_Array_0.isArray(v11) then
        v11 = v8(v11);
    end;
    if #v11 > 0 then
        local v12 = #v11 == 1;
        local v13 = v11[1];
        local l_status_0, l_result_0 = pcall(function()
            return v10[v13];
        end);
        if not l_status_0 or not v12 and l_result_0 == nil then
            return {
                hasEndProp = false,
                lastTraversedObject = v10,
                traversedPath = {}
            };
        else
            local v16 = v9(l_result_0, l_Array_0.slice(v11, 2));
            if v16.lastTraversedObject == nil then
                v16.lastTraversedObject = v10;
            end;
            table.insert(v16.traversedPath, 1, v13);
            if v12 then
                v16.hasEndProp = l_result_0 ~= nil;
                if not v16.hasEndProp then
                    l_Array_0.shift(v16.traversedPath);
                end;
            end;
            return v16;
        end;
    else
        return {
            lastTraversedObject = nil,
            traversedPath = {},
            value = v10
        };
    end;
end;
local l_getObjectSubset_0 = v6.expect.getObjectSubset;
local l_iterableEquality_0 = v6.expect.iterableEquality;
local l_subsetEquality_0 = v6.expect.subsetEquality;
local function v22(v20, v21)
    if not (v20 ~= nil) or v21 == nil then
        return nil;
    elseif typeof(v20) ~= typeof(v21) then
        return false;
    elseif getmetatable(v20) or getmetatable(v21) then
        if not (((not getmetatable(v20) or not getmetatable(v21)) or not getmetatable(v20).__index) or not getmetatable(v21).__index) and getmetatable(v20).__index == getmetatable(v21).__index then
            return nil;
        else
            return false;
        end;
    else
        return nil;
    end;
end;
local function v25(v23, v24)
    if l_Array_0.isArray(v23) and l_Array_0.isArray(v24) then
        return l_equals_0(v23, v24, {
            v22
        }, true) and l_equals_0(l_Object_0.keys(v23), (l_Object_0.keys(v24)));
    else
        return nil;
    end;
end;
local function v31(v26, v27)
    local v28 = {
        {},
        {}
    };
    for _, v30 in ipairs(v26) do
        table.insert(v28[not v27(v30) and 2 or 1], v30);
    end;
    return v28;
end;
v8 = function(v32)
    local v33 = v5("[^.[\\]]+|(?=(?:\\.)(?:\\.|$))");
    local v34 = {};
    if v32:sub(1, 1) == "." then
        table.insert(v34, "");
    end;
    local v35 = 0;
    local l_v32_0 = v32;
    local v37 = v33:exec(l_v32_0);
    while v37 ~= nil and v35 < #v32 do
        local v38 = v37[1];
        local v39 = v37.index + #v38;
        local v40 = v35 + v37.index;
        if v32:sub(v40 - 1, v40 - 1) == "[" then
            local v41 = tonumber(v38, 10);
            if not v41 then
                table.insert(v34, v38);
            else
                table.insert(v34, v41);
            end;
        else
            table.insert(v34, v38);
        end;
        v35 = v35 + v39;
        l_v32_0 = l_v32_0:sub(v39 + 1);
        v37 = v33:exec(l_v32_0);
    end;
    return v34;
end;
return {
    getPath = v9,
    getObjectSubset = l_getObjectSubset_0,
    iterableEquality = l_iterableEquality_0,
    subsetEquality = l_subsetEquality_0,
    typeEquality = v22,
    sparseArrayEquality = v25,
    partition = v31,
    pathAsArray = v8,
    isError = function(v42)
        if not (typeof(v42) ~= "string") or typeof(v42) == "table" then
            return true;
        else
            return false;
        end;
    end,
    emptyObject = function(v43)
        local v44;
        if typeof(v43) == "table" then
            v44 = true;
            if not (#l_Object_0.keys(v43) ~= 0) then
                goto label0;
            end;
        end;
        v44 = false;
        ::label0::;
        return v44;
    end,
    isOneline = function(v45, v46)
        local v47 = false;
        if typeof(v45) == "string" then
            v47 = false;
            if typeof(v46) == "string" then
                v47 = not v46:match("[\r\n]") or not v45:match("[\r\n]");
            end;
        end;
        return v47;
    end
};


local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.LuauPolyfill);
local l_Array_0 = v2.Array;
local l_Boolean_0 = v2.Boolean;
local l_Error_0 = v2.Error;
local l_Object_0 = v2.Object;
local l_Symbol_0 = v2.Symbol;
local l_instanceof_0 = v2.instanceof;
local _ = require(l_Parent_1.RegExp);
local l_getType_0 = require(l_Parent_1.JestGetType).getType;
local v11 = {};
local l_pluralize_0 = require(l_Parent_1.JestUtil).pluralize;
local v13 = require(l_Parent_0.jasmineUtils);
local l_equals_0 = v13.equals;
local l_hasProperty_0 = v13.hasProperty;
local l_isA_0 = v13.isA;
local l_isUndefined_0 = v13.isUndefined;
local l_getState_0 = require(l_Parent_0.jestMatchersObject_extracted).getState;
local _ = require(l_Parent_0.types);
local v20 = require(l_Parent_0.utils);
local v21 = l_Object_0.freeze(l_Object_0.assign({}, v11, {
    iterableEquality = v20.iterableEquality,
    subsetEquality = v20.subsetEquality
}));
local v22 = {};
v22.__index = v22;
v22.new = function(v23, v24)
    local v25 = if v24 ~= nil then v24 else false;
    local v26 = {
        sample = v23,
        inverse = not (v25 == nil) and v25,
        ["$$typeof"] = l_Symbol_0.for_("jest.asymmetricMatcher")
    };
    setmetatable(v26, v22);
    return v26;
end;
v22.getMatcherContext = function(v27)
    return l_Object_0.assign({}, l_getState_0(), {
        equals = l_equals_0,
        isNot = v27.inverse,
        utils = v21
    });
end;
local v28 = {};
v28.__index = v28;
setmetatable(v28, v22);
v28.new = function(v29)
    if typeof(v29) ~= "table" and typeof(v29) ~= "string" then
        error("any() expects to be passed a typename string or a prototype class. " .. "Please pass one or use anything() to match any object.");
    end;
    local v30 = v22.new(v29);
    setmetatable(v30, v28);
    return v30;
end;
v28.asymmetricMatch = function(v31, v32)
    local v33 = l_getType_0(v31.sample);
    local v34 = l_getType_0(v32);
    if not (not (v33 == "table") or v34 ~= "table") or v33 == "error" and v34 == "error" then
        return l_instanceof_0(v32, v31.sample);
    elseif v33 == "string" and v31.sample == v34 then
        return true;
    else
        return false;
    end;
end;
v28.toString = function(_)
    return "Any";
end;
v28.getExpectedType = function(v36)
    return (tostring(v36.sample));
end;
v28.toAsymmetricMatcher = function(v37)
    return "Any<" .. tostring(v37.sample) .. ">";
end;
local v38 = {};
v38.__index = v38;
setmetatable(v38, v22);
v38.new = function(v39)
    local v40 = v22.new(v39);
    setmetatable(v40, v38);
    return v40;
end;
v38.asymmetricMatch = function(_, v42)
    return not l_isUndefined_0(v42);
end;
v38.toString = function(_)
    return "Anything";
end;
v38.toAsymmetricMatcher = function(_)
    return "Anything";
end;
local v45 = {};
v45.__index = v45;
setmetatable(v45, v22);
v45.new = function(v46)
    local v47 = v22.new(v46);
    setmetatable(v47, v45);
    return v47;
end;
v45.asymmetricMatch = function(_, v49)
    return l_isUndefined_0(v49);
end;
v45.toString = function(_)
    return "Nothing";
end;
v45.getExpectedType = function(_)
    return "nil";
end;
v45.toAsymmetricMatcher = function(_)
    return "Nothing";
end;
local v53 = {};
v53.__index = v53;
setmetatable(v53, v22);
v53.new = function(v54, v55)
    if not (v55 ~= nil) then
        v55 = false;
    end;
    local v56 = v22.new(v54, v55);
    setmetatable(v56, v53);
    return v56;
end;
v53.asymmetricMatch = function(v57, v58)
    if not l_Array_0.isArray(v57.sample) then
        error(string.format("You must provide an array to %s, not '%s'.", v57:toString(), (typeof(v57.sample))));
    end;
    local v59 = false;
    if #v57.sample == 0 then
        v59 = true;
    elseif not (not l_Array_0.isArray(v58) or not l_Array_0.every(v57.sample, function(v60)
        return l_Array_0.some(v58, function(v61)
            return l_equals_0(v60, v61);
        end);
    end)) then
        v59 = true;
    end;
    if not v57.inverse then
        return v59;
    else
        return not v59;
    end;
end;
v53.toString = function(v62)
    if not v62.inverse then
        return "ArrayContaining";
    else
        return "ArrayNotContaining";
    end;
end;
v53.getExpectedType = function(_)
    return "array";
end;
local v64 = {};
v64.__index = v64;
setmetatable(v64, v22);
v64.new = function(v65, v66)
    if not (v66 ~= nil) then
        v66 = false;
    end;
    local v67 = v22.new(v65, v66);
    setmetatable(v67, v64);
    return v67;
end;
v64.asymmetricMatch = function(v68, v69)
    if typeof(v68.sample) ~= "table" then
        error(string.format("You must provide an object to %s, not '%s'.", v68:toString(), (typeof(v68.sample))));
    end;
    local v70 = true;
    for v71, v72 in pairs(v68.sample) do
        if not (l_hasProperty_0(v69, v71) and l_equals_0(v72, v69[v71])) then
            v70 = false;
            break;
        end;
    end;
    if not v68.inverse then
        return v70;
    else
        return not v70;
    end;
end;
v64.toString = function(v73)
    if not v73.inverse then
        return "ObjectContaining";
    else
        return "ObjectNotContaining";
    end;
end;
v64.getExpectedType = function(_)
    return "object";
end;
local v75 = {};
v75.__index = v75;
setmetatable(v75, v22);
v75.new = function(v76, v77)
    if not (v77 ~= nil) then
        v77 = false;
    end;
    if not l_isA_0("string", v76) then
        error("Expected is not a String");
    end;
    local v78 = v22.new(v76, v77);
    setmetatable(v78, v75);
    return v78;
end;
v75.asymmetricMatch = function(v79, v80)
    local v81 = l_isA_0("string", v80) and v80:find(v79.sample, 1, true);
    if not v79.inverse then
        return not not v81;
    else
        return not v81;
    end;
end;
v75.toString = function(v82)
    if not v82.inverse then
        return "StringContaining";
    else
        return "StringNotContaining";
    end;
end;
v75.getExpectedType = function(_)
    return "string";
end;
local v84 = {};
v84.__index = v84;
setmetatable(v84, v22);
v84.new = function(v85, v86)
    if not (v86 ~= nil) then
        v86 = false;
    end;
    if not (l_isA_0("string", v85) or l_isA_0("regexp", v85)) then
        error("Expected is not a String");
    end;
    local v87 = v22.new(v85, v86);
    setmetatable(v87, v84);
    return v87;
end;
v84.asymmetricMatch = function(v88, v89)
    local v90 = false;
    if l_isA_0("string", v89) then
        if not l_isA_0("string", v88.sample) then
            v90 = v88.sample:test(v89);
        else
            v88.sample = string.gsub(v88.sample, string.char(27) .. "%[", string.char(27) .. "%%[");
            v90 = v89:find(v88.sample);
        end;
    end;
    if not v88.inverse then
        return not not v90;
    else
        return not v90;
    end;
end;
v84.toString = function(v91)
    if not v91.inverse then
        return "StringMatching";
    else
        return "StringNotMatching";
    end;
end;
v84.getExpectedType = function(_)
    return "string";
end;
local v93 = setmetatable({}, {
    __index = v22
});
v93.__index = v93;
v93.new = function(v94, v95, v96)
    local v97 = if v95 ~= nil then v95 else 2;
    local v98 = if v96 ~= nil then v96 else false;
    if not l_Boolean_0.toJSBoolean(l_isA_0("number", v94)) then
        error(l_Error_0.new("Expected is not a Number"));
    end;
    if not l_Boolean_0.toJSBoolean(l_isA_0("number", v97)) then
        error(l_Error_0.new("Precision is not a Number"));
    end;
    local v99 = v22.new(v94);
    setmetatable(v99, v93);
    v99.inverse = v98;
    v99.precision = v97;
    return v99;
end;
v93.asymmetricMatch = function(v100, v101)
    if l_Boolean_0.toJSBoolean(l_isA_0("number", v101)) then
        local v102 = false;
        v102 = v101 == math.huge and v100.sample == math.huge or ((v101 == -math.huge and v100.sample == -math.huge) and true or math.abs(v100.sample - v101) < math.pow(10, -v100.precision) / 2);
        if not l_Boolean_0.toJSBoolean(v100.inverse) then
            return v102;
        else
            return not l_Boolean_0.toJSBoolean(v102);
        end;
    else
        return false;
    end;
end;
v93.toString = function(v103)
    return ("Number%sCloseTo"):format(not l_Boolean_0.toJSBoolean(v103.inverse) and "" or "Not");
end;
v93.getExpectedType = function(_)
    return "number";
end;
v93.toAsymmetricMatcher = function(v105)
    return l_Array_0.join({
        v105:toString(),
        v105.sample,
        ("(%s)"):format((tostring(l_pluralize_0("digit", v105.precision))))
    }, " ");
end;
return {
    AsymmetricMatcher = v22,
    any = function(v106)
        return v28.new(v106);
    end,
    anything = function()
        return v38.new();
    end,
    nothing = function()
        return v45.new();
    end,
    arrayContaining = function(v107)
        return v53.new(v107);
    end,
    arrayNotContaining = function(v108)
        return v53.new(v108, true);
    end,
    objectContaining = function(v109)
        return v64.new(v109);
    end,
    objectNotContaining = function(v110)
        return v64.new(v110, true);
    end,
    stringContaining = function(v111)
        return v75.new(v111);
    end,
    stringNotContaining = function(v112)
        return v75.new(v112, true);
    end,
    stringMatching = function(v113)
        return v84.new(v113);
    end,
    stringNotMatching = function(v114)
        return v84.new(v114, true);
    end,
    closeTo = function(v115, v116)
        return v93.new(v115, v116);
    end,
    notCloseTo = function(v117, v118)
        return v93.new(v117, v118, true);
    end
};


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.LuauPolyfill);
local l_Boolean_0 = v1.Boolean;
local l_Error_0 = v1.Error;
local l_Object_0 = v1.Object;
local v5 = {};
local v6 = require(l_Parent_0.JestMatcherUtils);
local l_EXPECTED_COLOR_0 = v6.EXPECTED_COLOR;
local l_RECEIVED_COLOR_0 = v6.RECEIVED_COLOR;
local l_matcherHint_0 = v6.matcherHint;
local l_pluralize_0 = v6.pluralize;
local v11 = require(script.Parent.jestMatchersObject);
local l_getState_0 = v11.getState;
local l_setState_0 = v11.setState;
local _ = require(script.Parent.types);
local function _()
    l_setState_0({
        assertionCalls = 0,
        expectedAssertionsNumber = l_Object_0.None,
        isExpectingAssertions = false
    });
end;
local _ = nil;
v5.default = function()
    local v17 = {};
    local v18 = nil;
    local v19 = nil;
    local v20 = nil;
    local v21 = nil;
    local v22 = nil;
    local v23 = l_getState_0();
    v18 = v23.assertionCalls;
    v19 = v23.expectedAssertionsNumber;
    v20 = v23.expectedAssertionsNumberError;
    v21 = v23.isExpectingAssertions;
    v22 = v23.isExpectingAssertionsError;
    l_setState_0({
        assertionCalls = 0,
        expectedAssertionsNumber = l_Object_0.None,
        isExpectingAssertions = false
    });
    if typeof(v19) == "number" and v18 ~= v19 then
        v20.message = l_matcherHint_0(".assertions", "", tostring(v19), {
            isDirectExpectCall = true
        }) .. "\n\n" .. ("Expected %s to be called but received "):format((tostring((l_EXPECTED_COLOR_0(l_pluralize_0("assertion", v19)))))) .. tostring(l_RECEIVED_COLOR_0(l_pluralize_0("assertion call", not not l_Boolean_0.toJSBoolean(v18) and v18 or 0))) .. ".";
        if typeof(l_Error_0.__recalculateStacktrace) == "function" then
            l_Error_0.__recalculateStacktrace(v20);
        end;
        table.insert(v17, {
            actual = tostring(v18),
            error = v20,
            expected = tostring(v19)
        });
    end;
    if v21 and v18 == 0 then
        v22.message = tostring(l_matcherHint_0(".hasAssertions", "", "", {
            isDirectExpectCall = true
        })) .. "\n\n" .. ("Expected %s to be called but %s."):format(tostring((l_EXPECTED_COLOR_0("at least one assertion"))), (tostring((l_RECEIVED_COLOR_0("received none")))));
        if typeof(l_Error_0.__recalculateStacktrace) == "function" then
            l_Error_0.__recalculateStacktrace(v22);
        end;
        table.insert(v17, {
            actual = "none",
            error = v22,
            expected = "at least one"
        });
    end;
    return v17;
end;
return v5;


local l_script_0 = script;
local l_Parent_0 = l_script_0.Parent;
local v2 = require(l_Parent_0.LuauPolyfill);
local l_Boolean_0 = v2.Boolean;
local l_Error_0 = v2.Error;
local l_Object_0 = v2.Object;
local v6 = require(l_Parent_0.Promise);
local v7 = require(l_Parent_0.JestMatcherUtils);
local v8 = require(l_script_0.asymmetricMatchers);
local l_any_0 = v8.any;
local l_anything_0 = v8.anything;
local l_arrayContaining_0 = v8.arrayContaining;
local l_arrayNotContaining_0 = v8.arrayNotContaining;
local l_closeTo_0 = v8.closeTo;
local l_notCloseTo_0 = v8.notCloseTo;
local l_nothing_0 = v8.nothing;
local l_objectContaining_0 = v8.objectContaining;
local l_objectNotContaining_0 = v8.objectNotContaining;
local l_stringContaining_0 = v8.stringContaining;
local l_stringMatching_0 = v8.stringMatching;
local l_stringNotContaining_0 = v8.stringNotContaining;
local l_stringNotMatching_0 = v8.stringNotMatching;
local l_default_0 = require(l_script_0.extractExpectedAssertionsErrors).default;
local l_equals_0 = require(l_script_0.jasmineUtils).equals;
local v24 = require(l_script_0.jestMatchersObject);
local l_getMatchers_0 = v24.getMatchers;
local l_getState_0 = v24.getState;
local l_setMatchers_0 = v24.setMatchers;
local l_setState_0 = v24.setState;
local v29 = require(l_script_0.matchers);
local v30 = require(l_script_0.spyMatchers);
local v31 = require(l_script_0.toThrowMatchers);
local l_matchers_0 = v31.matchers;
local l_createMatcher_0 = v31.createMatcher;
local _ = require(l_script_0.types);
local v35 = require(l_script_0.utils);
local l_iterableEquality_0 = v35.iterableEquality;
local l_subsetEquality_0 = v35.subsetEquality;
local v38 = nil;
local v39 = nil;
local v40 = setmetatable({}, {
    __index = l_Error_0
});
v40.__index = v40;
v40.new = function(v41)
    return (setmetatable(l_Error_0.new(v41), v40));
end;
local function _(v42)
    local v43 = not not l_Boolean_0.toJSBoolean(v42);
    if v43 then
        if typeof(v42) ~= "table" then
            v43 = false;
            if not (typeof(v42) == "function") then
                goto label0;
            end;
        end;
        v43 = typeof(v42.andThen) == "function";
    end;
    ::label0::;
    return v43;
end;
local function _(v45)
    return function(v46, v47, v48)
        return v45(v46, table.unpack({
            v47,
            v48,
            true
        }));
    end;
end;
local function _(v50, v51)
    if not (v50 ~= "toThrow") or v50 == "toThrowError" then
        return l_createMatcher_0(v50, true);
    elseif not (v50 ~= "toThrowErrorMatchingSnapshot") or v50 == "toThrowErrorMatchingInlineSnapshot" then
        return function(v52, v53, v54)
            return v51(v52, table.unpack({
                v53,
                v54,
                true
            }));
        end;
    else
        return nil;
    end;
end;
local v56 = nil;
local v57 = nil;
local function v70(_, v59, ...)
    if #{
        ...
    } ~= 0 then
        error("Expect takes at most one argument.");
    end;
    local v60 = l_getMatchers_0();
    local v61 = {
        never = {},
        rejects = {
            never = {}
        },
        resolves = {
            never = {}
        }
    };
    local v62 = v40.new();
    for v63, v64 in pairs(v60) do
        local v68 = if not (v63 ~= "toThrow") or v63 == "toThrowError" then l_createMatcher_0(v63, true) else (not (v63 ~= "toThrowErrorMatchingSnapshot") or v63 == "toThrowErrorMatchingInlineSnapshot") and function(v65, v66, v67)
            return v64(v65, table.unpack({
                v66,
                v67,
                true
            }));
        end or nil;
        local v69 = not not l_Boolean_0.toJSBoolean(v68) and v68 or v64;
        v61[v63] = v38(v64, false, "", v59);
        v61.never[v63] = v38(v64, true, "", v59);
        v61.resolves[v63] = v56(v63, v69, false, v59, v62);
        v61.resolves.never[v63] = v56(v63, v69, true, v59, v62);
        v61.rejects[v63] = v57(v63, v69, false, v59, v62);
        v61.rejects.never[v63] = v57(v63, v69, true, v59, v62);
    end;
    return v61;
end;
local function _(v71)
    if not v71 then
        return (v7.RECEIVED_COLOR("No message was specified for this matcher."));
    else
        return (v71());
    end;
end;
v56 = function(v73, v74, v75, v76, v77)
    return function(...)
        local v78 = {
            ...
        };
        local v79 = {
            isNot = v75,
            promise = "resolves"
        };
        local l_v76_0 = v76;
        local v81 = not not l_Boolean_0.toJSBoolean(l_v76_0);
        if v81 then
            if typeof(l_v76_0) ~= "table" then
                v81 = false;
                if not (typeof(l_v76_0) == "function") then
                    goto label1;
                end;
            end;
            v81 = typeof(l_v76_0.andThen) == "function";
        end;
        ::label1::;
        if not v81 then
            error(v40.new(v7.matcherErrorMessage(v7.matcherHint(v73, nil, "", v79), ("%s value must be a promise"):format((tostring(v7.RECEIVED_COLOR("received")))), v7.printWithType("Received", v76, v7.printReceived))));
        end;
        v81 = v40.new();
        return v76:andThen(function(v82)
            return v38(v74, v75, "resolves", v82, v81)(table.unpack(v78));
        end, function(v83)
            v77.message = tostring(v7.matcherHint(v73, nil, "", v79)) .. "\n\n" .. "Received promise rejected instead of resolved\n" .. ("Rejected to value: %s"):format(v7.printReceived(v83));
            return v6.reject(v77);
        end);
    end;
end;
v57 = function(v84, v85, v86, v87, v88)
    return function(...)
        local v89 = {
            ...
        };
        local v90 = {
            isNot = v86,
            promise = "rejects"
        };
        local v91 = if typeof(v87) == "function" then v87() else v87;
        local v92 = not not l_Boolean_0.toJSBoolean(v91);
        if v92 then
            if typeof(v91) ~= "table" then
                v92 = false;
                if not (typeof(v91) == "function") then
                    goto label2;
                end;
            end;
            v92 = typeof(v91.andThen) == "function";
        end;
        ::label2::;
        if not v92 then
            error(v40.new(v7.matcherErrorMessage(v7.matcherHint(v84, nil, "", v90), ("%s value must be a promise or a function returning a promise"):format((tostring(v7.RECEIVED_COLOR("received")))), v7.printWithType("Received", v87, v7.printReceived))));
        end;
        v92 = v40.new();
        return v91:andThen(function(v93)
            v88.message = tostring(v7.matcherHint(v84, nil, "", v90)) .. "\n\n" .. "Received promise resolved instead of rejected\n" .. ("Resolved to value: %s"):format(v7.printReceived(v93));
            return v6.reject(v88);
        end, function(v94)
            return v38(v85, v86, "rejects", v94, v92)(table.unpack(v89));
        end);
    end;
end;
v38 = function(v95, v96, v97, v98, v99)
    local function v100(...)
        local v101 = true;
        local v102 = {
            dontThrow = function()
                v101 = false;
            end,
            equals = l_equals_0,
            error = v99,
            isNot = v96,
            promise = v97,
            utils = l_Object_0.assign({
                iterableEquality = l_iterableEquality_0,
                subsetEquality = l_subsetEquality_0
            }, v7)
        };
        l_Object_0.assign(v102, l_getState_0());
        local function v107(v103, v104)
            v39(v103);
            l_getState_0().assertionCalls = l_getState_0().assertionCalls + 1;
            if not (not (v103.pass and v96) and (v103.pass or v96)) then
                local l_message_0 = v103.message;
                local v106 = if not l_message_0 then v7.RECEIVED_COLOR("No message was specified for this matcher.") else l_message_0();
                l_message_0 = nil;
                if not v99 then
                    if not v104 then
                        l_message_0 = v40.new(v106);
                    else
                        error("Currently async is not implemented");
                    end;
                else
                    l_message_0 = v99;
                    l_message_0.message = v106;
                end;
                l_message_0.matcherResult = l_Object_0.assign({}, v103, {
                    message = v106
                });
                if not v101 then
                    table.insert(l_getState_0().suppressedErrors, l_message_0);
                else
                    error(l_message_0);
                    return ;
                end;
            end;
        end;
        local function _(v108)
            if l_Error_0.captureStackTrace and typeof(v108) == "table" then
                l_Error_0.captureStackTrace(v108, v100);
            end;
            error(v108);
        end;
        local l_status_0, l_result_0 = pcall(function(...)
            v107((v95(v102, v98, ...)));
        end, ...);
        if not l_status_0 then
            if l_Error_0.captureStackTrace and typeof(l_result_0) == "table" then
                l_Error_0.captureStackTrace(l_result_0, v100);
            end;
            error(l_result_0);
        end;
    end;
    return v100;
end;
v39 = function(v112)
    if not (typeof(v112) == "table" and typeof(v112.pass) == "boolean") or (v112.message and typeof(v112.message) ~= "string") and typeof(v112.message) ~= "function" then
        error("Unexpected return from a matcher function.\n" .. "Matcher functions should " .. "return an object in the following format:\n" .. "  {message?: string | function, pass: boolean}\n" .. v7.stringify(v112) .. " was returned");
    end;
end;
local v113 = {};
v113.extend = function(v114)
    l_setMatchers_0(v114, false, v113);
end;
v113.anything = l_anything_0;
v113.any = l_any_0;
v113.nothing = l_nothing_0;
v113.never = {
    arrayContaining = l_arrayNotContaining_0,
    closeTo = l_notCloseTo_0,
    objectContaining = l_objectNotContaining_0,
    stringContaining = l_stringNotContaining_0,
    stringMatching = l_stringNotMatching_0
};
v113.objectContaining = l_objectContaining_0;
v113.arrayContaining = l_arrayContaining_0;
v113.closeTo = l_closeTo_0;
v113.stringContaining = l_stringContaining_0;
v113.stringMatching = l_stringMatching_0;
local function v115(v116)
    local v117 = l_Error_0.new();
    if l_Error_0.captureStackTrace then
        l_Error_0.captureStackTrace(v117, v115);
    end;
    l_setState_0({
        expectedAssertionsNumber = v116,
        expectedAssertionsNumberError = v117
    });
end;
local function v118(...)
    local v119 = {
        ...
    };
    local v120 = l_Error_0.new();
    if l_Error_0.captureStackTrace then
        l_Error_0.captureStackTrace(v120, v118);
    end;
    v7.ensureNoExpected(v119[1], ".hasAssertions");
    l_setState_0({
        isExpectingAssertions = true,
        isExpectingAssertionsError = v120
    });
end;
l_setMatchers_0(v29, true, v113);
l_setMatchers_0(v30, true, v113);
l_setMatchers_0(l_matchers_0, true, v113);
v113.addSnapshotSerializer = require(l_Parent_0.JestSnapshot).plugins.addSerializer;
v113.assertions = v115;
v113.hasAssertions = v118;
v113.getState = l_getState_0;
v113.setState = l_setState_0;
v113.extractExpectedAssertionsErrors = l_default_0;
local v121 = require(l_Parent_0.JestSnapshot);
l_setMatchers_0({
    toMatchSnapshot = v121.toMatchSnapshot,
    toThrowErrorMatchingSnapshot = v121.toThrowErrorMatchingSnapshot
}, false, v113);
setmetatable(v113, {
    __call = v70
});
return v113;


local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.LuauPolyfill);
local l_Symbol_0 = v2.Symbol;
local l_Object_0 = v2.Object;
local l_Error_0 = v2.Error;
local l_getType_0 = require(l_Parent_1.JestGetType).getType;
local l_AsymmetricMatcher_0 = require(l_Parent_0.asymmetricMatchers).AsymmetricMatcher;
local _ = require(l_Parent_0.types);
local v9 = require(l_Parent_0.jestMatchersObject_extracted);
local l_JEST_MATCHERS_OBJECT_0 = v9.JEST_MATCHERS_OBJECT;
local v11 = l_Symbol_0.for_("$$jest-internal-matcher");
if not _G[l_JEST_MATCHERS_OBJECT_0] then
    _G[l_JEST_MATCHERS_OBJECT_0] = {
        matchers = {},
        state = {
            assertionCalls = 0,
            expectedAssertionsNumber = nil,
            isExpectingAssertions = false,
            suppressedErrors = {}
        }
    };
end;
return {
    INTERNAL_MATCHER_FLAG = v11,
    getState = v9.getState,
    setState = function(v12)
        l_Object_0.assign(_G[l_JEST_MATCHERS_OBJECT_0].state, v12);
    end,
    getMatchers = function()
        return _G[l_JEST_MATCHERS_OBJECT_0].matchers;
    end,
    setMatchers = function(v13, v14, v15)
        for v16, v17 in pairs(v13) do
            if not v14 then
                if typeof(v17) ~= "function" then
                    error(l_Error_0.new(("expect.extend: `%s` is not a valid matcher. Must be a function, is \"%s\""):format(tostring(v16), (tostring(l_getType_0(v17))))));
                end;
                local v18 = {};
                v18.__index = v18;
                setmetatable(v18, l_AsymmetricMatcher_0);
                v18.new = function(v19, ...)
                    if not (v19 ~= nil) then
                        v19 = false;
                    end;
                    local v20 = l_AsymmetricMatcher_0.new({
                        ...
                    }, v19);
                    setmetatable(v20, v18);
                    return v20;
                end;
                v18.asymmetricMatch = function(v21, v22)
                    local l_pass_0 = v17(v21:getMatcherContext(), v22, unpack(v21.sample)).pass;
                    if not v21.inverse then
                        return l_pass_0;
                    else
                        return not l_pass_0;
                    end;
                end;
                v18.toString = function(v24)
                    if not v24.inverse then
                        return (tostring(v16));
                    else
                        return string.format("never.%s", v16);
                    end;
                end;
                v18.getExpectedType = function(_)
                    return "any";
                end;
                v18.toAsymmetricMatcher = function(v26)
                    local l_sample_0 = v26.sample;
                    local v28 = 1;
                    local v29 = "";
                    while v28 < #l_sample_0 do
                        v29 = v29 .. tostring(l_sample_0[v28]) .. ", ";
                        v28 = v28 + 1;
                    end;
                    return string.format("%s<%s>", v26:toString(), v29 .. tostring(l_sample_0[v28]));
                end;
                v15[v16] = function(...)
                    return v18.new(false, ...);
                end;
                if not v15.never then
                    v15.never = {};
                end;
                v15.never[v16] = function(...)
                    return v18.new(true, ...);
                end;
            end;
        end;
        l_Object_0.assign(_G[l_JEST_MATCHERS_OBJECT_0].matchers, v13);
    end
};