local l_Parent_0 = script.Parent.Parent.Parent;
local v1 = require(l_Parent_0.Parent.LuauPolyfill);
local l_Array_0 = v1.Array;
local l_Boolean_0 = v1.Boolean;
local l_uuid_0 = require(l_Parent_0.utilities.common.makeUniqueId).uuid;
local v5 = {};
local v6 = nil;
local v7 = {};
local v8 = 1;
local function v39()
    local v9 = {};
    v9.__index = v9;
    v9.new = function()
        local v10 = setmetatable({}, v9);
        v10.id = l_Array_0.join({
            "slot",
            v8,
            DateTime.now().UnixTimestampMillis,
            l_uuid_0()
        }, ":");
        v8 = v8 + 1;
        return v10;
    end;
    v9.hasValue = function(v11)
        local l_v6_0 = v6;
        while true do
            if not l_v6_0 then
                break;
            elseif not l_v6_0.slots[v11.id] then
                l_v6_0 = l_v6_0.parent;
            else
                local v13 = l_v6_0.slots[v11.id];
                if v13 ~= v7 then
                    if l_v6_0 ~= v6 then
                        v6.slots[v11.id] = v13;
                    end;
                    return true;
                else
                    break;
                end;
            end;
        end;
        if v6 then
            v6.slots[v11.id] = v7;
        end;
        return false;
    end;
    v9.getValue = function(v14)
        if not v14:hasValue() then
            return nil;
        else
            return v6.slots[v14.id];
        end;
    end;
    v9.withValue = function(v15, v16, v17, v18, v19)
        local v20 = {
            [v15.id] = v16
        };
        local l_v6_1 = v6;
        v6 = {
            parent = l_v6_1,
            slots = v20
        };
        local v22, v23, v24 = pcall(function()
            return v17(v19, table.unpack(v18 or {})), true;
        end);
        v6 = l_v6_1;
        if not v24 then
            if not v22 then
                error(v23);
            end;
            return nil;
        else
            return v23;
        end;
    end;
    v9.bind = function(v25)
        local l_v6_2 = v6;
        return function(v27, ...)
            local v28 = {
                ...
            };
            local l_v6_3 = v6;
            v6 = l_v6_2;
            local l_status_0, l_result_0 = pcall(v25, v27, table.unpack(v28));
            v6 = l_v6_3;
            if not l_status_0 then
                error(l_result_0);
            end;
            return l_result_0;
        end;
    end;
    v9.noContext = function(v32, v33, v34)
        if not v6 then
            return v32(v34, table.unpack(v33 or {}));
        else
            local l_v6_4 = v6;
            local v36, v37, v38 = pcall(function()
                v6 = nil;
                return v32(v34, table.unpack(v33 or {})), true;
            end);
            v6 = l_v6_4;
            if not v38 then
                if not v36 then
                    error(v37);
                end;
                return nil;
            else
                return v37;
            end;
        end;
    end;
    return v9;
end;
local v40, v41;
if l_Boolean_0.toJSBoolean(l_Array_0["@wry/context:Slot"]) then
    v41 = l_Array_0["@wry/context:Slot"];
    if v41 then
        goto label0;
    end;
end;
v40 = v39();
pcall(function()
    l_Array_0["@wry/context:Slot"] = v40;
end);
v41 = v40;
::label0::;
v5.Slot = v41;
return v5;


local _ = require(script.Parent.Parent.Parent.Parent.LuauPolyfill);
local v1 = {};
local function v2()
    return {};
end;
local v3 = {};
v3.__index = v3;
v3.new = function(v4, v5)
    local l_v4_0 = v4;
    local l_v5_0 = v5;
    if l_v4_0 == nil then
        l_v4_0 = true;
    end;
    if l_v5_0 == nil then
        l_v5_0 = v2;
    end;
    local v8 = setmetatable({}, v3);
    v8.weakness = l_v4_0;
    v8.makeData = l_v5_0;
    return v8;
end;
v3.lookup = function(v9, ...)
    return v9:lookupArray({
        ...
    });
end;
v3.lookupArray = function(v10, v11)
    local l_v10_0 = v10;
    for _, v14 in v11, nil, nil do
        l_v10_0 = l_v10_0:getChildTrie(v14);
    end;
    if not l_v10_0.data then
        l_v10_0.data = v10.makeData(table.clone(v11));
    end;
    return l_v10_0.data;
end;
v3.getChildTrie = function(v15, v16)
    local v17 = nil;
    if not v15.weakness then
        if v15.strong == nil then
            v15.strong = {};
        end;
        v17 = v15.strong;
    else
        if v15.weak == nil then
            v15.weak = setmetatable({}, {
                __mode = "k"
            });
        end;
        v17 = v15.weak;
    end;
    local v18 = v17[v16];
    if not v18 then
        v18 = v3.new(v15.weakness, v15.makeData);
        v17[v16] = v18;
    end;
    return v18;
end;
v1.Trie = v3;
return v1;


local l_invariant_0 = require(script.jsutils.invariant).invariant;
local l_DEV_0 = require(script.utilities).DEV;
l_invariant_0(typeof(l_DEV_0) == "boolean", l_DEV_0);
return (require(script.testing));


return {
    displayName = "ApolloClientTesting",
    testMatch = {
        "**/*.spec"
    }
};


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_0.testUtils.waitForExpect);
local l_getConfig_0 = require(l_Parent_1.ReactTestingLibrary).getConfig;
local v4 = {};
local function v11(v5, v6)
    local l_v6_0 = v6;
    local l_v5_0 = v5;
    if l_v5_0 == nil then
        l_v5_0 = function()
        end;
    end;
    if l_v6_0 == nil then
        l_v6_0 = {};
    end;
    local _ = nil;
    local _ = nil;
    return v2(l_v5_0, if l_v6_0.timeout == nil then l_getConfig_0().asyncUtilTimeout else l_v6_0.timeout, l_v6_0.interval == nil and 50 or l_v6_0.interval);
end;
v4.wait = function(...)
    local v12 = table.pack(...);
    return l_getConfig_0().asyncWrapper(function()
        return v11(table.unpack(v12));
    end);
end;
return v4;


local l_setTimeout_0 = require(script.Parent.Parent.Parent.Parent.LuauPolyfill).setTimeout;
local v1 = {};
local function _(v2)
    return (v2());
end;
v1.getSetTimeoutFn = function()
    return ((function()
        return l_setTimeout_0;
    end)());
end;
return v1;


local v0 = require(script.Parent.Parent.Parent.Promise);
local l_getSetTimeoutFn_0 = require(script.helpers).getSetTimeoutFn;
local v2 = {
    timeout = 5000,
    interval = 50
};
return function(v3, v4, v5)
    local v6 = v4 or v2.timeout;
    local v7 = v5 or v2.interval;
    local v8 = l_getSetTimeoutFn_0();
    if v7 < 50 then
        v7 = 50;
    end;
    local v9 = math.ceil(v6 / v7);
    local v10 = 0;
    return v0.new(function(v11, v12)
        local v13 = nil;
        local v14 = nil;
        v13 = function(v15)
            if v9 < v10 then
                v12(v15);
                return ;
            else
                v8(v14, v7);
                return ;
            end;
        end;
        v14 = function()
            v10 = v10 + 1;
            xpcall(function()
                v0.delay(0):andThen(function()
                    return v3();
                end):andThen(function()
                    return v0.delay(0);
                end):andThen(function()
                    return v11();
                end):catch(v13);
            end, function(v16)
                v13(v16);
            end);
        end;
        v8(v14, 50);
    end);
end;


local l_Parent_0 = script.Parent.Parent.Parent;
local _ = require(l_Parent_0.LuauPolyfill);
local v2 = require(l_Parent_0.Promise);
local l_it_0 = require(l_Parent_0.JestGlobals).it;
local v4 = {};
local function _(v5)
    return function(v6, v7, v8)
        return (if not v5 then l_it_0 else l_it_0[v5])(v6, function()
            return v2.new(function(v9, v10)
                v7(v9, v10);
            end):andThen(function(v11)
                return v2.delay(0.016666666666666666):andThenReturn(v11);
            end);
        end, v8);
    end;
end;
local v13 = nil;
local function v20(v14, v15, v16)
    return (if not v13 then l_it_0 else l_it_0[v13])(v14, function()
        return v2.new(function(v17, v18)
            v15(v17, v18);
        end):andThen(function(v19)
            return v2.delay(0.016666666666666666):andThenReturn(v19);
        end);
    end, v16);
end;
local v21 = {};
local v22 = "only";
local l_v22_0 = v22 --[[ copy: 12 -> 13 ]];
v21.only = function(v24, v25, v26)
    return (if not l_v22_0 then l_it_0 else l_it_0[l_v22_0])(v24, function()
        return v2.new(function(v27, v28)
            v25(v27, v28);
        end):andThen(function(v29)
            return v2.delay(0.016666666666666666):andThenReturn(v29);
        end);
    end, v26);
end;
v22 = "skip";
local l_v22_1 = v22 --[[ copy: 12 -> 14 ]];
v21.skip = function(v31, v32, v33)
    return (if not l_v22_1 then l_it_0 else l_it_0[l_v22_1])(v31, function()
        return v2.new(function(v34, v35)
            v32(v34, v35);
        end):andThen(function(v36)
            return v2.delay(0.016666666666666666):andThenReturn(v36);
        end);
    end, v33);
end;
v22 = "todo";
v21.todo = function(v37, v38, v39)
    return (if not v22 then l_it_0 else l_it_0[v22])(v37, function()
        return v2.new(function(v40, v41)
            v38(v40, v41);
        end):andThen(function(v42)
            return v2.delay(0.016666666666666666):andThenReturn(v42);
        end);
    end, v39);
end;
v4.itAsync = setmetatable(v21, {
    __call = function(_, v44, v45, v46)
        return v20(v44, v45, v46);
    end
});
return v4;


local v0 = {};
local l_Parent_0 = script.Parent.Parent.Parent.Parent;
local v2 = require(l_Parent_0.LuauPolyfill);
local l_Boolean_0 = v2.Boolean;
local l_Object_0 = v2.Object;
local v5 = require(l_Parent_0.React);
local v6 = require(l_Parent_0.ApolloClient);
local l_ApolloClient_0 = require(l_Parent_0.ApolloClient).ApolloClient;
local l_InMemoryCache_0 = v6.InMemoryCache;
local l_ApolloProvider_0 = v6.ApolloProvider;
local l_MockLink_0 = require(script.Parent.mockLink).MockLink;
local _ = require(l_Parent_0.ApolloClient);
local _ = require(l_Parent_0.ApolloClient);
local v13 = v5.Component:extend("MockedProvider");
v13.defaultProps = {
    addTypename = true
};
v13.init = function(v14, v15)
    v14.props = v15;
    local l_mocks_0 = v15.mocks;
    local l_addTypename_0 = v15.addTypename;
    local l_defaultOptions_0 = v15.defaultOptions;
    local l_cache_0 = v15.cache;
    local l_resolvers_0 = v15.resolvers;
    local l_link_0 = v15.link;
    v14.state = {
        client = l_ApolloClient_0.new({
            cache = not not l_Boolean_0.toJSBoolean(l_cache_0) and l_cache_0 or l_InMemoryCache_0.new({
                addTypename = l_addTypename_0
            }),
            defaultOptions = l_defaultOptions_0,
            link = not not l_Boolean_0.toJSBoolean(l_link_0) and l_link_0 or l_MockLink_0.new(l_mocks_0 ~= nil and l_mocks_0 or {}, l_addTypename_0),
            resolvers = l_resolvers_0
        })
    };
end;
v13.render = function(v22)
    local l_children_0 = v22.props.children;
    local l_childProps_0 = v22.props.childProps;
    if not v5.isValidElement(l_children_0) then
        return nil;
    else
        return v5.createElement(l_ApolloProvider_0, {
            client = v22.state.client
        }, v5.cloneElement(v5.Children.only(l_children_0), l_Object_0.assign({}, l_childProps_0)));
    end;
end;
v13.componentWillUnmount = function(v25)
    v25.state.client:stop();
end;
v0.MockedProvider = v13;
return v0;


local v0 = {};
local l_Parent_0 = script.Parent.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v3 = require(l_Parent_1.LuauPolyfill);
local l_Array_0 = v3.Array;
local l_Boolean_0 = v3.Boolean;
local l_Error_0 = v3.Error;
local l_setTimeout_0 = v3.setTimeout;
local l_Observable_0 = require(l_Parent_0.utilities).Observable;
local l_ApolloLink_0 = require(l_Parent_1.ApolloClient).ApolloLink;
local v10 = setmetatable({}, {
    __index = l_ApolloLink_0
});
v10.__index = v10;
v10.new = function()
    local v11 = setmetatable(l_ApolloLink_0.new(), v10);
    v11.unsubscribers = {};
    v11.setups = {};
    v11.observers = {};
    return v11;
end;
v10.request = function(v12, v13)
    v12.operation = v13;
    return l_Observable_0.new(function(v14)
        l_Array_0.forEach(v12.setups, function(v15)
            v15();
        end);
        table.insert(v12.observers, v14);
        return function()
            l_Array_0.forEach(v12.unsubscribers, function(v16)
                v16();
            end);
        end;
    end);
end;
v10.simulateResult = function(v17, v18, v19)
    if v19 == nil then
        v19 = false;
    end;
    l_setTimeout_0(function()
        local l_observers_0 = v17.observers;
        if not l_Boolean_0.toJSBoolean(#l_observers_0) then
            error(l_Error_0.new("subscription torn down"));
        end;
        l_Array_0.forEach(l_observers_0, function(v21)
            if not (not l_Boolean_0.toJSBoolean(v18.result) or not l_Boolean_0.toJSBoolean(v21.next)) then
                v21:next(v18.result);
            end;
            if not (not l_Boolean_0.toJSBoolean(v18.error) or not l_Boolean_0.toJSBoolean(v21.error)) then
                v21:error(v18.error);
            end;
            if not (not v19 or not l_Boolean_0.toJSBoolean(v21.complete)) then
                v21:complete();
            end;
        end);
    end, not not l_Boolean_0.toJSBoolean(v18.delay) and v18.delay or 0);
end;
v10.simulateComplete = function(v22)
    local l_observers_1 = v22.observers;
    if not l_Boolean_0.toJSBoolean(#l_observers_1) then
        error(l_Error_0.new("subscription torn down"));
    end;
    l_Array_0.forEach(l_observers_1, function(v24)
        if l_Boolean_0.toJSBoolean(v24.complete) then
            v24:complete();
        end;
    end);
end;
v10.onSetup = function(v25, v26)
    v25.setups = l_Array_0.concat(v25.setups, {
        v26
    });
end;
v10.onUnsubscribe = function(v27, v28)
    v27.unsubscribers = l_Array_0.concat(v27.unsubscribers, {
        v28
    });
end;
v0.MockSubscriptionLink = v10;
v0.mockObservableLink = function()
    return v10.new();
end;
return v0;


local v0 = {};
local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v3 = require(l_Parent_1.LuauPolyfill);
local l_Boolean_0 = v3.Boolean;
local l_Error_0 = v3.Error;
local l_setTimeout_0 = v3.setTimeout;
local v7 = require(l_Parent_1.Promise);
local _ = require(l_Parent_1.ApolloClient);
local _ = require(l_Parent_1.ApolloClient);
local _ = require(l_Parent_0.utilities.observables.Observable);
local function v35(v11, ...)
    local v12 = {
        ...
    };
    local l_observable_0 = v11.observable;
    local v14 = nil;
    local v15 = nil;
    local v16 = nil;
    v14 = not (v11.shouldResolve ~= nil) or v11.shouldResolve;
    v15 = if v11.wait ~= nil then v11.wait else -1;
    v16 = if v11.errorCallbacks ~= nil then v11.errorCallbacks else {};
    local v17 = nil;
    return {
        promise = v7.new(function(v18, v19)
            local v20 = 0;
            local v21 = 0;
            local v22 = {};
            local function v24()
                if v14 then
                    local function v23()
                        v17:unsubscribe();
                        v18(v22);
                    end;
                    if v21 == #v12 and v20 == #v16 then
                        if v15 == -1 then
                            v17:unsubscribe();
                            v18(v22);
                            return ;
                        else
                            l_setTimeout_0(v23, v15);
                        end;
                    end;
                    return ;
                else
                    return ;
                end;
            end;
            local v25 = v7.delay(0);
            v17 = l_observable_0:subscribe({
                next = function(_, v27)
                    v25 = v25:andThen(function()
                        local l_v21_0 = v21;
                        v21 = v21 + 1;
                        local v29 = v12[l_v21_0 + 1];
                        if not l_Boolean_0.toJSBoolean(v29) then
                            v19(l_Error_0.new(("Observable 'next' method called more than %d times"):format(#v12)));
                            return nil;
                        else
                            return v29(v27);
                        end;
                    end):andThen(function(v30)
                        table.insert(v22, v30);
                        v24();
                    end, v19);
                end,
                error = function(_, v32)
                    v25 = v25:andThen(function()
                        local l_v20_0 = v20;
                        v20 = v20 + 1;
                        local v34 = v16[l_v20_0 + 1];
                        if not l_Boolean_0.toJSBoolean(v34) then
                            v19(v32);
                            return nil;
                        else
                            return v34(v32);
                        end;
                    end):andThen(v24, v19);
                end
            });
        end),
        subscription = v17
    };
end;
v0.observableToPromiseAndSubscription = v35;
v0.default = function(v36, ...)
    return v35(v36, ...).promise;
end;
return v0;


local v0 = {};
local v1 = require(script.Parent.Parent.Parent.LuauPolyfill);
local l_Array_0 = v1.Array;
local l_Object_0 = v1.Object;
local function v4(v5)
    local v6 = l_Object_0.assign({}, v5);
    l_Array_0.forEach(l_Object_0.keys(v6), function(v7)
        if (typeof(v7) == "userdata" and string.sub(tostring(v7), 1, 7) == "Symbol(") and v7 ~= tostring(v7) then
            v6[v7] = nil;
            return ;
        else
            if not (not (typeof(v6[v7]) == "table") or l_Array_0.isArray(v6)) then
                v6[v7] = v4(v6[v7]);
            end;
            return ;
        end;
    end);
    return v6;
end;
v0.stripSymbols = v4;
return v0;


local v0 = {};
local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v3 = require(l_Parent_1.Promise);
local _ = require(l_Parent_1.ApolloClient);
local _ = require(l_Parent_1.ApolloClient);
local _ = require(l_Parent_0.utilities.observables.Observable);
local l_asyncMap_0 = require(l_Parent_0.utilities.observables.asyncMap).asyncMap;
v0.default = function(v8, v9, v10)
    local v11 = nil;
    local v12 = v3.delay(0);
    local v13 = 0;
    local v16 = l_asyncMap_0(v9, function(v14)
        v12 = v12:andThen(function()
            return v3.delay(0);
        end):andThen(function()
            v13 = v13 + 1;
            return v10(v13, v14);
        end):catch(v11);
        return v12;
    end):subscribe({
        error = function(_, ...)
            v11(...);
        end
    });
    v11 = function(v17)
        v16:unsubscribe();
        v8(v17);
    end;
    return v16;
end;
return v0;


local v0 = {};
local l_Parent_0 = script.Parent.Parent.Parent;
local v2 = require(l_Parent_0.Promise);
local v3 = require(l_Parent_0.JestGlobals);
local l_expect_0 = v3.expect;
local l_jest_0 = v3.jest;
local l_console_0 = require(l_Parent_0.LuauPolyfill).console;
local function _(v7, v8)
    return function(...)
        local v9 = table.pack(...);
        local v10 = l_console_0[v8];
        local v11 = l_jest_0.fn(function()
        end);
        l_console_0[v8] = v11;
        return v2.new(function(v12)
            v12(if not v7 then nil else v7(table.unpack(v9)));
        end):andThen(function()
            l_expect_0(v11).toMatchSnapshot();
            v11:mockClear();
            l_console_0[v8] = v10;
        end):catch(function(v13)
            l_expect_0(v11).toMatchSnapshot();
            v11:mockClear();
            l_console_0[v8] = v10;
            error(v13);
        end);
    end;
end;
v0.withErrorSpy = function(v15, ...)
    local v16 = {
        ...
    };
    local v17 = v16[2];
    local v18 = "error";
    v16[2] = function(...)
        local v19 = table.pack(...);
        local v20 = l_console_0[v18];
        local v21 = l_jest_0.fn(function()
        end);
        l_console_0[v18] = v21;
        return v2.new(function(v22)
            v22(if not v17 then nil else v17(table.unpack(v19)));
        end):andThen(function()
            l_expect_0(v21).toMatchSnapshot();
            v21:mockClear();
            l_console_0[v18] = v20;
        end):catch(function(v23)
            l_expect_0(v21).toMatchSnapshot();
            v21:mockClear();
            l_console_0[v18] = v20;
            error(v23);
        end);
    end;
    return v15(table.unpack(v16));
end;
v0.withWarningSpy = function(v24, ...)
    local v25 = {
        ...
    };
    local v26 = v25[2];
    local v27 = "warn";
    v25[2] = function(...)
        local v28 = table.pack(...);
        local v29 = l_console_0[v27];
        local v30 = l_jest_0.fn(function()
        end);
        l_console_0[v27] = v30;
        return v2.new(function(v31)
            v31(if not v26 then nil else v26(table.unpack(v28)));
        end):andThen(function()
            l_expect_0(v30).toMatchSnapshot();
            v30:mockClear();
            l_console_0[v27] = v29;
        end):catch(function(v32)
            l_expect_0(v30).toMatchSnapshot();
            v30:mockClear();
            l_console_0[v27] = v29;
            error(v32);
        end);
    end;
    return v24(table.unpack(v25));
end;
v0.withLogSpy = function(v33, ...)
    local v34 = {
        ...
    };
    local v35 = v34[2];
    local v36 = "log";
    v34[2] = function(...)
        local v37 = table.pack(...);
        local v38 = l_console_0[v36];
        local v39 = l_jest_0.fn(function()
        end);
        l_console_0[v36] = v39;
        return v2.new(function(v40)
            v40(if not v35 then nil else v35(table.unpack(v37)));
        end):andThen(function()
            l_expect_0(v39).toMatchSnapshot();
            v39:mockClear();
            l_console_0[v36] = v38;
        end):catch(function(v41)
            l_expect_0(v39).toMatchSnapshot();
            v39:mockClear();
            l_console_0[v36] = v38;
            error(v41);
        end);
    end;
    return v33(table.unpack(v34));
end;
return v0;


local l_Parent_0 = script.Parent.Parent.Parent;
local l_expect_0 = require(l_Parent_0.JestGlobals).expect;
local l_console_0 = require(l_Parent_0.LuauPolyfill).console;
local _ = require(l_Parent_0.LuauRegExp);
return {
    default = function(v4, v5)
        return function(...)
            local v6 = {
                ...
            };
            local l_status_0, l_result_0 = pcall(function()
                return v5(table.unpack(v6));
            end);
            if not l_status_0 then
                v4(l_result_0);
            end;
            return l_result_0;
        end;
    end,
    withError = function(v9, v10)
        local v11 = nil;
        local l_error_0 = l_console_0.error;
        l_console_0.error = function(v13)
            v11 = v13;
            return v11;
        end;
        local l_status_1, l_result_1 = pcall(function()
            local v14 = v9();
            l_expect_0(v11).toMatch(v10);
            return v14;
        end);
        l_console_0.error = l_error_0;
        if not l_status_1 then
            error(l_result_1);
        end;
        return l_result_1;
    end
};


return {
    DEV = require(script.DEV).default,
    NULL = require(script.null).NULL
};


local v0 = {};
local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_invariant_0 = require(l_Parent_0.jsutils.invariant).invariant;
local l_DEV_0 = require(script.globals).DEV;
l_invariant_0(typeof(l_DEV_0) == "boolean", (tostring(l_DEV_0)));
v0.DEV = l_DEV_0;
local l_Object_0 = require(l_Parent_1.LuauPolyfill).Object;
local v6 = require(script.graphql.transform);
v0.addTypenameToDocument = v6.addTypenameToDocument;
v0.buildQueryFromSelectionSet = v6.buildQueryFromSelectionSet;
v0.removeDirectivesFromDocument = v6.removeDirectivesFromDocument;
v0.removeConnectionDirectiveFromDocument = v6.removeConnectionDirectiveFromDocument;
v0.removeArgumentsFromDocument = v6.removeArgumentsFromDocument;
v0.removeFragmentSpreadFromDocument = v6.removeFragmentSpreadFromDocument;
v0.removeClientSetsFromDocument = v6.removeClientSetsFromDocument;
v0.Observable = require(script.observables.Observable).Observable;
l_Object_0.assign(v0, require(script.common.cloneDeep));
l_Object_0.assign(v0, require(script.common.stringifyForDisplay));
l_Object_0.assign(v0, require(script.common.makeUniqueId));
return v0;


return {
    RoactFitComponents = require(script.Parent.RoactFitComponents)
};


local v0 = require(script.Parent.Parent.Number);
return function(v1)
    local v2 = not not v1;
    if v2 then
        v2 = false;
        if v1 ~= 0 then
            v2 = false;
            if v1 ~= "" then
                v2 = not v0.isNaN(v1);
            end;
        end;
    end;
    return v2;
end;


local function v7(v0, v1, v2)
    local v3 = string.find(v0, v1, 1, true);
    if v3 == nil then
        return v0;
    else
        local v4 = #v1;
        local v5 = 1;
        local v6 = "";
        while true do
            v6 = v6 .. string.sub(v0, v5, v3 - 1) .. v1 .. v2;
            v5 = v3 + v4;
            v3 = string.find(v0, v1, v5, true);
            if not (v3 ~= nil) then
                break;
            end;
        end;
        return v6 .. string.sub(v0, v5);
    end;
end;
local function v15(v8, v9, v10, v11)
    local v12 = 1;
    local v13 = "";
    while true do
        local v14 = string.sub(v8, v11 - 1, v11 - 1) == "\r";
        v13 = v13 .. string.sub(v8, v12, if not v14 then v11 - 1 else v11 - 2) .. v9 .. (not v14 and "\n" or "\r\n") .. v10;
        v12 = v11 + 1;
        v11 = string.find(v8, "\n", v12);
        if not (v11 ~= nil) then
            break;
        end;
    end;
    return v13 .. string.sub(v8, v12);
end;
local v16 = {
    modifier = {
        reset = {
            0,
            0
        },
        bold = {
            1,
            22
        },
        dim = {
            2,
            22
        },
        italic = {
            3,
            23
        },
        underline = {
            4,
            24
        },
        overline = {
            53,
            55
        },
        inverse = {
            7,
            27
        },
        hidden = {
            8,
            28
        },
        strikethrough = {
            9,
            29
        }
    },
    color = {
        black = {
            30,
            39
        },
        red = {
            31,
            39
        },
        green = {
            32,
            39
        },
        yellow = {
            33,
            39
        },
        blue = {
            34,
            39
        },
        magenta = {
            35,
            39
        },
        cyan = {
            36,
            39
        },
        white = {
            37,
            39
        },
        blackBright = {
            90,
            39
        },
        gray = {
            90,
            39
        },
        grey = {
            90,
            39
        },
        redBright = {
            91,
            39
        },
        greenBright = {
            92,
            39
        },
        yellowBright = {
            93,
            39
        },
        blueBright = {
            94,
            39
        },
        magentaBright = {
            95,
            39
        },
        cyanBright = {
            96,
            39
        },
        whiteBright = {
            97,
            39
        }
    },
    bgColor = {
        bgBlack = {
            40,
            49
        },
        bgRed = {
            41,
            49
        },
        bgGreen = {
            42,
            49
        },
        bgYellow = {
            43,
            49
        },
        bgBlue = {
            44,
            49
        },
        bgMagenta = {
            45,
            49
        },
        bgCyan = {
            46,
            49
        },
        bgWhite = {
            47,
            49
        },
        bgBlackBright = {
            100,
            49
        },
        bgGray = {
            100,
            49
        },
        bgGrey = {
            100,
            49
        },
        bgRedBright = {
            101,
            49
        },
        bgGreenBright = {
            102,
            49
        },
        bgYellowBright = {
            103,
            49
        },
        bgBlueBright = {
            104,
            49
        },
        bgMagentaBright = {
            105,
            49
        },
        bgCyanBright = {
            106,
            49
        },
        bgWhiteBright = {
            107,
            49
        }
    }
};
local v17 = {};
for _, v19 in pairs(v16) do
    for v20, v21 in pairs(v19) do
        v17[v20] = {
            open = string.format("%c[%dm", 27, v21[1]),
            close = string.format("%c[%dm", 27, v21[2])
        };
    end;
end;
local v22 = nil;
local v23 = nil;
local function v26(v24, v25)
    return v22(v24.open .. v25.open, v25.close .. v24.close);
end;
local function _()
    return (pcall(function()
        game:GetService("ProcessService");
    end));
end;
local v28 = {
    level = 2
};
if not (not _G.NOCOLOR and pcall(function()
    game:GetService("ProcessService");
end)) then
    v28.level = 0;
end;
setmetatable(v28, {
    __call = function(_, v30)
        if not (v30 ~= nil) or type(v30) == "string" and #v30 == 0 then
            return "";
        else
            return (tostring(v30));
        end;
    end
});
v22 = function(v31, v32)
    local v33 = {
        open = v31,
        close = v32
    };
    setmetatable(v33, {
        __call = function(v34, v35)
            return v23(v34, v35);
        end,
        __concat = function(v36, v37)
            return v26(v36, v37);
        end
    });
    return v33;
end;
v23 = function(v38, v39)
    if not (v39 ~= nil) or type(v39) == "string" and #v39 == 0 then
        return "";
    elseif v28.level == 0 then
        return (tostring(v39));
    else
        local l_open_0 = v38.open;
        local l_close_0 = v38.close;
        if string.match(v39, "\027") then
            v39 = v7(v39, v38.close, v38.open);
        end;
        local v42 = string.find(v39, "\n");
        if v42 ~= nil then
            v39 = v15(v39, l_close_0, l_open_0, v42);
        end;
        return v38.open .. tostring(v39) .. v38.close;
    end;
end;
local function v43()
    return v22("", "");
end;
local v44 = string.format("%c[%dm", 27, 39);
local v45 = string.format("%c[%dm", 27, 49);
local v46 = string.format("%c[%dm", 27, 0);
for v47, v48 in pairs(v17) do
    v28[v47] = v22(v48.open, v48.close);
end;
v28.reset = v22(v46, v46);
local function v52(v49, v50, v51)
    if v49 == v50 and v50 == v51 then
        if v49 < 8 then
            return 16;
        elseif v49 > 248 then
            return 231;
        else
            return (math.round(((v49 - 8) / 247) * 24 + 232));
        end;
    else
        return ((16 + 36 * math.round((v49 / 255) * 5)) + 6 * math.round((v50 / 255) * 5)) + math.round((v51 / 255) * 5);
    end;
end;
v28.rgb = function(v53, v54, v55)
    if not (((((((type(v53) == "number" and type(v54) == "number") and type(v55) == "number") and v53 <= 255) and v53 >= 0) and v54 <= 255) and v54 >= 0) and v55 <= 255) or v55 < 0 then
        return v43();
    else
        return v22(string.format("%c[%d;5;%dm", 27, 38, (v52(v53, v54, v55))), v44);
    end;
end;
v28.bgRgb = function(v56, v57, v58)
    if not (((((((type(v56) == "number" and type(v57) == "number") and type(v58) == "number") and v56 <= 255) and v56 >= 0) and v57 <= 255) and v57 >= 0) and v58 <= 255) or v58 < 0 then
        return v43();
    else
        return v22(string.format("%c[%d;5;%dm", 27, 48, (v52(v56, v57, v58))), v45);
    end;
end;
local function _(v59)
    return (v52(tonumber(string.sub(v59, 2, 3), 16), tonumber(string.sub(v59, 4, 5), 16), (tonumber(string.sub(v59, 6, 7), 16))));
end;
v28.hex = function(v61)
    if not (type(v61) == "string" and string.find(v61, "#%X") == nil) or #v61 ~= 7 then
        return v43();
    else
        return v22(string.format("%c[%d;5;%dm", 27, 38, (v52(tonumber(string.sub(v61, 2, 3), 16), tonumber(string.sub(v61, 4, 5), 16), (tonumber(string.sub(v61, 6, 7), 16))))), v44);
    end;
end;
v28.bgHex = function(v62)
    if not (type(v62) == "string" and string.find(v62, "#%X") == nil) or #v62 ~= 7 then
        return v43();
    else
        return v22(string.format("%c[%d;5;%dm", 27, 48, (v52(tonumber(string.sub(v62, 2, 3), 16), tonumber(string.sub(v62, 4, 5), 16), (tonumber(string.sub(v62, 6, 7), 16))))), v45);
    end;
end;
v28.ansi = function(v63)
    if not ((type(v63) == "number" and v63 >= 30) and (not (v63 > 37) or v63 >= 90)) or v63 > 97 then
        return v43();
    else
        return v22(string.format("%c[%dm", 27, v63), v44);
    end;
end;
v28.bgAnsi = function(v64)
    if not ((type(v64) == "number" and v64 >= 40) and (not (v64 > 47) or v64 >= 100)) or v64 > 107 then
        return v43();
    else
        return v22(string.format("%c[%dm", 27, v64), v45);
    end;
end;
v28.ansi256 = function(v65)
    if not (type(v65) == "number" and v65 >= 0) or v65 > 255 then
        return v43();
    else
        return v22(string.format("%c[%d;5;%dm", 27, 38, v65), v44);
    end;
end;
v28.bgAnsi256 = function(v66)
    if not (type(v66) == "number" and v66 >= 0) or v66 > 255 then
        return v43();
    else
        return v22(string.format("%c[%d;5;%dm", 27, 48, v66), v45);
    end;
end;
return v28;


local l___DEV___0 = _G.__DEV__;
local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent.Parent;
local v3 = require(l_Parent_0.isArray);
local _ = require(l_Parent_1.ES7Types);
local v5 = "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(v6, ...)
    local v7 = nil;
    local v8 = 0;
    if not v3(v6) then
        v8 = v8 + 1;
        v7 = {
            [v8] = v6
        };
    else
        v7 = table.clone(v6);
        v8 = #v6;
    end;
    for v9 = 1, select("#", ...) do
        local v10 = select(v9, ...);
        local v11 = typeof(v10);
        if not (v10 == nil) then
            if v11 == "table" then
                if not (not l___DEV___0 or v3(v10)) then
                    error(v5);
                end;
                for v12 = 1, #v10 do
                    v8 = v8 + 1;
                    v7[v8] = v10[v12];
                end;
            else
                v8 = v8 + 1;
                v7[v8] = v10;
            end;
        end;
    end;
    return v7;
end;


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


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


local _ = require(script.Parent.Parent.Parent.ES7Types);
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.Parent.ES7Types);
return function(v1, v2)
    for v3 = 1, #v1 do
        if v2(v1[v3], v3, v1) then
            return v3;
        end;
    end;
    return -1;
end;


local l___DEV___0 = _G.__DEV__;
local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent.Parent;
local v3 = require(l_Parent_0.isArray);
local _ = require(l_Parent_1.ES7Types);
local function v5(v6, v7)
    if l___DEV___0 then
        if typeof(v6) ~= "table" then
            error(string.format("Array.flat called on %s", (typeof(v6))));
        end;
        if v7 ~= nil and typeof(v7) ~= "number" then
            error("depth is not a number or nil");
        end;
    end;
    local v8 = v7 or 1;
    local v9 = {};
    for _, v11 in v6, nil, nil do
        if not v3(v11) then
            table.insert(v9, v11);
        else
            local v12 = if v8 > 1 then v5(v11, v8 - 1) else v11;
            for _, v14 in v12, nil, nil do
                table.insert(v9, v14);
            end;
        end;
    end;
    return v9;
end;
return v5;


local l___DEV___0 = _G.__DEV__;
local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent.Parent;
local v3 = require(l_Parent_0.flat);
local v4 = require(l_Parent_0.map);
local _ = require(l_Parent_1.ES7Types);
return function(v6, v7, v8)
    if l___DEV___0 then
        if typeof(v6) ~= "table" then
            error(string.format("Array.flatMap called on %s", (typeof(v6))));
        end;
        if typeof(v7) ~= "function" then
            error("callback is not a function");
        end;
    end;
    return v3(v4(v6, v7, v8));
end;


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


local _ = require(script.Parent.Parent.Parent.Parent.ES7Types);
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.Parent.ES7Types);
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.Parent.ES7Types);
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.Parent.ES7Types);
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 l_Parent_2 = l_Parent_1.Parent;
local v3 = require(l_Parent_1.Set);
local v4 = require(l_Parent_1.Map.Map);
local v5 = require(l_Parent_0.isArray);
local v6 = require(l_Parent_2.InstanceOf);
local _ = require(l_Parent_2.ES7Types);
local v8 = require(script.fromString);
local v9 = require(script.fromSet);
local v10 = require(script.fromMap);
local v11 = require(script.fromArray);
return function(v12, v13, v14)
    if v12 == nil then
        error("cannot create array from a nil value");
    end;
    local v15 = typeof(v12);
    local _ = nil;
    if not (v15 == "table") or not v5(v12) then
        if not v6(v12, v3) then
            if not v6(v12, v4) then
                if v15 == "string" then
                    return (v8(v12, v13, v14));
                else
                    return {};
                end;
            else
                return (v10(v12, v13, v14));
            end;
        else
            return (v9(v12, v13, v14));
        end;
    else
        return (v11(v12, v13, v14));
    end;
end;


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


local _ = require(script.Parent.Parent.Parent.ES7Types);
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.ES7Types);
return {
    concat = require(script.concat),
    every = require(script.every),
    filter = require(script.filter),
    find = require(script.find),
    findIndex = require(script.findIndex),
    flat = require(script.flat),
    flatMap = require(script.flatMap),
    forEach = require(script.forEach),
    from = require(script.from),
    includes = require(script.includes),
    indexOf = require(script.indexOf),
    isArray = require(script.isArray),
    join = require(script.join),
    map = require(script.map),
    reduce = require(script.reduce),
    reverse = require(script.reverse),
    shift = require(script.shift),
    slice = require(script.slice),
    some = require(script.some),
    sort = require(script.sort),
    splice = require(script.splice),
    unshift = require(script.unshift)
};


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


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


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


local _ = require(script.Parent.Parent.Parent.ES7Types);
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___DEV___0 = _G.__DEV__;
local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent.Parent;
local v3 = require(l_Parent_0.isArray);
local _ = require(l_Parent_1.ES7Types);
return function(v5)
    if not (not l___DEV___0 or v3(v5)) then
        error(string.format("Array.shift called on non-array %s", (typeof(v5))));
    end;
    if #v5 > 0 then
        return table.remove(v5, 1);
    else
        return nil;
    end;
end;


local _ = require(script.Parent.Parent.Parent.ES7Types);
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.Parent.ES7Types);
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 l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_0.Object.None);
local _ = require(l_Parent_1.ES7Types);
local function v6(v4, v5)
    return type(v4) .. tostring(v4) < type(v5) .. tostring(v5);
end;
return function(v7, v8)
    local l_v6_0 = v6;
    if v8 ~= nil and v8 ~= v2 then
        if typeof(v8) ~= "function" then
            error("invalid argument to Array.sort: compareFunction must be a function");
        end;
        l_v6_0 = function(v10, v11)
            local v12 = v8(v10, v11);
            if typeof(v12) ~= "number" then
                error(("invalid result from compare function, expected number but got %s"):format((typeof(v12))));
            end;
            return v12 < 0;
        end;
    end;
    table.sort(v7, l_v6_0);
    return v7;
end;


local _ = require(script.Parent.Parent.Parent.ES7Types);
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___DEV___0 = _G.__DEV__;
local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent.Parent;
local v3 = require(l_Parent_0.isArray);
local _ = require(l_Parent_1.ES7Types);
return function(v5, ...)
    if not (not l___DEV___0 or v3(v5)) then
        error(string.format("Array.unshift called on non-array %s", (typeof(v5))));
    end;
    local v6 = select("#", ...);
    if v6 > 0 then
        for v7 = v6, 1, -1 do
            table.insert(v5, 1, (select(v7, ...)));
        end;
    end;
    return #v5;
end;


local l___DEV___0 = _G.__DEV__;
local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v3 = require(l_Parent_0.Array.forEach);
local v4 = require(l_Parent_0.Array.map);
local v5 = require(l_Parent_0.Array.isArray);
local v6 = require(l_Parent_1.InstanceOf);
local _ = require(l_Parent_1.ES7Types);
local v8 = {};
v8.new = function(v9)
    local v10 = nil;
    local v11 = nil;
    if v9 == nil then
        v10 = {};
        v11 = {};
    elseif not v5(v9) then
        if not v6(v9, v8) then
            error(("`%s` `%s` is not iterable, cannot make Map using it"):format(typeof(v9), (tostring(v9))));
        else
            v10 = table.clone(v9._array);
            v11 = table.clone(v9._map);
        end;
    else
        if (l___DEV___0 and #v9 > 0) and typeof(v9[1]) ~= "table" then
            error("Value `" .. typeof(v9[1]) .. "` is not an entry object.\n " .. "Cannot create Map from {K, V} form, it must be { {K, V}... }");
        end;
        v10 = table.create(#v9);
        v11 = {};
        for _, v13 in v9, nil, nil do
            local v14 = v13[1];
            if l___DEV___0 and v14 == nil then
                error("cannot create Map from a table that isn't an array.");
            end;
            local v15 = v13[2];
            if v11[v14] == nil then
                table.insert(v10, v14);
            end;
            v11[v14] = v15;
        end;
    end;
    return (setmetatable({
        size = #v10,
        _map = v11,
        _array = v10
    }, v8));
end;
v8.set = function(v16, v17, v18)
    if v16._map[v17] == nil then
        v16.size = v16.size + 1;
        table.insert(v16._array, v17);
    end;
    v16._map[v17] = v18;
    return v16;
end;
v8.get = function(v19, v20)
    return v19._map[v20];
end;
v8.clear = function(v21)
    local l_table_0 = table;
    v21.size = 0;
    l_table_0.clear(v21._map);
    l_table_0.clear(v21._array);
end;
v8.delete = function(v23, v24)
    if v23._map[v24] == nil then
        return false;
    else
        v23.size = v23.size - 1;
        v23._map[v24] = nil;
        local v25 = table.find(v23._array, v24);
        if v25 then
            table.remove(v23._array, v25);
        end;
        return true;
    end;
end;
v8.forEach = function(v26, v27, v28)
    if l___DEV___0 and typeof(v27) ~= "function" then
        error("callback is not a function");
    end;
    v3(v26._array, function(v29)
        local v30 = v26._map[v29];
        if v28 ~= nil then
            v27(v28, v30, v29, v26);
            return ;
        else
            v27(v30, v29, v26);
            return ;
        end;
    end);
end;
v8.has = function(v31, v32)
    return v31._map[v32] ~= nil;
end;
v8.keys = function(v33)
    return v33._array;
end;
v8.values = function(v34)
    return v4(v34._array, function(v35)
        return v34._map[v35];
    end);
end;
v8.entries = function(v36)
    return v4(v36._array, function(v37)
        return {
            v37,
            v36._map[v37]
        };
    end);
end;
v8.ipairs = function(v38)
    if l___DEV___0 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(v38:entries());
end;
v8.__iter = function(v39)
    return next, v39:entries();
end;
v8.__index = function(v40, v41)
    local v42 = rawget(v8, v41);
    if v42 ~= nil then
        return v42;
    else
        if l___DEV___0 then
            assert(rawget(v40, "_map"), "Map has been corrupted, and is missing private stateclear()?");
        end;
        return v8.get(v40, v41);
    end;
end;
v8.__newindex = function(v43, v44, v45)
    v43:set(v44, v45);
end;
return v8;


local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_Parent_2 = l_Parent_1.Parent;
local v3 = require(l_Parent_0.Map);
local v4 = require(l_Parent_1.Object);
local v5 = require(l_Parent_2.InstanceOf);
local _ = require(l_Parent_2.ES7Types);
return function(v7)
    return not not v5(v7, v3) and v7 or v3.new(v4.entries(v7));
end;


local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local l_Parent_2 = l_Parent_1.Parent;
local v3 = require(l_Parent_0.Map);
local v4 = require(l_Parent_2.InstanceOf);
local v5 = require(l_Parent_1.Array.reduce);
local _ = require(l_Parent_2.ES7Types);
return function(v7)
    if v4(v7, v3) then
        return v5(v7:entries(), function(v8, v9)
            v8[v9[1]] = v9[2];
            return v8;
        end, {});
    else
        return v7;
    end;
end;


local _ = require(script.Parent.Parent.ES7Types);
return {
    Map = require(script.Map),
    coerceToMap = require(script.coerceToMap),
    coerceToTable = require(script.coerceToTable)
};


local v0 = newproxy(true);
getmetatable(v0).__tostring = function()
    return "Object.None";
end;
return v0;


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


local _ = require(script.Parent.Parent.Parent.ES7Types);
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.Parent.ES7Types);
return function(v1)
    return (table.freeze(v1));
end;


return {
    assign = require(script.assign),
    entries = require(script.entries),
    freeze = require(script.freeze),
    is = require(script.is),
    isFrozen = require(script.isFrozen),
    keys = require(script.keys),
    preventExtensions = require(script.preventExtensions),
    seal = require(script.seal),
    values = require(script.values),
    None = require(script.None)
};


return function(v0, v1)
    if v0 == v1 then
        local v2 = true;
        if v0 == 0 then
            v2 = 1 / v0 == 1 / v1;
        end;
        return v2;
    else
        local v3 = false;
        if v0 ~= v0 then
            v3 = v1 ~= v1;
        end;
        return v3;
    end;
end;


local l___DEV___0 = _G.__DEV__;
local _ = require(script.Parent.Parent.Parent.ES7Types);
return function(v2)
    if l___DEV___0 then
        print("Luau now has a direct table.isfrozen call that can save the overhead of this library function call");
    end;
    return table.isfrozen(v2);
end;


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


local _ = require(script.Parent.Parent.Parent.ES7Types);
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.Parent.ES7Types);
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___DEV___0 = _G.__DEV__;
local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v3 = require(l_Parent_0.inspect);
local v4 = require(l_Parent_0.Array.isArray);
local v5 = require(l_Parent_0.Array.forEach);
local v6 = require(l_Parent_0.Array.from.fromString);
local _ = require(l_Parent_1.ES7Types);
local v11 = {
    __iter = function(v8)
        return next, v8._array;
    end,
    __tostring = function(v9)
        local v10 = "Set ";
        if #v9._array > 0 then
            v10 = v10 .. "(" .. tostring(#v9._array) .. ") ";
        end;
        return v10 .. v3(v9._array);
    end
};
v11.__index = v11;
v11.new = function(v12)
    local v13 = nil;
    local v14 = {};
    if v12 ~= nil then
        local v15 = nil;
        if typeof(v12) == "table" then
            if not v4(v12) then
                local v16 = getmetatable(v12);
                if not v16 or not rawget(v16, "__iter") then
                    if l___DEV___0 then
                        error("cannot create array from an object-like table");
                    end;
                else
                    v15 = v12;
                end;
            else
                v15 = table.clone(v12);
            end;
        elseif typeof(v12) == "string" then
            v15 = v6(v12);
        else
            error(("cannot create array from value of type `%s`"):format((typeof(v12))));
        end;
        if not v15 then
            v13 = {};
        else
            v13 = table.create(#v15);
            for _, v18 in v15, nil, nil do
                if not v14[v18] then
                    v14[v18] = true;
                    table.insert(v13, v18);
                end;
            end;
        end;
    else
        v13 = {};
    end;
    return (setmetatable({
        size = #v13,
        _map = v14,
        _array = v13
    }, v11));
end;
v11.add = function(v19, v20)
    if not v19._map[v20] then
        v19.size = v19.size + 1;
        v19._map[v20] = true;
        table.insert(v19._array, v20);
    end;
    return v19;
end;
v11.clear = function(v21)
    v21.size = 0;
    table.clear(v21._map);
    table.clear(v21._array);
end;
v11.delete = function(v22, v23)
    if v22._map[v23] then
        v22.size = v22.size - 1;
        v22._map[v23] = nil;
        local v24 = table.find(v22._array, v23);
        if v24 then
            table.remove(v22._array, v24);
        end;
        return true;
    else
        return false;
    end;
end;
v11.forEach = function(v25, v26, v27)
    if typeof(v26) ~= "function" then
        error("callback is not a function");
    end;
    v5(v25._array, function(v28)
        if v27 ~= nil then
            v26(v27, v28, v28, v25);
            return ;
        else
            v26(v28, v28, v25);
            return ;
        end;
    end);
end;
v11.has = function(v29, v30)
    return v29._map[v30] ~= nil;
end;
v11.ipairs = function(v31)
    if l___DEV___0 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(v31._array);
end;
return v11;


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


local l_Parent_0 = script.Parent;
local v1 = require(script.Array);
local v2 = require(script.Map);
local v3 = require(script.Object);
local v4 = require(script.Set);
local v5 = require(script.WeakMap);
local v6 = require(script.inspect);
local _ = require(l_Parent_0.ES7Types);
return {
    Array = v1,
    Object = v3,
    Map = v2.Map,
    coerceToMap = v2.coerceToMap,
    coerceToTable = v2.coerceToTable,
    Set = v4,
    WeakMap = v5,
    inspect = v6
};


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


local l_inspect_0 = require(script.Parent.Parent.Collections).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;


return {
    join = require(script.join),
    keys = require(script.keys),
    values = require(script.values)
};


local v0 = require(script.Parent.Parent.None);
return function(...)
    local v1 = select("#", ...);
    if v1 == 0 then
        return {};
    elseif v1 == 1 then
        local v2 = table.clone(...);
        setmetatable(v2, nil);
        return v2;
    else
        local v3 = table.clone(select(1, ...));
        setmetatable(v3, nil);
        for v4 = 2, v1 do
            for v5, v6 in pairs((select(v4, ...))) do
                if v6 == v0 then
                    v3[v5] = nil;
                else
                    v3[v5] = v6;
                end;
            end;
        end;
        return v3;
    end;
end;


return function(v0)
    local v1 = {};
    local v2 = 1;
    for v3 in pairs(v0) do
        v1[v2] = v3;
        v2 = v2 + 1;
    end;
    return v1;
end;


return function(v0)
    local v1 = {};
    local v2 = 1;
    for _, v4 in pairs(v0) do
        v1[v2] = v4;
        v2 = v2 + 1;
    end;
    return v1;
end;


return function(v0, v1)
    local v2 = {};
    local v3 = 1;
    for v4 = 1, #v0 do
        local v5 = v0[v4];
        if v1(v5, v4) then
            v2[v3] = v5;
            v3 = v3 + 1;
        end;
    end;
    return v2;
end;


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


return function(v0, v1)
    for v2 = 1, #v0 do
        if v0[v2] == v1 then
            return v2;
        end;
    end;
    return nil;
end;


return function(v0, v1)
    for v2 = 1, #v0 do
        if v1(v0[v2], v2) then
            return v2;
        end;
    end;
    return nil;
end;


return function(v0, v1, v2)
    local l_v2_0 = v2;
    for v4 = 1, #v0 do
        l_v2_0 = v1(l_v2_0, v0[v4], v4);
    end;
    return l_v2_0;
end;


return function(v0, v1, v2)
    local l_v2_0 = v2;
    for v4 = #v0, 1, -1 do
        l_v2_0 = v1(l_v2_0, v0[v4], v4);
    end;
    return l_v2_0;
end;


return function(v0, v1, v2)
    assert(v1 <= v2, "startIndex must be less than or equal to endIndex");
    local v3 = {};
    local v4 = 1;
    for v5 = math.max(1, v1), math.min(#v0, v2) do
        v3[v4] = v0[v5];
        v4 = v4 + 1;
    end;
    return v3;
end;


return {
    filter = require(script.filter),
    filterMap = require(script.filterMap),
    find = require(script.find),
    findWhere = require(script.findWhere),
    foldLeft = require(script.foldLeft),
    foldRight = require(script.foldRight),
    getRange = require(script.getRange),
    join = require(script.join),
    map = require(script.map),
    removeIndex = require(script.removeIndex),
    removeRange = require(script.removeRange),
    removeValue = require(script.removeValue),
    replaceIndex = require(script.replaceIndex),
    reverse = require(script.reverse),
    sort = require(script.sort),
    toSet = require(script.toSet)
};


local v0 = require(script.Parent.Parent.None);
return function(...)
    local v1 = {};
    for v2 = 1, select("#", ...) do
        local v3 = select(v2, ...);
        local v4 = #v1;
        for v5 = 1, #v3 do
            if v3[v5] == v0 then
                v4 = v4 - 1;
            else
                v1[v4 + v5] = v3[v5];
            end;
        end;
    end;
    return v1;
end;


return function(v0, v1)
    local v2 = {};
    for v3 = 1, #v0 do
        v2[v3] = v1(v0[v3], v3);
    end;
    return v2;
end;


return function(v0, v1)
    local v2 = {};
    local v3 = 0;
    for v4 = 1, #v0 do
        if v4 == v1 then
            v3 = 1;
        else
            v2[v4 - v3] = v0[v4];
        end;
    end;
    return v2;
end;


return function(v0, v1, v2)
    assert(v1 <= v2, "startIndex must be less than or equal to endIndex");
    local v3 = {};
    local v4 = 1;
    for v5 = 1, math.min(#v0, v1 - 1) do
        v3[v4] = v0[v5];
        v4 = v4 + 1;
    end;
    for v6 = v2 + 1, #v0 do
        v3[v4] = v0[v6];
        v4 = v4 + 1;
    end;
    return v3;
end;


return function(v0, v1)
    local v2 = {};
    local v3 = 1;
    for v4 = 1, #v0 do
        if v0[v4] ~= v1 then
            v2[v3] = v0[v4];
            v3 = v3 + 1;
        end;
    end;
    return v2;
end;


return function(v0, v1, v2)
    local v3 = {};
    local v4 = #v0;
    assert(v1 <= v4, "index must be less or equal than the list length");
    for v5 = 1, v4 do
        if v5 == v1 then
            v3[v5] = v2;
        else
            v3[v5] = v0[v5];
        end;
    end;
    return v3;
end;


return function(v0)
    local v1 = {};
    local v2 = #v0;
    local v3 = v2 + 1;
    for v4 = 1, v2 do
        v1[v4] = v0[v3 - v4];
    end;
    return v1;
end;


return function(v0, v1)
    local v2 = {};
    for v3 = 1, #v0 do
        v2[v3] = v0[v3];
    end;
    table.sort(v2, v1);
    return v2;
end;


return function(v0)
    local v1 = {};
    for v2 = 1, #v0 do
        v1[v0[v2]] = true;
    end;
    return v1;
end;


local v0 = newproxy(true);
getmetatable(v0).__tostring = function()
    return "Cryo.None";
end;
return v0;


return {
    Dictionary = require(script.Dictionary),
    List = require(script.List),
    isEmpty = require(script.isEmpty),
    None = require(script.None)
};


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.class);
local v3 = require(l_Parent_0.format);
local v4 = require(l_Parent_0.join);
local v8 = v2("Error", function(v5, v6, v7)
    return {
        name = v5,
        message = v6 or "An error occurred",
        tags = v7 or {}
    };
end);
v8.toString = function(v9)
    return v3("{}: {}\n{}", v9.name, v3(v9.message, v9.tags), v9.stack);
end;
v8.joinTags = function(v10, v11)
    return v8.new(v10.name, v10.message, v4(v10.tags, v11));
end;
v8.throw = function(v12, v13)
    local v14 = v12:joinTags(v13);
    v14.stack = debug.traceback();
    error(v14);
end;
return v8;


local v1 = require(script.Parent.class)("Symbol", function(v0)
    return {
        name = v0
    };
end);
v1.toString = function(v2)
    return ("Symbol(%s)"):format(v2.name);
end;
return v1;


local l_Parent_0 = script.Parent;
local v1 = require(l_Parent_0.None);
local _ = require(l_Parent_0.Types);
local v3 = require(l_Parent_0.assertEqual);
local v4 = require(l_Parent_0.forEachArgs);
local v5 = require(l_Parent_0.forEach);
local l_insert_0 = table.insert;
return function(v7, ...)
    v3(typeof(v7), "table", "Attempted to call Dash.append with argument #1 of type {left:?} not {right:?}");
    v4(function(v8)
        if not (v8 ~= v1) or v8 == nil then
            return ;
        else
            v5(v8, function(v9)
                l_insert_0(v7, v9);
            end);
            return ;
        end;
    end, ...);
    return v7;
end;


local l_Parent_0 = script.Parent;
return function(v1, v2, v3)
    if v1 ~= v2 then
        require(l_Parent_0.Error).new("AssertError", v3 or "Left {left:?} does not equal right {right:?}"):throw({
            left = v1,
            right = v2
        });
    end;
end;


local l_Parent_0 = script.Parent;
local v1 = require(l_Parent_0.None);
local _ = require(l_Parent_0.Types);
local v3 = require(l_Parent_0.assertEqual);
local v4 = require(l_Parent_0.forEach);
local v5 = require(l_Parent_0.forEachArgs);
return function(v6, ...)
    v3(typeof(v6), "table", "Attempted to call Dash.assign with argument #1 of type {left:?} not {right:?}");
    v5(function(v7)
        if not (v7 ~= nil) or v7 == v1 then
            return ;
        else
            v4(v7, function(v8, v9)
                if v8 == v1 then
                    v6[v9] = nil;
                    return ;
                else
                    v6[v9] = v8;
                    return ;
                end;
            end);
            return ;
        end;
    end, ...);
    return v6;
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local function _(v2)
    require(l_Parent_0.Error).new("NotImplemented", "The method \"{methodName}\" is not implemented on the class \"{className}\""):throw(v2);
end;
local function v4(v5, v6)
    v6 = v6 or function()
        return {};
    end;
    local v7 = {
        name = v5
    };
    v7.new = function(...)
        local v8 = v6(...);
        setmetatable(v8, {
            __index = v7,
            __tostring = v7.toString,
            __eq = v7.equals,
            __lt = v7.__lt,
            __le = v7.__le,
            __add = v7.__add,
            __sub = v7.__sub,
            __mul = v7.__mul,
            __div = v7.__div,
            __mod = v7.__mod
        });
        v8.Class = v7;
        v8:_init(...);
        return v8;
    end;
    v7._init = function(_)
    end;
    v7.isInstance = function(v10)
        local l_status_0, l_result_0 = pcall(function()
            local v11 = getmetatable(v10);
            while true do
                if not v11 then
                    return false;
                elseif v11.__index == v7 then
                    return true;
                else
                    v11 = getmetatable(v11.__index);
                end;
            end;
        end);
        return l_status_0 and l_result_0;
    end;
    v7.extend = function(v14, v15, v16)
        local v17 = v4(v15, v16 or v7.new);
        setmetatable(v17, {
            __index = v14
        });
        return v17;
    end;
    v7.toString = function(v18)
        return v18.name;
    end;
    v7.equals = function(v19, v20)
        return (rawequal(v19, v20));
    end;
    v7.__lt = function(_, _)
        require(l_Parent_0.Error).new("NotImplemented", "The method \"{methodName}\" is not implemented on the class \"{className}\""):throw({
            methodName = "__lt",
            className = v5
        });
    end;
    v7.__le = function(_, _)
        require(l_Parent_0.Error).new("NotImplemented", "The method \"{methodName}\" is not implemented on the class \"{className}\""):throw({
            methodName = "__le",
            className = v5
        });
    end;
    v7.__add = function(_)
        require(l_Parent_0.Error).new("NotImplemented", "The method \"{methodName}\" is not implemented on the class \"{className}\""):throw({
            methodName = "__add",
            className = v5
        });
    end;
    v7.__sub = function(_)
        require(l_Parent_0.Error).new("NotImplemented", "The method \"{methodName}\" is not implemented on the class \"{className}\""):throw({
            methodName = "__sub",
            className = v5
        });
    end;
    v7.__mul = function(_)
        require(l_Parent_0.Error).new("NotImplemented", "The method \"{methodName}\" is not implemented on the class \"{className}\""):throw({
            methodName = "__mul",
            className = v5
        });
    end;
    v7.__div = function(_)
        require(l_Parent_0.Error).new("NotImplemented", "The method \"{methodName}\" is not implemented on the class \"{className}\""):throw({
            methodName = "__div",
            className = v5
        });
    end;
    v7.__mod = function(_)
        require(l_Parent_0.Error).new("NotImplemented", "The method \"{methodName}\" is not implemented on the class \"{className}\""):throw({
            methodName = "__mod",
            className = v5
        });
    end;
    return v7;
end;
return v4;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.assertEqual);
local v3 = require(l_Parent_0.iterator);
return function(v4, v5)
    v2(typeof(v4), "table", "Attempted to call Dash.collect with argument #1 of type {left:?} not {right:?}");
    v2(typeof(v5), "function", "Attempted to call Dash.collect with argument #2 of type {left:?} not {right:?}");
    local v6 = {};
    for v7, v8 in v3(v4) do
        local v9, v10 = v5(v7, v8);
        if v9 ~= nil then
            v6[v9] = v10;
        end;
    end;
    return v6;
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.assertEqual);
local v3 = require(l_Parent_0.iterator);
local l_insert_0 = table.insert;
return function(v5, v6)
    v2(typeof(v5), "table", "Attempted to call Dash.collectArray with argument #1 of type {left:?} not {right:?}");
    v2(typeof(v6), "function", "Attempted to call Dash.collectArray with argument #2 of type {left:?} not {right:?}");
    local v7 = {};
    for v8, v9 in v3(v5) do
        local v10 = v6(v8, v9);
        if v10 ~= nil then
            l_insert_0(v7, v10);
        end;
    end;
    return v7;
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.assertEqual);
local v3 = require(l_Parent_0.iterator);
return function(v4, v5)
    v2(typeof(v4), "table", "Attempted to call Dash.collectSet with argument #1 of type {left:?} not {right:?}");
    local v6 = {};
    for v7, v8 in v3(v4) do
        local v9 = nil;
        v9 = if v5 == nil then v8 else v5(v7, v8);
        if v9 ~= nil then
            v6[v9] = true;
        end;
    end;
    return v6;
end;


local v0 = require(script.Parent.identity);
return function(...)
    local v1 = select("#", ...);
    if v1 == 0 then
        return v0;
    else
        local v2 = {
            ...
        };
        return function(...)
            local v3 = {
                v2[1](...)
            };
            for v4 = 2, v1 do
                v3 = {
                    v2[v4](unpack(v3))
                };
            end;
            return unpack(v3);
        end;
    end;
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.assign);
local v3 = require(l_Parent_0.assertEqual);
return function(v4)
    v3(typeof(v4), "table", "Attempted to call Dash.copy with argument #1 of type {left:?} not {right:?}");
    return v2({}, v4);
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.includes);
local _ = require(l_Parent_0.join);
local v4 = require(l_Parent_0.keys);
local l_sort_0 = table.sort;
local function v6()
    return {
        visited = {},
        refs = {},
        nextRef = 1,
        omit = {}
    };
end;
local function v7(v8, v9, v10)
    if v9 == -1 then
        return v10;
    elseif typeof(v8) == "table" then
        local v11 = v10 or v6();
        if not v11.visited[v8] then
            v11.visited[v8] = true;
            local v12 = v4(v8);
            l_sort_0(v12, function(v13, v14)
                if typeof(v13) == "number" and typeof(v14) == "number" then
                    return v13 < v14;
                else
                    return tostring(v13) < tostring(v14);
                end;
            end);
            for _, v16 in ipairs(v12) do
                local v17 = v8[v16];
                if not v2(v11.omit, v16) then
                    if not v9 then
                        v7(v16, nil, v11);
                        v7(v17, nil, v11);
                    else
                        v7(v16, v9 - 1, v11);
                        v7(v17, v9 - 1, v11);
                    end;
                end;
            end;
            return v11;
        else
            if not v11.refs[v8] then
                v11.refs[v8] = v11.nextRef;
                v11.nextRef = v11.nextRef + 1;
            end;
            return nil;
        end;
    else
        return nil;
    end;
end;
return v7;


local v0 = require(script.Parent.assertEqual);
return function(v1, v2)
    v0(typeof(v1), "string", "Attempted to call Dash.endsWith with argument #1 of type {left:?} not {right:?}");
    v0(typeof(v2), "string", "Attempted to call Dash.endsWith with argument #2 of type {left:?} not {right:?}");
    return v1:sub(-v2:len()) == v2;
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.assertEqual);
local v3 = require(l_Parent_0.iterator);
return function(v4, v5)
    v2(typeof(v4), "table", "Attempted to call Dash.filter with argument #1 of type {left:?} not {right:?}");
    v2(typeof(v5), "function", "Attempted to call Dash.filter with argument #2 of type {left:?} not {right:?}");
    local v6 = {};
    for v7, v8 in v3(v4) do
        if v5(v8, v7) then
            table.insert(v6, v8);
        end;
    end;
    return v6;
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.assertEqual);
local v3 = require(l_Parent_0.iterator);
return function(v4, v5)
    v2(typeof(v4), "table", "Attempted to call Dash.find with argument #1 of type {left:?} not {right:?}");
    v2(typeof(v5), "function", "Attempted to call Dash.find with argument #2 of type {left:?} not {right:?}");
    for v6, v7 in v3(v4) do
        if v5(v7, v6) then
            return v7;
        end;
    end;
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.assertEqual);
return function(v3, v4)
    v2(typeof(v3), "table", "Attempted to call Dash.findIndex with argument #1 of type {left:?} not {right:?}");
    v2(typeof(v4), "function", "Attempted to call Dash.findIndex with argument #2 of type {left:?} not {right:?}");
    for v5, v6 in ipairs(v3) do
        if v4(v6, v5) then
            return v5;
        end;
    end;
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.append);
local v3 = require(l_Parent_0.assertEqual);
local v4 = require(l_Parent_0.forEach);
return function(v5)
    v3(typeof(v5), "table", "Attempted to call Dash.flat with argument #1 of type {left:?} not {right:?}");
    local v6 = {};
    v4(v5, function(v7)
        v2(v6, v7);
    end);
    return v6;
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.assertEqual);
local v3 = require(l_Parent_0.iterator);
return function(v4, v5)
    v2(typeof(v4), "table", "Attempted to call Dash.forEach with argument #1 of type {left:?} not {right:?}");
    v2(typeof(v5), "function", "Attempted to call Dash.forEach with argument #2 of type {left:?} not {right:?}");
    for v6, v7 in v3(v4) do
        v5(v7, v6);
    end;
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.assertEqual);
return function(v3, ...)
    v2(typeof(v3), "function", "Attempted to call Dash.forEachArgs with argument #1 of type {left:?} not {right:?}");
    for v4 = 1, select("#", ...) do
        v3(select(v4, ...), v4);
    end;
end;


local l_Parent_0 = script.Parent;
local v1 = require(l_Parent_0.assertEqual);
local v2 = require(l_Parent_0.formatValue);
local v3 = require(l_Parent_0.splitOn);
local v4 = require(l_Parent_0.startsWith);
local l_concat_0 = table.concat;
local l_insert_0 = table.insert;
return function(v7, ...)
    v1(typeof(v7), "string", "Attempted to call Dash.format with argument #1 of type {left:?} not {right:?}");
    local v8 = {
        ...
    };
    local v9 = 1;
    local v10, v11 = v3(v7, "{[^{}]*}");
    local v12 = {};
    for v13, v14 in pairs(v10) do
        l_insert_0(v12, (v14:gsub("{{", "{"):gsub("}}", "}")));
        local v15 = v11[v13] and v11[v13]:sub(2, -2);
        if v15 then
            local v16 = v14:gmatch("{+$")();
            if v16 and #v16 % 2 == 1 then
                l_insert_0(v12, v15);
            else
                local v17 = v3(v15, ":");
                local v18 = v4(v17[1], "#");
                local v19 = not not v18 and v17[1]:sub(2) or v17[1];
                local v20 = tonumber(v19);
                local v21 = v17[2];
                local v22 = "nil";
                if not v20 then
                    if v19:len() > 0 then
                        local v23 = v8[1] and v8[1][v19];
                        if v23 ~= nil then
                            v22 = v23;
                        end;
                    else
                        v22 = v8[v9];
                        v9 = v9 + 1;
                    end;
                else
                    v22 = v8[v20];
                end;
                if v18 then
                    v22 = #v22;
                end;
                l_insert_0(v12, v2(v22, v21 or ""));
            end;
        end;
    end;
    return l_concat_0(v12, "");
end;


local l_Parent_0 = script.Parent;
local v1 = require(l_Parent_0.assertEqual);
return function(v2, v3)
    v3 = v3 or "";
    v1(typeof(v3), "string", "Attempted to call Dash.formatValue with argument #2 of type {left:?} not {right:?}");
    local v4, v5 = v3:find("[A-Za-z#?]+");
    if not v4 then
        local v6 = "s";
        if type(v2) == "number" then
            local _, v8 = math.modf(v2);
            v6 = v8 == 0 and "d" or "f";
        end;
        return ("%" .. v3 .. v6):format((tostring(v2)));
    else
        local v9 = v3:sub(v4, v5);
        local v10 = "%" .. v3:sub(1, v4 - 1) .. v3:sub(v5 + 1) .. "s";
        local v11 = require(l_Parent_0.pretty);
        if v9 == "#?" then
            return v10:format(v11(v2, {
                multiline = true
            }));
        elseif v9 == "?" then
            return v10:format(v11(v2));
        else
            return ("%" .. v3):format(v2);
        end;
    end;
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.Error);
local v3 = require(l_Parent_0.assertEqual);
local v4 = require(l_Parent_0.format);
local v5 = v2.new("ReadonlyKey", "Attempted to write to readonly key {key:?} of frozen object {objectName:?}");
local v6 = v2.new("MissingKey", "Attempted to read missing key {key:?} of frozen object {objectName:?}");
return function(v7, v8, v9)
    v3(typeof(v7), "string", "Attempted to call Dash.freeze with argument #1 of type {left:?} not {right:?}");
    v3(typeof(v8), "table", "Attempted to call Dash.freeze with argument #2 of type {left:?} not {right:?}");
    local v10 = {};
    setmetatable(v10, {
        __index = function(_, v12)
            local v13 = v8[v12];
            if not (not (v13 == nil) or not v9) then
                v6:throw({
                    key = v12,
                    objectName = v7
                });
            end;
            return v13;
        end,
        __newindex = function(_, v15)
            v5:throw({
                key = v15,
                objectName = v7
            });
        end,
        __len = function()
            return #v8;
        end,
        __tostring = function()
            return v4("Frozen({})", v7);
        end,
        __call = function(_, ...)
            return v8(...);
        end
    });
    return v10;
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local _ = require(l_Parent_0.Error);
local v3 = require(l_Parent_0.assertEqual);
local _ = require(l_Parent_0.format);
return function(v5, v6, v7)
    v3(typeof(v5), "table", "Attempted to call Dash.getOrSet with argument #1 of type {left:?} not {right:?}");
    v3(v6 == nil, false, "Attempted to call Dash.getOrSet with a nil key argument");
    v3(typeof(v7), "function", "Attempted to call Dash.getOrSet with argument #3 of type {left:?} not {right:?}");
    if v5[v6] == nil then
        v5[v6] = v7(v5, v6);
    end;
    return v5[v6];
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.assertEqual);
local l_insert_0 = table.insert;
return function(v4, v5)
    v2(typeof(v4), "table", "Attempted to call Dash.groupBy with argument #1 of type {left:?} not {right:?}");
    v2(v5 == nil, false, "Attempted to call Dash.groupBy with a nil getKey argument");
    local v6 = {};
    for v7, v8 in pairs(v4) do
        local v9 = nil;
        v9 = if typeof(v5) == "function" then v5(v8, v7) else v8[v5];
        if v9 ~= nil then
            if v6[v9] ~= nil then
                l_insert_0(v6[v9], v8);
            else
                v6[v9] = {
                    v8
                };
            end;
        end;
    end;
    return v6;
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.assertEqual);
return function(v3, v4)
    v2(typeof(v3), "table", "Attempted to call Dash.includes with argument #1 of type {left:?} not {right:?}");
    if v4 == nil then
        return false;
    else
        for _, v6 in pairs(v3) do
            if v6 == v4 then
                return true;
            end;
        end;
        return false;
    end;
end;


local v0 = {};
local _ = require(script.Types);
for _, v3 in pairs(script:GetChildren()) do
    if v3.ClassName == "ModuleScript" then
        v0[v3.Name] = require(v3);
    end;
end;
return v0.freeze("Dash", v0, true);


return function(v0)
    local v1 = true;
    if type(v0) ~= "function" then
        if not (not (type(v0) == "table") or not getmetatable(v0)) then
            v1 = true;
            if not (getmetatable(v0).__call == nil) then
                goto label0;
            end;
        end;
        v1 = false;
    end;
    ::label0::;
    return v1;
end;


local v0 = require(script.Parent.assertEqual);
return function(v1)
    v0(typeof(v1), "string", "Attempted to call Dash.isLowercase with argument #1 of type {left:?} not {right:?}");
    v0(#v1 > 0, true, "Attempted to call Dash.isLowercase with an empty string");
    local v2 = v1:sub(1, 1);
    return v2 == v2:lower();
end;


local v0 = require(script.Parent.assertEqual);
return function(v1)
    v0(typeof(v1), "string", "Attempted to call Dash.isUppercase with argument #1 of type {left:?} not {right:?}");
    v0(#v1 > 0, true, "Attempted to call Dash.isUppercase with an empty string");
    local v2 = v1:sub(1, 1);
    return v2 == v2:upper();
end;


local _ = require(script.Parent.Types);
return function(v1)
    local v2 = 1;
    local v3 = true;
    local v4 = nil;
    local _ = nil;
    return function()
        if v3 then
            local v6 = v1[v2];
            if v6 == nil then
                v3 = false;
            else
                local l_v2_0 = v2;
                v2 = v2 + 1;
                return l_v2_0, v6;
            end;
        end;
        while true do
            v4 = next(v1, v4);
            if not ((typeof(v4) == "number" and v4 > 0) and v4 < v2) or v4 % 1 ~= 0 then
                break;
            end;
        end;
        if v4 == nil then
            return nil;
        else
            return v4, v1[v4];
        end;
    end;
end;


local _ = require(script.Parent.Types);
return function(v1)
    if typeof(v1) == "function" then
        return v1;
    elseif typeof(v1) == "table" then
        if #v1 > 0 then
            return ipairs(v1);
        else
            return pairs(v1);
        end;
    else
        return nil;
    end;
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.assign);
return function(...)
    return v2({}, ...);
end;


local l_Parent_0 = script.Parent;
local v1 = require(l_Parent_0.None);
local _ = require(l_Parent_0.Types);
local v3 = require(l_Parent_0.assertEqual);
local v4 = require(l_Parent_0.forEach);
local v5 = require(l_Parent_0.copy);
local function v6(v7, v8)
    v3(typeof(v7), "table", "Attempted to call Dash.joinDeep with argument #1 of type {left:?} not {right:?}");
    v3(typeof(v8), "table", "Attempted to call Dash.joinDeep with argument #2 of type {left:?} not {right:?}");
    local v9 = v5(v7);
    v4(v8, function(v10, v11)
        if typeof(v7[v11]) == "table" and typeof(v10) == "table" then
            v9[v11] = v6(v7[v11], v10);
            return ;
        elseif v10 == v1 then
            v9[v11] = nil;
            return ;
        else
            v9[v11] = v10;
            return ;
        end;
    end);
    return v9;
end;
return v6;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.assertEqual);
local v3 = require(l_Parent_0.collect);
local _ = table.insert;
return function(v5, v6)
    v2(typeof(v5), "table", "Attempted to call Dash.keyBy with argument #1 of type {left:?} not {right:?}");
    v2(v6 == nil, false, "Attempted to call Dash.keyBy with a nil getKey argument");
    return v3(v5, function(v7, v8)
        local _ = nil;
        return if typeof(v6) == "function" then v6(v8, v7) else v8[v6], v8;
    end);
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.assertEqual);
local v3 = require(l_Parent_0.iterator);
local l_insert_0 = table.insert;
return function(v5)
    v2(typeof(v5), "table", "Attempted to call Dash.keys with argument #1 of type {left:?} not {right:?}");
    local v6 = {};
    for v7, _ in v3(v5) do
        l_insert_0(v6, v7);
    end;
    return v6;
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.assertEqual);
return function(v3, v4)
    v2(typeof(v3), "table", "Attempted to call Dash.last with argument #1 of type {left:?} not {right:?}");
    for v5 = #v3, 1, -1 do
        local v6 = v3[v5];
        if v4 then
            if v4(v6, v5) then
                return v6;
            end;
        else
            return v6;
        end;
    end;
end;


local v0 = require(script.Parent.assertEqual);
return function(v1, v2, v3)
    v0(typeof(v1), "string", "Attempted to call Dash.leftPad with argument #1 of type {left:?} not {right:?}");
    v0(typeof(v2), "number", "Attempted to call Dash.leftPad with argument #2 of type {left:?} not {right:?}");
    local v4 = v3 or " ";
    v0(typeof(v4), "string", "Attempted to call Dash.leftPad with argument #3 of type {left:?} not {right:?}");
    local v5 = v2 - v1:len();
    local v6 = v5 % v4:len();
    return string.rep(v4 or " ", (v5 - v6) / v4:len()) .. v4:sub(1, v6) .. v1;
end;


local l_Parent_0 = script.Parent;
local _ = require(l_Parent_0.Types);
local v2 = require(l_Parent_0.assertEqual);
local v3 = require(l_Parent_0.iterator);
return function(v4, v5)
    v2(typeof(v4), "table", "Attempted to call Dash.map with argument #1 of type {left:?} not {right:?}");
    v2(typeof(v5), "function", "Attempted to call Dash.map with argument #2 of type {left:?} not {right:?}");
    local v6 = {};
    for v7, v8 in v3(v4) do
        local v9 = v5(v8, v7);
        v2(v9 == nil, false, "Returned nil from a Dash.map handler");
        v6[v7] = v9;
    end;
    return v6;
end;